@hyper-fetch/react 7.5.2 → 7.5.3

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 (70) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.base.spec.ts +115 -0
  2. package/__tests__/features/helpers/use-request-events/use-request-events.utils.spec.ts +69 -0
  3. package/__tests__/features/helpers/use-socket-state/use-socket-state.base.spec.ts +175 -0
  4. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +382 -0
  5. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.base.spec.ts +527 -0
  6. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.utils.spec.ts +260 -0
  7. package/__tests__/features/provider/provider.hydration.spec.tsx +161 -0
  8. package/__tests__/features/provider/use-config-provider.base.spec.tsx +68 -0
  9. package/__tests__/features/use-app-manager/use-app-manager.base.spec.ts +85 -0
  10. package/__tests__/features/use-cache/use-cache.base.spec.ts +133 -0
  11. package/__tests__/features/use-cache/use-cache.helpers.ts +40 -0
  12. package/__tests__/features/use-emitter/use-emitter.base.spec.ts +124 -0
  13. package/__tests__/features/use-fetch/use-fetch.base.spec.ts +284 -0
  14. package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +83 -0
  15. package/__tests__/features/use-fetch/use-fetch.concurrency.spec.ts +91 -0
  16. package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +153 -0
  17. package/__tests__/features/use-fetch/use-fetch.deduplication.spec.ts +80 -0
  18. package/__tests__/features/use-fetch/use-fetch.infinite.ts +39 -0
  19. package/__tests__/features/use-fetch/use-fetch.integration.spec.tsx +172 -0
  20. package/__tests__/features/use-fetch/use-fetch.methods.spec.ts +233 -0
  21. package/__tests__/features/use-fetch/use-fetch.offline.spec.ts +103 -0
  22. package/__tests__/features/use-fetch/use-fetch.pagination.ts +36 -0
  23. package/__tests__/features/use-fetch/use-fetch.prefetch.spec.tsx +73 -0
  24. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +153 -0
  25. package/__tests__/features/use-fetch/use-fetch.rerender.spec.tsx +151 -0
  26. package/__tests__/features/use-fetch/use-fetch.retry.ts +38 -0
  27. package/__tests__/features/use-fetch/use-fetch.revalidate.spec.ts +235 -0
  28. package/__tests__/features/use-fetch/use-fetch.suspense.ts +37 -0
  29. package/__tests__/features/use-fetch/use-fetch.typescript.spec.ts +59 -0
  30. package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +26 -0
  31. package/__tests__/features/use-fetch/use-fetch.window.spec.ts +59 -0
  32. package/__tests__/features/use-listener/use-listener.base.spec.ts +57 -0
  33. package/__tests__/features/use-queue/use-queue.actions.spec.ts +238 -0
  34. package/__tests__/features/use-queue/use-queue.base.spec.ts +109 -0
  35. package/__tests__/features/use-submit/use-submit.base.spec.ts +76 -0
  36. package/__tests__/features/use-submit/use-submit.cancel.spec.ts +46 -0
  37. package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +62 -0
  38. package/__tests__/features/use-submit/use-submit.debounce.spec.ts +320 -0
  39. package/__tests__/features/use-submit/use-submit.methods.spec.ts +278 -0
  40. package/__tests__/features/use-submit/use-submit.queue.spec.ts +84 -0
  41. package/__tests__/features/use-submit/use-submit.retry.spec.ts +92 -0
  42. package/__tests__/features/use-submit/use-submit.revalidate.spec.ts +99 -0
  43. package/__tests__/features/use-submit/use-submit.submit.spec.ts +233 -0
  44. package/__tests__/global.d.ts +1 -0
  45. package/__tests__/jest.setup.ts +9 -0
  46. package/__tests__/shared/index.ts +2 -0
  47. package/__tests__/shared/isolation.tests.ts +12 -0
  48. package/__tests__/shared/response.tests.ts +127 -0
  49. package/__tests__/tsconfig.json +8 -0
  50. package/__tests__/utils/cache.utils.ts +53 -0
  51. package/__tests__/utils/client.utils.ts +3 -0
  52. package/__tests__/utils/emitter.utils.ts +7 -0
  53. package/__tests__/utils/helpers.utils.ts +9 -0
  54. package/__tests__/utils/index.ts +14 -0
  55. package/__tests__/utils/listener.utils.ts +10 -0
  56. package/__tests__/utils/request.utils.ts +12 -0
  57. package/__tests__/utils/state.utils.ts +7 -0
  58. package/__tests__/utils/use-app-manager.utils.ts +10 -0
  59. package/__tests__/utils/use-cache.utils.ts +11 -0
  60. package/__tests__/utils/use-emitter.utils.ts +11 -0
  61. package/__tests__/utils/use-fetch.utils.ts +11 -0
  62. package/__tests__/utils/use-listener.utils.ts +11 -0
  63. package/__tests__/utils/use-queue.utils.ts +68 -0
  64. package/__tests__/utils/use-request-events.utils.ts +42 -0
  65. package/__tests__/utils/use-socket-state.utils.ts +11 -0
  66. package/__tests__/utils/use-submit.utils.ts +11 -0
  67. package/__tests__/utils/use-tracked-state.utils.ts +26 -0
  68. package/jest.config.ts +6 -0
  69. package/package.json +1 -1
  70. package/project.json +4 -0
@@ -0,0 +1,103 @@
1
+ import { waitFor, act } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { testErrorState, testSuccessState } from "../../shared";
5
+ import { client, createRequest, renderUseFetch, waitForRender } from "../../utils";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ describe("useFetch [ Offline ]", () => {
10
+ let request = createRequest({ offline: true });
11
+
12
+ beforeAll(() => {
13
+ startServer();
14
+ });
15
+
16
+ afterEach(() => {
17
+ resetMocks();
18
+ });
19
+
20
+ afterAll(() => {
21
+ stopServer();
22
+ });
23
+
24
+ beforeEach(() => {
25
+ jest.resetModules();
26
+ request = createRequest({ offline: true });
27
+ client.clear();
28
+ });
29
+
30
+ describe("when application is offline", () => {
31
+ it("should not refetch on offline", async () => {
32
+ const mock = mockRequest(request);
33
+ const response = renderUseFetch(request);
34
+
35
+ await testSuccessState(mock, response);
36
+
37
+ const spy = jest.spyOn(client.adapter, "fetch");
38
+
39
+ act(() => {
40
+ client.appManager.setOnline(false);
41
+ response.result.current.refetch();
42
+ });
43
+
44
+ expect(spy).toHaveBeenCalledTimes(0);
45
+ });
46
+ it("should finish request when coming back online", async () => {
47
+ client.appManager.setOnline(false);
48
+
49
+ const mock = mockRequest(request);
50
+ const response = renderUseFetch(request);
51
+
52
+ act(() => {
53
+ client.appManager.setOnline(true);
54
+ });
55
+ await testSuccessState(mock, response);
56
+ });
57
+ it("should refetch when coming back online", async () => {
58
+ const spy = jest.fn();
59
+ const mock = mockRequest(request);
60
+ const response = renderUseFetch(request, { refetchOnReconnect: true });
61
+ await testSuccessState(mock, response);
62
+
63
+ act(() => {
64
+ response.result.current.onRequestStart(spy);
65
+ client.appManager.setOnline(false);
66
+ client.appManager.setOnline(true);
67
+ });
68
+ await waitFor(() => {
69
+ expect(spy).toHaveBeenCalledTimes(1);
70
+ });
71
+ });
72
+ });
73
+ describe("when request offline attribute is set to true", () => {
74
+ it("should not emit offline error until request is finished", async () => {
75
+ const mock = mockRequest(request);
76
+ const response = renderUseFetch(request);
77
+ await waitForRender();
78
+ act(() => {
79
+ client.appManager.setOnline(false);
80
+ });
81
+ await waitForRender();
82
+ act(() => {
83
+ client.appManager.setOnline(true);
84
+ });
85
+ await testSuccessState(mock, response);
86
+ });
87
+ });
88
+ describe("when request offline attribute is set to false", () => {
89
+ it("should emit offline error until request is finished", async () => {
90
+ const mock = mockRequest(request, { status: 400 });
91
+ const response = renderUseFetch(request.setOffline(false));
92
+ await waitForRender();
93
+ act(() => {
94
+ client.appManager.setOnline(false);
95
+ });
96
+ await waitForRender();
97
+ act(() => {
98
+ client.appManager.setOnline(true);
99
+ });
100
+ await testErrorState(mock, response);
101
+ });
102
+ });
103
+ });
@@ -0,0 +1,36 @@
1
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
2
+
3
+ import { client } from "../../utils";
4
+
5
+ const { resetMocks, startServer, stopServer } = createHttpMockingServer();
6
+
7
+ describe("useFetch [ Pagination ]", () => {
8
+ beforeAll(() => {
9
+ startServer();
10
+ });
11
+
12
+ afterEach(() => {
13
+ resetMocks();
14
+ });
15
+
16
+ afterAll(() => {
17
+ stopServer();
18
+ });
19
+
20
+ beforeEach(() => {
21
+ jest.resetModules();
22
+ client.clear();
23
+ });
24
+
25
+ describe("when request query params are changed", () => {
26
+ it("should allow to see previous results until new page is loaded", async () => {
27
+ // TODO
28
+ });
29
+ it("should not override previous results by initialData", async () => {
30
+ // TODO
31
+ });
32
+ it("should cache pages on change", async () => {
33
+ // TODO
34
+ });
35
+ });
36
+ });
@@ -0,0 +1,73 @@
1
+ import { render, screen, waitFor } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { useFetch } from "hooks/use-fetch";
5
+ import { client, createRequest } from "../../utils";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ describe("useFetch [ Prefetch ]", () => {
10
+ let request = createRequest<any, undefined>();
11
+ let mock = mockRequest(request);
12
+
13
+ beforeAll(() => {
14
+ startServer();
15
+ });
16
+
17
+ afterEach(() => {
18
+ resetMocks();
19
+ });
20
+
21
+ afterAll(() => {
22
+ stopServer();
23
+ });
24
+
25
+ beforeEach(() => {
26
+ jest.resetModules();
27
+ client.clear();
28
+ mock = mockRequest(request);
29
+ request = createRequest();
30
+ });
31
+
32
+ describe("when request is triggered while mounting page", () => {
33
+ it("should pre-fetch data", async () => {
34
+ await request.send({});
35
+
36
+ mockRequest(request, { data: { wrongData: 123 } });
37
+
38
+ const Page = () => {
39
+ const { data } = useFetch(request, { revalidate: false });
40
+ return <div>{JSON.stringify(data)}</div>;
41
+ };
42
+
43
+ render(<Page />);
44
+
45
+ await waitFor(async () => {
46
+ const successData = await screen.findByText(JSON.stringify(mock));
47
+ expect(successData).toBeInTheDocument();
48
+ });
49
+ });
50
+ it("should not show error when pre-fetching is failed and fetch again", async () => {
51
+ const errorMock = mockRequest(request, { status: 400 });
52
+
53
+ await request.send({});
54
+
55
+ const successMock = mockRequest(request);
56
+
57
+ const Page = () => {
58
+ const { data } = useFetch(request, { revalidate: false });
59
+ return <div>{JSON.stringify(data)}</div>;
60
+ };
61
+
62
+ render(<Page />);
63
+
64
+ const errorData = await screen.queryByText(JSON.stringify(errorMock));
65
+ expect(errorData).not.toBeInTheDocument();
66
+
67
+ await waitFor(async () => {
68
+ const successData = await screen.findByText(JSON.stringify(successMock));
69
+ expect(successData).toBeInTheDocument();
70
+ });
71
+ });
72
+ });
73
+ });
@@ -0,0 +1,153 @@
1
+ import { act } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { client, createRequest, renderUseFetch, waitForRender } from "../../utils";
5
+
6
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
7
+
8
+ describe("useFetch [ Refreshing ]", () => {
9
+ const hookOptions = {
10
+ refresh: true,
11
+ refreshTime: 100,
12
+ refetchBlurred: true,
13
+ refetchOnReconnect: true,
14
+ refetchOnBlur: true,
15
+ refetchOnFocus: true,
16
+ };
17
+
18
+ let request = createRequest();
19
+
20
+ beforeAll(() => {
21
+ startServer();
22
+ });
23
+
24
+ afterEach(() => {
25
+ resetMocks();
26
+ });
27
+
28
+ afterAll(() => {
29
+ stopServer();
30
+ });
31
+
32
+ beforeEach(() => {
33
+ jest.resetModules();
34
+ request = createRequest();
35
+ client.clear();
36
+ });
37
+
38
+ it("should refetch data after refresh time of 200ms", async () => {
39
+ const spy = jest.fn();
40
+ mockRequest(request);
41
+ const { result } = renderUseFetch(request, hookOptions);
42
+
43
+ act(() => {
44
+ result.current.onRequestStart(spy);
45
+ });
46
+
47
+ await waitForRender();
48
+ expect(spy).toHaveBeenCalledTimes(1);
49
+ await waitForRender(hookOptions.refreshTime * 1.5);
50
+
51
+ expect(spy).toHaveBeenCalledTimes(2);
52
+ });
53
+ it("should refresh blurred tab", async () => {
54
+ const spy = jest.fn();
55
+ mockRequest(request);
56
+ const { result } = renderUseFetch(request, { ...hookOptions, refetchOnBlur: false });
57
+
58
+ act(() => {
59
+ result.current.onRequestStart(spy);
60
+ client.appManager.setFocused(false);
61
+ });
62
+
63
+ await waitForRender();
64
+ await waitForRender(hookOptions.refreshTime * 1.5);
65
+ expect(spy).toHaveBeenCalledTimes(2);
66
+ });
67
+ it("should not refresh blurred tab", async () => {
68
+ const spy = jest.fn();
69
+ mockRequest(request);
70
+ const { result } = renderUseFetch(request, { ...hookOptions, refetchOnBlur: false, refetchBlurred: false });
71
+
72
+ act(() => {
73
+ result.current.onRequestStart(spy);
74
+ client.appManager.setFocused(false);
75
+ });
76
+
77
+ await waitForRender();
78
+ await waitForRender(hookOptions.refreshTime * 1.5);
79
+ expect(spy).toHaveBeenCalledTimes(1);
80
+ });
81
+ it("should postpone refresh when invalidation is triggered during countdown", async () => {
82
+ // TODO
83
+ });
84
+ it("should postpone refresh when dependencies change during countdown", async () => {
85
+ // TODO
86
+ });
87
+ it("should stop refreshing when value is changing from true to false", async () => {
88
+ const spy = jest.fn();
89
+ mockRequest(request);
90
+ const { result, rerender } = renderUseFetch(request, hookOptions);
91
+
92
+ act(() => {
93
+ result.current.onRequestStart(spy);
94
+ });
95
+
96
+ await waitForRender();
97
+ expect(spy).toHaveBeenCalledTimes(1);
98
+ await waitForRender(hookOptions.refreshTime * 1.5);
99
+
100
+ expect(spy).toHaveBeenCalledTimes(2);
101
+
102
+ act(() => {
103
+ rerender({ refresh: false });
104
+ });
105
+
106
+ await waitForRender(hookOptions.refreshTime * 1.5);
107
+
108
+ expect(spy).toHaveBeenCalledTimes(2);
109
+ });
110
+ it("should refetch when tab is focused and refetchOnFocus is true", async () => {
111
+ const spy = jest.fn();
112
+ mockRequest(request);
113
+ const { result } = renderUseFetch(request, { ...hookOptions });
114
+
115
+ act(() => {
116
+ result.current.onRequestStart(spy);
117
+ });
118
+
119
+ await waitForRender();
120
+ expect(spy).toHaveBeenCalledTimes(1);
121
+
122
+ // Simulate tab focus
123
+ act(() => {
124
+ client.appManager.setFocused(true);
125
+ });
126
+
127
+ await waitForRender();
128
+ expect(spy).toHaveBeenCalledTimes(2);
129
+ });
130
+ it("should not refetch when tab is focused and refetchOnFocus is false", async () => {
131
+ const spy = jest.fn();
132
+ mockRequest(request);
133
+ const { result } = renderUseFetch(request, {
134
+ ...hookOptions,
135
+ refetchOnFocus: false,
136
+ });
137
+
138
+ act(() => {
139
+ result.current.onRequestStart(spy);
140
+ });
141
+
142
+ await waitForRender();
143
+ expect(spy).toHaveBeenCalledTimes(1);
144
+
145
+ // Simulate tab focus
146
+ act(() => {
147
+ client.appManager.setFocused(true);
148
+ });
149
+
150
+ await waitForRender();
151
+ expect(spy).toHaveBeenCalledTimes(1);
152
+ });
153
+ });
@@ -0,0 +1,151 @@
1
+ import { useRef } from "react";
2
+ import { useDidMount, useDidUpdate } from "@better-hooks/lifecycle";
3
+ import { render } from "@testing-library/react";
4
+ import { createHttpMockingServer, sleep } from "@hyper-fetch/testing";
5
+
6
+ import { useFetch } from "hooks/use-fetch";
7
+ import { client, createRequest, waitForRender } from "../../utils";
8
+
9
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
10
+
11
+ // TODO fix error logs
12
+ const useWillMount = (fn: () => void) => {
13
+ const mounted = useRef(false);
14
+
15
+ if (!mounted.current) {
16
+ mounted.current = true;
17
+ fn();
18
+ }
19
+ };
20
+
21
+ describe("useFetch [ Rerender ]", () => {
22
+ let rerenders = 0;
23
+ let request = createRequest();
24
+
25
+ const fetchTime = 20;
26
+ const waitForDoubleFetch = async () => {
27
+ await waitForRender();
28
+ await sleep(fetchTime);
29
+ await waitForRender(fetchTime);
30
+ await sleep(fetchTime);
31
+ await waitForRender(fetchTime);
32
+ };
33
+
34
+ beforeAll(() => {
35
+ startServer();
36
+ });
37
+
38
+ afterEach(() => {
39
+ resetMocks();
40
+ });
41
+
42
+ afterAll(() => {
43
+ stopServer();
44
+ });
45
+
46
+ beforeEach(() => {
47
+ jest.resetModules();
48
+ rerenders = 0;
49
+ request = createRequest();
50
+ client.clear();
51
+ mockRequest(request, { delay: fetchTime });
52
+ });
53
+
54
+ // FIXES https://github.com/BetterTyped/hyper-fetch/issues/94
55
+ it("should start in loading state", async () => {
56
+ let isLoading = false;
57
+
58
+ function Page() {
59
+ const { loading } = useFetch(request);
60
+
61
+ useWillMount(() => {
62
+ isLoading = loading;
63
+ });
64
+
65
+ rerenders += 1;
66
+
67
+ return <div>{loading ? "loading" : "error"}</div>;
68
+ }
69
+
70
+ render(<Page />);
71
+
72
+ await waitForDoubleFetch();
73
+ await sleep(200);
74
+
75
+ expect(isLoading).toBe(true);
76
+ expect(rerenders).toBe(2);
77
+ });
78
+
79
+ it("should not rerender when the same data is received from backend", async () => {
80
+ const Page = () => {
81
+ const { data } = useFetch(request, { refresh: false, refreshTime: 0 });
82
+
83
+ rerenders += 1;
84
+
85
+ return <div>{JSON.stringify(data)}</div>;
86
+ };
87
+
88
+ render(<Page />);
89
+ await waitForDoubleFetch();
90
+
91
+ expect(rerenders).toBe(2);
92
+ });
93
+ it("should not rerender when changed key is not used", async () => {
94
+ const Page = () => {
95
+ const { setError, setResponseTimestamp } = useFetch(request);
96
+
97
+ rerenders += 1;
98
+
99
+ useDidMount(() => {
100
+ setResponseTimestamp(new Date());
101
+ setTimeout(() => {
102
+ setError(new Error("test"), true);
103
+ }, fetchTime / 2);
104
+ });
105
+
106
+ return <div>test</div>;
107
+ };
108
+
109
+ render(<Page />);
110
+
111
+ await waitForDoubleFetch();
112
+
113
+ expect(rerenders).toBe(1);
114
+ });
115
+ it("should rerender when dependency tracking is off", async () => {
116
+ const Page = () => {
117
+ const { data } = useFetch(request, { dependencyTracking: false });
118
+
119
+ rerenders += 1;
120
+
121
+ return <div>{JSON.stringify(data)}</div>;
122
+ };
123
+
124
+ render(<Page />);
125
+
126
+ await waitForDoubleFetch();
127
+
128
+ expect(rerenders).toBe(2);
129
+ });
130
+ it("should rerender while using the changed key", async () => {
131
+ const Page = () => {
132
+ const { data, setData } = useFetch(request);
133
+
134
+ rerenders += 1;
135
+
136
+ useDidUpdate(() => {
137
+ if (data) {
138
+ setData(null);
139
+ }
140
+ }, [data]);
141
+
142
+ return <div>{JSON.stringify(data)}</div>;
143
+ };
144
+
145
+ render(<Page />);
146
+
147
+ await waitForDoubleFetch();
148
+
149
+ expect(rerenders).toBe(3);
150
+ });
151
+ });
@@ -0,0 +1,38 @@
1
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
2
+
3
+ const { resetMocks, startServer, stopServer } = createHttpMockingServer();
4
+
5
+ describe("useFetch [ Retry ]", () => {
6
+ beforeAll(() => {
7
+ startServer();
8
+ });
9
+
10
+ afterEach(() => {
11
+ resetMocks();
12
+ });
13
+
14
+ afterAll(() => {
15
+ stopServer();
16
+ });
17
+
18
+ beforeEach(() => {
19
+ jest.resetModules();
20
+ });
21
+
22
+ describe("when request retry attribute is set to false", () => {
23
+ it("should not retry request on failure", async () => {
24
+ // Todo
25
+ });
26
+ });
27
+ describe("when request retry attribute is set to true", () => {
28
+ it("should retry request once", async () => {
29
+ // Todo
30
+ });
31
+ it("should retry request twice", async () => {
32
+ // Todo
33
+ });
34
+ it("should trigger retries with the config interval", async () => {
35
+ // Todo
36
+ });
37
+ });
38
+ });