Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

25.8 KB
Raw Blame
import {
  type AnyVariables,
  type Client,
  CombinedError,
  createRequest,
  type GraphQLRequest,
  gql,
  makeOperation,
  type Operation,
  type OperationContext,
  type OperationResult,
} from '@urql/core';
import { print } from 'graphql';
import {
  type Accessor,
  createComponent,
  createRenderEffect,
  createRoot,
  createSignal,
} from 'solid-js';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { fromValue, makeSubject, onEnd, pipe } from 'wonka';
import { UrqlProvider } from './context';
import { createUrqlQuery } from './create-urql-query';
import type {
  UrqlClientSource,
  UrqlQueryOptions,
  UrqlQueryResult,
} from './types';

type Data = {
  value: string;
  nested?: { count: number; removed?: string };
};
type Variables = { input: string };
type RuntimeResult<D, V extends AnyVariables> = Omit<
  Partial<OperationResult<D, V>>,
  'data'
> & {
  data?: D | null;
};

type FakeExecution<D, V extends AnyVariables> = {
  document: unknown;
  variables: V;
  context: Partial<OperationContext>;
  next(result: RuntimeResult<D, V>): void;
  complete(): void;
  readonly unsubscribed: boolean;
};

function makeFakeClient<D = Data, V extends AnyVariables = Variables>(): {
  client: Client;
  executions: FakeExecution<D, V>[];
} {
  const executions: FakeExecution<D, V>[] = [];
  const execute = (
    document: unknown,
    variables: V,
    context: Partial<OperationContext> = {}
  ) => {
    const subject = makeSubject<OperationResult<D, V>>();
    let unsubscribed = false;
    const operation = {
      kind: 'query',
      context,
    } as Operation<D, V>;
    const execution: FakeExecution<D, V> = {
      document,
      variables,
      context,
      next: (result) =>
        subject.next({ operation, ...result } as OperationResult<D, V>),
      complete: subject.complete,
      get unsubscribed() {
        return unsubscribed;
      },
    };
    executions.push(execution);
    return pipe(
      subject.source,
      onEnd(() => {
        unsubscribed = true;
      })
    );
  };
  const client = {
    query: execute,
    executeQuery: (
      request: GraphQLRequest<D, V>,
      context: Partial<OperationContext> = {}
    ) => execute(request.query, request.variables, context),
  } as unknown as Client;
  return { client, executions };
}

const DOCUMENT = gql`
  query TestQuery($input: String!) {
    test(input: $input)
  }
`;
const OTHER_DOCUMENT = gql`
  query OtherTestQuery($input: String!) {
    otherTest(input: $input)
  }
`;

const disabledWithoutVariables: UrqlQueryOptions<Data, Variables> = {
  query: DOCUMENT,
  enabled: false,
};
// @ts-expect-error Enabled requests retain generated variables requirements.
const enabledWithoutVariables: UrqlQueryOptions<Data, Variables> = {
  query: DOCUMENT,
  enabled: true,
};
void disabledWithoutVariables;
void enabledWithoutVariables;

const disposals: Array<() => void> = [];
afterEach(() => {
  for (const dispose of disposals.splice(0)) dispose();
  vi.restoreAllMocks();
});

function setup(
  getOptions: Accessor<UrqlQueryOptions<Data, Variables>>,
  provider?: UrqlClientSource
): UrqlQueryResult<Data, Variables> {
  let query!: UrqlQueryResult<Data, Variables>;
  const dispose = createRoot((rootDispose) => {
    if (provider) {
      createComponent(UrqlProvider, {
        client: provider,
        get children() {
          query = createUrqlQuery(getOptions);
          return undefined;
        },
      });
    } else {
      query = createUrqlQuery(getOptions);
    }
    return rootDispose;
  });
  disposals.push(dispose);
  return query;
}

function activeOptions(client?: Client): UrqlQueryOptions<Data, Variables> {
  return {
    query: DOCUMENT,
    variables: { input: 'first' },
    client,
  };
}

describe('createUrqlQuery client resolution', () => {
  it('uses the provider and reactively follows provider client changes', () => {
    const first = makeFakeClient();
    const second = makeFakeClient();
    const [providerClient, setProviderClient] = createSignal(first.client);
    setup(() => activeOptions(), providerClient);

    expect(first.executions).toHaveLength(1);
    setProviderClient(() => second.client);

    expect(first.executions[0]?.unsubscribed).toBe(true);
    expect(second.executions).toHaveLength(1);
  });

  it('uses the nearest provider', () => {
    const outer = makeFakeClient();
    const inner = makeFakeClient();
    const dispose = createRoot((rootDispose) => {
      createComponent(UrqlProvider, {
        client: outer.client,
        get children() {
          return createComponent(UrqlProvider, {
            client: inner.client,
            get children() {
              createUrqlQuery<Data, Variables>(() => activeOptions());
              return undefined;
            },
          });
        },
      });
      return rootDispose;
    });
    disposals.push(dispose);

    expect(outer.executions).toHaveLength(0);
    expect(inner.executions).toHaveLength(1);
  });

  it('prefers an optional override and reactively returns to the provider', () => {
    const provided = makeFakeClient();
    const overridden = makeFakeClient();
    const [override, setOverride] = createSignal<Client | undefined>(undefined);
    setup(
      () => ({
        ...activeOptions(),
        client: override(),
      }),
      provided.client
    );

    expect(provided.executions).toHaveLength(1);
    setOverride(() => overridden.client);
    expect(provided.executions[0]?.unsubscribed).toBe(true);
    expect(overridden.executions).toHaveLength(1);

    setOverride(undefined);
    expect(overridden.executions[0]?.unsubscribed).toBe(true);
    expect(provided.executions).toHaveLength(2);
  });

  it('throws clearly without a provider or override', () => {
    expect(() => setup(() => activeOptions())).toThrow(
      'createUrqlQuery requires an UrqlProvider or a client option override'
    );
  });
});

describe('createUrqlQuery reactive state', () => {
  it('tracks cache, network, and pushed results over one live source', () => {
    const fake = makeFakeClient();
    const query = setup(() => activeOptions(fake.client));
    const execution = fake.executions[0];

    expect(query.status).toBe('pending');
    expect(query.fetchStatus).toBe('fetching');
    expect(query.fetching).toBe(true);
    expect(query.isEnabled).toBe(true);
    expect(query.isPending).toBe(true);
    expect(query.isLoading).toBe(true);
    expect(query.isInitialLoading).toBe(true);
    expect(query.isFetched).toBe(false);

    execution?.next({
      data: { value: 'cache' },
      stale: true,
      extensions: { tier: 'cache' },
    });
    expect(query.data).toEqual({ value: 'cache' });
    expect(query.status).toBe('success');
    expect(query.fetching).toBe(false);
    expect(query.isFetching).toBe(true);
    expect(query.isRefetching).toBe(true);
    expect(query.stale).toBe(true);
    expect(query.extensions).toEqual({ tier: 'cache' });

    execution?.next({ data: { value: 'network' }, stale: false });
    expect(query.data).toEqual({ value: 'network' });
    expect(query.fetchStatus).toBe('idle');
    expect(query.isSuccess).toBe(true);
    expect(query.isFetched).toBe(true);

    execution?.next({ data: { value: 'pushed' } });
    expect(query.data).toEqual({ value: 'pushed' });
    expect(fake.executions).toHaveLength(1);
  });

  it('marks a completed data-less result as successful', () => {
    const fake = makeFakeClient();
    const query = setup(() => activeOptions(fake.client));

    fake.executions[0]?.next({});

    expect(query.data).toBeUndefined();
    expect(query.status).toBe('success');
    expect(query.isFetched).toBe(true);
    expect(query.isLoading).toBe(false);
  });

  it('replaces subscriptions when query, variables, or context change', () => {
    const fake = makeFakeClient();
    const [input, setInput] = createSignal('first');
    const [document, setDocument] = createSignal(DOCUMENT);
    const [header, setHeader] = createSignal('one');
    const query = setup(() => ({
      query: document(),
      variables: { input: input() },
      context: { fetchOptions: { headers: { 'x-test': header() } } },
      client: fake.client,
    }));

    fake.executions[0]?.next({ data: { value: 'first' } });
    setInput('second');
    expect(fake.executions[0]?.unsubscribed).toBe(true);
    expect(fake.executions[1]?.variables).toEqual({ input: 'second' });

    fake.executions[0]?.next({ data: { value: 'late' } });
    expect(query.data).toEqual({ value: 'first' });

    setHeader('two');
    expect(fake.executions[1]?.unsubscribed).toBe(true);
    expect(fake.executions[2]?.context.fetchOptions).toEqual({
      headers: { 'x-test': 'two' },
    });

    setDocument(OTHER_DOCUMENT);
    expect(fake.executions[2]?.unsubscribed).toBe(true);
    expect(fake.executions[3]?.document).toBe(OTHER_DOCUMENT);
  });

  it('preserves shared documents and prior operations when the query changes', () => {
    const firstDocument = gql`query InitialChannels { channels { id } }`;
    const secondDocument = gql`query RecentChannels { channels { id name } }`;
    const firstText = print(firstDocument);
    const firstOperation = makeOperation(
      'query',
      createRequest<Data, Variables>(firstDocument, { input: 'first' }),
      { url: 'https://localhost/graphql', requestPolicy: 'cache-first' }
    );
    const secondOperation = makeOperation(
      'query',
      createRequest<Data, Variables>(secondDocument, { input: 'first' }),
      { url: 'https://localhost/graphql', requestPolicy: 'network-only' }
    );
    const fake = makeFakeClient();
    const [document, setDocument] = createSignal(firstDocument);
    const query = setup(() => ({
      query: document(),
      variables: { input: 'first' },
      client: fake.client,
    }));
    fake.executions[0]?.next({
      data: { value: 'first' },
      operation: firstOperation,
    });
    setDocument(secondDocument);
    fake.executions[1]?.next({
      data: { value: 'second' },
      operation: secondOperation,
    });

    expect(query.data?.value).toBe('second');
    expect(query.operation?.query).toEqual(secondDocument);
    expect(print(firstDocument)).toBe(firstText);
    expect(firstOperation.context.requestPolicy).toBe('cache-first');
    expect(firstOperation.query).toBe(firstDocument);
  });

  it('disables synchronously, preserves state, and re-enables', () => {
    const fake = makeFakeClient();
    const [enabled, setEnabled] = createSignal(true);
    const query = setup(() => ({
      query: DOCUMENT,
      variables: { input: 'first' },
      client: fake.client,
      enabled: enabled(),
    }));

    fake.executions[0]?.next({
      data: { value: 'existing' },
      stale: true,
      hasNext: true,
    });
    setEnabled(false);
    expect(fake.executions[0]?.unsubscribed).toBe(true);
    expect(query.isEnabled).toBe(false);
    expect(query.fetchStatus).toBe('idle');
    expect(query.stale).toBe(false);
    expect(query.hasNext).toBe(false);
    expect(query.data).toEqual({ value: 'existing' });

    fake.executions[0]?.next({ data: { value: 'late' } });
    expect(query.data).toEqual({ value: 'existing' });

    setEnabled(true);
    expect(query.isEnabled).toBe(true);
    expect(query.isRefetching).toBe(true);
    expect(fake.executions).toHaveLength(2);
  });

  it('clears prior result state for a new identity when configured', () => {
    const fake = makeFakeClient();
    const [input, setInput] = createSignal('first');
    const query = setup(() => ({
      query: DOCUMENT,
      variables: { input: input() },
      client: fake.client,
      keepPreviousData: false,
    }));
    const priorError = new CombinedError({ graphQLErrors: ['old error'] });

    fake.executions[0]?.next({
      data: { value: 'first' },
      error: priorError,
      stale: true,
    });
    setInput('second');

    expect(query.data).toBeUndefined();
    expect(query.error).toBeNull();
    expect(query.stale).toBe(false);
    expect(query.status).toBe('pending');
    expect(query.isLoading).toBe(true);
  });

  it('retains valid data while exposing partial and root-null errors', () => {
    const fake = makeFakeClient();
    const query = setup(() => activeOptions(fake.client));
    const partialError = new CombinedError({ graphQLErrors: ['partial'] });
    const rootError = new CombinedError({ graphQLErrors: ['root null'] });

    fake.executions[0]?.next({
      data: { value: 'partial-data' },
      error: partialError,
    });
    expect(query.data).toEqual({ value: 'partial-data' });
    expect(query.error).toBe(partialError);
    expect(query.isError).toBe(true);

    fake.executions[0]?.next({ data: { value: 'valid' } });
    fake.executions[0]?.next({ data: null, error: rootError });
    expect(query.data).toEqual({ value: 'valid' });
    expect(query.error).toBe(rootError);
    expect(query.status).toBe('error');
  });

  it('calls the result observer after updating state', () => {
    const fake = makeFakeClient();
    let observed: string | undefined;
    let query!: UrqlQueryResult<Data, Variables>;
    query = setup(() => ({
      ...activeOptions(fake.client),
      onResult: () => {
        observed = query.data?.value;
      },
    }));

    fake.executions[0]?.next({ data: { value: 'observed' } });
    expect(observed).toBe('observed');
  });

  it('returns a stable proxy backed by deeply reactive reconciled data', () => {
    const fake = makeFakeClient();
    const observed: Array<[number | undefined, string | undefined]> = [];
    let query!: UrqlQueryResult<Data, Variables>;
    const dispose = createRoot((rootDispose) => {
      query = createUrqlQuery(() => activeOptions(fake.client));
      createRenderEffect(() => {
        observed.push([query.data?.nested?.count, query.data?.nested?.removed]);
      });
      return rootDispose;
    });
    disposals.push(dispose);

    fake.executions[0]?.next({
      data: { value: 'first', nested: { count: 1, removed: 'old' } },
    });
    const firstData = query.data;
    expect(observed.at(-1)).toEqual([1, 'old']);

    fake.executions[0]?.next({
      data: { value: 'second', nested: { count: 2 } },
    });
    expect(query.data).toBe(firstData);
    expect(observed.at(-1)).toEqual([2, undefined]);
  });

  it('does not traverse unchanged data for status-only emissions', () => {
    const fake = makeFakeClient();
    const query = setup(() => activeOptions(fake.client));
    const data = { value: 'cached', nested: { count: 1 } };
    fake.executions[0]?.next({ data, stale: true, hasNext: true });
    const firstData = query.data;
    const firstNested = query.data?.nested;
    const descriptors = vi.spyOn(Object, 'getOwnPropertyDescriptors');

    fake.executions[0]?.next({ data, stale: false, hasNext: true });
    fake.executions[0]?.complete();

    expect(query.stale).toBe(false);
    expect(query.hasNext).toBe(false);
    expect(query.isFetching).toBe(false);
    expect(query.data).toBe(firstData);
    expect(query.data?.nested).toBe(firstNested);
    expect(descriptors).not.toHaveBeenCalledWith(data);
    expect(descriptors).not.toHaveBeenCalledWith(data.nested);
  });

  it('reconciles changed data after skipping an unchanged emission', () => {
    const fake = makeFakeClient();
    const query = setup(() => activeOptions(fake.client));
    const first = { value: 'first', nested: { count: 1, removed: 'old' } };
    const second = { value: 'second', nested: { count: 2 } };
    fake.executions[0]?.next({ data: first, stale: true });
    const firstData = query.data;
    const firstNested = query.data?.nested;

    fake.executions[0]?.next({ data: first });
    fake.executions[0]?.next({ data: second });

    expect(query.data).toBe(firstData);
    expect(query.data?.nested).toBe(firstNested);
    expect(query.data).toEqual(second);
    expect(query.data?.nested?.removed).toBeUndefined();

    const descriptors = vi.spyOn(Object, 'getOwnPropertyDescriptors');
    fake.executions[0]?.next({ data: second, stale: true });
    expect(query.stale).toBe(true);
    expect(descriptors).not.toHaveBeenCalledWith(second);
    expect(descriptors).not.toHaveBeenCalledWith(second.nested);
  });

  it('publishes initial data and settled loading state atomically', () => {
    const fake = makeFakeClient();
    const snapshots: Array<[string | undefined, boolean]> = [];
    const dispose = createRoot((rootDispose) => {
      const query = createUrqlQuery(() => activeOptions(fake.client));
      createRenderEffect(() => {
        snapshots.push([query.data?.value, query.isFetching]);
      });
      return rootDispose;
    });
    disposals.push(dispose);

    fake.executions[0]?.next({ data: { value: 'loaded' } });

    expect(snapshots).toEqual([
      [undefined, true],
      ['loaded', false],
    ]);
  });

  it('publishes data and status together without notifying unchanged data consumers', () => {
    const fake = makeFakeClient();
    const snapshots: Array<[string | undefined, boolean]> = [];
    const values: Array<string | undefined> = [];
    const data = { value: 'cached' };
    const dispose = createRoot((rootDispose) => {
      const query = createUrqlQuery(() => activeOptions(fake.client));
      createRenderEffect(() => {
        snapshots.push([query.data?.value, query.isFetching]);
      });
      createRenderEffect(() => {
        values.push(query.data?.value);
      });
      return rootDispose;
    });
    disposals.push(dispose);

    fake.executions[0]?.next({ data, stale: true });
    fake.executions[0]?.next({ data });
    fake.executions[0]?.next({ data: { value: 'fresh' } });

    expect(snapshots).toEqual([
      [undefined, true],
      ['cached', true],
      ['cached', false],
      ['fresh', false],
    ]);
    expect(values).toEqual([undefined, 'cached', 'fresh']);
  });

  it('normalizes stale and incremental state when a source completes', () => {
    const fake = makeFakeClient();
    const query = setup(() => activeOptions(fake.client));

    fake.executions[0]?.next({
      data: { value: 'partial' },
      stale: true,
      hasNext: true,
    });
    expect(query.fetching).toBe(false);
    expect(query.isFetching).toBe(true);
    expect(query.stale).toBe(true);
    expect(query.hasNext).toBe(true);

    fake.executions[0]?.complete();
    expect(query.fetching).toBe(false);
    expect(query.isFetching).toBe(false);
    expect(query.stale).toBe(false);
    expect(query.hasNext).toBe(false);
  });

  it('does not track synchronous result-observer dependencies as options', () => {
    const [observerDependency, setObserverDependency] = createSignal(0);
    let executions = 0;
    const client = {
      executeQuery: () => {
        executions += 1;
        return fromValue({
          operation: { kind: 'query', context: {} } as Operation<
            Data,
            Variables
          >,
          data: { value: 'synchronous' },
          stale: false,
          hasNext: false,
        });
      },
    } as unknown as Client;
    const query = setup(() => ({
      ...activeOptions(client),
      onResult: () => observerDependency(),
    }));

    expect(query.data).toEqual({ value: 'synchronous' });
    expect(query.status).toBe('success');
    expect(query.fetchStatus).toBe('idle');
    expect(executions).toBe(1);

    setObserverDependency(1);
    expect(executions).toBe(1);
  });
});

describe('createUrqlQuery refetch', () => {
  it('applies overrides and resolves only after the final fresh result', async () => {
    const fake = makeFakeClient();
    const query = setup(() => ({
      ...activeOptions(fake.client),
      requestPolicy: 'cache-first',
      context: { fetchOptions: { headers: { base: 'yes' } } },
    }));
    fake.executions[0]?.next({ data: { value: 'initial' } });

    let settled = false;
    const refetch = query
      .refetch({
        requestPolicy: 'network-only',
        context: { fetchOptions: { headers: { refresh: 'yes' } } },
      })
      .then((value) => {
        settled = true;
        return value;
      });
    const execution = fake.executions[1];
    expect(execution?.context.requestPolicy).toBe('network-only');
    expect(execution?.context.fetchOptions).toEqual({
      headers: { refresh: 'yes' },
    });

    execution?.next({ data: { value: 'stale' }, stale: true });
    await Promise.resolve();
    expect(settled).toBe(false);

    execution?.next({ data: { value: 'part' }, hasNext: true });
    await Promise.resolve();
    expect(settled).toBe(false);

    execution?.next({ data: { value: 'fresh' }, hasNext: false });
    await expect(refetch).resolves.toBe(query);
    expect(query.data).toEqual({ value: 'fresh' });
  });

  it('retains data for a same-identity refetch when configured to clear new identities', async () => {
    const fake = makeFakeClient();
    const query = setup(() => ({
      ...activeOptions(fake.client),
      keepPreviousData: false,
    }));
    fake.executions[0]?.next({ data: { value: 'existing' } });

    const refetch = query.refetch();
    expect(query.data).toEqual({ value: 'existing' });
    expect(query.isRefetching).toBe(true);

    fake.executions[1]?.next({ data: { value: 'refetched' } });
    await expect(refetch).resolves.toBe(query);
  });

  it('resolves errors by default and rejects with throwOnError', async () => {
    const fake = makeFakeClient();
    const query = setup(() => activeOptions(fake.client));
    const firstError = new CombinedError({ graphQLErrors: ['first'] });
    const secondError = new CombinedError({ graphQLErrors: ['second'] });

    const first = query.refetch();
    fake.executions[1]?.next({ error: firstError });
    await expect(first).resolves.toBe(query);
    expect(query.error).toBe(firstError);

    const second = query.refetch({ throwOnError: true });
    fake.executions[2]?.next({ error: secondError });
    await expect(second).rejects.toBe(secondError);
    expect(query.error).toBe(secondError);
  });

  it('rejects a final stale error when its source completes', async () => {
    const fake = makeFakeClient();
    const query = setup(() => activeOptions(fake.client));
    const error = new CombinedError({ graphQLErrors: ['stale terminal'] });

    const refetch = query.refetch({ throwOnError: true });
    fake.executions[1]?.next({ error, stale: true });
    fake.executions[1]?.complete();

    await expect(refetch).rejects.toBe(error);
    expect(query.fetchStatus).toBe('idle');
    expect(query.stale).toBe(false);
  });

  it('settles before invoking throwing or reentrant result observers', async () => {
    const fake = makeFakeClient();
    const consoleError = vi
      .spyOn(console, 'error')
      .mockImplementation(() => {});
    let query!: UrqlQueryResult<Data, Variables>;
    let reentrant: Promise<UrqlQueryResult<Data, Variables>> | undefined;
    let shouldReenter = false;
    query = setup(() => ({
      ...activeOptions(fake.client),
      onResult: () => {
        if (shouldReenter) {
          shouldReenter = false;
          reentrant = query.refetch();
          return;
        }
        throw new Error('observer failed');
      },
    }));

    const throwing = query.refetch();
    expect(() =>
      fake.executions[1]?.next({ data: { value: 'first' } })
    ).not.toThrow();
    await expect(throwing).resolves.toBe(query);
    expect(consoleError).toHaveBeenCalledOnce();

    shouldReenter = true;
    const outer = query.refetch();
    fake.executions[2]?.next({ data: { value: 'outer' } });
    await expect(outer).resolves.toBe(query);
    expect(reentrant).toBeDefined();

    let reentrantSettled = false;
    const reentrantSettledFlag = reentrant?.then(() => {
      reentrantSettled = true;
    });
    await Promise.resolve();
    expect(reentrantSettled).toBe(false);
    fake.executions[3]?.next({ data: { value: 'inner' } });
    await expect(reentrant).resolves.toBe(query);
    await reentrantSettledFlag;
    consoleError.mockRestore();
  });

  it('settles refetches from synchronously completing sources', async () => {
    const client = {
      executeQuery: () =>
        fromValue({
          operation: { kind: 'query', context: {} } as Operation<
            Data,
            Variables
          >,
          data: { value: 'synchronous' },
          stale: false,
          hasNext: false,
        }),
    } as unknown as Client;
    const query = setup(() => activeOptions(client));

    await expect(query.refetch()).resolves.toBe(query);
    expect(query.data).toEqual({ value: 'synchronous' });
    expect(query.fetchStatus).toBe('idle');
  });

  it('manually executes a disabled query without changing its configured state', async () => {
    const fake = makeFakeClient();
    const query = setup(
      () => ({
        query: DOCUMENT,
        variables: { input: 'manual' },
        enabled: false,
      }),
      fake.client
    );

    expect(fake.executions).toHaveLength(0);
    expect(query.isEnabled).toBe(false);

    const refetch = query.refetch();
    expect(fake.executions).toHaveLength(1);
    expect(query.isEnabled).toBe(false);
    expect(query.isFetching).toBe(true);

    fake.executions[0]?.next({ data: { value: 'manual result' } });
    await expect(refetch).resolves.toBe(query);
    expect(query.data).toEqual({ value: 'manual result' });
    expect(query.isEnabled).toBe(false);
    expect(query.isFetching).toBe(false);
  });

  it('is a safe no-op for a disabled query without variables', async () => {
    const fake = makeFakeClient();
    const query = setup(
      () => ({
        query: DOCUMENT,
        enabled: false,
      }),
      fake.client
    );

    await expect(query.refetch()).resolves.toBe(query);
    expect(fake.executions).toHaveLength(0);
    expect(query.isEnabled).toBe(false);
  });

  it('settles superseded and disposed refetches without leaking promises', async () => {
    const fake = makeFakeClient();
    const query = setup(() => activeOptions(fake.client));

    const superseded = query.refetch();
    const active = query.refetch();
    await expect(superseded).resolves.toBe(query);
    expect(fake.executions[1]?.unsubscribed).toBe(true);

    fake.executions[2]?.next({ data: { value: 'active' } });
    await expect(active).resolves.toBe(query);

    const disposed = query.refetch();
    disposals.pop()?.();
    await expect(disposed).resolves.toBe(query);
    expect(fake.executions[3]?.unsubscribed).toBe(true);
  });
});