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.

8.7 KB
Raw Blame
import type { CacheChangeListener, CacheHost } from '@graphql-cache/host/types';
import {
  type HydrationSearchChanges,
  INITIAL_CACHE_REVISION,
} from '@graphql-cache/protocol';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { subscribeToVisibleCacheChanges } from './subscribe-to-visible-cache-changes';

let visibility: DocumentVisibilityState;
let dispose: (() => void) | undefined;

function setVisibility(value: DocumentVisibilityState) {
  visibility = value;
  document.dispatchEvent(new Event('visibilitychange'));
}

function setup(
  refresh = vi.fn<() => void | Promise<unknown>>(),
  options?: Parameters<typeof subscribeToVisibleCacheChanges>[2]
) {
  let notify: CacheChangeListener = () => {};
  const unsubscribe = vi.fn();
  const host = {
    onCacheChanged: vi.fn((callback: CacheChangeListener) => {
      notify = callback;
      return unsubscribe;
    }),
  } satisfies Pick<CacheHost, 'onCacheChanged'>;
  dispose = subscribeToVisibleCacheChanges(host, refresh, options);
  return {
    host,
    notify: (changes?: HydrationSearchChanges) =>
      notify(INITIAL_CACHE_REVISION, changes),
    refresh,
    unsubscribe,
  };
}

beforeEach(() => {
  vi.useFakeTimers();
  visibility = 'visible';
  vi.spyOn(document, 'visibilityState', 'get').mockImplementation(
    () => visibility
  );
});
afterEach(() => {
  dispose?.();
  dispose = undefined;
  vi.useRealTimers();
  vi.restoreAllMocks();
});

describe('subscribeToVisibleCacheChanges', () => {
  it('does no work for unrelated hydration, including while hidden', () => {
    const { notify, refresh } = setup(undefined, {
      searchBuckets: () => ['note', 'task'],
    });
    notify({ searchChangedBuckets: ['email'] });
    notify({ searchChangedBuckets: [] });
    setVisibility('hidden');
    notify({ searchChangedBuckets: ['channel'] });
    setVisibility('visible');
    vi.advanceTimersByTime(1000);
    expect(refresh).not.toHaveBeenCalled();
    expect(vi.getTimerCount()).toBe(0);
  });

  it('refreshes newly hydrated matching buckets and falls back for legacy/reset notifications', () => {
    const { notify, refresh } = setup(undefined, {
      searchBuckets: () => ['note'],
    });
    notify({ searchChangedBuckets: ['note'] });
    expect(refresh).toHaveBeenCalledOnce();
    vi.advanceTimersByTime(250);
    notify();
    expect(refresh).toHaveBeenCalledTimes(2);
  });

  it('does not queue a follow-up for unrelated hydration during a slow refresh', async () => {
    let finish!: () => void;
    const refresh = vi.fn<() => void | Promise<unknown>>().mockReturnValueOnce(
      new Promise<void>((resolve) => {
        finish = resolve;
      })
    );
    const { notify } = setup(refresh, {
      searchBuckets: () => ['channel', 'dm'],
    });
    notify({ searchChangedBuckets: ['dm'] });
    for (let i = 0; i < 20; i++)
      notify({ searchChangedBuckets: ['email', 'note'] });
    finish();
    await vi.advanceTimersByTimeAsync(1000);
    expect(refresh).toHaveBeenCalledOnce();
  });

  it('uses current bucket interests for projected lists', () => {
    let buckets = ['note'];
    const { notify, refresh } = setup(undefined, {
      searchBuckets: () => buckets,
    });
    notify({ searchChangedBuckets: ['channel'] });
    expect(refresh).not.toHaveBeenCalled();
    buckets = ['channel'];
    notify({ searchChangedBuckets: ['channel'] });
    expect(refresh).toHaveBeenCalledOnce();
  });

  it('retains leading/trailing throttling and hydration updates when visible', () => {
    const { host, notify, refresh } = setup();
    expect(host.onCacheChanged).toHaveBeenCalledWith(expect.any(Function), {
      includeHydration: true,
    });
    notify();
    expect(refresh).toHaveBeenCalledOnce();
    notify();
    notify();
    vi.advanceTimersByTime(249);
    expect(refresh).toHaveBeenCalledOnce();
    vi.advanceTimersByTime(1);
    expect(refresh).toHaveBeenCalledTimes(2);
  });

  it('coalesces hidden notifications into one immediate catch-up on visibility', () => {
    setVisibility('hidden');
    const { notify, refresh } = setup();
    for (let i = 0; i < 20; i++) notify();
    expect(vi.getTimerCount()).toBe(0);
    vi.advanceTimersByTime(1000);
    expect(refresh).not.toHaveBeenCalled();

    setVisibility('visible');
    expect(refresh).toHaveBeenCalledOnce();
    vi.advanceTimersByTime(1000);
    expect(refresh).toHaveBeenCalledOnce();
    setVisibility('hidden');
    setVisibility('visible');
    expect(refresh).toHaveBeenCalledOnce();
  });

  it('retains a pending trailing refresh when the tab becomes hidden', () => {
    const { notify, refresh } = setup();
    notify();
    notify();
    setVisibility('hidden');
    expect(vi.getTimerCount()).toBe(0);
    vi.advanceTimersByTime(1000);
    expect(refresh).toHaveBeenCalledOnce();

    setVisibility('visible');
    expect(refresh).toHaveBeenCalledTimes(2);
    vi.advanceTimersByTime(1000);
    expect(refresh).toHaveBeenCalledTimes(2);
  });

  it('checks visibility again when a scheduled callback runs', () => {
    const { notify, refresh } = setup();
    notify();
    notify();
    // Model the visibility event arriving after the timer fires.
    visibility = 'hidden';
    vi.advanceTimersByTime(250);
    expect(refresh).toHaveBeenCalledOnce();
    setVisibility('visible');
    expect(refresh).toHaveBeenCalledTimes(2);
  });

  it('keeps changes arriving after a catch-up refresh', () => {
    const { notify, refresh } = setup();
    setVisibility('hidden');
    notify();
    setVisibility('visible');
    notify();
    vi.advanceTimersByTime(250);
    expect(refresh).toHaveBeenCalledTimes(2);
  });

  it('does not refresh a clean tab when it becomes visible', () => {
    const { refresh } = setup();
    setVisibility('hidden');
    setVisibility('visible');
    vi.advanceTimersByTime(1000);
    expect(refresh).not.toHaveBeenCalled();
  });

  it('finishes a slow refresh before one follow-up for changes received in flight', async () => {
    let finishFirst!: () => void;
    let finishSecond!: () => void;
    const refresh = vi
      .fn<() => void | Promise<unknown>>()
      .mockReturnValueOnce(
        new Promise<void>((resolve) => {
          finishFirst = resolve;
        })
      )
      .mockReturnValueOnce(
        new Promise<void>((resolve) => {
          finishSecond = resolve;
        })
      );
    const { notify } = setup(refresh);
    notify();
    for (let i = 0; i < 6; i++) {
      notify();
      await vi.advanceTimersByTimeAsync(250);
    }
    expect(refresh).toHaveBeenCalledOnce();
    finishFirst();
    await vi.advanceTimersByTimeAsync(250);
    expect(refresh).toHaveBeenCalledTimes(2);
    finishSecond();
    await vi.advanceTimersByTimeAsync(1000);
    expect(refresh).toHaveBeenCalledTimes(2);
  });

  it.each(['hidden', 'disposed'] as const)(
    'does not run a dirty follow-up while %s after a pending refresh settles',
    async (state) => {
      let finish!: () => void;
      const refresh = vi
        .fn<() => void | Promise<unknown>>()
        .mockReturnValueOnce(
          new Promise<void>((resolve) => {
            finish = resolve;
          })
        );
      const { notify } = setup(refresh);
      notify();
      notify();
      if (state === 'hidden') setVisibility('hidden');
      else dispose?.();
      finish();
      await vi.advanceTimersByTimeAsync(1000);
      expect(refresh).toHaveBeenCalledOnce();
      setVisibility('visible');
      await vi.advanceTimersByTimeAsync(250);
      expect(refresh).toHaveBeenCalledTimes(state === 'hidden' ? 2 : 1);
    }
  );

  it('handles rejection without dropping a dirty follow-up or retrying forever', async () => {
    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
    let reject!: (error: Error) => void;
    const refresh = vi
      .fn<() => void | Promise<unknown>>()
      .mockReturnValueOnce(
        new Promise<void>((_resolve, fail) => {
          reject = fail;
        })
      )
      .mockRejectedValueOnce(new Error('still unavailable'));
    const { notify } = setup(refresh);
    notify();
    notify();
    reject(new Error('unavailable'));
    await vi.advanceTimersByTimeAsync(1000);
    expect(refresh).toHaveBeenCalledTimes(2);
    expect(warning).toHaveBeenCalledTimes(2);
  });

  it.each(['hidden', 'visible'] as const)(
    'disposes notifications, visibility handling, and timers while %s',
    (state) => {
      const { notify, refresh, unsubscribe } = setup();
      setVisibility(state);
      notify();
      notify();
      dispose?.();
      dispose = undefined;
      expect(unsubscribe).toHaveBeenCalledOnce();
      const count = refresh.mock.calls.length;
      notify();
      setVisibility('hidden');
      setVisibility('visible');
      vi.advanceTimersByTime(1000);
      expect(refresh).toHaveBeenCalledTimes(count);
      expect(vi.getTimerCount()).toBe(0);
    }
  );
});