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.
Files changed (42) hide show
  1. package/.dist/esp-react.js +68 -104
  2. package/.dist/esp-react.js.map +1 -1
  3. package/.dist/esp-react.min.js +1 -1
  4. package/.dist/esp-react.min.js.map +1 -1
  5. package/.dist/typings/connect.d.ts +2 -6
  6. package/.dist/typings/connectableComponent.d.ts +0 -16
  7. package/.dist/typings/espModelContextProvider.d.ts +24 -7
  8. package/.dist/typings/espRouterContextProvider.d.ts +5 -5
  9. package/.dist/typings/index.d.ts +2 -3
  10. package/.dist/typings/polimer/getEspPolimerImmutableModel.d.ts +21 -0
  11. package/.dist/typings/useModelSelector.d.ts +25 -1
  12. package/.dist/typings/viewBinder.d.ts +8 -1
  13. package/.dist/typings/viewBindingDecorator.d.ts +1 -1
  14. package/package.json +4 -4
  15. package/src/connect.tsx +2 -6
  16. package/src/connectableComponent.tsx +2 -19
  17. package/src/espModelContextProvider.tsx +26 -9
  18. package/src/espRouterContextProvider.tsx +5 -5
  19. package/src/index.ts +5 -9
  20. package/src/polimer/getEspPolimerImmutableModel.ts +50 -0
  21. package/src/useModelSelector.ts +31 -7
  22. package/src/viewBinder.tsx +13 -2
  23. package/src/viewBindingDecorator.ts +2 -2
  24. package/tests/connectableComponentTests.tsx +496 -0
  25. package/tests/espModelContextProviderTests.tsx +142 -0
  26. package/tests/espRouterContextProviderTests.tsx +54 -0
  27. package/tests/indexTests.ts +24 -91
  28. package/tests/testApi/asserts.ts +90 -0
  29. package/tests/testApi/testApi.tsx +100 -0
  30. package/tests/testApi/testModel.ts +44 -0
  31. package/tests/testApi/useStoreReceivedProps.ts +14 -0
  32. package/tests/testApi/viewFactory.tsx +31 -0
  33. package/tests/useModelSelectorTests.tsx +47 -153
  34. package/tests/viewBinderTests.tsx +61 -0
  35. package/.dist/typings/polimer/getEspReactRenderModel.d.ts +0 -21
  36. package/.dist/typings/viewBinderConnectable.d.ts +0 -15
  37. package/src/polimer/getEspReactRenderModel.ts +0 -50
  38. package/src/viewBinderConnectable.tsx +0 -54
  39. package/tests/connectableComponentLegacyTests.tsx +0 -405
  40. /package/.dist/typings/polimer/{polimerExtentsions.d.ts → polimerModelBuilderExtentsions.d.ts} +0 -0
  41. /package/src/polimer/{polimerExtentsions.ts → polimerModelBuilderExtentsions.ts} +0 -0
  42. /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
+ });