001/*
002 * Copyright 2023 the original author or authors.
003 * <p>
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 * <p>
008 * https://www.apache.org/licenses/LICENSE-2.0
009 * <p>
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package de.cuioss.test.juli;
017
018import static de.cuioss.test.juli.TestLoggerFactory.getTestHandler;
019import static org.junit.jupiter.api.Assertions.assertEquals;
020import static org.junit.jupiter.api.Assertions.assertNotEquals;
021import static org.junit.jupiter.api.Assertions.assertTrue;
022
023import java.util.logging.LogRecord;
024
025import de.cuioss.test.juli.junit5.EnableTestLogger;
026import lombok.experimental.UtilityClass;
027
028/**
029 * Provides a number of asserts against the {@link LogRecord}s gathered by
030 * {@link TestLogHandler}. Caution: In order to use the asserts the
031 * {@link TestLogHandler} must be properly configured by calling
032 * {@link TestLoggerFactory#install()} prior to usage. Usually this is done by
033 * {@link EnableTestLogger}
034 *
035 * @author Oliver Wolff
036 *
037 */
038@UtilityClass
039public class LogAsserts {
040
041    private static final String ALL_LOGS = ", All recorded Logs:\n";
042    private static final String MESSAGE_EXACTLY = " and message is exactly=";
043    private static final String MESSAGE_CONTAINS = " and message containing=";
044    private static final String AND_THROWABLE = " and throwable=";
045    private static final String NO_LOG_MESSAGE_FOUND_WITH_LEVEL = "No log message found with level=";
046
047    private static final String AT_LEAST_ONE_LOG_MESSAGE_FOUND_WITH_LEVEL = "At least one log message found with level=";
048    private static final String NO_SINGLE_MESSAGE_FOUND_WITH_LEVEL = "Expected one message to be found with level=";
049
050    /**
051     * Asserts whether at least one {@link LogRecord} for the given parameter is
052     * present
053     *
054     * @param logLevel to be checked, must not be null
055     * @param message  to be checked, must not be null
056     */
057    public static void assertLogMessagePresent(TestLogLevel logLevel, String message) {
058        var testHandler = getTestHandler();
059        var messages = testHandler.resolveLogMessages(logLevel, message);
060        var assertionMessage = NO_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_EXACTLY + message + ALL_LOGS
061                + testHandler.getRecordsAsString();
062
063        assertNotEquals(0, messages.size(), assertionMessage);
064    }
065
066    /**
067     * Asserts whether no {@link LogRecord} for the given parameter is present
068     *
069     * @param logLevel    to be checked, must not be null
070     * @param messagePart to be checked, must not be null
071     */
072    public static void assertNoLogMessagePresent(TestLogLevel logLevel, String messagePart) {
073        var testHandler = getTestHandler();
074        var messages = testHandler.resolveLogMessagesContaining(logLevel, messagePart);
075        var assertionMessage = AT_LEAST_ONE_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_EXACTLY + messagePart
076                + ALL_LOGS + testHandler.getRecordsAsString();
077
078        assertTrue(messages.isEmpty(), assertionMessage);
079    }
080
081    /**
082     * Asserts whether no {@link LogRecord} for the given parameter is present
083     *
084     * @param logLevel to be checked, must not be null
085     * @param logger   to be checked, must not be null
086     */
087    public static void assertNoLogMessagePresent(TestLogLevel logLevel, Class<?> logger) {
088        var testHandler = getTestHandler();
089        var messages = testHandler.resolveLogMessagesForLogger(logLevel, logger);
090        var assertionMessage = AT_LEAST_ONE_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + ", on logger= " + logger
091                + ALL_LOGS + testHandler.getRecordsAsString();
092
093        assertEquals(0, messages.size(), assertionMessage);
094    }
095
096    /**
097     * Asserts whether exactly one {@link LogRecord} for the given parameter is
098     * present
099     *
100     * @param logLevel to be checked, must not be null
101     * @param message  to be checked, must not be null
102     */
103    public static void assertSingleLogMessagePresent(TestLogLevel logLevel, String message) {
104        var testHandler = getTestHandler();
105        var records = testHandler.resolveLogMessages(logLevel, message);
106        var assertionMessage = NO_SINGLE_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_EXACTLY + message + ALL_LOGS
107                + testHandler.getRecordsAsString();
108
109        assertEquals(1, records.size(), assertionMessage);
110    }
111
112    /**
113     * Asserts whether at least one {@link LogRecord} for the given parameter is
114     * present
115     *
116     * @param logLevel  to be checked, must not be null
117     * @param message   to be checked, must not be null
118     * @param throwable to be checked, must not be null
119     */
120    public static void assertLogMessagePresent(TestLogLevel logLevel, String message, Throwable throwable) {
121        var testHandler = getTestHandler();
122        var messages = testHandler.resolveLogMessages(logLevel, message, throwable);
123        var assertionMessage = NO_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_EXACTLY + message + AND_THROWABLE
124                + throwable + ALL_LOGS + testHandler.getRecordsAsString();
125
126        assertNotEquals(0, messages.size(), assertionMessage);
127    }
128
129    /**
130     * Asserts whether exactly one {@link LogRecord} for the given parameter is
131     * present
132     *
133     * @param logLevel  to be checked, must not be null
134     * @param message   to be checked, must not be null
135     * @param throwable to be checked, must not be null
136     */
137    public static void assertSingleLogMessagePresent(TestLogLevel logLevel, String message, Throwable throwable) {
138        var testHandler = getTestHandler();
139        var records = testHandler.resolveLogMessages(logLevel, message, throwable);
140        var assertionMessage = NO_SINGLE_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_EXACTLY + message + AND_THROWABLE
141                + throwable + ALL_LOGS + testHandler.getRecordsAsString();
142
143        assertEquals(1, records.size(), assertionMessage);
144    }
145
146    /**
147     * Asserts whether at least one {@link LogRecord} for the given parameter is
148     * present
149     *
150     * @param logLevel       to be checked, must not be null
151     * @param message        to be checked, must not be null
152     * @param throwableClass to be checked, must not be null
153     */
154    public static void assertLogMessagePresent(TestLogLevel logLevel, String message,
155            Class<? extends Throwable> throwableClass) {
156        var testHandler = getTestHandler();
157        var messages = testHandler.resolveLogMessages(logLevel, message, throwableClass);
158        var assertionMessage = NO_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_EXACTLY + message + AND_THROWABLE
159                + throwableClass + ALL_LOGS + testHandler.getRecordsAsString();
160
161        assertNotEquals(0, messages.size(), assertionMessage);
162    }
163
164    /**
165     * Asserts whether exactly one {@link LogRecord} for the given parameter is
166     * present
167     *
168     * @param logLevel       to be checked, must not be null
169     * @param message        to be checked, must not be null
170     * @param throwableClass to be checked, must not be null
171     */
172    public static void assertSingleLogMessagePresent(TestLogLevel logLevel, String message,
173            Class<? extends Throwable> throwableClass) {
174        var testHandler = getTestHandler();
175        var records = testHandler.resolveLogMessages(logLevel, message, throwableClass);
176        var assertionMessage = NO_SINGLE_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_EXACTLY + message + AND_THROWABLE
177                + throwableClass + ALL_LOGS + testHandler.getRecordsAsString();
178
179        assertEquals(1, records.size(), assertionMessage);
180    }
181
182    /**
183     * Asserts whether at least one {@link LogRecord} for the given parameter is
184     * present
185     *
186     * @param logLevel    to be checked, must not be null
187     * @param messagePart to be checked, must not be null
188     */
189    public static void assertLogMessagePresentContaining(TestLogLevel logLevel, String messagePart) {
190        var testHandler = getTestHandler();
191        var messages = testHandler.resolveLogMessagesContaining(logLevel, messagePart);
192        var assertionMessage = NO_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_CONTAINS + messagePart + ALL_LOGS
193                + testHandler.getRecordsAsString();
194
195        assertNotEquals(0, messages.size(), assertionMessage);
196    }
197
198    /**
199     * Asserts whether exactly one {@link LogRecord} for the given parameter is
200     * present
201     *
202     * @param logLevel    to be checked, must not be null
203     * @param messagePart to be checked, must not be null
204     */
205    public static void assertSingleLogMessagePresentContaining(TestLogLevel logLevel, String messagePart) {
206        var testHandler = getTestHandler();
207        var records = testHandler.resolveLogMessagesContaining(logLevel, messagePart);
208        var assertionMessage = NO_SINGLE_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_CONTAINS + messagePart + ALL_LOGS
209                + testHandler.getRecordsAsString();
210
211        assertEquals(1, records.size(), assertionMessage);
212    }
213
214    /**
215     * Asserts whether at least one {@link LogRecord} for the given parameter is
216     * present
217     *
218     * @param logLevel    to be checked, must not be null
219     * @param messagePart to be checked, must not be null
220     * @param throwable   to be checked, must not be null
221     */
222    public static void assertLogMessagePresentContaining(TestLogLevel logLevel, String messagePart,
223            Throwable throwable) {
224        var testHandler = getTestHandler();
225        var records = testHandler.resolveLogMessagesContaining(logLevel, messagePart, throwable);
226        assertNotEquals(0, records.size(), NO_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_CONTAINS + messagePart
227                + AND_THROWABLE + throwable + ALL_LOGS + testHandler.getRecordsAsString());
228    }
229
230    /**
231     * Asserts whether at least one {@link LogRecord} for the given parameter is
232     * present
233     *
234     * @param logLevel       to be checked, must not be null
235     * @param messagePart    to be checked, must not be null
236     * @param throwableClass to be checked, must not be null
237     */
238    public static void assertLogMessagePresentContaining(TestLogLevel logLevel, String messagePart,
239            Class<? extends Throwable> throwableClass) {
240        var testHandler = getTestHandler();
241        var records = testHandler.resolveLogMessagesContaining(logLevel, messagePart, throwableClass);
242        assertNotEquals(0, records.size(), NO_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_CONTAINS + messagePart
243                + AND_THROWABLE + throwableClass + ALL_LOGS + testHandler.getRecordsAsString());
244    }
245
246    /**
247     * Asserts whether exactly one {@link LogRecord} for the given parameter is
248     * present
249     *
250     * @param logLevel    to be checked, must not be null
251     * @param messagePart to be checked, must not be null
252     * @param throwable   to be checked, must not be null
253     */
254    public static void assertSingleLogMessagePresentContaining(TestLogLevel logLevel, String messagePart,
255            Throwable throwable) {
256        var testHandler = getTestHandler();
257        var records = testHandler.resolveLogMessagesContaining(logLevel, messagePart, throwable);
258        assertEquals(1, records.size(), NO_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_CONTAINS + messagePart
259                + AND_THROWABLE + throwable + ALL_LOGS + testHandler.getRecordsAsString());
260    }
261
262    /**
263     * Asserts whether exactly one {@link LogRecord} for the given parameter is
264     * present
265     *
266     * @param logLevel       to be checked, must not be null
267     * @param messagePart    to be checked, must not be null
268     * @param throwableClass to be checked, must not be null
269     */
270    public static void assertSingleLogMessagePresentContaining(TestLogLevel logLevel, String messagePart,
271            Class<? extends Throwable> throwableClass) {
272        var testHandler = getTestHandler();
273        var records = testHandler.resolveLogMessagesContaining(logLevel, messagePart, throwableClass);
274        assertEquals(1, records.size(), NO_LOG_MESSAGE_FOUND_WITH_LEVEL + logLevel + MESSAGE_CONTAINS + messagePart
275                + AND_THROWABLE + throwableClass + ALL_LOGS + testHandler.getRecordsAsString());
276    }
277}