-
-
Notifications
You must be signed in to change notification settings - Fork 973
/
LoggerTestSuite.java
274 lines (215 loc) · 10.6 KB
/
LoggerTestSuite.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
package org.slf4j.simple;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.event.Level;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public abstract class LoggerTestSuite {
public static class ListAppendingOutputStream extends OutputStream {
private final StringBuilder word = new StringBuilder();
private int index = 0;
private final List<String> list;
private ListAppendingOutputStream(List<String> list) {this.list = list;}
@Override
public void write(int b) throws IOException {
word.append((char) b);
}
@Override
public void flush() {
list.add(word.toString());
word.delete(0, word.length());
index++;
}
}
private ListAppendingOutputStream prepareSink(List<String> source) {
return new ListAppendingOutputStream(source);
}
@Test
public void testTrace() {
ArrayList<String> loggingEvents = new ArrayList<>();
Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.TRACE);
assertTrue("Trace level should be enabled for this test", configuredLogger.isTraceEnabled());
configuredLogger.trace("Simple trace message");
assertEquals("Trace message should've been captured", 1, loggingEvents.size());
assertTrue("Message should be logged in trace level", isTraceMessage(loggingEvents.get(0)));
assertEquals("Supplied trace message wasn't found in the log",
"Simple trace message",
extractMessage(loggingEvents.get(0)));
loggingEvents.clear();
configuredLogger.debug("Simple debug message");
configuredLogger.info("Simple info message");
configuredLogger.warn("Simple warn message");
configuredLogger.error("Simple error message");
assertEquals("The other levels should have been captured", 4, loggingEvents.size());
}
@Test
public void testDebug() {
ArrayList<String> loggingEvents = new ArrayList<>();
Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.DEBUG);
configuredLogger.trace("Simple trace message");
assertEquals("Lower levels should have been ignored", 0, loggingEvents.size());
assertTrue("Debug level should be enabled for this test", configuredLogger.isDebugEnabled());
configuredLogger.debug("Simple debug message");
assertEquals("Debug message should've been captured", 1, loggingEvents.size());
assertTrue("Message should be logged in debug level", isDebugMessage(loggingEvents.get(0)));
assertEquals("Supplied debug message wasn't found in the log",
"Simple debug message",
extractMessage(loggingEvents.get(0)));
loggingEvents.clear();
configuredLogger.info("Simple info message");
configuredLogger.warn("Simple warn message");
configuredLogger.error("Simple error message");
assertEquals("The other levels should have been captured", 3, loggingEvents.size());
}
@Test
public void testInfo() {
ArrayList<String> loggingEvents = new ArrayList<>();
Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.INFO);
configuredLogger.trace("Simple trace message");
configuredLogger.debug("Simple debug message");
assertEquals("Lower levels should have been ignored", 0, loggingEvents.size());
assertTrue("Info level should be enabled for this test", configuredLogger.isInfoEnabled());
configuredLogger.info("Simple info message");
assertEquals("Info message should've been captured", 1, loggingEvents.size());
assertTrue("Message should be logged in debug level", isInfoMessage(loggingEvents.get(0)));
assertEquals("Supplied info message wasn't found in the log",
"Simple info message",
extractMessage(loggingEvents.get(0)));
loggingEvents.clear();
configuredLogger.warn("Simple warn message");
configuredLogger.error("Simple error message");
assertEquals("The other levels should have been captured", 2, loggingEvents.size());
}
@Test
public void testWarn() {
ArrayList<String> loggingEvents = new ArrayList<>();
Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.WARN);
configuredLogger.trace("Simple trace message");
configuredLogger.debug("Simple debug message");
configuredLogger.info("Simple info message");
assertEquals("Lower levels should have been ignored", 0, loggingEvents.size());
assertTrue("Warn level should be enabled for this test", configuredLogger.isWarnEnabled());
configuredLogger.warn("Simple warn message");
assertEquals("Warn message should've been captured", 1, loggingEvents.size());
assertTrue("Message should be logged in warn level", isWarnMessage(loggingEvents.get(0)));
assertEquals("Supplied warn message wasn't found in the log",
"Simple warn message",
extractMessage(loggingEvents.get(0)));
loggingEvents.clear();
configuredLogger.error("Simple error message");
assertEquals("The other levels should have been captured", 1, loggingEvents.size());
}
@Test
public void testError() {
ArrayList<String> loggingEvents = new ArrayList<>();
Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.ERROR);
configuredLogger.trace("Simple trace message");
configuredLogger.debug("Simple debug message");
configuredLogger.info("Simple info message");
configuredLogger.warn("Simple warn message");
assertEquals("Lower levels should have been ignored", 0, loggingEvents.size());
assertTrue("Error level should be enabled for this test", configuredLogger.isErrorEnabled());
configuredLogger.error("Simple error message");
assertEquals("Error message should've been captured", 1, loggingEvents.size());
assertTrue("Message should be logged in error level", isErrorMessage(loggingEvents.get(0)));
assertEquals("Supplied error message wasn't found in the log",
"Simple error message",
extractMessage(loggingEvents.get(0)));
}
@Test
public void testFormatting() {
ArrayList<String> loggingEvents = new ArrayList<>();
Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.INFO);
configuredLogger.info("Some {} string", "formatted");
assertEquals("The formatted message should've been captured", 1, loggingEvents.size());
assertEquals("Message should've been formatted", "Some formatted string", extractMessage(loggingEvents.get(0)));
}
@Test
public void testException() {
ArrayList<String> loggingEvents = new ArrayList<>();
Logger configuredLogger = createLogger(prepareSink(loggingEvents), Level.INFO);
Exception exception = new RuntimeException("My error");
configuredLogger.info("Logging with an exception", exception);
assertEquals("The formatted message should've been captured", 1, loggingEvents.size());
assertEquals("Message should've been formatted",
"My error",
extractExceptionMessage(loggingEvents.get(0)));
assertEquals("Message should've been formatted",
"java.lang.RuntimeException",
extractExceptionType(loggingEvents.get(0)));
}
/**
* Allows tests to check whether the log message contains a trace message.
* Override if needed.
* @param message String containing the full log message
* @return whether it is a trace message or not
*/
protected boolean isTraceMessage(String message) {
return message.toLowerCase().contains("trace");
}
/**
* Allows tests to check whether the log message contains a debug message.
* Override if needed.
* @param message String containing the full log message
* @return whether it is a debug message or not
*/
protected boolean isDebugMessage(String message) {
return message.toLowerCase().contains("debug");
}
/**
* Allows tests to check whether the log message contains an info message.
* Override if needed.
* @param message String containing the full log message
* @return whether it is an info message or not
*/
protected boolean isInfoMessage(String message) {
return message.toLowerCase().contains("info");
}
/**
* Allows tests to check whether the log message contains a warn message.
* Override if needed.
* @param message String containing the full log message
* @return whether it is a warn message or not
*/
protected boolean isWarnMessage(String message) {
return message.toLowerCase().contains("warn");
}
/**
* Allows tests to check whether the log message contains an error message.
* Override if needed.
* @param message String containing the full log message
* @return whether it is an error message or not
*/
protected boolean isErrorMessage(String message) {
return message.toLowerCase().contains("error");
}
/**
* Extracts only the part of the log string that should represent the `message` string.
* @param message the full log message
* @return only the supplied message
*/
public abstract String extractMessage(String message);
/**
* Extracts only the part of the log string that should represent the supplied exception message, if any.
* @param message the full log message
* @return only the supplied exception message
*/
public abstract String extractExceptionMessage(String message);
/**
* Extracts only the part of the log string that should represent the supplied exception type.
* @param message the full log message
* @return only the supplied exception type name
*/
public abstract String extractExceptionType(String message);
/**
* Configures the logger for running the tests.
* @param outputStream The output stream for logs to be written to
* @param level The expected level the tests will run for this logger
* @return a configured logger able to run the tests
*/
public abstract Logger createLogger(ListAppendingOutputStream outputStream, Level level);
}