@applicaster/zapp-react-native-ui-components 14.0.0-alpha.2523527255 → 14.0.0-alpha.2893452677

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 (41) hide show
  1. package/Components/BaseFocusable/index.tsx +23 -12
  2. package/Components/Cell/__tests__/CellWIthFocusable.test.js +3 -2
  3. package/Components/FeedLoader/FeedLoader.tsx +6 -15
  4. package/Components/FeedLoader/FeedLoaderHOC.tsx +21 -0
  5. package/Components/FeedLoader/index.js +2 -8
  6. package/Components/FreezeWithCallback/__tests__/index.test.tsx +67 -43
  7. package/Components/GeneralContentScreen/utils/useCurationAPI.ts +5 -6
  8. package/Components/Layout/TV/__tests__/index.test.tsx +0 -1
  9. package/Components/MasterCell/DefaultComponents/ActionButton.tsx +2 -0
  10. package/Components/MasterCell/DefaultComponents/__tests__/image.test.js +10 -10
  11. package/Components/MasterCell/DefaultComponents/__tests__/text.test.tsx +18 -18
  12. package/Components/MasterCell/SharedUI/CollapsibleTextContainer/__tests__/index.test.tsx +10 -10
  13. package/Components/MasterCell/utils/behaviorProvider.ts +2 -2
  14. package/Components/MasterCell/utils/index.ts +1 -15
  15. package/Components/OfflineHandler/__tests__/index.test.tsx +6 -13
  16. package/Components/River/ComponentsMap/hooks/__tests__/useLoadingState.test.ts +378 -0
  17. package/Components/River/ComponentsMap/hooks/useLoadingState.ts +2 -2
  18. package/Components/River/RefreshControl.tsx +11 -19
  19. package/Components/River/__tests__/river.test.js +12 -26
  20. package/Components/Screen/__tests__/Screen.test.tsx +5 -17
  21. package/Components/Tabs/Tabs.tsx +2 -3
  22. package/Components/Touchable/__tests__/touchable.test.tsx +12 -17
  23. package/Components/Transitioner/Scene.tsx +0 -1
  24. package/Components/VideoModal/ModalAnimation/AnimatedScrollModal.tsx +3 -9
  25. package/Components/VideoModal/__tests__/PlayerDetails.test.tsx +5 -5
  26. package/Contexts/ConfigutaionContext/__tests__/ConfigurationProvider.test.tsx +3 -3
  27. package/Contexts/ScreenContext/index.tsx +46 -6
  28. package/Decorators/ConfigurationWrapper/__tests__/withConfigurationProvider.test.tsx +3 -3
  29. package/Decorators/RiverFeedLoader/__tests__/__snapshots__/riverFeedLoader.test.tsx.snap +221 -209
  30. package/Decorators/RiverFeedLoader/__tests__/riverFeedLoader.test.tsx +14 -16
  31. package/Decorators/RiverFeedLoader/__tests__/utils.test.ts +0 -20
  32. package/Decorators/RiverFeedLoader/index.tsx +21 -9
  33. package/Decorators/RiverFeedLoader/utils/index.ts +0 -23
  34. package/Decorators/ZappPipesDataConnector/__tests__/UrlFeedResolver.test.tsx +27 -27
  35. package/Decorators/ZappPipesDataConnector/resolvers/UrlFeedResolver.tsx +21 -10
  36. package/Decorators/ZappPipesDataConnector/utils/index.ts +0 -40
  37. package/Decorators/ZappPipesDataConnector/utils/mongoFilter.ts +738 -0
  38. package/Decorators/ZappPipesDataConnector/utils/useFilter.tsx +136 -0
  39. package/events/index.ts +1 -0
  40. package/package.json +5 -6
  41. package/Components/River/__tests__/__snapshots__/river.test.js.snap +0 -27
@@ -24,7 +24,7 @@ const parseContextKey = (
24
24
  const getDataSourceProvider = (
25
25
  behavior: Behavior,
26
26
  screenRoute: string,
27
- screenStateStore: ScreenStateStore
27
+ screenStateStore: ReturnType<typeof useScreenStateStore>
28
28
  ): BehaviorSubject<string[] | string> | null => {
29
29
  if (!behavior) return null;
30
30
 
@@ -116,7 +116,7 @@ export const isCellSelected = ({
116
116
  }: {
117
117
  item: ZappEntry;
118
118
  screenRoute: string;
119
- screenStateStore: ScreenStateStore;
119
+ screenStateStore: ReturnType<typeof useScreenStateStore>;
120
120
  behavior?: Behavior;
121
121
  }): boolean => {
122
122
  if (!behavior) return false;
@@ -192,20 +192,6 @@ export const getFocusedButtonId = (focusable) => {
192
192
  });
193
193
  };
194
194
 
195
- export const isSelected = ({
196
- item,
197
- screenRoute,
198
- screenStateStore,
199
- behavior,
200
- }: {
201
- item: ZappEntry;
202
- screenRoute: string;
203
- screenStateStore: ScreenStateStore;
204
- behavior?: Behavior;
205
- }) => {
206
- return isCellSelected({ item, screenRoute, screenStateStore, behavior });
207
- };
208
-
209
195
  export const useCellState = ({
210
196
  item,
211
197
  behavior,
@@ -221,7 +207,7 @@ export const useCellState = ({
221
207
 
222
208
  const _isSelected = useMemo(
223
209
  () =>
224
- isSelected({
210
+ isCellSelected({
225
211
  item,
226
212
  screenRoute: router?.pathname,
227
213
  screenStateStore,
@@ -1,6 +1,5 @@
1
1
  import React from "react";
2
-
3
- import renderer, { act } from "react-test-renderer";
2
+ import { render } from "@testing-library/react-native";
4
3
 
5
4
  jest.useFakeTimers({ legacyFakeTimers: true });
6
5
 
@@ -49,24 +48,18 @@ describe("OfflineHandler", () => {
49
48
  const { OfflineHandler, NotificationView } = require("../");
50
49
 
51
50
  it("renders", () => {
52
- const instance = renderer.create(<OfflineHandler />);
53
- expect(instance.toJSON()).toMatchSnapshot();
51
+ const { toJSON } = render(<OfflineHandler />);
52
+ expect(toJSON()).toMatchSnapshot();
54
53
  });
55
54
 
56
55
  it("renders Notification mode if component was rendered while online", () => {
57
56
  mockConnectionStatus = true;
58
57
 
59
- let instance;
60
-
61
- act(() => {
62
- instance = renderer.create(<OfflineHandler />);
63
- });
58
+ const { rerender, UNSAFE_getByType } = render(<OfflineHandler />);
64
59
 
65
- act(() => {
66
- instance.update(<OfflineHandler />);
67
- });
60
+ rerender(<OfflineHandler />);
68
61
 
69
- const notificationsView = instance.root.findByType(NotificationView);
62
+ const notificationsView = UNSAFE_getByType(NotificationView);
70
63
  expect(notificationsView).toBeDefined();
71
64
  });
72
65
  });
@@ -0,0 +1,378 @@
1
+ import { renderHook, act } from "@testing-library/react-hooks";
2
+ import { BehaviorSubject } from "rxjs";
3
+ import { useLoadingState } from "../useLoadingState";
4
+
5
+ jest.mock(
6
+ "@applicaster/zapp-react-native-utils/reactHooks/state/useRefWithInitialValue",
7
+ () => ({
8
+ useRefWithInitialValue: jest.fn((initializer) => ({
9
+ current: initializer(),
10
+ })),
11
+ })
12
+ );
13
+
14
+ describe("useLoadingState", () => {
15
+ let onLoadDone: jest.Mock;
16
+
17
+ beforeEach(() => {
18
+ onLoadDone = jest.fn();
19
+ jest.clearAllMocks();
20
+ });
21
+
22
+ describe("initialization", () => {
23
+ it("should initialize with correct default state for zero components", () => {
24
+ const { result } = renderHook(() => useLoadingState(0, onLoadDone));
25
+
26
+ const initialState = result.current.loadingState.getValue();
27
+
28
+ expect(initialState).toEqual({
29
+ index: -1,
30
+ done: true,
31
+ waitForAllComponents: false,
32
+ });
33
+
34
+ expect(result.current.shouldShowLoadingError).toBe(false);
35
+ });
36
+
37
+ it("should initialize with correct default state for multiple components", () => {
38
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone));
39
+
40
+ const initialState = result.current.loadingState.getValue();
41
+
42
+ expect(initialState).toEqual({
43
+ index: -1,
44
+ done: false,
45
+ waitForAllComponents: false,
46
+ });
47
+
48
+ expect(result.current.shouldShowLoadingError).toBe(false);
49
+ });
50
+
51
+ it("should return a BehaviorSubject for loadingState", () => {
52
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone));
53
+
54
+ expect(result.current.loadingState).toBeInstanceOf(BehaviorSubject);
55
+ });
56
+ });
57
+
58
+ describe("arePreviousComponentsLoaded", () => {
59
+ it("should return true for index 0 (first component)", () => {
60
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone));
61
+
62
+ expect(result.current.arePreviousComponentsLoaded(0)).toBe(true);
63
+ });
64
+
65
+ it("should return false when previous components are not loaded", () => {
66
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone));
67
+
68
+ expect(result.current.arePreviousComponentsLoaded(1)).toBe(false);
69
+ expect(result.current.arePreviousComponentsLoaded(2)).toBe(false);
70
+ });
71
+
72
+ it("should return true when all previous components are loaded", () => {
73
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone));
74
+
75
+ act(() => {
76
+ result.current.onLoadFinished(0);
77
+ });
78
+
79
+ expect(result.current.arePreviousComponentsLoaded(1)).toBe(true);
80
+ expect(result.current.arePreviousComponentsLoaded(2)).toBe(false);
81
+
82
+ act(() => {
83
+ result.current.onLoadFinished(1);
84
+ });
85
+
86
+ expect(result.current.arePreviousComponentsLoaded(2)).toBe(true);
87
+ });
88
+ });
89
+
90
+ describe("onLoadFinished", () => {
91
+ it("should update component state and loading state when component finishes loading", () => {
92
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone));
93
+
94
+ act(() => {
95
+ result.current.onLoadFinished(0);
96
+ });
97
+
98
+ const state = result.current.loadingState.getValue();
99
+ expect(state.index).toBe(0);
100
+ expect(state.done).toBe(false);
101
+ });
102
+
103
+ it("should update index to highest loaded component", () => {
104
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone));
105
+
106
+ act(() => {
107
+ result.current.onLoadFinished(2);
108
+ });
109
+
110
+ let state = result.current.loadingState.getValue();
111
+ expect(state.index).toBe(2);
112
+
113
+ act(() => {
114
+ result.current.onLoadFinished(1);
115
+ });
116
+
117
+ state = result.current.loadingState.getValue();
118
+ expect(state.index).toBe(2); // Should remain 2, not decrease to 1
119
+ });
120
+
121
+ it("should mark as done when all components are loaded", () => {
122
+ const { result } = renderHook(() => useLoadingState(2, onLoadDone));
123
+
124
+ act(() => {
125
+ result.current.onLoadFinished(0);
126
+ });
127
+
128
+ let state = result.current.loadingState.getValue();
129
+ expect(state.done).toBe(true); // True because arePreviousComponentsLoaded(1) returns true when component 0 is loaded
130
+ expect(onLoadDone).toHaveBeenCalledTimes(1);
131
+
132
+ act(() => {
133
+ result.current.onLoadFinished(1);
134
+ });
135
+
136
+ state = result.current.loadingState.getValue();
137
+ expect(state.done).toBe(true);
138
+ expect(onLoadDone).toHaveBeenCalledTimes(2); // Called again
139
+ });
140
+
141
+ it("should call onLoadDone when count is 0", () => {
142
+ const { result } = renderHook(() => useLoadingState(0, onLoadDone));
143
+
144
+ const state = result.current.loadingState.getValue();
145
+ expect(state.done).toBe(true);
146
+ // onLoadDone is not called on initialization for count 0, only when all components are loaded via dispatch
147
+ });
148
+
149
+ it("should handle loading components out of order", () => {
150
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone));
151
+
152
+ // Load component 2 first
153
+ act(() => {
154
+ result.current.onLoadFinished(2);
155
+ });
156
+
157
+ let state = result.current.loadingState.getValue();
158
+ expect(state.done).toBe(false);
159
+
160
+ // Load component 0
161
+ act(() => {
162
+ result.current.onLoadFinished(0);
163
+ });
164
+
165
+ state = result.current.loadingState.getValue();
166
+ expect(state.done).toBe(false);
167
+
168
+ // Load component 1 - should complete loading
169
+ act(() => {
170
+ result.current.onLoadFinished(1);
171
+ });
172
+
173
+ state = result.current.loadingState.getValue();
174
+ expect(state.done).toBe(true);
175
+ expect(onLoadDone).toHaveBeenCalledTimes(1);
176
+ });
177
+
178
+ it("should call onLoadDone again on subsequent dispatches", () => {
179
+ const { result } = renderHook(() => useLoadingState(2, onLoadDone));
180
+
181
+ act(() => {
182
+ result.current.onLoadFinished(0);
183
+ result.current.onLoadFinished(1);
184
+ });
185
+
186
+ expect(onLoadDone).toHaveBeenCalledTimes(2); // Called for each dispatch when done is true
187
+
188
+ // Try loading again - onLoadDone will be called again because dispatch runs again
189
+ act(() => {
190
+ result.current.onLoadFinished(0);
191
+ });
192
+
193
+ expect(onLoadDone).toHaveBeenCalledTimes(3); // Will be called again
194
+ });
195
+ });
196
+
197
+ describe("onLoadFailed", () => {
198
+ it("should treat failed components as loaded when SHOULD_FAIL_ON_COMPONENT_LOADING is false", () => {
199
+ const { result } = renderHook(() => useLoadingState(2, onLoadDone));
200
+
201
+ const error = new Error("Load failed");
202
+
203
+ act(() => {
204
+ result.current.onLoadFailed({ error, index: 0 });
205
+ });
206
+
207
+ const state = result.current.loadingState.getValue();
208
+ expect(state.index).toBe(0);
209
+ expect(result.current.shouldShowLoadingError).toBe(false);
210
+ });
211
+
212
+ it("should complete loading when all components fail", () => {
213
+ const { result } = renderHook(() => useLoadingState(2, onLoadDone));
214
+
215
+ const error = new Error("Load failed");
216
+
217
+ act(() => {
218
+ result.current.onLoadFailed({ error, index: 0 });
219
+ result.current.onLoadFailed({ error, index: 1 });
220
+ });
221
+
222
+ const state = result.current.loadingState.getValue();
223
+ expect(state.done).toBe(true);
224
+ expect(onLoadDone).toHaveBeenCalledTimes(2); // Called for each failed component
225
+ });
226
+
227
+ it("should handle mixed success and failure", () => {
228
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone));
229
+
230
+ const error = new Error("Load failed");
231
+
232
+ act(() => {
233
+ result.current.onLoadFinished(0);
234
+ result.current.onLoadFailed({ error, index: 1 });
235
+ result.current.onLoadFinished(2);
236
+ });
237
+
238
+ const state = result.current.loadingState.getValue();
239
+ expect(state.done).toBe(true);
240
+ expect(onLoadDone).toHaveBeenCalledTimes(2); // Called when all components 0,1,2 are handled
241
+ });
242
+ });
243
+
244
+ describe("loading state observable", () => {
245
+ it("should emit state changes through BehaviorSubject", () => {
246
+ const { result } = renderHook(() => useLoadingState(3, onLoadDone)); // Use 3 components so loading component 0 doesn't complete everything
247
+ const mockSubscriber = jest.fn();
248
+
249
+ result.current.loadingState.subscribe(mockSubscriber);
250
+
251
+ act(() => {
252
+ result.current.onLoadFinished(0);
253
+ });
254
+
255
+ // Should have been called twice: initial state + update
256
+ expect(mockSubscriber).toHaveBeenCalledTimes(2);
257
+
258
+ expect(mockSubscriber).toHaveBeenLastCalledWith({
259
+ index: 0,
260
+ done: false, // Will be false because we need components 1 and 2 as well
261
+ waitForAllComponents: false,
262
+ });
263
+ });
264
+
265
+ it("should preserve waitForAllComponents flag in state updates", () => {
266
+ const { result } = renderHook(() => useLoadingState(2, onLoadDone));
267
+
268
+ act(() => {
269
+ result.current.onLoadFinished(0);
270
+ });
271
+
272
+ const state = result.current.loadingState.getValue();
273
+ expect(state.waitForAllComponents).toBe(false);
274
+ });
275
+ });
276
+
277
+ describe("memoization", () => {
278
+ it("should return stable references for functions", () => {
279
+ const { result, rerender } = renderHook(() =>
280
+ useLoadingState(2, onLoadDone)
281
+ );
282
+
283
+ const firstRender = {
284
+ onLoadFinished: result.current.onLoadFinished,
285
+ onLoadFailed: result.current.onLoadFailed,
286
+ arePreviousComponentsLoaded: result.current.arePreviousComponentsLoaded,
287
+ };
288
+
289
+ rerender();
290
+
291
+ expect(result.current.onLoadFinished).toBe(firstRender.onLoadFinished);
292
+ expect(result.current.onLoadFailed).toBe(firstRender.onLoadFailed);
293
+
294
+ expect(result.current.arePreviousComponentsLoaded).toBe(
295
+ firstRender.arePreviousComponentsLoaded
296
+ );
297
+ });
298
+
299
+ it("should return stable function references (current behavior)", () => {
300
+ const { result, rerender } = renderHook(
301
+ ({ onLoadDone }) => useLoadingState(2, onLoadDone),
302
+ { initialProps: { onLoadDone } }
303
+ );
304
+
305
+ const firstResult = result.current;
306
+
307
+ const newOnLoadDone = jest.fn();
308
+ rerender({ onLoadDone: newOnLoadDone });
309
+
310
+ // Functions should remain the same due to empty dependency arrays (this is the current behavior)
311
+ expect(result.current.onLoadFinished).toBe(firstResult.onLoadFinished);
312
+ expect(result.current.onLoadFailed).toBe(firstResult.onLoadFailed);
313
+ });
314
+ });
315
+
316
+ describe("edge cases", () => {
317
+ it("should handle duplicate load finished calls gracefully", () => {
318
+ const { result } = renderHook(() => useLoadingState(2, onLoadDone));
319
+
320
+ act(() => {
321
+ result.current.onLoadFinished(0);
322
+ result.current.onLoadFinished(0); // Duplicate call
323
+ });
324
+
325
+ const state = result.current.loadingState.getValue();
326
+ expect(state.index).toBe(0);
327
+ expect(state.done).toBe(true); // True because loading component 0 makes it done in a 2-component setup
328
+ });
329
+
330
+ it("should handle loading index greater than component count", () => {
331
+ const { result } = renderHook(() => useLoadingState(2, onLoadDone));
332
+
333
+ act(() => {
334
+ result.current.onLoadFinished(5); // Index out of bounds
335
+ });
336
+
337
+ const state = result.current.loadingState.getValue();
338
+ expect(state.index).toBe(5);
339
+ expect(state.done).toBe(false); // Should not be done as not all components loaded
340
+ });
341
+
342
+ it("should handle negative indices", () => {
343
+ const { result } = renderHook(() => useLoadingState(2, onLoadDone));
344
+
345
+ act(() => {
346
+ result.current.onLoadFinished(-1);
347
+ });
348
+
349
+ const state = result.current.loadingState.getValue();
350
+ expect(state.index).toBe(-1); // Should remain -1
351
+ });
352
+ });
353
+
354
+ describe("component count changes", () => {
355
+ it("should handle changing component count", () => {
356
+ const { result, rerender } = renderHook(
357
+ ({ count }) => useLoadingState(count, onLoadDone),
358
+ { initialProps: { count: 2 } }
359
+ );
360
+
361
+ act(() => {
362
+ result.current.onLoadFinished(0);
363
+ });
364
+
365
+ // Change count
366
+ rerender({ count: 3 });
367
+
368
+ // The hook should work with the new count
369
+ act(() => {
370
+ result.current.onLoadFinished(1);
371
+ result.current.onLoadFinished(2);
372
+ });
373
+
374
+ const state = result.current.loadingState.getValue();
375
+ expect(state.done).toBe(true);
376
+ });
377
+ });
378
+ });
@@ -1,5 +1,5 @@
1
1
  import * as React from "react";
2
- import { isNil, set, lensIndex, T, slice } from "ramda";
2
+ import { isNil, set, lensIndex, slice } from "ramda";
3
3
  import { BehaviorSubject } from "rxjs";
4
4
  import { useRefWithInitialValue } from "@applicaster/zapp-react-native-utils/reactHooks/state/useRefWithInitialValue";
5
5
 
@@ -53,7 +53,7 @@ export const useLoadingState = (
53
53
 
54
54
  const componentsBefore = slice(0, index, componentStateRef.current);
55
55
 
56
- return componentsBefore.every(T);
56
+ return componentsBefore.every(Boolean);
57
57
  }, []);
58
58
 
59
59
  const dispatch = React.useCallback(({ payload }) => {
@@ -13,10 +13,7 @@ import { useCurrentScreenData } from "@applicaster/zapp-react-native-utils/react
13
13
  import { useShallow } from "zustand/react/shallow";
14
14
  import { useScreenContextV2 } from "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext";
15
15
  import { useSafeAreaInsets } from "react-native-safe-area-context";
16
- import {
17
- ZappPipes,
18
- useAppDispatch,
19
- } from "@applicaster/zapp-react-native-redux";
16
+ import { useLoadPipesDataDispatch } from "@applicaster/zapp-react-native-utils/reactHooks";
20
17
 
21
18
  const BRIGHTNESS_THRESHOLD = 160;
22
19
  const ABOVE_DEFAULT_COLOR = "gray";
@@ -63,38 +60,33 @@ export const usePullToRefresh = (
63
60
  ) => {
64
61
  const isPipesV1 = !!pullToRefreshPipesV1RefreshingStateUpdater;
65
62
 
66
- const dispatch = useAppDispatch();
67
-
68
63
  const [refreshing, setRefreshing] = React.useState(false);
69
64
 
70
65
  const feeds: string[] =
71
66
  riverComponents?.map(R.path(["data", "source"])).filter((feed) => !!feed) ??
72
67
  [];
73
68
 
74
- const screenData = useCurrentScreenData();
75
-
76
69
  const feedsLength = feeds.length;
77
70
 
78
71
  const [requestsCompletedCounter, setRequestsCompletedCounter] =
79
72
  React.useState(0);
80
73
 
74
+ const loadPipesDataDispatcher = useLoadPipesDataDispatch();
75
+
81
76
  React.useEffect(() => {
82
77
  // will not work for pipes v1 on 1st level screens
83
78
  if (refreshing && !isPipesV1) {
84
79
  feeds.forEach((feed) => {
85
- dispatch(
86
- ZappPipes.loadPipesData(feed, {
87
- silentRefresh: true,
88
- clearCache: true,
89
- callback: () => {
90
- setRequestsCompletedCounter(R.inc);
91
- },
92
- riverId: screenData.id,
93
- })
94
- );
80
+ loadPipesDataDispatcher(feed, {
81
+ silentRefresh: true,
82
+ clearCache: true,
83
+ callback: () => {
84
+ setRequestsCompletedCounter(R.inc);
85
+ },
86
+ });
95
87
  });
96
88
  }
97
- }, [refreshing, isPipesV1]);
89
+ }, [refreshing, isPipesV1, feeds, loadPipesDataDispatcher]);
98
90
 
99
91
  React.useEffect(() => {
100
92
  if (requestsCompletedCounter === feedsLength) {
@@ -1,20 +1,10 @@
1
1
  import React from "react";
2
- import { render, screen } from "@testing-library/react-native";
3
- import configureStore from "redux-mock-store";
2
+ import { screen } from "@testing-library/react-native";
4
3
  import { renderWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
5
- import { Provider } from "react-redux";
6
4
 
7
- import { River } from "../";
8
5
  import { ScreenResolver } from "../../ScreenResolver";
9
6
  import { RiverComponent } from "../River";
10
7
 
11
- jest.mock(
12
- "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive",
13
- () => ({
14
- useIsScreenActive: jest.fn(() => true),
15
- })
16
- );
17
-
18
8
  jest.mock(
19
9
  "@applicaster/zapp-react-native-ui-components/Components/GeneralContentScreen",
20
10
  () => {
@@ -46,6 +36,13 @@ jest.mock(
46
36
  })
47
37
  );
48
38
 
39
+ jest.mock(
40
+ "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive",
41
+ () => ({
42
+ useIsScreenActive: jest.fn(() => true),
43
+ })
44
+ );
45
+
49
46
  const river = {
50
47
  home: true,
51
48
  id: "A1234",
@@ -89,28 +86,17 @@ const riverProps = {
89
86
 
90
87
  const appData = { layoutVersion: "v1" };
91
88
 
92
- const store = configureStore()({ rivers, appData });
89
+ const store = { rivers, appData };
93
90
 
94
91
  describe("When River has a general_content type", () => {
95
92
  it("renders GeneralContentScreen correctly", () => {
96
- const { getByTestId } = render(
97
- <Provider store={store}>
98
- <RiverComponent {...riverProps} />
99
- </Provider>
93
+ const { getByTestId } = renderWithProviders(
94
+ <RiverComponent {...riverProps} />,
95
+ store
100
96
  );
101
97
 
102
98
  expect(getByTestId("general-content-screen")).toBeTruthy();
103
99
  });
104
-
105
- it("renders River component correctly", () => {
106
- const wrapper = render(
107
- <Provider store={store}>
108
- <River screenId="A1234" />
109
- </Provider>
110
- );
111
-
112
- expect(wrapper.toJSON()).toMatchSnapshot();
113
- });
114
100
  });
115
101
 
116
102
  describe("When River has any other type other than general_content", () => {
@@ -1,6 +1,6 @@
1
1
  import * as React from "react";
2
2
  import { View } from "react-native";
3
- import { act, create } from "react-test-renderer";
3
+ import { render } from "@testing-library/react-native";
4
4
 
5
5
  const Mocked_RouteManager = jest.fn((props) => (
6
6
  <View testID="routeManager" {...props} />
@@ -152,8 +152,6 @@ const screenProps = {
152
152
  const { Screen } = require("..");
153
153
 
154
154
  describe("<Screen Component />", () => {
155
- let wrapper;
156
-
157
155
  beforeEach(() => {
158
156
  allowedOrientationsForScreen.mockClear();
159
157
  getOrientation.mockClear();
@@ -161,26 +159,16 @@ describe("<Screen Component />", () => {
161
159
  });
162
160
 
163
161
  describe("when the navbar should show", () => {
164
- act(() => {
165
- wrapper = create(<Screen {...screenProps} />);
166
- });
167
-
168
162
  it("renders correctly", () => {
169
- expect(wrapper.toJSON()).toMatchSnapshot();
163
+ const { toJSON } = render(<Screen {...screenProps} />);
164
+ expect(toJSON()).toMatchSnapshot();
170
165
  });
171
166
  });
172
167
 
173
168
  describe("when the navbar should be hidden", () => {
174
- beforeEach(() => {
175
- wrapper = create(<Screen {...screenProps} />);
176
- });
177
-
178
169
  it("renders correctly", () => {
179
- act(() => {
180
- wrapper = create(<Screen {...screenProps} />);
181
- });
182
-
183
- expect(wrapper.toJSON()).toMatchSnapshot();
170
+ const { toJSON } = render(<Screen {...screenProps} />);
171
+ expect(toJSON()).toMatchSnapshot();
184
172
  });
185
173
  });
186
174
  });
@@ -158,12 +158,11 @@ const TabsComponent = ({
158
158
 
159
159
  const renderItem = React.useCallback(
160
160
  ({ item, index, item: { id } }: RenderItemProps) => (
161
- <>
161
+ <React.Fragment key={id}>
162
162
  <Tab
163
163
  ref={(ref) => {
164
164
  tabRefs.current[index] = ref;
165
165
  }}
166
- key={id}
167
166
  {...{
168
167
  title: getTitle(item),
169
168
  id,
@@ -177,7 +176,7 @@ const TabsComponent = ({
177
176
  {display_mode === "fractional" &&
178
177
  index !== tabs?.length - 1 &&
179
178
  renderGutter()}
180
- </>
179
+ </React.Fragment>
181
180
  ),
182
181
  [tabs, display_mode, configuration, onTabPress, getTitle, getSelectedItem]
183
182
  );