@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,92 @@
1
+ import { act, waitFor } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { client, createRequest, renderUseSubmit, waitForRender } from "../../utils";
5
+
6
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
7
+
8
+ describe("useSubmit [ Retry ]", () => {
9
+ let request = createRequest<{ response: null; payload: null }>({ method: "POST" });
10
+
11
+ beforeAll(() => {
12
+ startServer();
13
+ });
14
+
15
+ afterEach(() => {
16
+ resetMocks();
17
+ });
18
+
19
+ afterAll(() => {
20
+ stopServer();
21
+ });
22
+
23
+ beforeEach(() => {
24
+ jest.resetModules();
25
+ client.clear();
26
+ request = createRequest({ method: "POST" });
27
+ });
28
+
29
+ describe("when request retry attribute is set to false", () => {
30
+ it("should not retry request on failure", async () => {
31
+ const spy = jest.fn();
32
+ mockRequest(request, { status: 400, delay: 5 });
33
+ const response = renderUseSubmit(request.setRetry(0).setRetryTime(0));
34
+
35
+ act(() => {
36
+ response.result.current.onSubmitRequestStart(spy);
37
+ response.result.current.submit();
38
+ });
39
+
40
+ await waitForRender(150);
41
+
42
+ expect(spy).toHaveBeenCalledTimes(1);
43
+ });
44
+ });
45
+ describe("when request retry attribute is set to true", () => {
46
+ it("should retry request once", async () => {
47
+ const spy = jest.fn();
48
+ mockRequest(request, { status: 400, delay: 5 });
49
+ const response = renderUseSubmit(request.setRetry(1).setRetryTime(10));
50
+
51
+ act(() => {
52
+ response.result.current.onSubmitRequestStart(spy);
53
+ response.result.current.submit();
54
+ });
55
+
56
+ await waitForRender(150);
57
+
58
+ expect(spy).toHaveBeenCalledTimes(2);
59
+ });
60
+ it("should retry request twice", async () => {
61
+ const spy = jest.fn();
62
+ mockRequest(request, { status: 400, delay: 5 });
63
+ const response = renderUseSubmit(request.setRetry(2).setRetryTime(10));
64
+
65
+ act(() => {
66
+ response.result.current.onSubmitRequestStart(spy);
67
+ response.result.current.submit();
68
+ });
69
+
70
+ await waitForRender(150);
71
+
72
+ expect(spy).toHaveBeenCalledTimes(3);
73
+ });
74
+ it("should trigger retries with the config interval", async () => {
75
+ const time: number[] = [];
76
+ mockRequest(request, { status: 400, delay: 0 });
77
+ const response = renderUseSubmit(request.setRetry(1).setRetryTime(100));
78
+
79
+ act(() => {
80
+ response.result.current.onSubmitRequestStart(() => {
81
+ time.push(+new Date());
82
+ });
83
+ response.result.current.submit();
84
+ });
85
+
86
+ await waitFor(() => {
87
+ expect(time[1] - time[0]);
88
+ expect(time[1] - time[0]).toBeGreaterThan(99);
89
+ });
90
+ });
91
+ });
92
+ });
@@ -0,0 +1,99 @@
1
+ import { act } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { testErrorState, testSuccessState } from "../../shared";
5
+ import { client, createRequest, renderUseFetch, renderUseSubmit } from "../../utils";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ // Todo: refactor all tests after changes in the refetch function
10
+ describe("useFetch [ refetch ]", () => {
11
+ let requestSubmit = createRequest<{ response: null; payload: null }>({ method: "POST" });
12
+ let requestFetch = createRequest({ endpoint: "fetch-test" });
13
+
14
+ beforeAll(() => {
15
+ startServer();
16
+ });
17
+
18
+ afterEach(() => {
19
+ resetMocks();
20
+ });
21
+
22
+ afterAll(() => {
23
+ stopServer();
24
+ });
25
+
26
+ beforeEach(() => {
27
+ jest.resetModules();
28
+ client.clear();
29
+ requestSubmit = createRequest({ method: "POST" });
30
+ requestFetch = createRequest({ endpoint: "fetch-test" });
31
+ });
32
+
33
+ it("should allow to refetch other request on finished", async () => {
34
+ const submitMock = mockRequest(requestSubmit);
35
+ const errorFetchMock = mockRequest(requestFetch, { status: 400 });
36
+ const responseSubmit = renderUseSubmit(requestSubmit);
37
+ const responseFetch = renderUseFetch(requestFetch);
38
+
39
+ await testErrorState(errorFetchMock, responseFetch);
40
+ const fetchMock = mockRequest(requestFetch);
41
+
42
+ act(() => {
43
+ responseSubmit.result.current.onSubmitFinished(() => {
44
+ requestFetch.client.cache.invalidate(requestFetch);
45
+ });
46
+ responseSubmit.result.current.submit();
47
+ });
48
+
49
+ await testSuccessState(submitMock, responseSubmit);
50
+ await testSuccessState(fetchMock, responseFetch);
51
+ });
52
+ it("should allow to refetch by Request", async () => {
53
+ const spy = jest.spyOn(client.cache, "invalidate");
54
+
55
+ renderUseSubmit(requestSubmit);
56
+
57
+ act(() => {
58
+ client.cache.invalidate(requestSubmit);
59
+ });
60
+
61
+ expect(spy).toHaveBeenCalledTimes(1);
62
+ expect(spy).toHaveBeenCalledWith(requestSubmit);
63
+ });
64
+ it("should allow to refetch by RegExp", async () => {
65
+ const spy = jest.spyOn(client.cache, "invalidate");
66
+
67
+ renderUseSubmit(requestSubmit);
68
+
69
+ act(() => {
70
+ client.cache.invalidate(new RegExp(requestSubmit.cacheKey));
71
+ });
72
+
73
+ expect(spy).toHaveBeenCalledTimes(1);
74
+ expect(spy).toHaveBeenCalledWith(new RegExp(requestSubmit.cacheKey));
75
+ });
76
+ it("should allow to refetch by cacheKey", async () => {
77
+ const spy = jest.spyOn(client.cache, "invalidate");
78
+
79
+ renderUseSubmit(requestSubmit);
80
+
81
+ act(() => {
82
+ client.cache.invalidate(requestSubmit.cacheKey);
83
+ });
84
+
85
+ expect(spy).toHaveBeenCalledTimes(1);
86
+ expect(spy).toHaveBeenCalledWith(requestSubmit.cacheKey);
87
+ });
88
+ it("should allow to refetch without key", async () => {
89
+ const spy = jest.spyOn(client.cache, "invalidate");
90
+
91
+ const { result } = renderUseSubmit(requestSubmit);
92
+
93
+ act(() => {
94
+ result.current.refetch();
95
+ });
96
+
97
+ expect(spy).toHaveBeenCalledTimes(1);
98
+ });
99
+ });
@@ -0,0 +1,233 @@
1
+ import { ExtendRequest, RequestSendType, xhrExtra } from "@hyper-fetch/core";
2
+ import { act } from "@testing-library/react";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+
5
+ import { client, createRequest, renderUseSubmit } from "../../utils";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ describe("useSubmit [ Base ]", () => {
10
+ let request = createRequest<{ payload: { value: string }; queryParams?: Record<string, string> | string }>({
11
+ method: "POST",
12
+ });
13
+
14
+ beforeAll(() => {
15
+ startServer();
16
+ });
17
+
18
+ afterEach(() => {
19
+ resetMocks();
20
+ });
21
+
22
+ afterAll(() => {
23
+ stopServer();
24
+ });
25
+
26
+ beforeEach(() => {
27
+ jest.resetModules();
28
+ client.clear();
29
+ request = createRequest({ method: "POST" });
30
+ });
31
+
32
+ describe("when submit method gets triggered", () => {
33
+ it("should return data from submit method", async () => {
34
+ let data: unknown = null;
35
+ const mock = mockRequest(request);
36
+ const response = renderUseSubmit(request);
37
+
38
+ await act(async () => {
39
+ data = await response.result.current.submit({ payload: { value: "string" } });
40
+ });
41
+
42
+ expect(data).toStrictEqual({
43
+ data: mock,
44
+ error: null,
45
+ status: 200,
46
+ success: true,
47
+ extra: { headers: { "content-type": "application/json", "content-length": "2" } },
48
+ responseTimestamp: expect.toBeNumber(),
49
+ requestTimestamp: expect.toBeNumber(),
50
+ });
51
+ });
52
+ it("should call onBeforeSent", async () => {
53
+ const spy = jest.fn();
54
+ mockRequest(request);
55
+ const response = renderUseSubmit(request);
56
+
57
+ await act(async () => {
58
+ await response.result.current.submit({ payload: { value: "string" }, onBeforeSent: spy });
59
+ });
60
+
61
+ expect(spy).toHaveBeenCalledTimes(1);
62
+ });
63
+ it("should return data from submit method on retries", async () => {
64
+ let data: unknown = null;
65
+ let mock: unknown = {};
66
+ mockRequest(request, { status: 400 });
67
+ const response = renderUseSubmit(request.setRetry(1).setRetryTime(10));
68
+
69
+ await act(async () => {
70
+ response.result.current.onSubmitResponseStart(() => {
71
+ mock = mockRequest(request);
72
+ });
73
+ data = await response.result.current.submit({ payload: { value: "string" } });
74
+ });
75
+
76
+ expect(data).toStrictEqual({
77
+ data: mock,
78
+ error: null,
79
+ status: 200,
80
+ success: true,
81
+ extra: { headers: { "content-type": "application/json", "content-length": "2" } },
82
+ responseTimestamp: expect.toBeNumber(),
83
+ requestTimestamp: expect.toBeNumber(),
84
+ });
85
+ });
86
+ it("should return data from submit method on offline", async () => {
87
+ let data: unknown = null;
88
+ let mock: unknown = {};
89
+ mockRequest(request, { status: 400 });
90
+ const response = renderUseSubmit(request.setOffline(true));
91
+
92
+ await act(async () => {
93
+ response.result.current.onSubmitResponseStart(() => {
94
+ client.appManager.setOnline(false);
95
+ mock = mockRequest(request);
96
+ setTimeout(() => {
97
+ client.appManager.setOnline(true);
98
+ }, 100);
99
+ });
100
+ data = await response.result.current.submit({ payload: { value: "string" } });
101
+ });
102
+
103
+ expect(data).toStrictEqual({
104
+ data: mock,
105
+ error: null,
106
+ status: 200,
107
+ success: true,
108
+ extra: { headers: { "content-type": "application/json", "content-length": "2" } },
109
+ responseTimestamp: expect.toBeNumber(),
110
+ requestTimestamp: expect.toBeNumber(),
111
+ });
112
+ });
113
+ it("should allow to change submit details", async () => {
114
+ // Todo
115
+ });
116
+ it("should allow to pass payload to submit", async () => {
117
+ let payload: unknown = null;
118
+ const myData = { value: "string" };
119
+ mockRequest(request);
120
+ const response = renderUseSubmit(request);
121
+
122
+ await act(async () => {
123
+ response.result.current.onSubmitRequestStart(({ request: cmd }) => {
124
+ payload = cmd.payload;
125
+ });
126
+ response.result.current.submit({ payload: myData });
127
+ });
128
+
129
+ expect(payload).toStrictEqual(myData);
130
+ });
131
+ it("should allow to pass params to submit", async () => {
132
+ let endpoint: unknown = null;
133
+ const requestWithParams = createRequest({ endpoint: "/users/:userId" });
134
+ mockRequest(requestWithParams.setParams({ userId: 1 } as any));
135
+ const response = renderUseSubmit(requestWithParams);
136
+
137
+ await act(async () => {
138
+ response.result.current.onSubmitRequestStart(({ request: cmd }) => {
139
+ endpoint = cmd.endpoint;
140
+ });
141
+ response.result.current.submit({ params: { userId: 1 } } as any);
142
+ });
143
+
144
+ expect(endpoint).toBe("/users/1");
145
+ });
146
+ it("should allow to pass query params to submit", async () => {
147
+ let endpoint: unknown = null;
148
+ let queryParams: unknown = null;
149
+ mockRequest(request);
150
+ const response = renderUseSubmit(
151
+ request as unknown as ExtendRequest<typeof request, { payload: { value: string }; queryParams: string }>,
152
+ );
153
+
154
+ await act(async () => {
155
+ response.result.current.onSubmitRequestStart(({ request: cmd }) => {
156
+ endpoint = cmd.endpoint;
157
+ queryParams = cmd.queryParams;
158
+ });
159
+ response.result.current.submit({ payload: { value: "string" }, queryParams: "?something=test" });
160
+ });
161
+
162
+ expect(endpoint).toBe("/shared-endpoint");
163
+ expect(queryParams).toBe("?something=test");
164
+ });
165
+ it("should trigger methods when submit modifies the queue keys", async () => {
166
+ let data: unknown = null;
167
+ const mock = mockRequest(request);
168
+ const response = renderUseSubmit(
169
+ request as unknown as ExtendRequest<typeof request, { payload: { value: string }; queryParams: string }>,
170
+ );
171
+
172
+ await act(async () => {
173
+ data = await response.result.current.submit({ payload: { value: "123" }, queryParams: "?something=test" });
174
+ });
175
+
176
+ expect(data).toStrictEqual({
177
+ data: mock,
178
+ error: null,
179
+ status: 200,
180
+ success: true,
181
+ extra: { headers: { "content-type": "application/json", "content-length": "2" } },
182
+ responseTimestamp: expect.toBeNumber(),
183
+ requestTimestamp: expect.toBeNumber(),
184
+ });
185
+ });
186
+ it("should throw error when hook is disabled", async () => {
187
+ let res: Awaited<ReturnType<RequestSendType<typeof request>>> = {} as Awaited<
188
+ ReturnType<RequestSendType<typeof request>>
189
+ >;
190
+ mockRequest(request);
191
+ const response = renderUseSubmit(request, { disabled: true });
192
+
193
+ await act(async () => {
194
+ res = await response.result.current.submit({ payload: { value: "string" } });
195
+ });
196
+
197
+ expect(res.data).toBeNull();
198
+ expect(res.error).toBeInstanceOf(Error);
199
+ expect(res.status).toBe(null);
200
+ expect(res.extra).toStrictEqual(xhrExtra);
201
+ });
202
+ it("should allow to set data on mapped request", async () => {
203
+ let data: unknown = null;
204
+ const mock = mockRequest(request);
205
+ const mappedRequest = (
206
+ request as unknown as ExtendRequest<
207
+ typeof request,
208
+ { payload: { value: string }; queryParams: { something: string } }
209
+ >
210
+ ).setPayloadMapper(() => new FormData());
211
+ const response = renderUseSubmit(mappedRequest);
212
+
213
+ await act(async () => {
214
+ data = await response.result.current.submit({
215
+ payload: {
216
+ value: "string",
217
+ },
218
+ queryParams: { something: "test" },
219
+ });
220
+ });
221
+
222
+ expect(data).toStrictEqual({
223
+ data: mock,
224
+ error: null,
225
+ status: 200,
226
+ success: true,
227
+ extra: { headers: { "content-type": "application/json", "content-length": "2" } },
228
+ responseTimestamp: expect.toBeNumber(),
229
+ requestTimestamp: expect.toBeNumber(),
230
+ });
231
+ });
232
+ });
233
+ });
@@ -0,0 +1 @@
1
+ import "jest-extended";
@@ -0,0 +1,9 @@
1
+ // jest-dom adds custom jest matchers for asserting on DOM nodes.
2
+ // allows you to do things like:
3
+ // expect(element).toHaveTextContent(/react/i)
4
+ // learn more: https://github.com/testing-library/jest-dom
5
+ import "@testing-library/jest-dom";
6
+
7
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
8
+ // @ts-ignore
9
+ global.IS_REACT_ACT_ENVIRONMENT = true;
@@ -0,0 +1,2 @@
1
+ export * from "./response.tests";
2
+ export * from "./isolation.tests";
@@ -0,0 +1,12 @@
1
+ import { waitFor } from "@testing-library/react";
2
+ import { ClientInstance } from "@hyper-fetch/core";
3
+
4
+ export const testClientIsolation = async (client: ClientInstance) => {
5
+ await waitFor(() => {
6
+ expect(client.fetchDispatcher.getAllRunningRequests()).toStrictEqual([]);
7
+ expect(client.submitDispatcher.getAllRunningRequests()).toStrictEqual([]);
8
+
9
+ const cacheKeys = client.cache.keys();
10
+ expect(cacheKeys).toStrictEqual([]);
11
+ });
12
+ };
@@ -0,0 +1,127 @@
1
+ import { waitFor, RenderHookResult } from "@testing-library/react";
2
+ import { ResponseType, RequestInstance, AdapterInstance } from "@hyper-fetch/core";
3
+
4
+ import { UseFetchReturnType } from "hooks/use-fetch";
5
+ import { UseSubmitReturnType } from "hooks/use-submit";
6
+ import { getCurrentState } from "../utils";
7
+
8
+ export const testInitialState = <H extends RenderHookResult<any, any>>(render: H, expectedLoading = true) => {
9
+ const response = getCurrentState(render);
10
+ expect(response.data).toBe(null);
11
+ expect(response.status).toBe(null);
12
+ expect(response.error).toBe(null);
13
+ if (typeof response.submitting === "boolean") {
14
+ expect(response.submitting).toBe(false);
15
+ } else {
16
+ expect(response.loading).toBe(expectedLoading);
17
+ }
18
+ };
19
+
20
+ export const testSuccessState = async <
21
+ T extends UseFetchReturnType<RequestInstance> | UseSubmitReturnType<RequestInstance>,
22
+ H extends RenderHookResult<any, any>,
23
+ >(
24
+ mock: T["data"],
25
+ render: H,
26
+ ) => {
27
+ await waitFor(() => {
28
+ const response = getCurrentState(render);
29
+ expect(response.data).toStrictEqual(mock as Record<string, unknown>);
30
+ expect(response.data).toBeDefined();
31
+ expect(response.success).toBeTrue();
32
+ expect(response.status).toBe(200);
33
+ expect(response.extra).toHaveProperty("headers");
34
+ expect(response.retries).toBeNumber();
35
+
36
+ expect(response.responseTimestamp).toBeDate();
37
+ expect(response.requestTimestamp).toBeDate();
38
+ if (typeof response.submitting === "boolean") {
39
+ expect(response.submitting).toBe(false);
40
+ } else {
41
+ expect(response.loading).toBe(false);
42
+ }
43
+ expect(response.error).toBe(null);
44
+ });
45
+ };
46
+
47
+ export const testErrorState = async <
48
+ T extends UseFetchReturnType<RequestInstance>,
49
+ H extends RenderHookResult<any, any>,
50
+ >(
51
+ mock: T["error"],
52
+ render: H,
53
+ data: any | null = null,
54
+ ) => {
55
+ await waitFor(() => {
56
+ const response = getCurrentState(render);
57
+ const status = response.status || 0;
58
+ expect(response.error).toStrictEqual(mock);
59
+ expect(response.error).toBeDefined();
60
+ expect(response.retries).toBeNumber();
61
+ expect(response.responseTimestamp).toBeDate();
62
+ expect(response.requestTimestamp).toBeDate();
63
+ expect(response.success).toBeFalse();
64
+ expect(response.extra).toHaveProperty("headers");
65
+ expect(Object.keys(response.extra)).toHaveLength(1);
66
+ expect((status >= 400 && status < 600) || status === 0).toBeTruthy();
67
+ if (typeof response.submitting === "boolean") {
68
+ expect(response.submitting).toBe(false);
69
+ } else {
70
+ expect(response.loading).toBe(false);
71
+ }
72
+ expect(response.data).toStrictEqual(data);
73
+ });
74
+ };
75
+
76
+ export const testCacheState = async <
77
+ T extends ResponseType<any, any, AdapterInstance>,
78
+ H extends RenderHookResult<any, any>,
79
+ >(
80
+ mock: T,
81
+ render: H,
82
+ ) => {
83
+ await waitFor(() => {
84
+ const response = getCurrentState(render);
85
+ expect(response.data).toStrictEqual(mock.data);
86
+ expect(response.error).toStrictEqual(mock.error);
87
+ expect(response.status).toBe(mock.status);
88
+ expect(response.extra).toStrictEqual(mock.extra);
89
+ });
90
+ };
91
+
92
+ export const testLoading = async <H extends RenderHookResult<any, any>>(mock: boolean, render: H) => {
93
+ await waitFor(() => {
94
+ const response = getCurrentState(render);
95
+ if (typeof response.submitting === "boolean") {
96
+ expect(response.submitting).toBe(mock);
97
+ } else {
98
+ expect(response.loading).toBe(mock);
99
+ }
100
+ });
101
+ };
102
+
103
+ export const testData = async <
104
+ T extends UseFetchReturnType<RequestInstance> | UseSubmitReturnType<RequestInstance>,
105
+ H extends RenderHookResult<any, any>,
106
+ >(
107
+ mock: T["data"],
108
+ render: H,
109
+ ) => {
110
+ await waitFor(() => {
111
+ const response = getCurrentState(render);
112
+ expect(response.data).toStrictEqual(mock as Record<string, unknown>);
113
+ });
114
+ };
115
+
116
+ export const testError = async <
117
+ T extends UseFetchReturnType<RequestInstance> | UseSubmitReturnType<RequestInstance>,
118
+ H extends RenderHookResult<any, any>,
119
+ >(
120
+ mock: T["error"],
121
+ render: H,
122
+ ) => {
123
+ await waitFor(() => {
124
+ const response = getCurrentState(render);
125
+ expect(response.error).toStrictEqual(mock as Record<string, unknown>);
126
+ });
127
+ };
@@ -0,0 +1,8 @@
1
+ {
2
+ "compilerOptions": {
3
+ "strict": true,
4
+ "noEmit": true,
5
+ "baseUrl": "../src",
6
+ "jsx": "react-jsx"
7
+ }
8
+ }
@@ -0,0 +1,53 @@
1
+ import {
2
+ ResponseType,
3
+ ResponseDetailsType,
4
+ RequestInstance,
5
+ ExtractResponseType,
6
+ ExtractErrorType,
7
+ ExtractAdapterType,
8
+ AdapterType,
9
+ xhrExtra,
10
+ ExtractAdapterStatusType,
11
+ ExtractAdapterExtraType,
12
+ } from "@hyper-fetch/core";
13
+
14
+ export const createCacheData = <T extends RequestInstance>(
15
+ request: T,
16
+ response?: {
17
+ data?: ResponseType<ExtractResponseType<T>, ExtractErrorType<T>, ExtractAdapterType<T>>;
18
+ details?: Partial<ResponseDetailsType>;
19
+ },
20
+ ) => {
21
+ const dataValue: ResponseType<
22
+ ExtractResponseType<T>,
23
+ ExtractErrorType<T>,
24
+ ExtractAdapterType<T>
25
+ > = response?.data || {
26
+ data: { data: 1 } as ExtractResponseType<T>,
27
+ error: null,
28
+ status: 200 as unknown as ExtractAdapterStatusType<ExtractAdapterType<T>>,
29
+ success: true,
30
+ extra: xhrExtra as unknown as ExtractAdapterExtraType<ExtractAdapterType<T>>,
31
+ requestTimestamp: +new Date(),
32
+ responseTimestamp: +new Date(),
33
+ };
34
+ const detailsValue: ResponseDetailsType = {
35
+ retries: 0,
36
+ triggerTimestamp: +new Date(),
37
+ addedTimestamp: +new Date(),
38
+ requestTimestamp: +new Date(),
39
+ responseTimestamp: +new Date(),
40
+ isCanceled: false,
41
+ isOffline: false,
42
+ ...response?.details,
43
+ };
44
+
45
+ request.client.cache.storage.set<any, any, AdapterType>(request.cacheKey, {
46
+ ...(dataValue as any),
47
+ ...detailsValue,
48
+ staleTime: 1000,
49
+ version: request.client.cache.version,
50
+ cacheTime: Infinity,
51
+ });
52
+ return [dataValue, detailsValue] as const;
53
+ };
@@ -0,0 +1,3 @@
1
+ import { Client } from "@hyper-fetch/core";
2
+
3
+ export const client = new Client({ url: "shared-test-client/" });
@@ -0,0 +1,7 @@
1
+ import { EmitterOptionsType, Socket, SocketAdapterType } from "@hyper-fetch/sockets";
2
+
3
+ export const createEmitter = <ResponseType = { name: string; age: number }>(
4
+ options?: Partial<EmitterOptionsType<any, SocketAdapterType>>,
5
+ ) => {
6
+ return new Socket({ url: "ws://localhost:1234" }).createEmitter<ResponseType>()({ topic: "some-event", ...options });
7
+ };
@@ -0,0 +1,9 @@
1
+ import { sleep } from "@hyper-fetch/testing";
2
+ import { act } from "@testing-library/react";
3
+
4
+ // Solves the issue: https://github.com/testing-library/react-testing-library/issues/1051
5
+ export const waitForRender = async (time = 10) => {
6
+ await act(async () => {
7
+ await sleep(time);
8
+ });
9
+ };
@@ -0,0 +1,14 @@
1
+ export * from "./client.utils";
2
+ export * from "./cache.utils";
3
+ export * from "./request.utils";
4
+ export * from "./helpers.utils";
5
+ export * from "./state.utils";
6
+
7
+ export * from "./use-fetch.utils";
8
+ export * from "./use-submit.utils";
9
+ export * from "./use-app-manager.utils";
10
+ export * from "./use-queue.utils";
11
+ export * from "./use-request-events.utils";
12
+ export * from "./use-tracked-state.utils";
13
+ export * from "./use-listener.utils";
14
+ export * from "./use-emitter.utils";