1 | const assert = require('assert'),
|
2 | { clone,
|
3 | compress,
|
4 | configMerge,
|
5 | get,
|
6 | merge,
|
7 | mergeWith,
|
8 | _defaultMerge,
|
9 | _getMerger,
|
10 | _isEnvKey,
|
11 | _isValueType,
|
12 | _parseKey } = require('../src/lib/object');
|
13 |
|
14 | describe('object', function() {
|
15 | const obj1 = {
|
16 | "username": "app",
|
17 | "password": "password123",
|
18 | "host": undefined,
|
19 | "port": null,
|
20 | "nested": {
|
21 | "nEggs": null,
|
22 | "nChicks": 3,
|
23 | "height": "12 ft."
|
24 | }
|
25 | };
|
26 |
|
27 | const obj2 = {
|
28 | "username": "admin",
|
29 | "password": null,
|
30 | "host": null,
|
31 | "port": undefined,
|
32 | "nested": {
|
33 | "nEggs": 3,
|
34 | "nChicks": 0,
|
35 | "height": null
|
36 | }
|
37 | };
|
38 |
|
39 | describe('get', function() {
|
40 | it('get(obj, "") should return the original object', function() {
|
41 | let obj = {};
|
42 | assert.equal(obj, get(obj, ""));
|
43 | });
|
44 |
|
45 | it('get(null, "fkey") should throw', function() {
|
46 | assert.throws(() => {
|
47 | get(null)
|
48 | });
|
49 | });
|
50 |
|
51 | it('get(undefined, "fkey") should throw', function() {
|
52 | assert.throws(() => {
|
53 | get(undefined)
|
54 | });
|
55 | });
|
56 |
|
57 | it(`get(obj1, "username") === ${obj1["username"]})}`, function() {
|
58 | assert.strictEqual(get(obj1, "username"), obj1.username);
|
59 | });
|
60 |
|
61 | it(`get(obj1, "host") === ${obj1["host"]}`, function() {
|
62 | assert.strictEqual(get(obj1, "host"), obj1.host);
|
63 | });
|
64 |
|
65 | it(`get(obj1, "port") === ${obj1.port}`, function() {
|
66 | assert.strictEqual(get(obj1, "port"), obj1.port);
|
67 | });
|
68 |
|
69 | it(`get(obj1, "nested.nEggs") === ${obj1.nested.nEggs}`, function() {
|
70 | assert.strictEqual(get(obj1, "nested.nEggs"),
|
71 | obj1.nested.nEggs);
|
72 | });
|
73 |
|
74 | it(`get(obj1, "nested.nChicks") === ${obj1.nested.nChicks}`, function() {
|
75 | assert.strictEqual(get(obj1, "nested.nChicks"), obj1.nested.nChicks);
|
76 | });
|
77 |
|
78 | it(`get(obj1, "nested.height") === ${obj1.nested.height}`, function() {
|
79 | assert.strictEqual(get(obj1, "nested.height"),
|
80 | obj1.nested.height);
|
81 | });
|
82 |
|
83 | it(`get(obj1, "notDefined") === ${obj1.notDefined}`, function() {
|
84 | assert.strictEqual(get(obj1, "notDefined"),
|
85 | obj1.notDefined);
|
86 | });
|
87 |
|
88 | it(`get(obj1, "nested.notDefined") === ${obj1.nested.notDefined}`, function() {
|
89 | assert.strictEqual(get(obj1, "nested.notDefined"),
|
90 | obj1.nested.notDefined);
|
91 | });
|
92 |
|
93 | it(`get(obj1, "notDefined.notDefined") === undefinded`, function() {
|
94 | assert.strictEqual(get(obj1, "notDefined.notDefined"),
|
95 | undefined);
|
96 | });
|
97 |
|
98 | });
|
99 |
|
100 | describe('_isEnvKey', function() {
|
101 | it('db', function() {
|
102 | assert.strictEqual(_isEnvKey('db'), false);
|
103 | });
|
104 |
|
105 | it('db+TEST', function() {
|
106 | assert.strictEqual(_isEnvKey('db+TEST'), true);
|
107 | });
|
108 |
|
109 | it('db+TEST=someValue', function() {
|
110 | assert.strictEqual(_isEnvKey('db+TEST=someValue'), true);
|
111 | });
|
112 |
|
113 | it('db+TEST+NODE_ENV=staging', function() {
|
114 | assert.strictEqual(_isEnvKey('db+TEST+NODE_ENV=staging'), true);
|
115 | });
|
116 |
|
117 | it('db+TEST=someValue+NODE_ENV=staging', function() {
|
118 | assert.strictEqual(_isEnvKey('db+TEST=someValue+NODE_ENV=staging'), true);
|
119 | });
|
120 | });
|
121 |
|
122 | describe('_parseKey', function() {
|
123 | let saved = Object.create(null);
|
124 | saved.NODE_ENV = process.env.NODE_ENV;
|
125 | saved.TEST = process.env.TEST;
|
126 |
|
127 | beforeEach(function() {
|
128 | process.env.NODE_ENV = 'development';
|
129 | process.env.TEST = 'hubbub';
|
130 | });
|
131 |
|
132 | it('db+TEST', function() {
|
133 | let result = _parseKey('db+TEST');
|
134 | assert.strictEqual(result.$ok, true, '!$ok');
|
135 | assert.strictEqual(result.$key, 'db+TEST');
|
136 | assert.strictEqual(result.$base, 'db');
|
137 | assert.strictEqual(result.$env.TEST, 'hubbub');
|
138 |
|
139 | delete process.env.TEST;
|
140 | result = _parseKey('db+TEST');
|
141 | assert.strictEqual(result.$ok, false, "delete process.env.TEST");
|
142 | assert.strictEqual(result.$key, 'db+TEST');
|
143 | assert.strictEqual(result.$base, 'db');
|
144 | assert.strictEqual(result.$env.TEST, undefined);
|
145 | });
|
146 |
|
147 | it('db+TEST=someValue', function() {
|
148 | let result = _parseKey('db+TEST=someValue');
|
149 | assert.strictEqual(result.$ok, false);
|
150 | assert.strictEqual(result.$key, 'db+TEST=someValue');
|
151 | assert.strictEqual(result.$base, 'db');
|
152 | assert.strictEqual(result.$env.TEST, "someValue");
|
153 |
|
154 | process.env.TEST = "someValue";
|
155 | result = _parseKey('db+TEST=someValue');
|
156 | assert.strictEqual(result.$ok, true);
|
157 | assert.strictEqual(result.$key, 'db+TEST=someValue');
|
158 | assert.strictEqual(result.$base, 'db');
|
159 | assert.strictEqual(result.$env.TEST, "someValue");
|
160 | });
|
161 |
|
162 | it('db+TEST+NODE_ENV=staging', function() {
|
163 | let result = _parseKey('db+TEST+NODE_ENV=staging');
|
164 | assert.strictEqual(result.$ok, false);
|
165 | assert.strictEqual(result.$key, 'db+TEST+NODE_ENV=staging');
|
166 | assert.strictEqual(result.$base, 'db');
|
167 | assert.strictEqual(result.$env.TEST, "hubbub");
|
168 | assert.strictEqual(result.$env.NODE_ENV, "staging");
|
169 |
|
170 | process.env.NODE_ENV = "staging";
|
171 | result = _parseKey('db+TEST+NODE_ENV=staging');
|
172 | assert.strictEqual(result.$ok, true);
|
173 | assert.strictEqual(result.$key, 'db+TEST+NODE_ENV=staging');
|
174 | assert.strictEqual(result.$base, 'db');
|
175 | assert.strictEqual(result.$env.TEST, "hubbub");
|
176 | assert.strictEqual(result.$env.NODE_ENV, "staging");
|
177 | });
|
178 |
|
179 | it('db+TEST+NODE_ENV=development', function() {
|
180 | let result = _parseKey('db+TEST+NODE_ENV=development');
|
181 | assert.strictEqual(result.$ok, true);
|
182 | assert.strictEqual(result.$key, 'db+TEST+NODE_ENV=development');
|
183 | assert.strictEqual(result.$base, 'db');
|
184 | assert.strictEqual(result.$env.TEST, "hubbub");
|
185 | assert.strictEqual(result.$env.NODE_ENV, "development");
|
186 |
|
187 | result = _parseKey('db+TEST+NODE_ENV');
|
188 | assert.strictEqual(result.$ok, true);
|
189 | assert.strictEqual(result.$key, 'db+TEST+NODE_ENV');
|
190 | assert.strictEqual(result.$base, 'db');
|
191 | assert.strictEqual(result.$env.TEST, "hubbub");
|
192 | assert.strictEqual(result.$env.NODE_ENV, "development");
|
193 | });
|
194 |
|
195 | after(function() {
|
196 | process.env.NODE_ENV = saved.NODE_ENV;
|
197 | process.env.TEST = saved.TEST;
|
198 | });
|
199 | });
|
200 |
|
201 | describe('_isValueType', function() {
|
202 | it('boolean', function() {
|
203 | assert.strictEqual(_isValueType(true), true);
|
204 | });
|
205 |
|
206 | it('number', function() {
|
207 | assert.strictEqual(_isValueType(3.17), true);
|
208 | });
|
209 |
|
210 | it('string', function() {
|
211 | assert.strictEqual(_isValueType("string"), true);
|
212 | });
|
213 |
|
214 | it('null', function() {
|
215 | assert.strictEqual(_isValueType(null), true);
|
216 | });
|
217 |
|
218 | it('undefined', function() {
|
219 | assert.strictEqual(_isValueType(undefined), true);
|
220 | });
|
221 |
|
222 | it('symbol', function() {
|
223 | assert.strictEqual(_isValueType(Symbol("uhh")), true);
|
224 | });
|
225 |
|
226 | it('!object', function() {
|
227 | assert.strictEqual(_isValueType({}), false);
|
228 | });
|
229 |
|
230 | it('!function', function() {
|
231 | assert.strictEqual(_isValueType(() => { return "hello"}), false);
|
232 | assert.strictEqual(_isValueType(function() { return "hello"}), false);
|
233 | });
|
234 | });
|
235 |
|
236 | describe('_defaultMerge', function() {
|
237 | it('Object.create(null) as target', function() {
|
238 | let target = Object.create(null), source = { cool: "beans" };
|
239 | let merged = _defaultMerge(target, source);
|
240 |
|
241 | assert.equal(merged, target);
|
242 | assert.strictEqual(merged.cool, source.cool);
|
243 | assert.notEqual(merged, source);
|
244 | });
|
245 |
|
246 | it('target as a value type', function() {
|
247 | let obj2 = { a: 0 };
|
248 | let merged = _defaultMerge(5, obj2);
|
249 |
|
250 | assert.notEqual(merged, obj2);
|
251 | assert.notStrictEqual(merged, 5);
|
252 | assert.strictEqual(merged.a, obj2.a);
|
253 | });
|
254 |
|
255 | it('source as a value type', function() {
|
256 | let target = { a: 5}, source = 5;
|
257 | let merged = _defaultMerge(target, source);
|
258 |
|
259 | assert.strictEqual(merged, source);
|
260 | assert.strictEqual(typeof merged, 'number');
|
261 | assert.strictEqual(typeof target, 'object');
|
262 | assert.strictEqual(source, 5);
|
263 | });
|
264 |
|
265 | it('source as an array', function() {
|
266 | let target = { a: 5}, source = ["one", { two: "two"}, "three", [4]];
|
267 | let merged = _defaultMerge(target, source);
|
268 |
|
269 | assert.strictEqual(merged.length, 4);
|
270 | assert.strictEqual(merged[0], "one");
|
271 | assert.strictEqual(merged[1].two, "two");
|
272 | assert.strictEqual(merged[3][0], 4);
|
273 | });
|
274 | });
|
275 |
|
276 | describe('_getMerger', function() {
|
277 | it('', function() {
|
278 |
|
279 | });
|
280 | });
|
281 |
|
282 | describe('clone', function() {
|
283 | it('value types', function() {
|
284 | let b = true, n = 3, s = "hello", x = null, sy = Symbol("yep");
|
285 | let cb = clone(b),
|
286 | cn = clone(n),
|
287 | cs = clone(s),
|
288 | cx = clone(x),
|
289 | csy = clone(sy);
|
290 |
|
291 | assert.strictEqual(cb, b);
|
292 | assert.strictEqual(cn, n);
|
293 | assert.strictEqual(cs, s);
|
294 | assert.strictEqual(cx, x);
|
295 | assert.strictEqual(csy, sy);
|
296 | });
|
297 |
|
298 |
|
299 |
|
300 | it('objects', function() {
|
301 | let sy = Symbol('sy');
|
302 | let fn = () => {return "world"};
|
303 | fn.x = 200;
|
304 | fn.y = 500;
|
305 | let obj = { b: true, n: 4, s: "hello", x: null, sy: sy, a: [true, 4, "hello", null, Symbol('ello')], o: {b: true, n: 4, s: "hello", x: null, sy: Symbol("sy")}, fn: fn};
|
306 | let copy = clone(obj);
|
307 |
|
308 | assert.notEqual(copy, obj);
|
309 | assert.strictEqual(Object.keys(copy).length, 8);
|
310 | assert.strictEqual(Object.keys(obj).length, 8);
|
311 |
|
312 | assert.strictEqual(Array.isArray(obj.a), Array.isArray(copy.a));
|
313 | assert.strictEqual(copy.a.length, 5);
|
314 | assert.strictEqual(copy.a.length, obj.a.length);
|
315 | for(let i = 0; i < copy.a.length; i++) {
|
316 | assert.strictEqual(copy.a[i], obj.a[i]);
|
317 | }
|
318 |
|
319 | assert.strictEqual(copy.b, obj.b);
|
320 |
|
321 | assert.strictEqual(copy.n, 4);
|
322 | assert.strictEqual(copy.n, obj.n);
|
323 |
|
324 | assert.strictEqual(copy.s, "hello");
|
325 | assert.strictEqual(copy.s, obj.s);
|
326 |
|
327 | assert.strictEqual(copy.x, null);
|
328 | assert.strictEqual(copy.x, obj.x);
|
329 |
|
330 | assert.strictEqual(copy.sy, sy);
|
331 | assert.strictEqual(copy.sy, obj.sy);
|
332 |
|
333 | assert.notEqual(copy.o, obj.o);
|
334 | assert.strictEqual(Object.keys(copy.o).length, 5);
|
335 | assert.strictEqual(Object.keys(copy.o).length, Object.keys(obj.o).length);
|
336 | assert.strictEqual(copy.o.b, true);
|
337 | assert.strictEqual(copy.o.b, obj.o.b);
|
338 | assert.strictEqual(copy.o.n, 4);
|
339 | assert.strictEqual(copy.o.n, obj.o.n);
|
340 | assert.strictEqual(copy.o.s, "hello");
|
341 | assert.strictEqual(copy.o.s, obj.o.s);
|
342 | assert.strictEqual(copy.o.x, null);
|
343 | assert.strictEqual(copy.o.x, obj.o.x);
|
344 | assert.strictEqual(copy.o.y, undefined);
|
345 | assert.strictEqual(copy.o.y, undefined);
|
346 | assert.strictEqual(copy.o.sy, obj.o.sy);
|
347 |
|
348 |
|
349 |
|
350 | assert.strictEqual(Object.keys(copy.fn).length, 2);
|
351 | assert.strictEqual(copy.fn.x, obj.fn.x);
|
352 | assert.strictEqual(copy.fn.y, obj.fn.y);
|
353 | });
|
354 |
|
355 |
|
356 | });
|
357 |
|
358 | describe('compress', function() {
|
359 | let testObj = {
|
360 | "a": "error", "a+TEST": "ok",
|
361 | "b": "ok", "b+NODE_ENV=staging": "error",
|
362 | "c": "error", "c+NODE_ENV=development": "ok",
|
363 | "d": { "a": "error", "b": "ok"}, "d+TEST": { "a": "ok"},
|
364 | "e": { "a": "ok", "b": "ok"}, "e+NODE_ENV=staging": { "a": "error", "b": "error", "c": "error"},
|
365 | "f": "ok", "f+TEST": null,
|
366 | "g": null, "g+TEST": "ok",
|
367 | "h": {"f": "ok", "g": null}, "h+TEST": {"f+TEST": null, "g+TEST": "ok"}
|
368 | };
|
369 | let compressed = compress(testObj);
|
370 |
|
371 | it('shallow compress', function() {
|
372 | assert.strictEqual(compressed.a, "ok");
|
373 | assert.strictEqual(compressed.b, "ok");
|
374 | assert.strictEqual(compressed.c, "ok");
|
375 | });
|
376 |
|
377 | it('Object Object', function() {
|
378 | assert.strictEqual(compressed.d.a, "ok");
|
379 | assert.strictEqual(compressed.d.b, "ok");
|
380 | assert.strictEqual(Object.keys(compressed.d).length, 2);
|
381 |
|
382 | assert.strictEqual(compressed.e.a, "ok");
|
383 | assert.strictEqual(compressed.e.b, "ok");
|
384 | assert.strictEqual(Object.keys(compressed.e).length, 2);
|
385 | });
|
386 |
|
387 | it('with null(s)', function() {
|
388 | assert.strictEqual(compressed.f, "ok");
|
389 | assert.strictEqual(compressed.g, "ok");
|
390 | });
|
391 |
|
392 | it('nested null(s)', function() {
|
393 | assert.strictEqual(compressed.h.f, "ok", `'f': error`);
|
394 | assert.strictEqual(compressed.h.g, "ok", "'g': error");
|
395 | });
|
396 | });
|
397 |
|
398 | describe('merge', function() {
|
399 | let target = {};
|
400 | let merged = merge(target, obj1, obj2);
|
401 |
|
402 | it('merged object should equal first arg', function() {
|
403 | assert.equal(merged, target);
|
404 | assert.notEqual(merged, obj1);
|
405 | assert.notEqual(merged, obj2);
|
406 | });
|
407 |
|
408 | it(`obj.username === ${merged.username}`, function() {
|
409 | assert.strictEqual(merged.username, "admin");
|
410 | });
|
411 |
|
412 | it(`obj.password === ${merged.password}`, function() {
|
413 | assert.strictEqual(merged.password, null);
|
414 | });
|
415 |
|
416 | it(`obj.host === ${merged.host}`, function() {
|
417 | assert.strictEqual(merged.host, null);
|
418 | });
|
419 |
|
420 | it(`obj.port === ${merged.port}`, function() {
|
421 | assert.strictEqual(merged.port, undefined);
|
422 | });
|
423 |
|
424 | });
|
425 | }); |
\ | No newline at end of file |