refactor: delete unused contract test helpers

src/channels/plugins/contracts/test-helpers/lazy-object-surface.ts

@@ -1,18 +0,0 @@
-export function createLazyObjectSurface<T extends object>(loadSurface: () => T): T {
-  return new Proxy({} as T, {
-    get(_target, property) {
-      const surface = loadSurface();
-      const value = Reflect.get(surface, property, surface);
-      return typeof value === "function" ? value.bind(surface) : value;
-    },
-    has(_target, property) {
-      return property in loadSurface();
-    },
-    ownKeys() {
-      return Reflect.ownKeys(loadSurface());
-    },
-    getOwnPropertyDescriptor(_target, property) {
-      return Reflect.getOwnPropertyDescriptor(loadSurface(), property);
-    },
-  });
-}

src/plugins/runtime/typing-lease.test-support.ts

@@ -1,121 +0,0 @@
-import { expect, it, vi } from "vitest";
-import type { MockFn } from "../../test-utils/vitest-mock-fn.js";
-
-type MockedPulse = { mock: { calls: unknown[] } };
-
-function asMockedPulse(pulse: unknown): MockedPulse {
-  return pulse as MockedPulse;
-}
-
-export function expectTypingPulseCount(pulse: MockedPulse, expected: number) {
-  expect(pulse.mock.calls).toHaveLength(expected);
-}
-
-export function createPulseWithBackgroundFailure<
-  TPulse extends (...args: never[]) => Promise<unknown>,
->() {
-  let callCount = 0;
-  const pulse: MockFn<TPulse> = vi.fn(async () => {
-    callCount += 1;
-    if (callCount === 2) {
-      throw new Error("boom");
-    }
-    return undefined;
-  }) as MockFn<TPulse>;
-  return pulse;
-}
-
-export async function expectIndependentTypingLeases<
-  TParams extends { intervalMs?: number; pulse: (...args: never[]) => Promise<unknown> },
-  TLease extends { refresh: () => Promise<void>; stop: () => void },
->(params: {
-  createLease: (params: TParams) => Promise<TLease>;
-  buildParams: (pulse: TParams["pulse"]) => TParams;
-}) {
-  vi.useFakeTimers();
-  const pulse: MockFn<TParams["pulse"]> = vi.fn(async () => undefined) as MockFn<TParams["pulse"]>;
-  const mockedPulse = asMockedPulse(pulse);
-
-  const leaseA = await params.createLease(params.buildParams(pulse));
-  const leaseB = await params.createLease(params.buildParams(pulse));
-
-  expectTypingPulseCount(mockedPulse, 2);
-
-  await vi.advanceTimersByTimeAsync(2_000);
-  expectTypingPulseCount(mockedPulse, 4);
-
-  leaseA.stop();
-  await vi.advanceTimersByTimeAsync(2_000);
-  expectTypingPulseCount(mockedPulse, 5);
-
-  await leaseB.refresh();
-  expectTypingPulseCount(mockedPulse, 6);
-
-  leaseB.stop();
-}
-
-export async function expectBackgroundTypingPulseFailuresAreSwallowed<
-  TParams extends { intervalMs?: number; pulse: (...args: never[]) => Promise<unknown> },
-  TLease extends { stop: () => void },
->(params: {
-  createLease: (params: TParams) => Promise<TLease>;
-  buildParams: (pulse: TParams["pulse"]) => TParams;
-  pulse: TParams["pulse"];
-}) {
-  vi.useFakeTimers();
-  const mockedPulse = asMockedPulse(params.pulse);
-
-  const lease = await params.createLease(params.buildParams(params.pulse));
-
-  await expect(vi.advanceTimersByTimeAsync(2_000)).resolves.toBe(vi);
-  expectTypingPulseCount(mockedPulse, 2);
-
-  lease.stop();
-}
-
-export function registerSharedTypingLeaseTests<
-  TParams extends { intervalMs?: number; pulse: (...args: never[]) => Promise<unknown> },
-  TLease extends { refresh: () => Promise<void>; stop: () => void },
->(params: {
-  createLease: (params: TParams) => Promise<TLease>;
-  buildParams: (pulse: TParams["pulse"]) => TParams;
-}) {
-  it("pulses immediately and keeps leases independent", async () => {
-    await expectIndependentTypingLeases(params);
-  });
-
-  it("swallows background pulse failures", async () => {
-    const pulse = createPulseWithBackgroundFailure<TParams["pulse"]>();
-
-    await expectBackgroundTypingPulseFailuresAreSwallowed({
-      createLease: params.createLease,
-      pulse,
-      buildParams: params.buildParams,
-    });
-  });
-}
-
-export async function expectDefaultTypingLeaseInterval<
-  TParams extends { intervalMs?: number; pulse: (...args: never[]) => Promise<unknown> },
-  TLease extends { stop: () => void },
->(params: {
-  createLease: (params: TParams) => Promise<TLease>;
-  buildParams: (pulse: TParams["pulse"]) => TParams;
-  defaultIntervalMs: number;
-}) {
-  vi.useFakeTimers();
-  const pulse = vi.fn(async () => undefined);
-
-  const lease = await params.createLease({
-    ...params.buildParams(pulse as TParams["pulse"]),
-    intervalMs: Number.NaN,
-  });
-
-  expectTypingPulseCount(asMockedPulse(pulse), 1);
-  await vi.advanceTimersByTimeAsync(params.defaultIntervalMs - 1);
-  expectTypingPulseCount(asMockedPulse(pulse), 1);
-  await vi.advanceTimersByTimeAsync(1);
-  expectTypingPulseCount(asMockedPulse(pulse), 2);
-
-  lease.stop();
-}