Clean code

Author: TaiSakuma

src/api/__tests__/use-state-subscription.spec.ts

@@ -1,10 +1,8 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { UseQueryResponse } from "@urql/vue";
 import fc from "fast-check";
 
 import type {
   CtrlStateQuery,
-  CtrlStateQueryVariables,
   CtrlStateSSubscription,
 } from "@/graphql/codegen/generated";
 import {
@@ -23,63 +21,17 @@ vi.mock("@/graphql/codegen/generated", () => ({
 }));
 
 const fcState = fc.string({ minLength: 1 });
+const fcQueryData = fc.oneof(
+  fc.constant(undefined),
+  fc.record({ ctrl: fc.record({ state: fcState }) }),
+);
+const fcSubData = fc.oneof(fc.constant(undefined), fc.record({ ctrlState: fcState }));
 
 const fcErrorInstance = fc.string().map((msg) => new Error(msg));
 const fcError = fc.oneof(fc.constant(undefined), fcErrorInstance);
 
-interface QRes {
-  data: { ctrl: { state: string } } | undefined;
-  error: Error | undefined;
-}
-
-const fcQRes: fc.Arbitrary<QRes> = fc.record({
-  data: fc.oneof(
-    fc.constant(undefined),
-    fc.record({
-      ctrl: fc.record({
-        state: fcState,
-      }),
-    }),
-  ),
-  error: fcError,
-});
-
-interface SRes {
-  data: { ctrlState: string } | undefined;
-  error: Error | undefined;
-}
-
-const fcSRes: fc.Arbitrary<SRes> = fc.record({
-  data: fc.oneof(
-    fc.constant(undefined),
-    fc.record({
-      ctrlState: fcState,
-    }),
-  ),
-  error: fcError,
-});
-
-// type Query = ReturnType<typeof useCtrlStateQuery>;
-type Query = UseQueryResponse<CtrlStateQuery, CtrlStateQueryVariables>;
-
-type Sub = ReturnType<typeof useCtrlStateSSubscription>;
-
-function mockUseCtrlStateQueryResponse(res: QRes): Query {
-  return mockUseQueryResponse<CtrlStateQuery>(res) as Query;
-}
-
-interface MockSubscription {
-  response: Sub;
-  issue: Iterable<SRes>;
-}
-
-function mockUseCtrlStateSSubscriptionResponse(
-  resArray: Iterable<SRes>,
-): MockSubscription {
-  return mockUseSubscriptionResponse<CtrlStateSSubscription>(
-    resArray,
-  ) as MockSubscription;
-}
+const fcQueryArg = fc.record({ data: fcQueryData, error: fcError });
+const fcSubArg = fc.record({ data: fcSubData, error: fcError });
 
 describe("useSubscribeState()", () => {
   beforeEach(() => {
@@ -92,22 +44,32 @@ describe("useSubscribeState()", () => {
 
   it("Property test", async () => {
     await fc.assert(
-      fc.asyncProperty(fcQRes, fc.array(fcSRes), async (queryRes, subResArray) => {
-        const query = mockUseCtrlStateQueryResponse(queryRes);
-        const { response: sub, issue } =
-          mockUseCtrlStateSSubscriptionResponse(subResArray);
-        vi.mocked(useCtrlStateQuery).mockReturnValue(query);
-        vi.mocked(useCtrlStateSSubscription).mockReturnValue(sub);
+      fc.asyncProperty(fcQueryArg, fc.array(fcSubArg), async (queryArg, subArg) => {
+        // Mock useCtrlStateQuery()
+        const queryRes = mockUseQueryResponse<CtrlStateQuery>(queryArg);
+        type Query = ReturnType<typeof useCtrlStateQuery>;
+        vi.mocked(useCtrlStateQuery).mockReturnValue(queryRes as Query);
+
+        // Mock useCtrlStateSSubscription()
+        const { response: subRes, issue } =
+          mockUseSubscriptionResponse<CtrlStateSSubscription>(subArg);
+        type SubRes = ReturnType<typeof useCtrlStateSSubscription>;
+        vi.mocked(useCtrlStateSSubscription).mockReturnValue(subRes as SubRes);
+
         const { state, error } = await useSubscribeState();
-        expect(error.value).toBe(queryRes.error);
+
+        // Assert initial values are from query.
+        expect(error.value).toBe(queryArg.error);
         expect(state.value).toBe(
-          queryRes.error ? undefined : queryRes.data?.ctrl.state,
+          queryArg.error ? undefined : queryArg.data?.ctrl.state,
         );
+
+        // Assert the subsequent values are issued from subscription backed up by query.
         for (const issued of issue) {
-          const expectedError = issued.error || queryRes.error;
+          const expectedError = issued.error || queryArg.error;
           const expectedState = expectedError
             ? undefined
-            : issued.data?.ctrlState || queryRes.data?.ctrl.state;
+            : issued.data?.ctrlState || queryArg.data?.ctrl.state;
           expect(error.value).toBe(expectedError);
           expect(state.value).toBe(expectedState);
         }