Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
import { expect } from 'chai';
import utils from '../../../src/core/utils';
import optionAPI from '../../../src/api/option';
/* global describe, it */
describe('Utils', () => {
describe('hasProperties function', () => {
const bigObject = {
some: 'keys',
existing: 'on',
the: 'object',
};
const smallObject = {
some: 'keys',
};
it('should return true when one key being checked', () => {
expect(utils.hasProperties(bigObject, 'some')).to.eql(true);
expect(utils.hasProperties(bigObject, 'existing')).to.eql(true);
expect(utils.hasProperties(bigObject, 'the')).to.eql(true);
expect(utils.hasProperties(smallObject, 'some')).to.eql(true);
});
it('should return true when all keys being checked', () => {
expect(utils.hasProperties(bigObject, 'some', 'existing', 'the')).to.eql(true);
expect(utils.hasProperties(smallObject, 'some', 'existing', 'the')).to.eql(true);
});
it('should return false when no keys exist on object', () => {
expect(utils.hasProperties(bigObject, 'different')).to.eql(false);
expect(utils.hasProperties(smallObject, 'different')).to.eql(false);
});
});
describe('getSubAttribute function', () => {
const object = {
outer: {
inner: {
key: 'value',
},
},
};
it('should return a leaf if chain is long enough', () => {
expect(utils.getSubAttribute(object, 'outer.inner.key')).to.eql('value');
expect(utils.getSubAttribute(object, 'outer.inner.key.help.me')).to.eql('value');
});
it('should return a subobject if the chain doesn\'t reach a leaf (is shorter)', () => {
expect(utils.getSubAttribute(object, 'outer.inner')).to.eql({ key: 'value' });
});
it('should return a subobject of the valid chain part (and ignore the invalid chain part)', () => {
expect(utils.getSubAttribute(object, 'outer.help.me')).to.eql({ inner: { key: 'value' } });
expect(utils.getSubAttribute(object, 'help.me')).to.eql(object);
});
});
describe('typecast function', () => {
it('should normalize constraints and format final values', () => {
utils.typecast(null, {}, opts => {
expect(opts).to.eql({});
});
const schema = {
type: 'integer',
enum: [1, 2, 3],
minimum: 2,
};
utils.typecast(null, schema, opts => {
expect(schema.enum).to.eql([2, 3]);
expect(opts).to.eql({ minimum: 2 });
});
});
it('should normalize constraints with global options', () => {
optionAPI({
maxLength: 4,
});
utils.typecast(null, {
type: 'string',
maxLength: 10,
}, opts => {
expect(opts).to.eql({ maxLength: 4 });
});
});
it('should accept custom types for typecasting', () => {
optionAPI({
maxLength: 5,
});
utils.typecast('string', {
maxLength: 10,
}, opts => {
expect(opts).to.eql({ maxLength: 5 });
});
});
});
describe('clone function', () => {
it('should handle circular refs in objects', () => {
const a = {};
const b = {
a,
};
a.b = b;
const clone = utils.clone(a);
expect(clone.b.a).to.eql(clone);
});
it('should handle circular refs in arrays', () => {
const a = [];
const b = [a];
a.push(b);
const clone = utils.clone(a);
expect(clone[0][0]).to.eql(clone);
});
});