Reorganize test code

eslint.config.ts

@@ -117,6 +117,13 @@ export default [
       "no-unused-vars": "off",
       "@typescript-eslint/no-var-requires": "off",
       "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+        },
+      ],
       "@typescript-eslint/ban-ts-comment": "off",
       "prettier/prettier": ["warn", { printWidth: 88 }],
     },

src/api/__tests__/run-property-test.ts

@@ -4,9 +4,9 @@ import { useQuery, useSubscription } from "@urql/vue";
 import type { UseQueryResponse, UseSubscriptionResponse } from "@urql/vue";
 import fc from "fast-check";
 
+import { mockUseQueryResponse, mockUseSubscriptionResponse } from "@/graphql/tests";
+
 import { fcMockUseQueryResponseArg, fcMockUseSubscriptionResponseArg } from "./fc";
-import { mockUseQueryResponse } from "./mock-use-query-response";
-import { mockUseSubscriptionResponse } from "./mock-use-subscription-response";
 
 interface _UseSubscribeXXXReturn<R> {
   data: ComputedRef<R | undefined>;

src/api/__tests__/scratch.spec.ts

@@ -7,8 +7,7 @@ import { fromValue, makeSubject, never } from "wonka";
 
 import type { CtrlStateQuery } from "@/graphql/codegen/generated";
 import { useCtrlStateQuery } from "@/graphql/codegen/generated";
-
-import { useInSetupWithUrqlClient } from "./setup-with-client";
+import { useInSetupWithUrqlClient } from "@/graphql/tests";
 
 function useQueryFromClient(client: MaybeRef<Client>) {
   const disposable = useInSetupWithUrqlClient(

src/api/__tests__/use-mapped-with-fallback.spec.ts

@@ -1,10 +1,10 @@
 import { describe, expect, it } from "vitest";
 import fc from "fast-check";
 
-import { useMappedWithFallback } from "../use-mapped-with-fallback";
+import { mockUseQueryResponse } from "@/graphql/tests";
+import { mockUseSubscriptionResponse } from "@/graphql/tests/mock-use-subscription-response";
 
-import { mockUseQueryResponse } from "./mock-use-query-response";
-import { mockUseSubscriptionResponse } from "./mock-use-subscription-response";
+import { useMappedWithFallback } from "../use-mapped-with-fallback";
 
 type QueryData = { ctrl: { state: string } };
 type SubscriptionData = { ctrlState: string };

src/api/__tests__/example-use-query.spec.ts → src/graphql/tests/__tests__/example-wonka.spec.ts

@@ -1,42 +1,11 @@
 import { describe, expect, it } from "vitest";
-import type { App, MaybeRef } from "vue";
-import { createApp, defineComponent, ref } from "vue";
-import { Client, CombinedError, provideClient, useQuery } from "@urql/vue";
+import type { MaybeRef } from "vue";
+import { ref } from "vue";
+import { Client, CombinedError, useQuery } from "@urql/vue";
 import gql from "graphql-tag";
 import { fromValue, never } from "wonka";
 
-type SetupFunction = () => Record<string, unknown>;
-
-interface WitSetupsOptions {
-  setupParent: SetupFunction;
-  setupChild: SetupFunction;
-}
-
-class DisposableApp implements Disposable {
-  constructor(private app: App) {}
-
-  [Symbol.dispose]() {
-    this.app.unmount();
-  }
-}
-
-function withSetups(options: WitSetupsOptions) {
-  const ParentComponent = defineComponent({
-    setup: options.setupParent,
-    template: "<child-component />",
-  });
-
-  const ChildComponent = defineComponent({
-    setup: options.setupChild,
-    template: "<template />",
-  });
-
-  const app = createApp(ParentComponent);
-  app.component("ChildComponent", ChildComponent);
-  app.mount(document.createElement("div"));
-  const disposable = new DisposableApp(app);
-  return { app, [Symbol.dispose]: () => disposable[Symbol.dispose]() };
-}
+import { useInSetupWithUrqlClient } from "@/graphql/tests";
 
 export const FooDocument = gql`
   query foo {
@@ -50,19 +19,11 @@ export type FooQuery = {
 };
 
 function useQueryFromClient(client: MaybeRef<Client>) {
-  let query: ReturnType<typeof useQuery<FooQuery>> | undefined;
-  const app = withSetups({
-    setupParent() {
-      provideClient(client);
-      return {};
-    },
-    setupChild() {
-      query = useQuery<FooQuery>({ query: FooDocument });
-      return {};
-    },
-  });
-  if (!query) throw new Error("query is undefined");
-  return { ...app, query, [Symbol.dispose]: () => app[Symbol.dispose]() };
+  const { ret: query, [Symbol.dispose]: dispose } = useInSetupWithUrqlClient(
+    () => useQuery<FooQuery>({ query: FooDocument }),
+    client,
+  );
+  return { query, [Symbol.dispose]: () => dispose() };
 }
 
 describe("one", () => {

src/api/__tests__/mock-use-query-response.spec.ts → src/graphql/tests/__tests__/mock-use-query-response.spec.ts

@@ -4,7 +4,7 @@ import type { UseQueryResponse } from "@urql/vue";
 import gql from "graphql-tag";
 import fc from "fast-check";
 
-import { mockUseQueryResponse } from "./mock-use-query-response";
+import { mockUseQueryResponse } from "..";
 
 vi.mock("@urql/vue", () => ({
   useQuery: vi.fn(),

src/api/__tests__/mock-use-subscription-response.spec.ts → src/graphql/tests/__tests__/mock-use-subscription-response.spec.ts

@@ -4,7 +4,7 @@ import type { UseSubscriptionResponse } from "@urql/vue";
 import gql from "graphql-tag";
 import fc from "fast-check";
 
-import { mockUseSubscriptionResponse } from "./mock-use-subscription-response";
+import { mockUseSubscriptionResponse } from "..";
 
 vi.mock("@urql/vue", () => ({
   useSubscription: vi.fn(),

src/graphql/tests/index.ts

@@ -0,0 +1,3 @@
+export * from "./mock-use-query-response";
+export * from "./mock-use-subscription-response"
+export * from "./setup-with-client";

src/api/__tests__/setup-with-client.ts → src/graphql/tests/setup-with-client.ts

@@ -1,8 +1,8 @@
 import type { MaybeRef } from "vue";
 import type { Client } from "@urql/vue";
-import { provideClient, useClientHandle } from "@urql/vue";
+import { createClient, provideClient, useClientHandle } from "@urql/vue";
 
-import { setupNestedComponents } from "./setup-nested-components";
+import { setupNestedComponents } from "@/tests/vue";
 
 /**
  * Execute `func` in a Vue component `setup` in which the `client` can be injected.
@@ -29,8 +29,11 @@ export function useInSetupWithUrqlClient<T>(func: () => T, client: MaybeRef<Clie
 if (import.meta.vitest) {
   const { it, expect } = import.meta.vitest;
 
-  it.skip("useInSetupWithUrqlClient", () => {
-    const mockClient = {} as Client;
+  it("useInSetupWithUrqlClient", () => {
+    const mockClient = createClient({
+      url: "http://example.com/graphql",
+      exchanges: [],
+    });
 
     using ret = useInSetupWithUrqlClient(() => useClientHandle(), mockClient);
     const { ret: handle } = ret;

src/tests/vue/index.ts

@@ -0,0 +1,2 @@
+export * from "./app-disposer";
+export * from "./setup-nested-components";

src/api/__tests__/setup-nested-components.ts → src/tests/vue/setup-nested-components.ts

@@ -1,6 +1,6 @@
 import { createApp, defineComponent, inject, provide } from "vue";
 
-import { AppDisposer } from "./app-disposer";
+import { AppDisposer } from "@/tests/vue";
 
 type SetupFunction = () => Record<string, unknown>;