/
index.js
108 lines (93 loc) · 3.77 KB
/
index.js
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
104
105
106
107
108
import { h, render } from 'preact';
import 'preact-jsx-chai';
import Provider, { MergingProvider, provide, mergingProvide } from 'preact-context-provider';
describe('preact-context-provider', () => {
let scratch = document.createElement('div'),
mount = jsx => root = render(jsx, scratch, root),
context = { a: { name: 'a' }, b: 'b' },
Spy,
root;
beforeEach( () => {
mount(h(() => null));
Spy = sinon.spy();
scratch.innerHTML = '';
});
describe('<Provider />', () => {
it('should be a function', () => {
expect(Provider).to.be.a('function');
});
it('should expose props into context', () => {
mount(<Provider {...context}><Spy /></Provider>);
expect(Spy).to.have.been.calledOnce.and.calledWith({ children: [] }, context);
});
it('should overwrite higher context keys', () => {
mount(
<Provider {...context}>
<Provider a="overwrittenA" >
<Spy />
</Provider>
</Provider>);
expect(Spy).to.have.been.calledOnce.and.calledWith({ children: [] }, { a: 'overwrittenA', b: 'b' });
});
});
describe('<MergingProvider />', () => {
it('should deep merge with higher context keys, giving them precendence, when mergeProps is unset', () => {
mount(
<MergingProvider {...context}>
<MergingProvider a={{ name: 'notOverwrittenNameA', newProp: 'c' }} b="newB">
<Spy />
</MergingProvider>
</MergingProvider>);
expect(Spy).to.have.been.calledOnce.and.calledWith({ children: [] },
{ a: { name: 'a', newProp: 'c' }, b: 'b' });
});
it('should deep merge with higher context keys, giving them precendence, when mergeProps is true', () => {
mount(
<MergingProvider {...context}>
<MergingProvider mergeProps a={{ name: 'notOverwrittenNameA', newProp: 'c' }} b="newB">
<Spy />
</MergingProvider>
</MergingProvider>);
expect(Spy).to.have.been.calledOnce.and.calledWith({ children: [] },
{ a: { name: 'a', newProp: 'c' }, b: 'b' });
});
it('should deep merge with selected higher context keys, giving them precendence, when mergeProps is an array', () => {
mount(
<MergingProvider a={{ name: 'a' }} b={{ name: 'b' }} >
<MergingProvider mergeProps={['a']} a={{ name: 'notOverwrittenNameA', newProp: 'c' }} b={{ newProp: 'd' }} >
<Spy />
</MergingProvider>
</MergingProvider>);
expect(Spy).to.have.been.calledOnce.and.calledWith({ children: [] },
{ a: { name: 'a', newProp: 'c' }, b: { newProp: 'd' } });
});
it('should allow parent to prevent child value from merging by using null value for a key', () => {
mount(
<MergingProvider a={null} b={{ name: 'b' }} >
<MergingProvider mergeProps a={{ name: 'a', newProp: 'c' }} b={{ newProp: 'd' }} >
<Spy />
</MergingProvider>
</MergingProvider>);
expect(Spy).to.have.been.calledOnce.and.calledWith({ children: [] },
{ a: null, b: { name: 'b', newProp: 'd' } });
});
});
describe('provide()', () => {
it('should be a function', () => {
expect(provide).to.be.a('function');
});
it('should wrap a child with a <Provider> tag with the supplied context, and pass through any props to the child after wrapped', () => {
let ProvidedSpy = provide(context)(Spy);
expect(<ProvidedSpy foo="bar" />).to.equal(<Provider a={{ name: 'a' }} b="b"><Spy foo="bar" /></Provider>);
});
});
describe('mergingProvide()', () => {
it('should be a function', () => {
expect(mergingProvide).to.be.a('function');
});
it('should wrap a child with a <MergingProvider> tag with the supplied context, and pass through any props to the child after wrapped', () => {
let MergingProvidedSpy = mergingProvide({ ...context, mergeProps: true })(Spy);
expect(<MergingProvidedSpy foo="bar" />).to.equal(<MergingProvider a={{ name: 'a' }} b="b" mergeProps><Spy foo="bar" /></MergingProvider>);
});
});
});