UNPKG

14.4 kBJavaScriptView Raw
1const 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 // TODO: arrays
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 // a
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 // b
319 assert.strictEqual(copy.b, obj.b);
320 // n
321 assert.strictEqual(copy.n, 4);
322 assert.strictEqual(copy.n, obj.n);
323 // s
324 assert.strictEqual(copy.s, "hello");
325 assert.strictEqual(copy.s, obj.s);
326 // x
327 assert.strictEqual(copy.x, null);
328 assert.strictEqual(copy.x, obj.x);
329 // sy
330 assert.strictEqual(copy.sy, sy);
331 assert.strictEqual(copy.sy, obj.sy);
332 // o
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 // fn
348 // Note: functions are no longer cloned into objects
349 // assert.strictEqual(typeof copy.fn, 'object');
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 // TODO: functions and arrow functions
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