esp-js-react 8.0.1-next.0 → 8.0.3-next.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.dist/esp-react.js +68 -104
- package/.dist/esp-react.js.map +1 -1
- package/.dist/esp-react.min.js +1 -1
- package/.dist/esp-react.min.js.map +1 -1
- package/.dist/typings/connect.d.ts +2 -6
- package/.dist/typings/connectableComponent.d.ts +0 -16
- package/.dist/typings/espModelContextProvider.d.ts +24 -7
- package/.dist/typings/espRouterContextProvider.d.ts +5 -5
- package/.dist/typings/index.d.ts +2 -3
- package/.dist/typings/polimer/getEspPolimerImmutableModel.d.ts +21 -0
- package/.dist/typings/useModelSelector.d.ts +25 -1
- package/.dist/typings/viewBinder.d.ts +8 -1
- package/.dist/typings/viewBindingDecorator.d.ts +1 -1
- package/package.json +4 -4
- package/src/connect.tsx +2 -6
- package/src/connectableComponent.tsx +2 -19
- package/src/espModelContextProvider.tsx +26 -9
- package/src/espRouterContextProvider.tsx +5 -5
- package/src/index.ts +5 -9
- package/src/polimer/getEspPolimerImmutableModel.ts +50 -0
- package/src/useModelSelector.ts +31 -7
- package/src/viewBinder.tsx +13 -2
- package/src/viewBindingDecorator.ts +2 -2
- package/tests/connectableComponentTests.tsx +496 -0
- package/tests/espModelContextProviderTests.tsx +142 -0
- package/tests/espRouterContextProviderTests.tsx +54 -0
- package/tests/indexTests.ts +24 -91
- package/tests/testApi/asserts.ts +90 -0
- package/tests/testApi/testApi.tsx +100 -0
- package/tests/testApi/testModel.ts +44 -0
- package/tests/testApi/useStoreReceivedProps.ts +14 -0
- package/tests/testApi/viewFactory.tsx +31 -0
- package/tests/useModelSelectorTests.tsx +47 -153
- package/tests/viewBinderTests.tsx +61 -0
- package/.dist/typings/polimer/getEspReactRenderModel.d.ts +0 -21
- package/.dist/typings/viewBinderConnectable.d.ts +0 -15
- package/src/polimer/getEspReactRenderModel.ts +0 -50
- package/src/viewBinderConnectable.tsx +0 -54
- package/tests/connectableComponentLegacyTests.tsx +0 -405
- /package/.dist/typings/polimer/{polimerExtentsions.d.ts → polimerModelBuilderExtentsions.d.ts} +0 -0
- /package/src/polimer/{polimerExtentsions.ts → polimerModelBuilderExtentsions.ts} +0 -0
- /package/tests/{routerSpy.ts → testApi/routerSpy.ts} +0 -0
|
@@ -0,0 +1,496 @@
|
|
|
1
|
+
import 'jest';
|
|
2
|
+
import * as React from 'react';
|
|
3
|
+
import {act} from 'react';
|
|
4
|
+
import {
|
|
5
|
+
connect,
|
|
6
|
+
ConnectableComponent,
|
|
7
|
+
ConnectableComponentProps,
|
|
8
|
+
getEspPolimerImmutableModel,
|
|
9
|
+
PublishModelEventDelegate,
|
|
10
|
+
viewBinding,
|
|
11
|
+
MapModelToProps,
|
|
12
|
+
CreatePublishEventProps,
|
|
13
|
+
GetEspPolimerImmutableModelConsts,
|
|
14
|
+
} from '../src';
|
|
15
|
+
import {testApi, TestApi} from './testApi/testApi';
|
|
16
|
+
import {observeEvent} from 'esp-js';
|
|
17
|
+
import {viewFactory} from './testApi/viewFactory';
|
|
18
|
+
|
|
19
|
+
interface MappedModel {
|
|
20
|
+
value: string;
|
|
21
|
+
value2: string;
|
|
22
|
+
value3: string;
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
@viewBinding(viewFactory('View1'))
|
|
26
|
+
@viewBinding(viewFactory('View3'), 'alternative-view-context')
|
|
27
|
+
class TestModel {
|
|
28
|
+
public value: string;
|
|
29
|
+
|
|
30
|
+
constructor() {
|
|
31
|
+
this.value = 'initial-value';
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
@observeEvent('test-event')
|
|
35
|
+
_onTestEvent(ev: string) {
|
|
36
|
+
this.value = ev;
|
|
37
|
+
}
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
class TestModel2 extends TestModel {
|
|
41
|
+
@getEspPolimerImmutableModel()
|
|
42
|
+
_getOtherState() {
|
|
43
|
+
return {
|
|
44
|
+
value: this.value,
|
|
45
|
+
value2: this.value,
|
|
46
|
+
value3: 'value-3'
|
|
47
|
+
} as MappedModel;
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
class TestModel3 extends TestModel {
|
|
52
|
+
[GetEspPolimerImmutableModelConsts.HandlerFunctionName] = () => {
|
|
53
|
+
return {
|
|
54
|
+
value: this.value,
|
|
55
|
+
foo: 'the-foo'
|
|
56
|
+
};
|
|
57
|
+
};
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
interface ConnectedComponentElementCreationProperties {
|
|
61
|
+
modelId: string;
|
|
62
|
+
useConnectFunction?: boolean;
|
|
63
|
+
useMapModelToProps?: boolean;
|
|
64
|
+
useCreatePublishEventProps?: boolean;
|
|
65
|
+
useAlternativeViewContext?: boolean;
|
|
66
|
+
passOtherProps?: boolean;
|
|
67
|
+
useImmutableModelSelectorDecorator?: boolean;
|
|
68
|
+
useImmutableModelSelectorFunction?: boolean;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
describe('ConnectableComponentTests', () => {
|
|
72
|
+
let api: TestApi,
|
|
73
|
+
testModel: TestModel,
|
|
74
|
+
testModel2: TestModel2,
|
|
75
|
+
testModel3: TestModel3;
|
|
76
|
+
|
|
77
|
+
beforeEach(() => {
|
|
78
|
+
api = testApi();
|
|
79
|
+
testModel = new TestModel();
|
|
80
|
+
testModel2 = new TestModel2();
|
|
81
|
+
testModel3 = new TestModel3();
|
|
82
|
+
api.setupModel('model-id1', testModel);
|
|
83
|
+
api.setupModel('model-id2', testModel2);
|
|
84
|
+
api.setupModel('model-id3', testModel3);
|
|
85
|
+
});
|
|
86
|
+
|
|
87
|
+
const createConnectedComponentElement = (options: ConnectedComponentElementCreationProperties): React.JSX.Element => {
|
|
88
|
+
// Refactor note:
|
|
89
|
+
// These tests were ported from some very old Enzime based tests.
|
|
90
|
+
// They have been cleaned up quite a bit.
|
|
91
|
+
// The next step in the cleanup would be to largely eliminate the option parameter.
|
|
92
|
+
// It makes sense to have a function that returns the thing to render,
|
|
93
|
+
// however, having an 'options' object just binds/funnels all the tests into one confusing API.
|
|
94
|
+
// It'd be best to take a Partial<ConnectableComponentProps> and have more localized `beforeEach` calls invoke function this using new structure.
|
|
95
|
+
let connectableComponentProps: ConnectableComponentProps<TestModel> = {
|
|
96
|
+
modelId: options.modelId
|
|
97
|
+
};
|
|
98
|
+
let mapModelToProps: MapModelToProps<any, any, any>;
|
|
99
|
+
let createPublishEventProps: CreatePublishEventProps<any>;
|
|
100
|
+
const otherProps = {other1: 'other-value'};
|
|
101
|
+
let publishEventProps: { publishEvent1: () => void };
|
|
102
|
+
let userAlternativeViewContext: string;
|
|
103
|
+
if (options.useMapModelToProps) {
|
|
104
|
+
mapModelToProps = (model: TestModel | MappedModel, publishEventProps2: any) => {
|
|
105
|
+
return {
|
|
106
|
+
foo: model.value,
|
|
107
|
+
publishEventPropsPassedMapModelToProps: publishEventProps2 && typeof publishEventProps2.publishEvent1 === 'function',
|
|
108
|
+
...model
|
|
109
|
+
};
|
|
110
|
+
};
|
|
111
|
+
}
|
|
112
|
+
if (options.useCreatePublishEventProps) {
|
|
113
|
+
publishEventProps = {
|
|
114
|
+
publishEvent1: () => {
|
|
115
|
+
}
|
|
116
|
+
};
|
|
117
|
+
createPublishEventProps = (publishEvent: PublishModelEventDelegate) => publishEventProps;
|
|
118
|
+
}
|
|
119
|
+
if (options.useAlternativeViewContext) {
|
|
120
|
+
userAlternativeViewContext = 'alternative-view-context';
|
|
121
|
+
}
|
|
122
|
+
let viewElement: React.JSX.Element;
|
|
123
|
+
if (options.useConnectFunction) {
|
|
124
|
+
const TestModelView2ConnectedComponent = connect(
|
|
125
|
+
mapModelToProps,
|
|
126
|
+
createPublishEventProps
|
|
127
|
+
)(viewFactory('View2'));
|
|
128
|
+
viewElement = (<TestModelView2ConnectedComponent {...otherProps} {...connectableComponentProps}/>);
|
|
129
|
+
} else {
|
|
130
|
+
viewElement = (
|
|
131
|
+
<ConnectableComponent
|
|
132
|
+
{...connectableComponentProps}
|
|
133
|
+
mapModelToProps={mapModelToProps}
|
|
134
|
+
viewContext={userAlternativeViewContext}
|
|
135
|
+
{...otherProps}
|
|
136
|
+
/>
|
|
137
|
+
);
|
|
138
|
+
}
|
|
139
|
+
return viewElement;
|
|
140
|
+
};
|
|
141
|
+
|
|
142
|
+
const publishTestEvent = (modelId: string, eventData: string) => {
|
|
143
|
+
act(() => {
|
|
144
|
+
api.router.publishEvent(modelId, 'test-event', eventData);
|
|
145
|
+
});
|
|
146
|
+
};
|
|
147
|
+
|
|
148
|
+
describe('ConnectableComponent via connect()', () => {
|
|
149
|
+
beforeEach(() => {
|
|
150
|
+
let elementCreationProperties: ConnectedComponentElementCreationProperties = {
|
|
151
|
+
modelId: 'model-id1',
|
|
152
|
+
useConnectFunction: true,
|
|
153
|
+
useMapModelToProps: true,
|
|
154
|
+
useCreatePublishEventProps: true
|
|
155
|
+
};
|
|
156
|
+
api.doRender(
|
|
157
|
+
createConnectedComponentElement(elementCreationProperties),
|
|
158
|
+
elementCreationProperties.modelId
|
|
159
|
+
);
|
|
160
|
+
});
|
|
161
|
+
|
|
162
|
+
it('Renders the view provided to connect', () => {
|
|
163
|
+
api.asserts.view.viewNameElementTextIs('View2');
|
|
164
|
+
});
|
|
165
|
+
|
|
166
|
+
describe('Child view props', () => {
|
|
167
|
+
|
|
168
|
+
it('renders only once', () => {
|
|
169
|
+
api.asserts.props
|
|
170
|
+
.receivedPropCountIs(1);
|
|
171
|
+
});
|
|
172
|
+
|
|
173
|
+
it('passes mapped props', () => {
|
|
174
|
+
api.asserts.props
|
|
175
|
+
.propAtIndex(
|
|
176
|
+
0,
|
|
177
|
+
props => {
|
|
178
|
+
expect(props.foo).toBe('initial-value');
|
|
179
|
+
}
|
|
180
|
+
);
|
|
181
|
+
});
|
|
182
|
+
|
|
183
|
+
it('passes results of publishEventProps to mapModelToProps', () => {
|
|
184
|
+
api.asserts.props
|
|
185
|
+
.propAtIndex(
|
|
186
|
+
0,
|
|
187
|
+
props => {
|
|
188
|
+
expect(props.publishEventPropsPassedMapModelToProps).toBeTruthy();
|
|
189
|
+
}
|
|
190
|
+
);
|
|
191
|
+
});
|
|
192
|
+
|
|
193
|
+
it('passes model', () => {
|
|
194
|
+
api.asserts.props
|
|
195
|
+
.propAtIndex(
|
|
196
|
+
0,
|
|
197
|
+
props => {
|
|
198
|
+
expect(props.model).toBeDefined();
|
|
199
|
+
expect(props.model instanceof TestModel).toBeTruthy();
|
|
200
|
+
}
|
|
201
|
+
);
|
|
202
|
+
});
|
|
203
|
+
|
|
204
|
+
it('flattens and passes results of createPublishEventProps', () => {
|
|
205
|
+
api.asserts.props
|
|
206
|
+
.receivedPropCountIs(1)
|
|
207
|
+
.propAtIndex(
|
|
208
|
+
0,
|
|
209
|
+
props => {
|
|
210
|
+
expect(props.publishEvent1).toBeDefined();
|
|
211
|
+
expect(typeof props.publishEvent1).toBe('function');
|
|
212
|
+
}
|
|
213
|
+
);
|
|
214
|
+
});
|
|
215
|
+
|
|
216
|
+
it('passes other props', () => {
|
|
217
|
+
api.asserts.props
|
|
218
|
+
.propAtIndex(
|
|
219
|
+
0,
|
|
220
|
+
props => {
|
|
221
|
+
expect(props.other1).toBeDefined();
|
|
222
|
+
expect(props.other1).toBe('other-value');
|
|
223
|
+
}
|
|
224
|
+
);
|
|
225
|
+
});
|
|
226
|
+
});
|
|
227
|
+
});
|
|
228
|
+
|
|
229
|
+
describe('ConnectableComponent directly', () => {
|
|
230
|
+
|
|
231
|
+
describe('Child view props', () => {
|
|
232
|
+
beforeEach(() => {
|
|
233
|
+
let elementCreationProperties: ConnectedComponentElementCreationProperties = {
|
|
234
|
+
modelId: 'model-id1',
|
|
235
|
+
useConnectFunction: false
|
|
236
|
+
};
|
|
237
|
+
api.doRender(
|
|
238
|
+
createConnectedComponentElement(elementCreationProperties),
|
|
239
|
+
elementCreationProperties.modelId
|
|
240
|
+
);
|
|
241
|
+
});
|
|
242
|
+
|
|
243
|
+
it('passes modelId', () => {
|
|
244
|
+
api.asserts.props
|
|
245
|
+
.propAtIndex(
|
|
246
|
+
0,
|
|
247
|
+
props => {
|
|
248
|
+
expect(props.modelId).toBe('model-id1');
|
|
249
|
+
}
|
|
250
|
+
);
|
|
251
|
+
});
|
|
252
|
+
|
|
253
|
+
it('passes router', () => {
|
|
254
|
+
api.asserts.props
|
|
255
|
+
.propAtIndex(
|
|
256
|
+
0,
|
|
257
|
+
props => {
|
|
258
|
+
expect(props.router).toBe(api.router);
|
|
259
|
+
}
|
|
260
|
+
);
|
|
261
|
+
});
|
|
262
|
+
|
|
263
|
+
it('passes model', () => {
|
|
264
|
+
api.asserts.props
|
|
265
|
+
.propAtIndex(
|
|
266
|
+
0,
|
|
267
|
+
props => {
|
|
268
|
+
expect(props.model).toBeDefined();
|
|
269
|
+
expect(props.model instanceof TestModel).toBeTruthy();
|
|
270
|
+
}
|
|
271
|
+
);
|
|
272
|
+
});
|
|
273
|
+
|
|
274
|
+
it('passes other props', () => {
|
|
275
|
+
api.asserts.props
|
|
276
|
+
.propAtIndex(
|
|
277
|
+
0,
|
|
278
|
+
props => {
|
|
279
|
+
expect(props.other1).toBeDefined();
|
|
280
|
+
expect(props.other1).toBe('other-value');
|
|
281
|
+
}
|
|
282
|
+
);
|
|
283
|
+
});
|
|
284
|
+
});
|
|
285
|
+
|
|
286
|
+
it('arbitrary props are passed down to the child', () => {
|
|
287
|
+
api.doRender(
|
|
288
|
+
(
|
|
289
|
+
<ConnectableComponent className={'foo-bar'} />
|
|
290
|
+
),
|
|
291
|
+
'model-id1'
|
|
292
|
+
);
|
|
293
|
+
api.asserts.props
|
|
294
|
+
.receivedPropCountIs(1)
|
|
295
|
+
.propAtIndex(0, props => {
|
|
296
|
+
expect(props.className).toBe('foo-bar');
|
|
297
|
+
});
|
|
298
|
+
});
|
|
299
|
+
|
|
300
|
+
describe('Re-renders', () => {
|
|
301
|
+
beforeEach(() => {
|
|
302
|
+
let elementCreationProperties: ConnectedComponentElementCreationProperties = {
|
|
303
|
+
modelId: 'model-id1',
|
|
304
|
+
useConnectFunction: false,
|
|
305
|
+
};
|
|
306
|
+
api.doRender(
|
|
307
|
+
createConnectedComponentElement(elementCreationProperties),
|
|
308
|
+
elementCreationProperties.modelId
|
|
309
|
+
);
|
|
310
|
+
});
|
|
311
|
+
|
|
312
|
+
it('Re-renders when model updates', () => {
|
|
313
|
+
publishTestEvent( 'model-id1', 'the-event-value');
|
|
314
|
+
api.asserts.props
|
|
315
|
+
.receivedPropCountIs(2)
|
|
316
|
+
.propAtIndex(
|
|
317
|
+
1,
|
|
318
|
+
props => {
|
|
319
|
+
expect(props.model).toBeDefined();
|
|
320
|
+
expect(props.model.value).toBe('the-event-value');
|
|
321
|
+
}
|
|
322
|
+
);
|
|
323
|
+
});
|
|
324
|
+
});
|
|
325
|
+
|
|
326
|
+
describe('Model Subscription - modelId source', () => {
|
|
327
|
+
it('subscribes to modelId via props', () => {
|
|
328
|
+
api.doRender(
|
|
329
|
+
(
|
|
330
|
+
<ConnectableComponent modelId={'model-id1'} />
|
|
331
|
+
)
|
|
332
|
+
);
|
|
333
|
+
api.asserts.props
|
|
334
|
+
.receivedPropCountIs(1)
|
|
335
|
+
.propAtIndexHasModelId(0, 'model-id1');
|
|
336
|
+
});
|
|
337
|
+
|
|
338
|
+
it('subscribes to modelId via context', () => {
|
|
339
|
+
api.doRender(
|
|
340
|
+
(
|
|
341
|
+
<ConnectableComponent />
|
|
342
|
+
),
|
|
343
|
+
'model-id1'
|
|
344
|
+
);
|
|
345
|
+
api.asserts.props
|
|
346
|
+
.receivedPropCountIs(1)
|
|
347
|
+
.propAtIndexHasModelId(0, 'model-id1');
|
|
348
|
+
});
|
|
349
|
+
});
|
|
350
|
+
|
|
351
|
+
describe('Model Subscription - when modelId changes', () => {
|
|
352
|
+
beforeEach(() => {
|
|
353
|
+
let elementCreationProperties: ConnectedComponentElementCreationProperties = {
|
|
354
|
+
modelId: 'model-id1',
|
|
355
|
+
useConnectFunction: false,
|
|
356
|
+
useMapModelToProps: true
|
|
357
|
+
};
|
|
358
|
+
api.doRender(
|
|
359
|
+
createConnectedComponentElement(elementCreationProperties),
|
|
360
|
+
elementCreationProperties.modelId
|
|
361
|
+
);
|
|
362
|
+
});
|
|
363
|
+
|
|
364
|
+
it('Re-subscribes to new model when modelId changes', () => {
|
|
365
|
+
api.asserts.props
|
|
366
|
+
.receivedPropCountIs(1)
|
|
367
|
+
.propAtIndexHasModelId(0,'model-id1');
|
|
368
|
+
const element = createConnectedComponentElement({modelId: 'model-id2', useConnectFunction: false, useMapModelToProps: true});
|
|
369
|
+
api.doReRender(element, 'model-id2');
|
|
370
|
+
api.asserts.props
|
|
371
|
+
.receivedPropCountIs(2)
|
|
372
|
+
.propAtIndexHasModelId(1,'model-id2');
|
|
373
|
+
publishTestEvent( 'model-id2', 'the-event-value2');
|
|
374
|
+
api.asserts.props
|
|
375
|
+
.receivedPropCountIs(3)
|
|
376
|
+
.propAtIndexHasModelId(2,'model-id2')
|
|
377
|
+
.propAtIndex(
|
|
378
|
+
2,
|
|
379
|
+
props => {
|
|
380
|
+
expect(props.model.value).toBe('the-event-value2');
|
|
381
|
+
expect(props.foo).toBe('the-event-value2');
|
|
382
|
+
}
|
|
383
|
+
);
|
|
384
|
+
});
|
|
385
|
+
});
|
|
386
|
+
|
|
387
|
+
describe('View rendering', () => {
|
|
388
|
+
it('Renders the view found via @viewBinding', () => {
|
|
389
|
+
let elementCreationProperties: ConnectedComponentElementCreationProperties = {
|
|
390
|
+
modelId: 'model-id1',
|
|
391
|
+
useConnectFunction: false,
|
|
392
|
+
};
|
|
393
|
+
api.doRender(
|
|
394
|
+
createConnectedComponentElement(elementCreationProperties),
|
|
395
|
+
elementCreationProperties.modelId
|
|
396
|
+
);
|
|
397
|
+
api.asserts.view.viewNameElementTextIs('View1');
|
|
398
|
+
});
|
|
399
|
+
|
|
400
|
+
it('Renders alternative view found via @viewBinding', () => {
|
|
401
|
+
let elementCreationProperties: ConnectedComponentElementCreationProperties = {
|
|
402
|
+
modelId: 'model-id1',
|
|
403
|
+
useConnectFunction: false,
|
|
404
|
+
useAlternativeViewContext: true
|
|
405
|
+
};
|
|
406
|
+
api.doRender(
|
|
407
|
+
createConnectedComponentElement(elementCreationProperties),
|
|
408
|
+
elementCreationProperties.modelId
|
|
409
|
+
);
|
|
410
|
+
api.asserts.view.viewNameElementTextIs('View3');
|
|
411
|
+
});
|
|
412
|
+
|
|
413
|
+
it('re-renders the view when the model changes', () => {
|
|
414
|
+
api.doRender(
|
|
415
|
+
(
|
|
416
|
+
<ConnectableComponent />
|
|
417
|
+
),
|
|
418
|
+
'model-id1'
|
|
419
|
+
);
|
|
420
|
+
api.asserts.view.viewNameElementTextIs('View1');
|
|
421
|
+
api.asserts.props.receivedPropCountIs(1);
|
|
422
|
+
act(() => {
|
|
423
|
+
api.router.publishEvent('model-id1', 'test-event', 'changed-value');
|
|
424
|
+
});
|
|
425
|
+
api.asserts.props
|
|
426
|
+
.receivedPropCountIs(2)
|
|
427
|
+
.propAtIndex(1, props => {
|
|
428
|
+
expect(props.model.value).toBe('changed-value');
|
|
429
|
+
});
|
|
430
|
+
});
|
|
431
|
+
|
|
432
|
+
it('can pass view via prop', () => {
|
|
433
|
+
const View = viewFactory('MyPropView')
|
|
434
|
+
api.doRender(
|
|
435
|
+
(
|
|
436
|
+
<ConnectableComponent view={View} />
|
|
437
|
+
),
|
|
438
|
+
'model-id1'
|
|
439
|
+
);
|
|
440
|
+
api.asserts.view.viewNameElementTextIs('MyPropView');
|
|
441
|
+
});
|
|
442
|
+
});
|
|
443
|
+
|
|
444
|
+
describe('Overriding model/state selector with @getEspPolimerImmutableModel', () => {
|
|
445
|
+
it('The model returned by the function decorated with a @getEspPolimerImmutableModel decorator is passed to useMapModelToProps', () => {
|
|
446
|
+
let elementCreationProperties: ConnectedComponentElementCreationProperties = {
|
|
447
|
+
modelId: 'model-id2', // this model has a @getEspPolimerImmutableModel decorator
|
|
448
|
+
useConnectFunction: false,
|
|
449
|
+
useAlternativeViewContext: true
|
|
450
|
+
};
|
|
451
|
+
api.doRender(
|
|
452
|
+
createConnectedComponentElement(elementCreationProperties),
|
|
453
|
+
elementCreationProperties.modelId
|
|
454
|
+
);
|
|
455
|
+
api.asserts.props
|
|
456
|
+
.receivedPropCountIs(1)
|
|
457
|
+
.propAtIndex(0, props => {
|
|
458
|
+
const mappedModel = props.model as any as MappedModel;
|
|
459
|
+
expect(mappedModel.value2).toBe('initial-value');
|
|
460
|
+
expect(mappedModel.value3).toBe('value-3');
|
|
461
|
+
});
|
|
462
|
+
publishTestEvent(elementCreationProperties.modelId, 'the-event-value');
|
|
463
|
+
api.asserts.props
|
|
464
|
+
.receivedPropCountIs(2)
|
|
465
|
+
.propAtIndex(1, props => {
|
|
466
|
+
const mappedModel = props.model as any as MappedModel;
|
|
467
|
+
expect(mappedModel.value2).toBe('the-event-value');
|
|
468
|
+
});
|
|
469
|
+
});
|
|
470
|
+
|
|
471
|
+
it('will select esp-js-polimer model based on const', () => {
|
|
472
|
+
api.doRender(
|
|
473
|
+
(
|
|
474
|
+
<ConnectableComponent />
|
|
475
|
+
),
|
|
476
|
+
'model-id3'
|
|
477
|
+
);
|
|
478
|
+
api.asserts.props
|
|
479
|
+
.receivedPropCountIs(1)
|
|
480
|
+
.propAtIndex(0, props => {
|
|
481
|
+
expect(props.model.value).toBe('initial-value');
|
|
482
|
+
expect(props.model.foo).toBe('the-foo');
|
|
483
|
+
});
|
|
484
|
+
act(() => {
|
|
485
|
+
api.router.publishEvent('model-id3', 'test-event', 'changed-value');
|
|
486
|
+
});
|
|
487
|
+
api.asserts.props
|
|
488
|
+
.receivedPropCountIs(2)
|
|
489
|
+
.propAtIndex(1, props => {
|
|
490
|
+
expect(props.model.value).toBe('changed-value');
|
|
491
|
+
expect(props.model.foo).toBe('the-foo');
|
|
492
|
+
});
|
|
493
|
+
});
|
|
494
|
+
});
|
|
495
|
+
});
|
|
496
|
+
});
|
|
@@ -0,0 +1,142 @@
|
|
|
1
|
+
import {
|
|
2
|
+
EspRouterContextProvider,
|
|
3
|
+
EspModelContextProvider,
|
|
4
|
+
useGetModelId,
|
|
5
|
+
useGetModel,
|
|
6
|
+
usePublishModelEvent,
|
|
7
|
+
usePublishModelEventWithEntityKey
|
|
8
|
+
} from '../src';
|
|
9
|
+
import {testApi, TestApi} from './testApi/testApi';
|
|
10
|
+
import {renderHook} from '@testing-library/react';
|
|
11
|
+
import * as React from 'react';
|
|
12
|
+
import {Router} from 'esp-js';
|
|
13
|
+
import {TestModel} from './testApi/testModel';
|
|
14
|
+
|
|
15
|
+
describe('EspModelContextProviderTests tests', () => {
|
|
16
|
+
let api: TestApi,
|
|
17
|
+
testModel1: TestModel,
|
|
18
|
+
testModel2: TestModel;
|
|
19
|
+
|
|
20
|
+
beforeEach(() => {
|
|
21
|
+
api = testApi();
|
|
22
|
+
|
|
23
|
+
testModel1 = api.setupTestModel('model-id1');
|
|
24
|
+
testModel2 = api.setupTestModel('model-id2');
|
|
25
|
+
});
|
|
26
|
+
|
|
27
|
+
// https://testing-library.com/docs/react-testing-library/api/#renderhook-options-initialprops
|
|
28
|
+
const createEspRouterContextProviderWrapper = (
|
|
29
|
+
router: Router,
|
|
30
|
+
modelsForContextPerRender: TestModel[],
|
|
31
|
+
modelIdForContextPerRender: string[]
|
|
32
|
+
) => {
|
|
33
|
+
|
|
34
|
+
return ({children}: React.PropsWithChildren) => {
|
|
35
|
+
// Each re-render we pop a model ID out of modelIdForContextPerRender for our context.
|
|
36
|
+
// This is the only way to inject some re-render differences using RTL with renderHook
|
|
37
|
+
let modelForContext = modelsForContextPerRender.length === 1
|
|
38
|
+
? modelsForContextPerRender[0]
|
|
39
|
+
: modelsForContextPerRender.shift();
|
|
40
|
+
let modelIdForContext = modelIdForContextPerRender.length === 1
|
|
41
|
+
? modelIdForContextPerRender[0]
|
|
42
|
+
: modelIdForContextPerRender.shift();
|
|
43
|
+
return (
|
|
44
|
+
<EspRouterContextProvider router={router}>
|
|
45
|
+
<EspModelContextProvider modelId={modelIdForContext} model={modelForContext}>
|
|
46
|
+
{children},
|
|
47
|
+
</EspModelContextProvider>
|
|
48
|
+
</EspRouterContextProvider>
|
|
49
|
+
);
|
|
50
|
+
};
|
|
51
|
+
};
|
|
52
|
+
|
|
53
|
+
it('useGetModelId returns new modelId and changes on re-render', () => {
|
|
54
|
+
const {result, rerender} = renderHook(
|
|
55
|
+
props => {
|
|
56
|
+
return useGetModelId();
|
|
57
|
+
},
|
|
58
|
+
{
|
|
59
|
+
wrapper: createEspRouterContextProviderWrapper(
|
|
60
|
+
api.router,
|
|
61
|
+
[testModel1, testModel2],
|
|
62
|
+
['model-id1', 'model-id2']
|
|
63
|
+
),
|
|
64
|
+
}
|
|
65
|
+
);
|
|
66
|
+
expect(result.current).toBe('model-id1');
|
|
67
|
+
rerender();
|
|
68
|
+
expect(result.current).toBe('model-id2');
|
|
69
|
+
});
|
|
70
|
+
|
|
71
|
+
it('useGetModel returns model and changes on re-render', () => {
|
|
72
|
+
const {result, rerender} = renderHook(
|
|
73
|
+
props => {
|
|
74
|
+
return useGetModel<TestModel>();
|
|
75
|
+
},
|
|
76
|
+
{
|
|
77
|
+
wrapper: createEspRouterContextProviderWrapper(
|
|
78
|
+
api.router,
|
|
79
|
+
[testModel1, testModel2],
|
|
80
|
+
['model-id1', 'model-id2']
|
|
81
|
+
),
|
|
82
|
+
}
|
|
83
|
+
);
|
|
84
|
+
expect(result.current).toBe(testModel1);
|
|
85
|
+
rerender();
|
|
86
|
+
expect(result.current).toBe(testModel2);
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
it('publishModelEvent publishes to correct model and changes on re-render', () => {
|
|
90
|
+
const {result, rerender} = renderHook(
|
|
91
|
+
props => {
|
|
92
|
+
return usePublishModelEvent();
|
|
93
|
+
},
|
|
94
|
+
{
|
|
95
|
+
wrapper: createEspRouterContextProviderWrapper(
|
|
96
|
+
api.router,
|
|
97
|
+
[testModel1, testModel2],
|
|
98
|
+
['model-id1', 'model-id2']
|
|
99
|
+
),
|
|
100
|
+
}
|
|
101
|
+
);
|
|
102
|
+
|
|
103
|
+
expect(testModel1.state.value).toBe('initial-value');
|
|
104
|
+
result.current('test-event', 'updated');
|
|
105
|
+
expect(testModel1.state.value).toBe('updated');
|
|
106
|
+
|
|
107
|
+
rerender();
|
|
108
|
+
|
|
109
|
+
expect(testModel2.state.value).toBe('initial-value');
|
|
110
|
+
result.current('test-event', 'updated');
|
|
111
|
+
expect(testModel2.state.value).toBe('updated');
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
it('publishModelEventWithEntityKey publishes to correct model and changes on re-render', () => {
|
|
115
|
+
const {result, rerender} = renderHook(
|
|
116
|
+
props => {
|
|
117
|
+
return usePublishModelEventWithEntityKey();
|
|
118
|
+
},
|
|
119
|
+
{
|
|
120
|
+
wrapper: createEspRouterContextProviderWrapper(
|
|
121
|
+
api.router,
|
|
122
|
+
[testModel1, testModel2],
|
|
123
|
+
['model-id1', 'model-id2']
|
|
124
|
+
),
|
|
125
|
+
}
|
|
126
|
+
);
|
|
127
|
+
|
|
128
|
+
expect(testModel1.state.value).toBe('initial-value');
|
|
129
|
+
expect(testModel1.state.entityKey).toBe('');
|
|
130
|
+
result.current('the-entity-key', 'test-event-with-entity-key', 'updated');
|
|
131
|
+
expect(testModel1.state.value).toBe('updated');
|
|
132
|
+
expect(testModel1.state.entityKey).toBe('the-entity-key');
|
|
133
|
+
|
|
134
|
+
rerender();
|
|
135
|
+
|
|
136
|
+
expect(testModel2.state.value).toBe('initial-value');
|
|
137
|
+
expect(testModel2.state.entityKey).toBe('');
|
|
138
|
+
result.current('the-entity-key', 'test-event-with-entity-key', 'updated');
|
|
139
|
+
expect(testModel2.state.value).toBe('updated');
|
|
140
|
+
expect(testModel2.state.entityKey).toBe('the-entity-key');
|
|
141
|
+
});
|
|
142
|
+
});
|
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
import {
|
|
2
|
+
EspRouterContextProvider,
|
|
3
|
+
useRouter,
|
|
4
|
+
usePublishEvent
|
|
5
|
+
} from '../src';
|
|
6
|
+
import {testApi, TestApi} from './testApi/testApi';
|
|
7
|
+
import {renderHook} from '@testing-library/react';
|
|
8
|
+
import {TestModel} from './testApi/testModel';
|
|
9
|
+
import * as React from 'react';
|
|
10
|
+
import {Router} from 'esp-js';
|
|
11
|
+
|
|
12
|
+
describe('EspRouterContextProvider tests', () => {
|
|
13
|
+
let api: TestApi;
|
|
14
|
+
|
|
15
|
+
beforeEach(() => {
|
|
16
|
+
api = testApi();
|
|
17
|
+
|
|
18
|
+
api.setupTestModel('model-id');
|
|
19
|
+
});
|
|
20
|
+
|
|
21
|
+
// https://testing-library.com/docs/react-testing-library/api/#renderhook-options-initialprops
|
|
22
|
+
const createEspRouterContextProviderWrapper = (router: Router) => {
|
|
23
|
+
return ({ children }: React.PropsWithChildren) => {
|
|
24
|
+
return (<EspRouterContextProvider router={router}>{children}</EspRouterContextProvider>);
|
|
25
|
+
};
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
it('useRouter returns Router', () => {
|
|
29
|
+
const {result} =renderHook(
|
|
30
|
+
props => {
|
|
31
|
+
return useRouter();
|
|
32
|
+
},
|
|
33
|
+
{
|
|
34
|
+
wrapper: createEspRouterContextProviderWrapper(api.router),
|
|
35
|
+
}
|
|
36
|
+
);
|
|
37
|
+
expect(result.current).toBe(api.router);
|
|
38
|
+
});
|
|
39
|
+
|
|
40
|
+
it('usePublishEvent returns publishEvent delegate', () => {
|
|
41
|
+
const {result} =renderHook(
|
|
42
|
+
props => {
|
|
43
|
+
return usePublishEvent();
|
|
44
|
+
},
|
|
45
|
+
{
|
|
46
|
+
wrapper: createEspRouterContextProviderWrapper(api.router),
|
|
47
|
+
}
|
|
48
|
+
);
|
|
49
|
+
let testModel = api.router.getModel<TestModel>('model-id');
|
|
50
|
+
expect(testModel.state.value).toBe('initial-value');
|
|
51
|
+
result.current('model-id', 'test-event', 'updated');
|
|
52
|
+
expect(testModel.state.value).toBe('updated');
|
|
53
|
+
});
|
|
54
|
+
});
|