1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
package org.xwiki.logging.logback.internal; |
21 |
|
|
22 |
|
import java.util.Iterator; |
23 |
|
|
24 |
|
import org.junit.Assert; |
25 |
|
import org.junit.Before; |
26 |
|
import org.junit.Rule; |
27 |
|
import org.junit.Test; |
28 |
|
import org.slf4j.Logger; |
29 |
|
import org.slf4j.LoggerFactory; |
30 |
|
import org.xwiki.logging.LogLevel; |
31 |
|
import org.xwiki.logging.LogQueue; |
32 |
|
import org.xwiki.logging.event.LogQueueListener; |
33 |
|
import org.xwiki.observation.internal.DefaultObservationManager; |
34 |
|
import org.xwiki.test.annotation.ComponentList; |
35 |
|
import org.xwiki.test.mockito.MockitoComponentMockingRule; |
36 |
|
|
37 |
|
import ch.qos.logback.classic.spi.ILoggingEvent; |
38 |
|
import ch.qos.logback.core.Appender; |
39 |
|
import ch.qos.logback.core.filter.Filter; |
40 |
|
import ch.qos.logback.core.read.ListAppender; |
41 |
|
import ch.qos.logback.core.spi.FilterReply; |
42 |
|
|
43 |
|
import static org.mockito.Mockito.spy; |
44 |
|
import static org.mockito.Mockito.verify; |
45 |
|
import static org.mockito.Mockito.when; |
46 |
|
|
47 |
|
|
48 |
|
@link |
49 |
|
|
50 |
|
@version |
51 |
|
@since |
52 |
|
|
53 |
|
@ComponentList({ DefaultLoggerManager.class, DefaultObservationManager.class, LogbackEventGenerator.class }) |
|
|
| 95.3% |
Uncovered Elements: 4 (86) |
Complexity: 14 |
Complexity Density: 0.2 |
|
54 |
|
public class DefaultLoggerManagerTest |
55 |
|
{ |
56 |
|
@Rule |
57 |
|
public final MockitoComponentMockingRule<DefaultLoggerManager> mocker = |
58 |
|
new MockitoComponentMockingRule<DefaultLoggerManager>(DefaultLoggerManager.class); |
59 |
|
|
60 |
|
private DefaultLoggerManager loggerManager; |
61 |
|
|
62 |
|
private Logger logger; |
63 |
|
|
64 |
|
private ListAppender<ILoggingEvent> listAppender; |
65 |
|
|
66 |
|
private LogbackUtils utils = new LogbackUtils(); |
67 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (13) |
Complexity: 2 |
Complexity Density: 0.18 |
|
68 |
7 |
@Before... |
69 |
|
public void setUp() throws Exception |
70 |
|
{ |
71 |
7 |
ch.qos.logback.classic.Logger rootLogger = this.utils.getRootLogger(); |
72 |
|
|
73 |
|
|
74 |
7 |
Filter<ILoggingEvent> filter = new Filter<ILoggingEvent>() |
75 |
|
{ |
|
|
| 60% |
Uncovered Elements: 2 (5) |
Complexity: 3 |
Complexity Density: 1 |
|
76 |
33 |
@Override... |
77 |
|
public FilterReply decide(ILoggingEvent event) |
78 |
|
{ |
79 |
33 |
if (event.getMessage() != null && event.getMessage().startsWith("[test]")) { |
80 |
33 |
return FilterReply.DENY; |
81 |
|
} |
82 |
|
|
83 |
0 |
return FilterReply.NEUTRAL; |
84 |
|
} |
85 |
|
}; |
86 |
7 |
Iterator<Appender<ILoggingEvent>> appendersIterator = rootLogger.iteratorForAppenders(); |
87 |
35 |
while (appendersIterator.hasNext()) { |
88 |
28 |
Appender<ILoggingEvent> appender = appendersIterator.next(); |
89 |
28 |
appender.addFilter(filter); |
90 |
|
} |
91 |
|
|
92 |
|
|
93 |
7 |
this.listAppender = new ListAppender<ILoggingEvent>(); |
94 |
7 |
this.listAppender.start(); |
95 |
7 |
rootLogger.addAppender(this.listAppender); |
96 |
|
|
97 |
7 |
this.logger = LoggerFactory.getLogger(getClass()); |
98 |
7 |
this.loggerManager = this.mocker.getComponentUnderTest(); |
99 |
|
} |
100 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (15) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
101 |
1 |
@Test... |
102 |
|
public void testPushPopLogListener() throws InterruptedException |
103 |
|
{ |
104 |
1 |
this.logger.error("[test] before push"); |
105 |
|
|
106 |
|
|
107 |
1 |
Assert.assertEquals("[test] before push", this.listAppender.list.get(0).getMessage()); |
108 |
|
|
109 |
1 |
LogQueue queue = new LogQueue(); |
110 |
|
|
111 |
1 |
this.loggerManager.pushLogListener(new LogQueueListener("loglistenerid", queue)); |
112 |
|
|
113 |
1 |
this.logger.error("[test] after push"); |
114 |
|
|
115 |
|
|
116 |
1 |
Assert.assertEquals("[test] after push", queue.poll().getMessage()); |
117 |
|
|
118 |
|
|
119 |
1 |
Assert.assertTrue(this.listAppender.list.size() == 1); |
120 |
|
|
121 |
1 |
Thread thread = new Thread(new Runnable() |
122 |
|
{ |
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
123 |
1 |
@Override... |
124 |
|
public void run() |
125 |
|
{ |
126 |
1 |
DefaultLoggerManagerTest.this.logger.error("[test] other thread"); |
127 |
|
} |
128 |
|
}); |
129 |
1 |
thread.start(); |
130 |
1 |
thread.join(); |
131 |
|
|
132 |
|
|
133 |
1 |
Assert.assertEquals("[test] other thread", this.listAppender.list.get(1).getMessage()); |
134 |
|
|
135 |
1 |
this.loggerManager.popLogListener(); |
136 |
|
|
137 |
1 |
this.logger.error("[test] after pop"); |
138 |
|
|
139 |
1 |
Assert.assertTrue(queue.isEmpty()); |
140 |
1 |
Assert.assertEquals("[test] after pop", this.listAppender.list.get(2).getMessage()); |
141 |
|
} |
142 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (13) |
Complexity: 1 |
Complexity Density: 0.08 |
1PASS
|
|
143 |
1 |
@Test... |
144 |
|
public void testStackedListeners() |
145 |
|
{ |
146 |
1 |
this.logger.error("[test] before push"); |
147 |
|
|
148 |
|
|
149 |
1 |
Assert.assertEquals("[test] before push", this.listAppender.list.get(0).getMessage()); |
150 |
|
|
151 |
1 |
LogQueue queue1 = new LogQueue(); |
152 |
|
|
153 |
1 |
this.loggerManager.pushLogListener(new LogQueueListener("loglistenerid1", queue1)); |
154 |
|
|
155 |
1 |
LogQueue queue2 = new LogQueue(); |
156 |
|
|
157 |
1 |
this.loggerManager.pushLogListener(new LogQueueListener("loglistenerid2", queue2)); |
158 |
|
|
159 |
1 |
this.logger.error("[test] log queue2"); |
160 |
|
|
161 |
|
|
162 |
1 |
Assert.assertTrue(queue1.isEmpty()); |
163 |
|
|
164 |
|
|
165 |
1 |
Assert.assertEquals("[test] log queue2", queue2.poll().getMessage()); |
166 |
|
|
167 |
1 |
this.loggerManager.popLogListener(); |
168 |
|
|
169 |
1 |
this.logger.error("[test] log queue1"); |
170 |
|
|
171 |
|
|
172 |
1 |
Assert.assertEquals("[test] log queue1", queue1.poll().getMessage()); |
173 |
|
|
174 |
1 |
this.loggerManager.popLogListener(); |
175 |
|
} |
176 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
1PASS
|
|
177 |
1 |
@Test... |
178 |
|
public void testNullListeners() |
179 |
|
{ |
180 |
1 |
this.logger.error("[test] before push"); |
181 |
|
|
182 |
|
|
183 |
1 |
Assert.assertEquals("[test] before push", this.listAppender.list.get(0).getMessage()); |
184 |
|
|
185 |
1 |
this.loggerManager.pushLogListener(null); |
186 |
|
|
187 |
1 |
this.logger.error("[test] log to null"); |
188 |
|
|
189 |
|
|
190 |
1 |
Assert.assertEquals(1, this.listAppender.list.size()); |
191 |
|
|
192 |
1 |
this.loggerManager.popLogListener(); |
193 |
|
|
194 |
1 |
this.logger.error("[test] after pop"); |
195 |
|
|
196 |
|
|
197 |
1 |
Assert.assertEquals("[test] after pop", this.listAppender.list.get(1).getMessage()); |
198 |
|
} |
199 |
|
|
|
|
| 84.6% |
Uncovered Elements: 2 (13) |
Complexity: 2 |
Complexity Density: 0.18 |
1PASS
|
|
200 |
1 |
@Test... |
201 |
|
public void testGetSetLoggerLevel() |
202 |
|
{ |
203 |
1 |
Assert.assertNull(this.loggerManager.getLoggerLevel(getClass().getName())); |
204 |
|
|
205 |
1 |
LogQueue queue = new LogQueue(); |
206 |
|
|
207 |
1 |
this.loggerManager.pushLogListener(new LogQueueListener("loglistenerid", queue)); |
208 |
|
|
209 |
1 |
this.loggerManager.setLoggerLevel(getClass().getName(), LogLevel.WARN); |
210 |
|
|
211 |
1 |
this.logger.debug("[test] debug message 1"); |
212 |
|
|
213 |
1 |
if (queue.size() > 0) { |
214 |
0 |
Assert.fail("Should have contained no message but got [" + queue.peek().getFormattedMessage() |
215 |
|
+ "] instead (last message, there might be more)"); |
216 |
|
} |
217 |
1 |
Assert.assertEquals(0, queue.size()); |
218 |
|
|
219 |
1 |
this.loggerManager.setLoggerLevel(getClass().getName(), LogLevel.DEBUG); |
220 |
|
|
221 |
1 |
this.logger.debug("[test] debug message 2"); |
222 |
1 |
Assert.assertEquals(1, queue.size()); |
223 |
|
} |
224 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
1PASS
|
|
225 |
1 |
@Test... |
226 |
|
public void testGetLoggers() |
227 |
|
{ |
228 |
1 |
this.loggerManager.getLoggers(); |
229 |
|
} |
230 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (4) |
Complexity: 1 |
Complexity Density: 0.25 |
1PASS
|
|
231 |
1 |
@Test... |
232 |
|
public void initializeWhenNoLogback() throws Exception |
233 |
|
{ |
234 |
|
|
235 |
1 |
DefaultLoggerManager spyLoggerManager = spy(this.loggerManager); |
236 |
1 |
when(spyLoggerManager.getRootLogger()).thenReturn(null); |
237 |
|
|
238 |
1 |
spyLoggerManager.initialize(); |
239 |
|
|
240 |
1 |
verify(this.mocker.getMockedLogger()).warn( |
241 |
|
"Could not find any Logback root logger. All logging module advanced features will be disabled."); |
242 |
|
} |
243 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0.33 |
1PASS
|
|
244 |
1 |
@Test... |
245 |
|
public void getLoggerLevelWhenNoLogback() throws Exception |
246 |
|
{ |
247 |
|
|
248 |
1 |
DefaultLoggerManager spyLoggerManager = spy(this.loggerManager); |
249 |
1 |
when(spyLoggerManager.getLoggerContext()).thenReturn(null); |
250 |
|
|
251 |
1 |
Assert.assertNull(spyLoggerManager.getLoggerLevel("whatever")); |
252 |
|
} |
253 |
|
} |