UNPKG

11 kBJavaScriptView Raw
1"use strict";
2
3define(['test/test-helpers'], function(testHelpers) {
4 var describeIf = testHelpers.describeIf;
5 var it = testHelpers.itWithFreshLog;
6
7 var originalConsole = window.console;
8
9 describe("Multiple logger instances tests:", function() {
10
11 describe("log.getLogger()", function() {
12 it("returns a new logger that is not the default one", function(log) {
13 var newLogger = log.getLogger("newLogger");
14 expect(newLogger).not.toEqual(log);
15 expect(newLogger.trace).toBeDefined();
16 expect(newLogger.debug).toBeDefined();
17 expect(newLogger.info).toBeDefined();
18 expect(newLogger.warn).toBeDefined();
19 expect(newLogger.error).toBeDefined();
20 expect(newLogger.setLevel).toBeDefined();
21 expect(newLogger.setDefaultLevel).toBeDefined();
22 expect(newLogger.enableAll).toBeDefined();
23 expect(newLogger.disableAll).toBeDefined();
24 expect(newLogger.methodFactory).toBeDefined();
25 });
26
27 it("returns loggers without `getLogger()` and `noConflict()`", function(log) {
28 var newLogger = log.getLogger("newLogger");
29 expect(newLogger.getLogger).toBeUndefined();
30 expect(newLogger.noConflict).toBeUndefined();
31 });
32
33 it("returns the same instance when called repeatedly with the same name", function(log) {
34 var logger1 = log.getLogger("newLogger");
35 var logger2 = log.getLogger("newLogger");
36
37 expect(logger1).toEqual(logger2);
38 });
39
40 it("should throw if called with no name", function(log) {
41 expect(function() {
42 log.getLogger();
43 }).toThrow();
44 });
45
46 it("should throw if called with empty string for name", function(log) {
47 expect(function() {
48 log.getLogger("");
49 }).toThrow();
50 });
51
52 it("should throw if called with a non-string name", function(log) {
53 expect(function() { log.getLogger(true); }).toThrow();
54 expect(function() { log.getLogger({}); }).toThrow();
55 expect(function() { log.getLogger([]); }).toThrow();
56 expect(function() { log.getLogger(10); }).toThrow();
57 expect(function() { log.getLogger(function(){}); }).toThrow();
58 expect(function() { log.getLogger(null); }).toThrow();
59 expect(function() { log.getLogger(undefined); }).toThrow();
60 });
61
62 // NOTE: this test is the same as the similarly-named test in
63 // `node-integration.js` (which only runs in Node.js). If making
64 // changes here, be sure to adjust that test as well.
65 it(typeof Symbol !== "undefined", "supports using symbols as names", function(log) {
66 var s1 = Symbol("a-symbol");
67 var s2 = Symbol("a-symbol");
68
69 var logger1 = log.getLogger(s1);
70 var defaultLevel = logger1.getLevel();
71 logger1.setLevel(log.levels.TRACE);
72
73 var logger2 = log.getLogger(s2);
74
75 // Should be unequal: same name, but different symbol instances
76 expect(logger1).not.toEqual(logger2);
77 expect(logger2.getLevel()).toEqual(defaultLevel);
78 });
79 });
80
81 describe("inheritance", function() {
82 beforeEach(function() {
83 window.console = {"log" : jasmine.createSpy("console.log")};
84 jasmine.addMatchers({
85 "toBeAtLevel" : testHelpers.toBeAtLevel
86 });
87 testHelpers.clearStoredLevels();
88 });
89
90 afterEach(function() {
91 window.console = originalConsole;
92 });
93
94 it("loggers are created with the same level as the default logger", function(log) {
95 log.setLevel("ERROR");
96 var newLogger = log.getLogger("newLogger");
97 expect(newLogger).toBeAtLevel("error");
98 });
99
100 it("if a logger's level is persisted, it uses that level rather than the default logger's level", function(log) {
101 testHelpers.setStoredLevel("error", "newLogger");
102 log.setLevel("TRACE");
103 var newLogger = log.getLogger("newLogger");
104 expect(newLogger).toBeAtLevel("error");
105 });
106
107 it("other loggers do not change when the default logger's level is changed", function(log) {
108 log.setLevel("TRACE");
109 var newLogger = log.getLogger("newLogger");
110 log.setLevel("ERROR");
111 expect(newLogger).toBeAtLevel("TRACE");
112 expect(log.getLogger("newLogger")).toBeAtLevel("TRACE");
113 });
114
115 it("loggers are created with the same methodFactory as the default logger", function(log) {
116 log.methodFactory = function(methodName, level) {
117 return function() {};
118 };
119
120 var newLogger = log.getLogger("newLogger");
121 expect(newLogger.methodFactory).toEqual(log.methodFactory);
122 });
123
124 it("loggers have independent method factories", function(log) {
125 var log1 = log.getLogger('logger1');
126 var log2 = log.getLogger('logger2');
127
128 var log1Spy = jasmine.createSpy('log1spy');
129 log1.methodFactory = function(methodName, level) {
130 return log1Spy;
131 };
132 log1.setLevel(log1.getLevel());
133
134 var log2Spy = jasmine.createSpy('log2spy');
135 log2.methodFactory = function(methodName, level) {
136 return log2Spy;
137 };
138 log2.setLevel(log2.getLevel());
139
140 log1.error('test1');
141 log2.error('test2');
142
143 expect(log1Spy).toHaveBeenCalledWith("test1");
144 expect(log2Spy).toHaveBeenCalledWith("test2");
145 });
146
147 it("new loggers correctly inherit a logging level of `0`", function(log) {
148 log.setLevel(0);
149 var newLogger = log.getLogger("newLogger");
150 expect(newLogger).toBeAtLevel("trace");
151 });
152 });
153
154 describe("logger.resetLevel()", function() {
155 beforeEach(function() {
156 window.console = {"log" : jasmine.createSpy("console.log")};
157 jasmine.addMatchers({
158 "toBeAtLevel" : testHelpers.toBeAtLevel
159 });
160 testHelpers.clearStoredLevels();
161 });
162
163 afterEach(function() {
164 window.console = originalConsole;
165 });
166
167 it("resets to the inherited level if no local level was set", function(log) {
168 testHelpers.setStoredLevel("ERROR", "newLogger");
169
170 log.setLevel("TRACE");
171 var newLogger = log.getLogger("newLogger");
172 expect(newLogger).toBeAtLevel("ERROR");
173
174 newLogger.resetLevel();
175 expect(newLogger).toBeAtLevel("TRACE");
176
177 // resetLevel() should not have broken inheritance.
178 log.setLevel("DEBUG");
179 log.rebuild();
180 expect(newLogger).toBeAtLevel("DEBUG");
181 });
182
183 it("resets to the inherited level if no default level was set", function(log) {
184 log.setLevel("TRACE");
185 var newLogger = log.getLogger("newLogger");
186 expect(newLogger).toBeAtLevel("TRACE");
187
188 newLogger.setLevel("ERROR");
189 expect(newLogger).toBeAtLevel("ERROR");
190
191 newLogger.resetLevel();
192 expect(newLogger).toBeAtLevel("TRACE");
193
194 // resetLevel() should not have broken inheritance.
195 log.setLevel("DEBUG");
196 log.rebuild();
197 expect(newLogger).toBeAtLevel("DEBUG");
198 });
199
200 it("resets to the default level if one was set", function(log) {
201 testHelpers.setStoredLevel("ERROR", "newLogger");
202
203 log.setLevel("TRACE");
204 var newLogger = log.getLogger("newLogger");
205 newLogger.setDefaultLevel("INFO");
206 expect(newLogger).toBeAtLevel("ERROR");
207
208 newLogger.resetLevel();
209 expect(newLogger).toBeAtLevel("INFO");
210
211 // resetLevel() should not have caused inheritance to start.
212 log.setLevel("DEBUG");
213 log.rebuild();
214 expect(newLogger).toBeAtLevel("INFO");
215 });
216 });
217
218 describe("logger.rebuild()", function() {
219 beforeEach(function() {
220 window.console = {"log" : jasmine.createSpy("console.log")};
221 jasmine.addMatchers({
222 "toBeAtLevel" : testHelpers.toBeAtLevel
223 });
224 testHelpers.clearStoredLevels();
225 });
226
227 afterEach(function() {
228 window.console = originalConsole;
229 });
230
231 it("rebuilds existing child loggers", function(log) {
232 log.setLevel("TRACE");
233 var newLogger = log.getLogger("newLogger");
234 expect(newLogger).toBeAtLevel("TRACE");
235
236 log.setLevel("ERROR");
237 expect(newLogger).toBeAtLevel("TRACE");
238
239 log.rebuild();
240 expect(newLogger).toBeAtLevel("ERROR");
241 });
242
243 it("should not change a child's persisted level", function(log) {
244 testHelpers.setStoredLevel("ERROR", "newLogger");
245
246 log.setLevel("TRACE");
247 var newLogger = log.getLogger("newLogger");
248 expect(newLogger).toBeAtLevel("ERROR");
249
250 log.rebuild();
251 expect(newLogger).toBeAtLevel("ERROR");
252 });
253
254 it("should not change a child's level set with `setLevel()`", function(log) {
255 log.setLevel("TRACE");
256 var newLogger = log.getLogger("newLogger");
257 expect(newLogger).toBeAtLevel("TRACE");
258
259 newLogger.setLevel("DEBUG", false);
260 log.rebuild();
261 expect(newLogger).toBeAtLevel("DEBUG");
262 });
263
264 it("should not change a child's level set with `setDefaultLevel()`", function(log) {
265 log.setLevel("TRACE");
266 var newLogger = log.getLogger("newLogger");
267 expect(newLogger).toBeAtLevel("TRACE");
268
269 newLogger.setDefaultLevel("DEBUG");
270 log.rebuild();
271 expect(newLogger).toBeAtLevel("DEBUG");
272 });
273 });
274 });
275});