esp-js-react 8.0.1-next.0 → 8.0.2-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.
@@ -0,0 +1,84 @@
1
+ import {TestModel} from './testModel';
2
+ import {RouterSpy} from './routerSpy';
3
+ import {render, RenderResult} from '@testing-library/react';
4
+ import * as React from 'react';
5
+ import {EspModelContextProvider, EspRouterContextProvider} from '../../src';
6
+ import {PropAsserts, propAsserts, RouterAsserts, routerAsserts, ViewAsserts, viewAsserts} from './asserts';
7
+ import {isValidElement} from 'react';
8
+ import {TestPropStore, TestPropStoreContext} from './useStoreReceivedProps';
9
+
10
+ export type TestApi = {
11
+ router: RouterSpy;
12
+ asserts: {
13
+ router: RouterAsserts,
14
+ view: ViewAsserts,
15
+ props: PropAsserts,
16
+ };
17
+ setupModel(modelId: string, alternativeModel?: object): any;
18
+ setupModelAndRender(modelId: string, Component: React.ComponentType): any;
19
+ doRender(Component: React.ComponentType, modelIdForContext: string): any
20
+ doRender(Component: React.JSX.Element, modelIdForContext: string): any
21
+ doReRender(Component: React.ComponentType, modelIdForContext: string): any;
22
+ doReRender(Component: React.JSX.Element, modelIdForContext: string): any;
23
+ };
24
+
25
+ export const testApi = ()=> {
26
+ let router: RouterSpy = new RouterSpy();
27
+ let renderResult: RenderResult;
28
+ let propStore = new TestPropStore();
29
+ return {
30
+ router,
31
+ asserts: {
32
+ get router() {
33
+ return routerAsserts(router);
34
+ },
35
+ get view() {
36
+ return viewAsserts(renderResult);
37
+ },
38
+ get props() {
39
+ return propAsserts(propStore);
40
+ }
41
+ },
42
+ setupModelAndRender(modelId: string, view: React.ComponentType) {
43
+ this.setupModel(modelId);
44
+ this.doRender(view, modelId);
45
+ return this;
46
+ },
47
+ setupModel(modelId: string, alternativeModel?: object) {
48
+ const testModel = alternativeModel || new TestModel(modelId);
49
+ router.addModel(modelId, testModel);
50
+ router.observeEventsOn(modelId, testModel);
51
+ return this;
52
+ },
53
+ doRender(ComponentOrElement: any, modelIdForContext: string) {
54
+ let e: any = isValidElement(ComponentOrElement)
55
+ ? ComponentOrElement
56
+ : (<ComponentOrElement />);
57
+ renderResult = render((
58
+ <TestPropStoreContext.Provider value={propStore}>
59
+ <EspRouterContextProvider router={router}>
60
+ <EspModelContextProvider modelId={modelIdForContext}>
61
+ {e},
62
+ </EspModelContextProvider>
63
+ </EspRouterContextProvider>
64
+ </TestPropStoreContext.Provider>
65
+ ));
66
+ return this;
67
+ },
68
+ doReRender(ComponentOrElement: any, modelIdForContext: string) {
69
+ let componentOrElement: any = isValidElement(ComponentOrElement)
70
+ ? ComponentOrElement
71
+ : (<ComponentOrElement />);
72
+ renderResult.rerender((
73
+ <TestPropStoreContext.Provider value={propStore}>
74
+ <EspRouterContextProvider router={router}>
75
+ <EspModelContextProvider modelId={modelIdForContext}>
76
+ {componentOrElement},
77
+ </EspModelContextProvider>
78
+ </EspRouterContextProvider>
79
+ </TestPropStoreContext.Provider>
80
+ ));
81
+ return this;
82
+ }
83
+ } as TestApi;
84
+ };
@@ -0,0 +1,37 @@
1
+ import {observeEvent} from 'esp-js';
2
+ import {GetEspPolimerImmutableModelConsts} from '../../src';
3
+
4
+ export type TestModelImmutableState = { value: string, modelId: string };
5
+
6
+ export class TestModel {
7
+
8
+ private _internalState: TestModelImmutableState;
9
+
10
+ constructor(modelId: string) {
11
+ this._internalState = {
12
+ value: 'initial-value',
13
+ modelId: modelId,
14
+ };
15
+ }
16
+
17
+ public get valueViaModelGetter() {
18
+ return this._internalState.value;
19
+ }
20
+
21
+ public get modelIdViaModelGetter() {
22
+ return this._internalState.modelId;
23
+ }
24
+
25
+ @observeEvent('test-event')
26
+ _onTestEvent(ev: string) {
27
+ // mimic some immutable logic that would be provided by a lib such as immer in a real app.
28
+ this._internalState = {
29
+ ...this._internalState,
30
+ value: ev
31
+ };
32
+ }
33
+
34
+ [GetEspPolimerImmutableModelConsts.HandlerFunctionName]: () => TestModelImmutableState = () => {
35
+ return this._internalState;
36
+ };
37
+ }
@@ -0,0 +1,11 @@
1
+ import {createContext, useContext} from 'react';
2
+
3
+ export const TestPropStoreContext = createContext<TestPropStore>(null);
4
+ export const useTestPropStore = () => useContext(TestPropStoreContext);
5
+
6
+ export class TestPropStore {
7
+ receivedProps: any[] = [];
8
+ pushProps(props: any) {
9
+ this.receivedProps.push(props);
10
+ }
11
+ }
@@ -0,0 +1,46 @@
1
+ import * as React from 'react';
2
+ import {utils} from 'esp-js';
3
+
4
+ /**
5
+ * This is a bit of a hack to get the types and values of props passed into our HOC.
6
+ *
7
+ * React testing library doesn't have a lot of hooks for this, and generally you don't need to write HOC in modern React.
8
+ * However we need to support legacy code that uses the prop passing via HOC patterns.
9
+ * This function helps parse the props into attributes we can put on the DOM to asserts they are flowing through.
10
+ */
11
+ const getPropsAsDataAttributesWithMetadata = (props: any) => {
12
+ const propsAsDataAttributes: {[key: string]: string} = Object.keys(props).reduce((result: any, key: string) => {
13
+ let prop = props[key];
14
+ let value: string;
15
+ if (utils.isString(prop)) {
16
+ value = prop;
17
+ } else if (utils.isFunction(props)) {
18
+ value = 'function';
19
+ } else if (utils.isObject(props)) {
20
+ value = 'object';
21
+ } else {
22
+ value = String(props);
23
+ }
24
+ // need to lower case data-* attributes else React throws a warning
25
+ result[`data-${key.toLowerCase()}`] = value;
26
+ return result;
27
+ }, {});
28
+ return propsAsDataAttributes;
29
+ };
30
+
31
+ type ViewMetadataProps = {
32
+ modelId: string,
33
+ modelValue: string
34
+ [key: string]: string; // ...rest props
35
+ };
36
+
37
+ export const ViewMetadata = (props: ViewMetadataProps) => {
38
+ const { modelId, modelValue, ...rest} = props;
39
+ return (
40
+ <div>
41
+ <span data-testid='modelIdDisplay'>{modelId}</span>
42
+ <span data-testid='valueDisplay'>{modelValue}</span>
43
+ <span data-testid='span-with-props-as-attributes' {...getPropsAsDataAttributesWithMetadata(rest)} />
44
+ </div>
45
+ );
46
+ };
@@ -1,126 +1,26 @@
1
1
  import 'jest';
2
2
  import * as React from 'react';
3
3
  import {act} from 'react';
4
- import {configure, render, RenderResult} from '@testing-library/react';
5
- import {useModelSelector, EspModelContextProvider, EspRouterContextProvider, GetEspReactRenderModelConsts, modelSelectorOptions} from '../src';
6
- import {observeEvent} from 'esp-js';
7
- // import for extra asserts
8
- import '@testing-library/jest-dom';
9
- import {RouterSpy} from './routerSpy';
10
-
11
- type TestModelImmutableStateState = { value: string, modelId: string };
12
- configure({reactStrictMode: false});
13
-
14
- class TestModel {
15
-
16
- private _internalState: TestModelImmutableStateState;
17
-
18
- constructor(modelId: string) {
19
- this._internalState = {
20
- value: 'initial-value',
21
- modelId: modelId,
22
- };
23
- }
24
-
25
- public get valueViaModelGetter() {
26
- return this._internalState.value;
27
- }
28
-
29
- public get modelIdViaModelGetter() {
30
- return this._internalState.modelId;
31
- }
32
-
33
- @observeEvent('test-event')
34
- _onTestEvent(ev: string) {
35
- // mimic some immutable logic that would be provided by a lib such as immer in a real app.
36
- this._internalState = {
37
- ...this._internalState,
38
- value: ev
39
- };
40
- }
41
-
42
- [GetEspReactRenderModelConsts.HandlerFunctionName]: () => TestModelImmutableStateState = () => {
43
- return this._internalState;
44
- };
45
- }
46
-
47
- const ViewMetadata = ({modelId, modelValue}: {modelId: string, modelValue: string}) => {
48
- return (
49
- <div>
50
- <span data-testid='modelIdDisplay'>{modelId}</span>
51
- <span data-testid='valueDisplay'>{modelValue}</span>
52
- </div>
53
- );
54
- };
55
-
56
- const viewAsserts = (renderResult: RenderResult) => {
57
- let valueElement = renderResult.getByTestId('valueDisplay');
58
- let idElement = renderResult.getByTestId('modelIdDisplay');
59
-
60
- expect(valueElement).toBeInTheDocument();
61
- expect(idElement).toBeInTheDocument();
62
- return {
63
- modelIdIs(expected: string) {
64
- expect(idElement).toHaveTextContent(expected);
65
- return this;
66
- },
67
- valueIs(expected: string) {
68
- expect(valueElement).toHaveTextContent(expected);
69
- return this;
70
- },
71
- };
72
- };
73
-
74
- const routerAsserts = (routerSpy: RouterSpy) => {
75
- return {
76
- subscriberCountIs(modelId: string, expectedCount: number) {
77
- expect(routerSpy.getSubscriberCount(modelId)).toEqual(expectedCount);
78
- return this;
79
- },
80
- };
81
- };
4
+ import {modelSelectorOptions, useModelSelector} from '../src';
5
+ import {TestModel, TestModelImmutableState} from './testApi/testModel';
6
+ import {ViewMetadata} from './testApi/viewMetadata';
7
+ import {routerAsserts} from './testApi/asserts';
8
+ import {testApi, TestApi} from './testApi/testApi';
82
9
 
83
10
  type SelectedObject = { id: string, value: string };
84
11
 
85
12
  describe('useModelSelector', () => {
86
- let router: RouterSpy,
87
- renderResult: RenderResult;
13
+ let api: TestApi;
88
14
 
89
15
  beforeEach(() => {
90
- router = new RouterSpy();
16
+ api = testApi();
91
17
  });
92
18
 
93
- function setupModel(modelId: string) {
94
- const testModel = new TestModel(modelId);
95
- router.addModel(modelId, testModel);
96
- router.observeEventsOn(modelId, testModel);
97
- }
98
-
99
- function doRender(Component: React.ComponentType, modelIdForContext: string) {
100
- renderResult = render((
101
- <EspRouterContextProvider router={router}>
102
- <EspModelContextProvider modelId={modelIdForContext}>
103
- <Component/>,
104
- </EspModelContextProvider>
105
- </EspRouterContextProvider>
106
- ));
107
- }
108
-
109
- function doReRender(Component: React.ComponentType, modelIdForContext: string) {
110
- renderResult.rerender((
111
- <EspRouterContextProvider router={router}>
112
- <EspModelContextProvider modelId={modelIdForContext}>
113
- <Component/>,
114
- </EspModelContextProvider>
115
- </EspRouterContextProvider>
116
- ));
117
- }
118
-
119
19
  describe('Default API case', () => {
120
20
  const modelId = 'modelId';
121
21
 
122
22
  const View = () => {
123
- const valuesObj = useModelSelector<TestModelImmutableStateState, SelectedObject>(
23
+ const valuesObj = useModelSelector<TestModelImmutableState, SelectedObject>(
124
24
  model => {
125
25
  return {id: model.modelId, value: model.value};
126
26
  },
@@ -134,21 +34,20 @@ describe('useModelSelector', () => {
134
34
  };
135
35
 
136
36
  beforeEach(() => {
137
- setupModel(modelId);
138
- doRender(View, modelId);
37
+ api.setupModelAndRender(modelId, View);
139
38
  });
140
39
 
141
40
  it('renders immutable model based on modelId found on context', () => {
142
- viewAsserts(renderResult)
41
+ api.asserts.view
143
42
  .modelIdIs(modelId)
144
43
  .valueIs('initial-value');
145
44
  });
146
45
 
147
46
  it('updates are rendered', () => {
148
47
  act(() => {
149
- router.publishEvent(modelId, 'test-event', 'new-value');
48
+ api.router.publishEvent(modelId, 'test-event', 'new-value');
150
49
  });
151
- viewAsserts(renderResult)
50
+ api.asserts.view
152
51
  .modelIdIs(modelId)
153
52
  .valueIs('new-value');
154
53
  });
@@ -158,7 +57,7 @@ describe('useModelSelector', () => {
158
57
  const modelId = 'modelId';
159
58
 
160
59
  const View = () => {
161
- const values: string[] = useModelSelector<TestModelImmutableStateState, string[]>(
60
+ const values: string[] = useModelSelector<TestModelImmutableState, string[]>(
162
61
  model => [model.modelId, model.value],
163
62
  modelSelectorOptions().setModelId(modelId)
164
63
  );
@@ -171,12 +70,12 @@ describe('useModelSelector', () => {
171
70
  };
172
71
 
173
72
  beforeEach(() => {
174
- setupModel(modelId);
175
- doRender(View, undefined);
73
+ api.setupModel(modelId);
74
+ api.doRender(View, undefined);
176
75
  });
177
76
 
178
77
  it('renders correct model data', () => {
179
- viewAsserts(renderResult)
78
+ api.asserts.view
180
79
  .modelIdIs(modelId)
181
80
  .valueIs('initial-value');
182
81
  });
@@ -186,7 +85,7 @@ describe('useModelSelector', () => {
186
85
  const modelId = 'modelId';
187
86
 
188
87
  const View = () => {
189
- const values = useModelSelector<TestModelImmutableStateState, SelectedObject>(
88
+ const values = useModelSelector<TestModelImmutableState, SelectedObject>(
190
89
  model => ({id: model.modelId, value: model.value}),
191
90
  modelSelectorOptions<SelectedObject>()
192
91
  .setEqualityFn((a, b) => {
@@ -207,30 +106,29 @@ describe('useModelSelector', () => {
207
106
  };
208
107
 
209
108
  beforeEach(() => {
210
- setupModel(modelId);
211
- doRender(View, modelId);
109
+ api.setupModelAndRender(modelId, View);
212
110
  });
213
111
 
214
112
  it('renders initial model data', () => {
215
- viewAsserts(renderResult)
113
+ api.asserts.view
216
114
  .modelIdIs(modelId)
217
115
  .valueIs('initial-value');
218
116
  });
219
117
 
220
118
  it('updates are ignored due to equalityFn', () => {
221
- viewAsserts(renderResult)
119
+ api.asserts.view
222
120
  .modelIdIs(modelId)
223
121
  .valueIs('initial-value');
224
122
  act(() => {
225
- router.publishEvent(modelId, 'test-event', 'assume-no-change');
123
+ api.router.publishEvent(modelId, 'test-event', 'assume-no-change');
226
124
  });
227
- viewAsserts(renderResult)
125
+ api.asserts.view
228
126
  .modelIdIs(modelId)
229
127
  .valueIs('initial-value'); // event data WAS NOT propagated
230
128
  act(() => {
231
- router.publishEvent(modelId, 'test-event', 'do-change');
129
+ api.router.publishEvent(modelId, 'test-event', 'do-change');
232
130
  });
233
- viewAsserts(renderResult)
131
+ api.asserts.view
234
132
  .modelIdIs(modelId)
235
133
  .valueIs('do-change'); // event data WAS propagated
236
134
  });
@@ -241,7 +139,7 @@ describe('useModelSelector', () => {
241
139
  const modelId2 = 'modelId2';
242
140
 
243
141
  const View = (props: {modelId: string}) => {
244
- const values = useModelSelector<TestModelImmutableStateState, SelectedObject>(
142
+ const values = useModelSelector<TestModelImmutableState, SelectedObject>(
245
143
  model => ({id: model.modelId, value: model.value}),
246
144
  modelSelectorOptions().setModelId(props.modelId)
247
145
  );
@@ -254,36 +152,36 @@ describe('useModelSelector', () => {
254
152
  };
255
153
 
256
154
  beforeEach(() => {
257
- setupModel(modelId1);
258
- doRender(View, modelId1);
155
+ api.setupModel(modelId1);
156
+ api.doRender(View, modelId1);
259
157
  });
260
158
 
261
159
  it('selector subscribed to Router', () => {
262
- routerAsserts(router).subscriberCountIs(modelId1, 1);
160
+ routerAsserts(api.router).subscriberCountIs(modelId1, 1);
263
161
  });
264
162
 
265
163
  it('unsubscribes when modelId changes', () => {
266
- doReRender(View, undefined);
267
- routerAsserts(router).subscriberCountIs(modelId1, 0);
164
+ api.doReRender(View, undefined);
165
+ api.asserts.router.subscriberCountIs(modelId1, 0);
268
166
  });
269
167
 
270
168
  it('resubscribes to new model when modelId changes', () => {
271
- viewAsserts(renderResult)
169
+ api.asserts.view
272
170
  .modelIdIs(modelId1)
273
171
  .valueIs('initial-value');
274
- doReRender(View, undefined);
275
- viewAsserts(renderResult)
172
+ api.doReRender(View, undefined);
173
+ api.asserts.view
276
174
  .modelIdIs('')
277
175
  .valueIs('');
278
- setupModel(modelId2);
279
- doReRender(View, modelId2);
280
- viewAsserts(renderResult)
176
+ api.setupModel(modelId2);
177
+ api.doReRender(View, modelId2);
178
+ api.asserts.view
281
179
  .modelIdIs(modelId2)
282
180
  .valueIs('initial-value');
283
181
  act(() => {
284
- router.publishEvent(modelId2, 'test-event', 'updated');
182
+ api.router.publishEvent(modelId2, 'test-event', 'updated');
285
183
  });
286
- viewAsserts(renderResult)
184
+ api.asserts.view
287
185
  .modelIdIs(modelId2)
288
186
  .valueIs('updated');
289
187
  });
@@ -295,7 +193,7 @@ describe('useModelSelector', () => {
295
193
  const View = () => {
296
194
  const values: string[] = useModelSelector<TestModel, string[]>(
297
195
  model => {
298
- // here we're expecting to receive a TestModel, not testModelInstance[GetEspReactRenderModelConsts.HandlerFunctionName]()
196
+ // here we're expecting to receive a TestModel, not testModelInstance[GetEspPolimerImmutableModelConsts.HandlerFunctionName]()
299
197
  return [model.modelIdViaModelGetter, model.valueViaModelGetter];
300
198
  },
301
199
  modelSelectorOptions().setTryPreSelectPolimerImmutableModel(false)
@@ -309,14 +207,13 @@ describe('useModelSelector', () => {
309
207
  };
310
208
 
311
209
  beforeEach(() => {
312
- setupModel(modelId);
313
- doRender(View, modelId);
210
+ api.setupModelAndRender(modelId, View);
314
211
  });
315
212
 
316
213
  it('selector passes router root model to selector', () => {
317
214
  // Not much to test here, it's really in the View logic for this case.
318
215
  // If the below passes, it means the selector was given the root ESP model.
319
- viewAsserts(renderResult)
216
+ api.asserts.view
320
217
  .modelIdIs(modelId)
321
218
  .valueIs('initial-value');
322
219
  });
@@ -339,21 +236,20 @@ describe('useModelSelector', () => {
339
236
  };
340
237
 
341
238
  beforeEach(() => {
342
- setupModel(modelId);
343
- doRender(View, modelId);
239
+ api.setupModelAndRender(modelId, View);
344
240
  });
345
241
 
346
242
  it('view renders correct data', () => {
347
- viewAsserts(renderResult)
243
+ api.asserts.view
348
244
  .modelIdIs(modelId)
349
245
  .valueIs('initial-value');
350
246
  });
351
247
 
352
248
  it('Updates propagated', () => {
353
249
  act(() => {
354
- router.publishEvent(modelId, 'test-event', 'updated');
250
+ api.router.publishEvent(modelId, 'test-event', 'updated');
355
251
  });
356
- viewAsserts(renderResult)
252
+ api.asserts.view
357
253
  .modelIdIs(modelId)
358
254
  .valueIs('updated');
359
255
  });
@@ -1,21 +0,0 @@
1
- export interface GetEspReactRenderModelMetadata {
2
- functionName: string;
3
- }
4
- export declare namespace GetEspReactRenderModelConsts {
5
- const CustomDataKey = "GetEspReactRenderModelCustomDataKey";
6
- /**
7
- * If there is no @getEspReactRenderModel decorator and a function by this name exists on a model, then it will be invoked to identify the sub model which will replaced the `model` prop passed to the child view of a ConnectableComponent
8
- */
9
- const HandlerFunctionName = "getEspReactRenderModel";
10
- }
11
- /**
12
- * A decorator which can be used to identify the render model which will replaced the `model` prop passed to the child view of a ConnectableComponent
13
- */
14
- export declare function getEspReactRenderModel(): (target: any, name: any, descriptor: any) => any;
15
- /**
16
- * Returns the model which will be used to pluck state/props for the current view.
17
- *
18
- * This is basically a hook (not a React 'hook') to call a function on `model` and get a new subgraph to use as state.
19
- *
20
- */
21
- export declare const tryGetRenderModel: <TRenderModel>(model: any) => TRenderModel;
@@ -1,50 +0,0 @@
1
- import {EspMetadata, EspDecoratorUtil, utils} from 'esp-js';
2
-
3
- export interface GetEspReactRenderModelMetadata {
4
- functionName: string;
5
- }
6
-
7
- export namespace GetEspReactRenderModelConsts {
8
- export const CustomDataKey = 'GetEspReactRenderModelCustomDataKey';
9
- /**
10
- * If there is no @getEspReactRenderModel decorator and a function by this name exists on a model, then it will be invoked to identify the sub model which will replaced the `model` prop passed to the child view of a ConnectableComponent
11
- */
12
- export const HandlerFunctionName = 'getEspReactRenderModel';
13
- }
14
-
15
- /**
16
- * A decorator which can be used to identify the render model which will replaced the `model` prop passed to the child view of a ConnectableComponent
17
- */
18
- export function getEspReactRenderModel() {
19
- return function (target, name, descriptor) {
20
- let metadata: EspMetadata = EspDecoratorUtil.getOrCreateMetaData(target.constructor);
21
- metadata.addCustomData(
22
- GetEspReactRenderModelConsts.CustomDataKey,
23
- <GetEspReactRenderModelMetadata>{ functionName: name }
24
- );
25
- return descriptor;
26
- };
27
- }
28
-
29
- /**
30
- * Returns the model which will be used to pluck state/props for the current view.
31
- *
32
- * This is basically a hook (not a React 'hook') to call a function on `model` and get a new subgraph to use as state.
33
- *
34
- */
35
- export const tryGetRenderModel = <TRenderModel>(model: any): TRenderModel => {
36
- // does the given model have a decorated function we can invoke to get a different model to render?
37
- if (EspDecoratorUtil.hasMetadata(model)) {
38
- let metadata: GetEspReactRenderModelMetadata = EspDecoratorUtil.getCustomData(model, GetEspReactRenderModelConsts.CustomDataKey);
39
- if (metadata) {
40
- return model[metadata.functionName]();
41
- }
42
- }
43
- // else see if there is a function with name GetEspReactRenderModelConsts.HandlerFunctionName we can invoke to get a different model to render?
44
- let renderModelGetter = model[GetEspReactRenderModelConsts.HandlerFunctionName];
45
- if (renderModelGetter && utils.isFunction(renderModelGetter)) {
46
- return renderModelGetter.call(model);
47
- }
48
- // else return the initial model passed in
49
- return model;
50
- };
File without changes