1 | "use strict";
|
2 |
|
3 | define(['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 |
|
63 |
|
64 |
|
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 |
|
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 |
|
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 |
|
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 |
|
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 | });
|