@@ -8,6 +8,76 @@ test('assign own enumerable propreties from source to target object', t => {
8 8
t.end();
9 9
});
10 10 11 +
test('do not assign null values', t => {
12 +
t.same(fn({}, {foo: null}), {});
13 +
t.end();
14 +
});
15 + 16 +
test('assign values to null targets', t => {
17 +
t.same(fn({foo: null}, {foo: {}}), {foo: {}});
18 +
t.end();
19 +
});
20 + 21 +
test('do not assign undefined values', t => {
22 +
t.same(fn({}, {foo: undefined}), {});
23 +
t.end();
24 +
});
25 + 26 +
test('assign values to undefined targets', t => {
27 +
t.same(fn({foo: undefined}, {foo: {}}), {foo: {}});
28 +
t.end();
29 +
});
30 + 31 +
test('support numbers as targets', t => {
32 +
var target = fn({answer: 42}, {answer: {rainbows: 'many'}});
33 +
t.is(target.answer / 7, 6);
34 +
t.is(target.answer.constructor, Number);
35 +
t.is(target.answer.rainbows, 'many');
36 +
t.end();
37 +
});
38 + 39 +
test('support boolean as targets', t => {
40 +
var target = fn({foo: true}, {foo: {rainbows: 'many'}});
41 +
t.is(target.foo.toString(), 'true');
42 +
t.is(target.foo.constructor, Boolean);
43 +
t.is(target.foo.rainbows, 'many');
44 +
t.end();
45 +
});
46 + 47 +
test('support strings as targets', t => {
48 +
var target = fn({rainbows: 'many'}, {rainbows: {answer: 42}});
49 +
t.is('' + target.rainbows, 'many');
50 +
t.is(target.rainbows.constructor, String);
51 +
t.is(target.rainbows.answer, 42);
52 +
t.end();
53 +
});
54 + 55 +
test('support arrays as targets', t => {
56 +
var target = {a: ['many']};
57 +
var source = {a: []};
58 +
source.a[2] = 'unicorns';
59 +
fn(target, source, {a: {answer: 42}});
60 +
t.is(target.a[0], 'many');
61 +
t.is(target.a[1], undefined);
62 +
t.is(target.a[2], 'unicorns');
63 +
t.is(target.a.constructor, Array);
64 +
t.is(target.a.answer, 42);
65 +
t.end();
66 +
});
67 + 68 +
test('support functions', t => {
69 +
var oracle42 = () => 42;
70 +
var oracle666 = () => 666;
71 +
oracle42.foo = true;
72 +
oracle42.bar = true;
73 +
oracle666.bar = false;
74 +
var target = fn({}, {oracle: oracle42}, {oracle: oracle666});
75 +
t.is(target.oracle(), 42);
76 +
t.is(target.oracle.foo, true);
77 +
t.is(target.oracle.bar, false);
78 +
t.end();
79 +
});
80 + 11 81
test('support multiple sources', t => {
12 82
t.same(fn({foo: 0}, {bar: 1}, {bar: 2}), {foo: 0, bar: 2});
13 83
t.same(fn({}, {}, {foo: 1}), {foo: 1});
@@ -93,6 +163,13 @@ if (typeof Symbol !== 'undefined') {
93 163
t.end();
94 164
});
95 165 166 +
test('support symbols as targets', t => {
167 +
var target = fn({sym: Symbol('foo')}, {sym: {rainbows: 'many'}});
168 +
t.is(target.sym.constructor, Symbol);
169 +
t.is(target.sym.rainbows, 'many');
170 +
t.end();
171 +
});
172 + 96 173
test('only copy enumerable symbols', t => {
97 174
var target = {};
98 175
var source = {};
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4