esp-js-react 8.0.2-next.0 → 8.0.4-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 -112
- 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 +27 -12
- package/.dist/typings/espRouterContextProvider.d.ts +5 -5
- package/.dist/typings/index.d.ts +2 -3
- package/.dist/typings/useSyncModelWithSelector.d.ts +50 -0
- 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 +3 -20
- package/src/espModelContextProvider.tsx +30 -46
- package/src/espRouterContextProvider.tsx +5 -5
- package/src/index.ts +6 -13
- package/src/{useModelSelector.ts → useSyncModelWithSelector.ts} +47 -16
- package/src/viewBinder.tsx +13 -2
- package/src/viewBindingDecorator.ts +2 -2
- package/tests/connectableComponentTests.tsx +323 -246
- package/tests/espModelContextProviderTests.tsx +142 -0
- package/tests/espRouterContextProviderTests.tsx +54 -0
- package/tests/indexTests.ts +3 -4
- package/tests/testApi/asserts.ts +17 -2
- package/tests/testApi/testApi.tsx +37 -21
- package/tests/testApi/testModel.ts +15 -8
- package/tests/testApi/useStoreReceivedProps.ts +3 -0
- package/tests/testApi/viewFactory.tsx +31 -0
- package/tests/{useModelSelectorTests.tsx → useSyncModelWithSelectorTests.tsx} +52 -22
- package/tests/viewBinderTests.tsx +61 -0
- package/.dist/typings/useModelSelector.d.ts +0 -27
- package/.dist/typings/viewBinderConnectable.d.ts +0 -15
- package/src/viewBinderConnectable.tsx +0 -54
- package/tests/connectableComponentLegacyTests.tsx +0 -405
- package/tests/testApi/viewMetadata.tsx +0 -46
|
@@ -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
|
+
});
|
package/tests/indexTests.ts
CHANGED
|
@@ -20,17 +20,16 @@ import * as espReact from '../src/index';
|
|
|
20
20
|
|
|
21
21
|
describe('index exports', () => {
|
|
22
22
|
it('check exports', () => {
|
|
23
|
-
expect(espReact.ViewBinder).toBeDefined();
|
|
24
|
-
expect(espReact.ViewBinderConnectable).toBeDefined();
|
|
25
23
|
expect(espReact.viewBinding).toBeDefined();
|
|
24
|
+
expect(espReact.ViewBinder).toBeDefined();
|
|
26
25
|
expect(espReact.DEFAULT_VIEW_KEY).toBeDefined();
|
|
27
26
|
expect(espReact.GetEspPolimerImmutableModelConsts).toBeDefined();
|
|
28
27
|
expect(espReact.getEspPolimerImmutableModel).toBeDefined();
|
|
29
28
|
expect(espReact.createViewForModel).toBeDefined();
|
|
30
29
|
expect(espReact.connect).toBeDefined();
|
|
31
30
|
expect(espReact.ConnectableComponent).toBeDefined();
|
|
32
|
-
expect(espReact.
|
|
33
|
-
expect(espReact.
|
|
31
|
+
expect(espReact.useSyncModelWithSelector).toBeDefined();
|
|
32
|
+
expect(espReact.syncModelWithSelectorOptions).toBeDefined();
|
|
34
33
|
expect(espReact.RouterProvider).toBeDefined();
|
|
35
34
|
expect(espReact.EspRouterContextProvider).toBeDefined();
|
|
36
35
|
expect(espReact.RouterContext).toBeDefined();
|
package/tests/testApi/asserts.ts
CHANGED
|
@@ -8,6 +8,7 @@ export type ViewAsserts = {
|
|
|
8
8
|
valueIs(expected: string): ViewAsserts;
|
|
9
9
|
modelIdIs(expected: string): ViewAsserts
|
|
10
10
|
propIs(propName: string, expected: string): ViewAsserts
|
|
11
|
+
viewNameElementTextIs(viewName: string);
|
|
11
12
|
htmlElementInnerTextIs(elementsTestId: string, expectedText: string): ViewAsserts
|
|
12
13
|
};
|
|
13
14
|
|
|
@@ -33,6 +34,11 @@ export const viewAsserts = (renderResult: RenderResult) => {
|
|
|
33
34
|
expect(span.getAttribute(attributeName)).toBe(expected);
|
|
34
35
|
return this;
|
|
35
36
|
},
|
|
37
|
+
viewNameElementTextIs(viewName: string) {
|
|
38
|
+
let span = renderResult.getByTestId('view-name');
|
|
39
|
+
expect(span).toHaveTextContent(viewName);
|
|
40
|
+
return this;
|
|
41
|
+
},
|
|
36
42
|
htmlElementInnerTextIs(elementsTestId: string, expectedText: string) {
|
|
37
43
|
let span = renderResult.getByTestId(elementsTestId);
|
|
38
44
|
expect(span).toHaveTextContent(expectedText);
|
|
@@ -49,7 +55,12 @@ export type RouterAsserts = {
|
|
|
49
55
|
export const routerAsserts = (routerSpy: RouterSpy) => {
|
|
50
56
|
return {
|
|
51
57
|
subscriberCountIs(modelId: string, expectedCount: number) {
|
|
52
|
-
|
|
58
|
+
if (expectedCount === 0) {
|
|
59
|
+
let modelNotSubscribed = routerSpy.getSubscriberCount(modelId) === undefined || routerSpy.getSubscriberCount(modelId) === 0;
|
|
60
|
+
expect(modelNotSubscribed).toBeTruthy();
|
|
61
|
+
} else {
|
|
62
|
+
expect(routerSpy.getSubscriberCount(modelId)).toEqual(expectedCount);
|
|
63
|
+
}
|
|
53
64
|
return this;
|
|
54
65
|
},
|
|
55
66
|
} as RouterAsserts;
|
|
@@ -58,6 +69,7 @@ export const routerAsserts = (routerSpy: RouterSpy) => {
|
|
|
58
69
|
export type PropAsserts = {
|
|
59
70
|
receivedPropCountIs(expectedCount: number): PropAsserts;
|
|
60
71
|
propAtIndex(index: number, asserter: (props) => void): PropAsserts
|
|
72
|
+
propAtIndexHasModelId(index: number, expectedModelId: string): PropAsserts
|
|
61
73
|
};
|
|
62
74
|
|
|
63
75
|
export const propAsserts = (testPropStore: TestPropStore) => {
|
|
@@ -70,6 +82,9 @@ export const propAsserts = (testPropStore: TestPropStore) => {
|
|
|
70
82
|
asserter(testPropStore.receivedProps[index]);
|
|
71
83
|
return this;
|
|
72
84
|
},
|
|
73
|
-
|
|
85
|
+
propAtIndexHasModelId(index: number, expectedModelId: string): PropAsserts {
|
|
86
|
+
expect(testPropStore.receivedProps[index].modelId).toBe(expectedModelId);
|
|
87
|
+
return this;
|
|
88
|
+
},
|
|
74
89
|
} as PropAsserts;
|
|
75
90
|
};
|
|
@@ -4,22 +4,24 @@ import {render, RenderResult} from '@testing-library/react';
|
|
|
4
4
|
import * as React from 'react';
|
|
5
5
|
import {EspModelContextProvider, EspRouterContextProvider} from '../../src';
|
|
6
6
|
import {PropAsserts, propAsserts, RouterAsserts, routerAsserts, ViewAsserts, viewAsserts} from './asserts';
|
|
7
|
-
import {isValidElement} from 'react';
|
|
7
|
+
import {isValidElement, ReactElement} from 'react';
|
|
8
8
|
import {TestPropStore, TestPropStoreContext} from './useStoreReceivedProps';
|
|
9
9
|
|
|
10
10
|
export type TestApi = {
|
|
11
11
|
router: RouterSpy;
|
|
12
|
+
propStore: TestPropStore;
|
|
12
13
|
asserts: {
|
|
13
14
|
router: RouterAsserts,
|
|
14
15
|
view: ViewAsserts,
|
|
15
16
|
props: PropAsserts,
|
|
16
17
|
};
|
|
17
|
-
setupModel(modelId: string,
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
doRender(Component: React.
|
|
21
|
-
|
|
22
|
-
doReRender(Component: React.
|
|
18
|
+
setupModel<TModel>(modelId: string, model: TModel): TModel;
|
|
19
|
+
setupTestModel(modelId: string): TestModel;
|
|
20
|
+
setupModelAndRender(modelId: string, Component: React.ComponentType): TestApi;
|
|
21
|
+
doRender(Component: React.ComponentType, modelIdForContext?: string): TestApi
|
|
22
|
+
doRender(Component: React.JSX.Element, modelIdForContext?: string): TestApi
|
|
23
|
+
doReRender(Component: React.ComponentType, modelIdForContext?: string, nextProps?: any): TestApi;
|
|
24
|
+
doReRender(Component: React.JSX.Element, modelIdForContext?: string, nextProps?: any): TestApi;
|
|
23
25
|
};
|
|
24
26
|
|
|
25
27
|
export const testApi = ()=> {
|
|
@@ -28,6 +30,7 @@ export const testApi = ()=> {
|
|
|
28
30
|
let propStore = new TestPropStore();
|
|
29
31
|
return {
|
|
30
32
|
router,
|
|
33
|
+
propStore,
|
|
31
34
|
asserts: {
|
|
32
35
|
get router() {
|
|
33
36
|
return routerAsserts(router);
|
|
@@ -40,40 +43,53 @@ export const testApi = ()=> {
|
|
|
40
43
|
}
|
|
41
44
|
},
|
|
42
45
|
setupModelAndRender(modelId: string, view: React.ComponentType) {
|
|
43
|
-
this.
|
|
46
|
+
this.setupTestModel(modelId);
|
|
44
47
|
this.doRender(view, modelId);
|
|
45
48
|
return this;
|
|
46
49
|
},
|
|
47
|
-
setupModel(modelId: string,
|
|
48
|
-
|
|
50
|
+
setupModel<TModel>(modelId: string, model: TModel): TModel {
|
|
51
|
+
router.addModel(modelId, model);
|
|
52
|
+
router.observeEventsOn(modelId, model);
|
|
53
|
+
return model;
|
|
54
|
+
},
|
|
55
|
+
setupTestModel(modelId: string): TestModel {
|
|
56
|
+
const testModel = new TestModel(modelId);
|
|
49
57
|
router.addModel(modelId, testModel);
|
|
50
58
|
router.observeEventsOn(modelId, testModel);
|
|
51
|
-
return
|
|
59
|
+
return testModel;
|
|
52
60
|
},
|
|
53
|
-
doRender(ComponentOrElement: any, modelIdForContext
|
|
54
|
-
let
|
|
55
|
-
|
|
56
|
-
|
|
61
|
+
doRender(ComponentOrElement: any, modelIdForContext?: string, nextProps?: any) {
|
|
62
|
+
let element: React.JSX.Element;
|
|
63
|
+
if (isValidElement(ComponentOrElement)) {
|
|
64
|
+
element = ComponentOrElement;
|
|
65
|
+
} else {
|
|
66
|
+
element = <ComponentOrElement />;
|
|
67
|
+
}
|
|
68
|
+
let elementWithProps = React.cloneElement(element, nextProps);
|
|
57
69
|
renderResult = render((
|
|
58
70
|
<TestPropStoreContext.Provider value={propStore}>
|
|
59
71
|
<EspRouterContextProvider router={router}>
|
|
60
72
|
<EspModelContextProvider modelId={modelIdForContext}>
|
|
61
|
-
{
|
|
73
|
+
{elementWithProps},
|
|
62
74
|
</EspModelContextProvider>
|
|
63
75
|
</EspRouterContextProvider>
|
|
64
76
|
</TestPropStoreContext.Provider>
|
|
65
77
|
));
|
|
66
78
|
return this;
|
|
67
79
|
},
|
|
68
|
-
doReRender(ComponentOrElement: any, modelIdForContext
|
|
69
|
-
let
|
|
70
|
-
|
|
71
|
-
|
|
80
|
+
doReRender(ComponentOrElement: any, modelIdForContext?: string, nextProps?: any) {
|
|
81
|
+
let element: React.JSX.Element;
|
|
82
|
+
if (isValidElement(ComponentOrElement)) {
|
|
83
|
+
element = ComponentOrElement;
|
|
84
|
+
} else {
|
|
85
|
+
element = <ComponentOrElement />;
|
|
86
|
+
}
|
|
87
|
+
let elementWithProps = React.cloneElement(element, nextProps);
|
|
72
88
|
renderResult.rerender((
|
|
73
89
|
<TestPropStoreContext.Provider value={propStore}>
|
|
74
90
|
<EspRouterContextProvider router={router}>
|
|
75
91
|
<EspModelContextProvider modelId={modelIdForContext}>
|
|
76
|
-
{
|
|
92
|
+
{elementWithProps},
|
|
77
93
|
</EspModelContextProvider>
|
|
78
94
|
</EspRouterContextProvider>
|
|
79
95
|
</TestPropStoreContext.Provider>
|
|
@@ -1,7 +1,7 @@
|
|
|
1
|
-
import {observeEvent} from 'esp-js';
|
|
1
|
+
import {EventContext, observeEvent} from 'esp-js';
|
|
2
2
|
import {GetEspPolimerImmutableModelConsts} from '../../src';
|
|
3
3
|
|
|
4
|
-
export type TestModelImmutableState = { value: string, modelId: string };
|
|
4
|
+
export type TestModelImmutableState = { value: string, modelId: string, entityKey: string };
|
|
5
5
|
|
|
6
6
|
export class TestModel {
|
|
7
7
|
|
|
@@ -10,16 +10,13 @@ export class TestModel {
|
|
|
10
10
|
constructor(modelId: string) {
|
|
11
11
|
this._internalState = {
|
|
12
12
|
value: 'initial-value',
|
|
13
|
+
entityKey: '',
|
|
13
14
|
modelId: modelId,
|
|
14
15
|
};
|
|
15
16
|
}
|
|
16
17
|
|
|
17
|
-
public get
|
|
18
|
-
return this._internalState
|
|
19
|
-
}
|
|
20
|
-
|
|
21
|
-
public get modelIdViaModelGetter() {
|
|
22
|
-
return this._internalState.modelId;
|
|
18
|
+
public get state(): TestModelImmutableState {
|
|
19
|
+
return this._internalState;
|
|
23
20
|
}
|
|
24
21
|
|
|
25
22
|
@observeEvent('test-event')
|
|
@@ -31,6 +28,16 @@ export class TestModel {
|
|
|
31
28
|
};
|
|
32
29
|
}
|
|
33
30
|
|
|
31
|
+
@observeEvent('test-event-with-entity-key')
|
|
32
|
+
_onTestEventWithEntityKey(ev: string, eventContext: EventContext) {
|
|
33
|
+
// mimic some immutable logic that would be provided by a lib such as immer in a real app.
|
|
34
|
+
this._internalState = {
|
|
35
|
+
...this._internalState,
|
|
36
|
+
entityKey: eventContext.entityKey,
|
|
37
|
+
value: ev
|
|
38
|
+
};
|
|
39
|
+
}
|
|
40
|
+
|
|
34
41
|
[GetEspPolimerImmutableModelConsts.HandlerFunctionName]: () => TestModelImmutableState = () => {
|
|
35
42
|
return this._internalState;
|
|
36
43
|
};
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
import {useTestPropStore} from './useStoreReceivedProps';
|
|
2
|
+
import * as React from 'react';
|
|
3
|
+
|
|
4
|
+
export const viewFactory = (name: string) => {
|
|
5
|
+
return (props: { modelId: string; value: string, [key: string]: any }) => {
|
|
6
|
+
let testPropStore = useTestPropStore();
|
|
7
|
+
testPropStore.pushProps(props);
|
|
8
|
+
return (
|
|
9
|
+
<>
|
|
10
|
+
<span data-testid='view-name'>{name}</span>
|
|
11
|
+
<ViewMetadata modelId={props.modelId} modelValue={props.value} {...props}/>
|
|
12
|
+
</>
|
|
13
|
+
);
|
|
14
|
+
};
|
|
15
|
+
};
|
|
16
|
+
|
|
17
|
+
export type ViewMetadataProps = {
|
|
18
|
+
modelId: string,
|
|
19
|
+
modelValue: string
|
|
20
|
+
[key: string]: string; // ...rest props
|
|
21
|
+
};
|
|
22
|
+
|
|
23
|
+
export const ViewMetadata = (props: ViewMetadataProps) => {
|
|
24
|
+
const { modelId, modelValue, ...rest} = props;
|
|
25
|
+
return (
|
|
26
|
+
<div>
|
|
27
|
+
<span data-testid='modelIdDisplay'>{modelId}</span>
|
|
28
|
+
<span data-testid='valueDisplay'>{modelValue}</span>
|
|
29
|
+
</div>
|
|
30
|
+
);
|
|
31
|
+
};
|
|
@@ -1,15 +1,15 @@
|
|
|
1
1
|
import 'jest';
|
|
2
2
|
import * as React from 'react';
|
|
3
3
|
import {act} from 'react';
|
|
4
|
-
import {
|
|
4
|
+
import {syncModelWithSelectorOptions, useSyncModelWithSelector} from '../src';
|
|
5
5
|
import {TestModel, TestModelImmutableState} from './testApi/testModel';
|
|
6
|
-
import {ViewMetadata} from './testApi/
|
|
6
|
+
import {ViewMetadata} from './testApi/viewFactory';
|
|
7
7
|
import {routerAsserts} from './testApi/asserts';
|
|
8
8
|
import {testApi, TestApi} from './testApi/testApi';
|
|
9
9
|
|
|
10
10
|
type SelectedObject = { id: string, value: string };
|
|
11
11
|
|
|
12
|
-
describe('
|
|
12
|
+
describe('useSyncModelWithSelector', () => {
|
|
13
13
|
let api: TestApi;
|
|
14
14
|
|
|
15
15
|
beforeEach(() => {
|
|
@@ -20,7 +20,7 @@ describe('useModelSelector', () => {
|
|
|
20
20
|
const modelId = 'modelId';
|
|
21
21
|
|
|
22
22
|
const View = () => {
|
|
23
|
-
const valuesObj =
|
|
23
|
+
const valuesObj = useSyncModelWithSelector<TestModelImmutableState, SelectedObject>(
|
|
24
24
|
model => {
|
|
25
25
|
return {id: model.modelId, value: model.value};
|
|
26
26
|
},
|
|
@@ -57,9 +57,9 @@ describe('useModelSelector', () => {
|
|
|
57
57
|
const modelId = 'modelId';
|
|
58
58
|
|
|
59
59
|
const View = () => {
|
|
60
|
-
const values: string[] =
|
|
60
|
+
const values: string[] = useSyncModelWithSelector<TestModelImmutableState, string[]>(
|
|
61
61
|
model => [model.modelId, model.value],
|
|
62
|
-
|
|
62
|
+
syncModelWithSelectorOptions().setModelId(modelId)
|
|
63
63
|
);
|
|
64
64
|
if (!values) {
|
|
65
65
|
return;
|
|
@@ -70,7 +70,7 @@ describe('useModelSelector', () => {
|
|
|
70
70
|
};
|
|
71
71
|
|
|
72
72
|
beforeEach(() => {
|
|
73
|
-
api.
|
|
73
|
+
api.setupTestModel(modelId);
|
|
74
74
|
api.doRender(View, undefined);
|
|
75
75
|
});
|
|
76
76
|
|
|
@@ -85,15 +85,15 @@ describe('useModelSelector', () => {
|
|
|
85
85
|
const modelId = 'modelId';
|
|
86
86
|
|
|
87
87
|
const View = () => {
|
|
88
|
-
const values =
|
|
88
|
+
const values = useSyncModelWithSelector<TestModelImmutableState, SelectedObject>(
|
|
89
89
|
model => ({id: model.modelId, value: model.value}),
|
|
90
|
-
|
|
90
|
+
syncModelWithSelectorOptions<SelectedObject>()
|
|
91
91
|
.setEqualityFn((a, b) => {
|
|
92
92
|
if (!a) {
|
|
93
93
|
return false; // first time
|
|
94
94
|
}
|
|
95
95
|
// delegate to model, set via the test, to see if we're 'equal'
|
|
96
|
-
// If this returns true,
|
|
96
|
+
// If this returns true, useSyncModelWithSelector internally assume the last snapshot is the same thus doesn't propagate the last snapshot.
|
|
97
97
|
return b.value === 'assume-no-change';
|
|
98
98
|
})
|
|
99
99
|
);
|
|
@@ -139,9 +139,9 @@ describe('useModelSelector', () => {
|
|
|
139
139
|
const modelId2 = 'modelId2';
|
|
140
140
|
|
|
141
141
|
const View = (props: {modelId: string}) => {
|
|
142
|
-
const values =
|
|
142
|
+
const values = useSyncModelWithSelector<TestModelImmutableState, SelectedObject>(
|
|
143
143
|
model => ({id: model.modelId, value: model.value}),
|
|
144
|
-
|
|
144
|
+
syncModelWithSelectorOptions().setModelId(props.modelId)
|
|
145
145
|
);
|
|
146
146
|
if (!values) {
|
|
147
147
|
return;
|
|
@@ -152,7 +152,7 @@ describe('useModelSelector', () => {
|
|
|
152
152
|
};
|
|
153
153
|
|
|
154
154
|
beforeEach(() => {
|
|
155
|
-
api.
|
|
155
|
+
api.setupTestModel(modelId1);
|
|
156
156
|
api.doRender(View, modelId1);
|
|
157
157
|
});
|
|
158
158
|
|
|
@@ -173,7 +173,7 @@ describe('useModelSelector', () => {
|
|
|
173
173
|
api.asserts.view
|
|
174
174
|
.modelIdIs('')
|
|
175
175
|
.valueIs('');
|
|
176
|
-
api.
|
|
176
|
+
api.setupTestModel(modelId2);
|
|
177
177
|
api.doReRender(View, modelId2);
|
|
178
178
|
api.asserts.view
|
|
179
179
|
.modelIdIs(modelId2)
|
|
@@ -191,12 +191,12 @@ describe('useModelSelector', () => {
|
|
|
191
191
|
const modelId = 'modelId';
|
|
192
192
|
|
|
193
193
|
const View = () => {
|
|
194
|
-
const values: string[] =
|
|
194
|
+
const values: string[] = useSyncModelWithSelector<TestModel, string[]>(
|
|
195
195
|
model => {
|
|
196
196
|
// here we're expecting to receive a TestModel, not testModelInstance[GetEspPolimerImmutableModelConsts.HandlerFunctionName]()
|
|
197
|
-
return [model.
|
|
197
|
+
return [model.state.modelId, model.state.value];
|
|
198
198
|
},
|
|
199
|
-
|
|
199
|
+
syncModelWithSelectorOptions().setTryPreSelectPolimerImmutableModel(false)
|
|
200
200
|
);
|
|
201
201
|
if (!values) {
|
|
202
202
|
return;
|
|
@@ -211,8 +211,6 @@ describe('useModelSelector', () => {
|
|
|
211
211
|
});
|
|
212
212
|
|
|
213
213
|
it('selector passes router root model to selector', () => {
|
|
214
|
-
// Not much to test here, it's really in the View logic for this case.
|
|
215
|
-
// If the below passes, it means the selector was given the root ESP model.
|
|
216
214
|
api.asserts.view
|
|
217
215
|
.modelIdIs(modelId)
|
|
218
216
|
.valueIs('initial-value');
|
|
@@ -223,15 +221,15 @@ describe('useModelSelector', () => {
|
|
|
223
221
|
const modelId = 'modelId';
|
|
224
222
|
|
|
225
223
|
const View = () => {
|
|
226
|
-
const model: TestModel =
|
|
224
|
+
const model: TestModel = useSyncModelWithSelector<TestModel, TestModel>(
|
|
227
225
|
m => m,
|
|
228
|
-
|
|
226
|
+
syncModelWithSelectorOptions().setTryPreSelectPolimerImmutableModel(false)
|
|
229
227
|
);
|
|
230
228
|
if (!model) {
|
|
231
229
|
return;
|
|
232
230
|
}
|
|
233
231
|
return (
|
|
234
|
-
<ViewMetadata modelId={model.
|
|
232
|
+
<ViewMetadata modelId={model.state.modelId} modelValue={model.state.value} />
|
|
235
233
|
);
|
|
236
234
|
};
|
|
237
235
|
|
|
@@ -254,4 +252,36 @@ describe('useModelSelector', () => {
|
|
|
254
252
|
.valueIs('updated');
|
|
255
253
|
});
|
|
256
254
|
});
|
|
255
|
+
|
|
256
|
+
describe('argument checking', () => {
|
|
257
|
+
it('throws if selector incorrect', () => {
|
|
258
|
+
expect(() => {
|
|
259
|
+
useSyncModelWithSelector(null, syncModelWithSelectorOptions());
|
|
260
|
+
}).toThrow(new Error('You must pass a selector function to useSyncModelWithSelector'));
|
|
261
|
+
expect(() => {
|
|
262
|
+
useSyncModelWithSelector(undefined, syncModelWithSelectorOptions());
|
|
263
|
+
}).toThrow(new Error('You must pass a selector function to useSyncModelWithSelector'));
|
|
264
|
+
expect(() => {
|
|
265
|
+
const x: any = {};
|
|
266
|
+
useSyncModelWithSelector(x, syncModelWithSelectorOptions());
|
|
267
|
+
}).toThrow(new Error('You must pass a selector function to useSyncModelWithSelector'));
|
|
268
|
+
});
|
|
269
|
+
it('throws if options incorrect', () => {
|
|
270
|
+
expect(() => {
|
|
271
|
+
useSyncModelWithSelector((m) => m, null);
|
|
272
|
+
}).toThrow(new Error('You must provide options when using useSyncModelWithSelector'));
|
|
273
|
+
expect(() => {
|
|
274
|
+
useSyncModelWithSelector((m) => m, syncModelWithSelectorOptions().setEqualityFn(null));
|
|
275
|
+
}).toThrow(new Error('You must provide an equalityFn when using useSyncModelWithSelector'));
|
|
276
|
+
expect(() => {
|
|
277
|
+
useSyncModelWithSelector(
|
|
278
|
+
(m) => m,
|
|
279
|
+
{
|
|
280
|
+
modelId: '',
|
|
281
|
+
equalityFn: null,
|
|
282
|
+
tryPreSelectPolimerImmutableModel: true
|
|
283
|
+
});
|
|
284
|
+
}).toThrow(new Error('You must provide an equalityFn when using useSyncModelWithSelector'));
|
|
285
|
+
});
|
|
286
|
+
});
|
|
257
287
|
});
|