1 package uk.org.lidalia.slf4jtest;
2
3 import java.util.Collections;
4 import java.util.HashMap;
5 import java.util.List;
6 import java.util.Map;
7
8 import org.junit.After;
9 import org.junit.Test;
10 import org.junit.runner.RunWith;
11 import org.powermock.core.classloader.annotations.PrepareForTest;
12 import org.powermock.modules.junit4.PowerMockRunner;
13
14 import uk.org.lidalia.slf4jext.Level;
15
16 import static java.util.Arrays.asList;
17 import static org.hamcrest.CoreMatchers.instanceOf;
18 import static org.hamcrest.CoreMatchers.is;
19 import static org.hamcrest.collection.IsEmptyCollection.empty;
20 import static org.junit.Assert.assertNotSame;
21 import static org.junit.Assert.assertSame;
22 import static org.junit.Assert.assertThat;
23 import static org.powermock.api.mockito.PowerMockito.mock;
24 import static org.powermock.api.mockito.PowerMockito.when;
25 import static org.powermock.api.mockito.PowerMockito.whenNew;
26 import static uk.org.lidalia.slf4jext.Level.WARN;
27 import static uk.org.lidalia.slf4jtest.LoggingEvent.debug;
28 import static uk.org.lidalia.slf4jtest.LoggingEvent.info;
29 import static uk.org.lidalia.slf4jtest.LoggingEvent.trace;
30 import static uk.org.lidalia.slf4jtest.TestLoggerFactory.getInstance;
31 import static uk.org.lidalia.test.ShouldThrow.shouldThrow;
32
33 @RunWith(PowerMockRunner.class)
34 public class TestLoggerFactoryTests {
35
36 @Test
37 public void getLoggerDifferentNames() throws Exception {
38 TestLogger logger1 = getInstance().getLogger("name1");
39 TestLogger logger2 = getInstance().getLogger("name2");
40
41 assertNotSame(logger1, logger2);
42 }
43
44 @Test
45 public void getLoggerSameNames() throws Exception {
46 TestLogger logger1 = getInstance().getLogger("name1");
47 TestLogger logger2 = getInstance().getLogger("name1");
48
49 assertSame(logger1, logger2);
50 }
51
52 @Test
53 public void staticGetTestLoggerStringReturnsSame() throws Exception {
54 TestLogger logger1 = TestLoggerFactory.getTestLogger("name1");
55 TestLogger logger2 = getInstance().getLogger("name1");
56
57 assertSame(logger1, logger2);
58 }
59
60 @Test
61 public void staticGetTestLoggerClassReturnsSame() throws Exception {
62 TestLogger logger1 = TestLoggerFactory.getTestLogger(String.class);
63 TestLogger logger2 = getInstance().getLogger("java.lang.String");
64
65 assertSame(logger1, logger2);
66 }
67
68 @Test
69 public void clear() throws Exception {
70 TestLogger logger1 = getInstance().getLogger("name1");
71 logger1.trace("hello");
72 assertThat(logger1.getLoggingEvents().size(), is(1));
73 TestLogger logger2 = getInstance().getLogger("name2");
74 logger2.trace("world");
75 assertThat(logger2.getLoggingEvents().size(), is(1));
76
77 TestLoggerFactory.clear();
78
79 assertThat(logger1.getLoggingEvents(), is(empty()));
80 assertThat(logger2.getLoggingEvents(), is(empty()));
81 assertThat(TestLoggerFactory.getLoggingEvents(), is(empty()));
82 }
83
84 @Test
85 public void getAllLoggingEvents() throws Exception {
86 TestLogger logger1 = getInstance().getLogger("name1");
87 TestLogger logger2 = getInstance().getLogger("name2");
88 logger1.trace("hello");
89 logger2.trace("world");
90 logger1.trace("here");
91 logger2.trace("I am");
92
93 assertThat(TestLoggerFactory.getLoggingEvents(),
94 is(asList(
95 trace("hello"),
96 trace("world"),
97 trace("here"),
98 trace("I am"))));
99 }
100
101 @Test
102 public void getAllLoggingEventsDoesNotAddToMultipleLoggers() throws Exception {
103 TestLogger logger1 = getInstance().getLogger("name1");
104 TestLogger logger2 = getInstance().getLogger("name2");
105 logger1.trace("hello");
106 logger2.trace("world");
107
108 assertThat(logger1.getLoggingEvents(),
109 is(asList(
110 trace("hello"))
111 ));
112 assertThat(logger2.getLoggingEvents(),
113 is(asList(
114 trace("world"))
115 ));
116 }
117
118 @Test
119 public void getAllLoggingEventsDoesNotGetEventsForLoggersNotEnabled() {
120 TestLogger logger = getInstance().getLogger("name1");
121 logger.setEnabledLevels(WARN);
122 logger.info("hello");
123
124 assertThat(TestLoggerFactory.getLoggingEvents(), is(empty()));
125 }
126
127 @Test
128 public void getAllTestLoggers() {
129 TestLogger logger1 = getInstance().getLogger("name1");
130 TestLogger logger2 = getInstance().getLogger("name2");
131 Map<String, TestLogger> expected = new HashMap<String, TestLogger>();
132 expected.put("name1", logger1);
133 expected.put("name2", logger2);
134 assertThat(TestLoggerFactory.getAllTestLoggers(), is(expected));
135 }
136
137 @Test
138 public void clearDoesNotRemoveLoggers() {
139 TestLogger logger1 = getInstance().getLogger("name1");
140 TestLoggerFactory.clear();
141
142 Map<String, TestLogger> expected = new HashMap<String, TestLogger>();
143 expected.put("name1", logger1);
144 assertThat(TestLoggerFactory.getAllTestLoggers(), is(expected));
145 }
146
147 @Test
148 public void resetRemovesAllLoggers() {
149 getInstance().getLogger("name1");
150
151 TestLoggerFactory.reset();
152
153 final Map<String, TestLogger> emptyMap = Collections.emptyMap();
154 assertThat(TestLoggerFactory.getAllTestLoggers(), is(emptyMap));
155 }
156
157 @Test
158 public void resetRemovesAllLoggingEvents() {
159 getInstance().getLogger("name1").info("hello");
160
161 TestLoggerFactory.reset();
162
163 assertThat(TestLoggerFactory.getLoggingEvents(), is(empty()));
164 }
165
166 @Test
167 public void getLoggingEventsReturnsCopyNotView() {
168 getInstance().getLogger("name1").debug("hello");
169 List<LoggingEvent> loggingEvents = TestLoggerFactory.getLoggingEvents();
170 getInstance().getLogger("name1").info("world");
171 assertThat(loggingEvents, is(asList(debug("hello"))));
172 }
173
174 @Test(expected = UnsupportedOperationException.class)
175 public void getLoggingEventsReturnsUnmodifiableList() {
176 List<LoggingEvent> loggingEvents = TestLoggerFactory.getLoggingEvents();
177 loggingEvents.add(debug("hello"));
178 }
179
180 @Test
181 public void getAllLoggersReturnsCopyNotView() {
182 TestLogger logger1 = getInstance().getLogger("name1");
183 Map<String, TestLogger> allTestLoggers = TestLoggerFactory.getAllTestLoggers();
184 getInstance().getLogger("name2");
185
186 Map<String, TestLogger> expected = new HashMap<String, TestLogger>();
187 expected.put("name1", logger1);
188 assertThat(allTestLoggers, is(expected));
189 }
190
191 @Test(expected = UnsupportedOperationException.class)
192 public void getAllLoggersReturnsUnmodifiableList() {
193 Map<String, TestLogger> allTestLoggers = TestLoggerFactory.getAllTestLoggers();
194 allTestLoggers.put("newlogger", new TestLogger("newlogger", TestLoggerFactory.getInstance()));
195 }
196
197 @Test
198 public void getLoggingEventsOnlyReturnsEventsLoggedInThisThread() throws InterruptedException {
199 Thread t = new Thread(new Runnable() {
200 @Override
201 public void run() {
202 TestLoggerFactory.getTestLogger("name1").info("hello");
203 }
204 });
205 t.start();
206 t.join();
207 assertThat(TestLoggerFactory.getLoggingEvents(), is(empty()));
208 }
209
210 @Test
211 public void getAllLoggingEventsReturnsEventsLoggedInAllThreads() throws InterruptedException {
212 Thread t = new Thread(new Runnable() {
213 @Override
214 public void run() {
215 TestLoggerFactory.getTestLogger("name1").info("message1");
216 }
217 });
218 t.start();
219 t.join();
220 TestLoggerFactory.getTestLogger("name1").info("message2");
221 assertThat(TestLoggerFactory.getAllLoggingEvents(), is(asList(info("message1"), info("message2"))));
222 }
223
224 @Test
225 public void clearOnlyClearsEventsLoggedInThisThread() throws InterruptedException {
226 final TestLogger logger = TestLoggerFactory.getTestLogger("name");
227 Thread t = new Thread(new Runnable() {
228 @Override
229 public void run() {
230 logger.info("hello");
231 }
232 });
233 t.start();
234 t.join();
235 TestLoggerFactory.clear();
236 assertThat(TestLoggerFactory.getAllLoggingEvents(), is(asList(info("hello"))));
237 }
238
239 @Test
240 public void clearAllClearsEventsLoggedInAllThreads() throws InterruptedException {
241 final TestLogger logger1 = TestLoggerFactory.getTestLogger("name1");
242 final TestLogger logger2 = TestLoggerFactory.getTestLogger("name2");
243 logger1.info("hello11");
244 logger2.info("hello21");
245 Thread t = new Thread(new Runnable() {
246 @Override
247 public void run() {
248 logger1.info("hello12");
249 logger2.info("hello22");
250 TestLoggerFactory.clearAll();
251 }
252 });
253 t.start();
254 t.join();
255 assertThat(TestLoggerFactory.getLoggingEvents(), is(empty()));
256 assertThat(TestLoggerFactory.getAllLoggingEvents(), is(empty()));
257 assertThat(logger1.getLoggingEvents(), is(empty()));
258 assertThat(logger1.getAllLoggingEvents(), is(empty()));
259 assertThat(logger2.getLoggingEvents(), is(empty()));
260 assertThat(logger2.getAllLoggingEvents(), is(empty()));
261 }
262
263 @Test
264 public void defaultPrintLevelIsOff() {
265 assertThat(TestLoggerFactory.getInstance().getPrintLevel(), is(Level.OFF));
266 }
267
268 @Test
269 @PrepareForTest(TestLoggerFactory.class)
270 public void printLevelTakenFromOverridableProperties() throws Exception {
271 final OverridableProperties properties = mock(OverridableProperties.class);
272 whenNew(OverridableProperties.class).withArguments("slf4jtest").thenReturn(properties);
273 when(properties.getProperty("print.level", "OFF")).thenReturn("INFO");
274
275 assertThat(TestLoggerFactory.getInstance().getPrintLevel(), is(Level.INFO));
276 }
277
278 @Test
279 @PrepareForTest(TestLoggerFactory.class)
280 public void printLevelInvalidInOverridableProperties() throws Exception {
281 final OverridableProperties properties = mock(OverridableProperties.class);
282 whenNew(OverridableProperties.class).withArguments("slf4jtest").thenReturn(properties);
283 final String invalidLevelName = "nonsense";
284 when(properties.getProperty("print.level", "OFF")).thenReturn(invalidLevelName);
285
286 final IllegalStateException illegalStateException = shouldThrow(IllegalStateException.class, new Runnable() {
287 @Override
288 public void run() {
289 TestLoggerFactory.getInstance();
290 }
291 });
292 assertThat(illegalStateException.getMessage(),
293 is("Invalid level name in property print.level of file slf4jtest.properties " +
294 "or System property slf4jtest.print.level"));
295 assertThat(illegalStateException.getCause(), instanceOf(IllegalArgumentException.class));
296 assertThat(illegalStateException.getCause().getMessage(),
297 is("No enum constant "+Level.class.getName()+"."+invalidLevelName));
298
299 }
300
301 @Test
302 public void setLevel() {
303 for (Level printLevel: Level.values()) {
304 TestLoggerFactory.getInstance().setPrintLevel(printLevel);
305 assertThat(TestLoggerFactory.getInstance().getPrintLevel(), is(printLevel));
306 }
307 }
308
309 @After
310 public void resetLoggerFactory() {
311 try {
312 TestLoggerFactory.reset();
313 } catch (IllegalStateException e) {
314
315 }
316 }
317 }