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.

13.9 KB
Raw Blame
import type { ArchiveThreadOptions } from '@app/features/email-thread/context/email-thread-context';
import { registerListNavigationSource } from '@app/features/soup/collection/list-navigation-source';
import type { SplitId } from '@components/app/split-layout/layoutManager';
import type { EntityData } from '@entity';
import { createRoot, createSignal } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { useEmailListNavigation } from './use-email-list-navigation';

const mocks = vi.hoisted(() => ({
  open: vi.fn(async () => {}),
  loadMore: vi.fn(async () => {}),
  rows: [
    { id: 'a', type: 'email' },
    { id: 'b', type: 'email' },
  ],
  hasMore: false,
  active: true,
  currentId: 'a',
  viewId: 'mail' as 'mail' | 'home',
  sourceId: 'email-split',
  handle: {
    id: 'email-split',
    referredFrom: () => mocks.viewId,
    content: () => ({
      type: 'email',
      id: mocks.currentId,
      state: { 'list.sourceSplitId': mocks.sourceId },
    }),
  },
}));
vi.mock('@app/features/next-soup/utils', () => ({
  openEntityInSplitFromUnifiedList: mocks.open,
}));
vi.mock('@app/features/next-soup/soup-context', () => ({
  useMaybeSoup: () => undefined,
}));
vi.mock('@app/signal/splitLayout', () => ({
  globalSplitManager: () => undefined,
}));
vi.mock('@components/app/GlobalAppState', () => ({
  useGlobalNotificationSource: () => undefined,
}));
vi.mock('@components/app/split-layout/layoutUtils', () => ({
  useSplitPanel: () => ({
    handle: mocks.handle,
    isPanelActive: () => mocks.active,
  }),
}));
vi.mock('@core/component/Toast/Toast', () => ({ toast: { failure: vi.fn() } }));

let disposeSource: () => void;
afterEach(() => disposeSource());

function createNavigation(threadId: () => string) {
  mocks.currentId = threadId();
  return useEmailListNavigation(threadId);
}

beforeEach(() => {
  mocks.open.mockClear();
  mocks.loadMore.mockReset();
  mocks.rows = [
    { id: 'a', type: 'email' },
    { id: 'b', type: 'email' },
  ];
  mocks.hasMore = false;
  mocks.active = true;
  mocks.sourceId = 'email-split';
  mocks.viewId = 'mail';
  disposeSource = createRoot((dispose) => {
    registerListNavigationSource(
      {
        id: 'email-split' as SplitId,
        content: () => ({ type: 'component', id: 'mail' }),
        registerEntryStateCaptor: () => () => {},
      },
      {
        viewId: 'mail',
        entities: () => mocks.rows as EntityData[],
        hasMore: () => mocks.hasMore,
        loadMore: mocks.loadMore,
      }
    );
    return dispose;
  });
});

describe('email list navigation adapter', () => {
  it('finds the source list when native navigation gives the email a new split', async () => {
    mocks.handle.id = 'native-detail';
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'a'), dispose] as const
    );
    expect(nav.canNext()).toBe(true);
    const marked = nav.markDone(() => true);
    expect(mocks.open).toHaveBeenCalledWith(
      expect.objectContaining({ id: 'b' }),
      expect.objectContaining({ splitHandle: mocks.handle, mergeHistory: true })
    );
    await marked;
    dispose();
    mocks.handle.id = 'email-split';
  });

  it.each(['next', 'markDone'] as const)(
    '%s skips additional pages without eligible emails',
    async (action) => {
      mocks.hasMore = true;
      mocks.loadMore
        .mockImplementationOnce(async () => {
          mocks.rows.push({ id: 'document', type: 'document' });
        })
        .mockImplementationOnce(async () => {
          // A page can also be completely filtered out of the visible list.
        })
        .mockImplementationOnce(async () => {
          mocks.rows.push({ id: 'c', type: 'email' });
          mocks.hasMore = false;
        });
      const [nav, dispose] = createRoot(
        (dispose) => [createNavigation(() => 'b'), dispose] as const
      );
      const archive = vi.fn(() => true);
      const stepped = nav[action](archive);
      await vi.waitFor(() => expect(mocks.open).toHaveBeenCalledOnce());
      expect(mocks.loadMore).toHaveBeenCalledTimes(3);
      expect(mocks.open).toHaveBeenCalledWith(
        expect.objectContaining({ id: 'c' }),
        expect.anything()
      );
      expect(archive).toHaveBeenCalledTimes(action === 'markDone' ? 1 : 0);
      await stepped;
      dispose();
    }
  );

  it.each(['dispose', 'deactivate'] as const)(
    'cancels pending navigation and archiving after %s',
    async (leave) => {
      mocks.hasMore = true;
      let finishLoading!: () => void;
      mocks.loadMore.mockImplementation(
        () => new Promise<void>((resolve) => (finishLoading = resolve))
      );
      const [nav, dispose] = createRoot(
        (dispose) => [createNavigation(() => 'b'), dispose] as const
      );
      const archive = vi.fn(() => true);
      const marked = nav.markDone(archive);
      if (leave === 'dispose') dispose();
      else mocks.active = false;
      mocks.rows.push({ id: 'c', type: 'email' });
      mocks.hasMore = false;
      finishLoading();
      await vi.waitFor(() => expect(nav.canPrevious()).toBe(true));
      expect(archive).not.toHaveBeenCalled();
      expect(mocks.open).not.toHaveBeenCalled();
      expect(await marked).toBe(false);
      dispose();
    }
  );

  it('stops paging without archiving when loading fails', async () => {
    mocks.hasMore = true;
    mocks.loadMore.mockRejectedValue(new Error('offline'));
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'b'), dispose] as const
    );
    const archive = vi.fn(() => true);
    const marked = nav.markDone(archive);
    await vi.waitFor(() => expect(nav.canPrevious()).toBe(true));
    expect(mocks.loadMore).toHaveBeenCalledOnce();
    expect(archive).not.toHaveBeenCalled();
    expect(mocks.open).not.toHaveBeenCalled();
    expect(await marked).toBe(false);
    dispose();
  });

  it('replaces the email in the active detail slot', async () => {
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'a'), dispose] as const
    );
    expect(nav.canPrevious()).toBe(false);
    nav.next();
    await vi.waitFor(() =>
      expect(mocks.open).toHaveBeenCalledWith(
        mocks.rows[1],
        expect.objectContaining({
          splitHandle: mocks.handle,
          mergeHistory: true,
          referredFrom: 'mail',
        })
      )
    );
    dispose();
  });
  it('loads another page at the end before finding the next email', async () => {
    mocks.hasMore = true;
    mocks.loadMore.mockImplementation(async () => {
      mocks.rows.push({ id: 'c', type: 'email' });
      mocks.hasMore = false;
    });
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'b'), dispose] as const
    );
    expect(nav.canNext()).toBe(true);
    nav.next();
    await vi.waitFor(() =>
      expect(mocks.open).toHaveBeenCalledWith(
        expect.objectContaining({ id: 'c' }),
        expect.anything()
      )
    );
    expect(mocks.loadMore).toHaveBeenCalledOnce();
    dispose();
  });
  it('leaves directly opened threads without a list position disabled', () => {
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'missing'), dispose] as const
    );
    expect(nav.canPrevious()).toBe(false);
    expect(nav.canNext()).toBe(false);
    nav.next();
    expect(mocks.open).not.toHaveBeenCalled();
    dispose();
  });

  it('advances once even when archiving immediately removes the current row, and can undo', async () => {
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'a'), dispose] as const
    );
    const archive = vi.fn((options?: ArchiveThreadOptions) => {
      expect(options?.navigate).toBe(false);
      mocks.rows = mocks.rows.filter((row) => row.id !== 'a');
      return true;
    });

    const marked = nav.markDone(archive);
    await vi.waitFor(() => expect(mocks.open).toHaveBeenCalledOnce());
    expect(await marked).toBe(true);
    expect(archive).toHaveBeenCalledOnce();
    expect(mocks.open).toHaveBeenLastCalledWith(
      expect.objectContaining({ id: 'b' }),
      expect.objectContaining({ mergeHistory: true, referredFrom: 'mail' })
    );

    archive.mock.calls[0][0]?.navigateBack?.();
    await vi.waitFor(() => expect(mocks.open).toHaveBeenCalledTimes(2));
    expect(mocks.open).toHaveBeenLastCalledWith(
      expect.objectContaining({ id: 'a' }),
      expect.objectContaining({ mergeHistory: true, referredFrom: 'mail' })
    );
    dispose();
  });

  it('loads the next page before archiving and ignores repeated taps while loading', async () => {
    mocks.hasMore = true;
    let finishLoading!: () => void;
    mocks.loadMore.mockImplementation(
      () => new Promise<void>((resolve) => (finishLoading = resolve))
    );
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'b'), dispose] as const
    );
    const archive = vi.fn(() => {
      mocks.rows = mocks.rows.filter((row) => row.id !== 'b');
      return true;
    });

    const first = nav.markDone(archive);
    const repeated = nav.markDone(archive);
    expect(await repeated).toBe(false);
    expect(archive).not.toHaveBeenCalled();
    expect(mocks.loadMore).toHaveBeenCalledOnce();
    mocks.rows.push({ id: 'c', type: 'email' });
    mocks.hasMore = false;
    finishLoading();

    await vi.waitFor(() => expect(mocks.open).toHaveBeenCalledOnce());
    expect(await first).toBe(true);
    expect(archive).toHaveBeenCalledOnce();
    expect(mocks.open).toHaveBeenCalledWith(
      expect.objectContaining({ id: 'c' }),
      expect.anything()
    );
    dispose();
  });

  it('falls back to the previous email at the end of the list', async () => {
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'b'), dispose] as const
    );
    const marked = nav.markDone(() => true);
    await vi.waitFor(() =>
      expect(mocks.open).toHaveBeenCalledWith(
        expect.objectContaining({ id: 'a' }),
        expect.anything()
      )
    );
    expect(await marked).toBe(true);
    dispose();
  });

  it.each(['missing', 'a'])(
    'archives without navigating when %s has no neighboring email',
    async (id) => {
      mocks.rows = [{ id: 'a', type: 'email' }];
      const [nav, dispose] = createRoot(
        (dispose) => [createNavigation(() => id), dispose] as const
      );
      const archive = vi.fn(() => true);
      const marked = nav.markDone(archive);
      expect(archive).toHaveBeenCalledWith({
        navigate: false,
        navigateBack: undefined,
      });
      expect(mocks.open).not.toHaveBeenCalled();
      expect(await marked).toBe(true);
      dispose();
    }
  );

  it('does not advance when the archive command rejects the action', async () => {
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'a'), dispose] as const
    );
    const marked = nav.markDone(() => false);
    expect(mocks.open).not.toHaveBeenCalled();
    expect(await marked).toBe(false);
    dispose();
  });

  it('does not archive a different thread if it changes while loading the next page', async () => {
    mocks.hasMore = true;
    let currentId = 'b';
    mocks.loadMore.mockImplementation(async () => {
      mocks.rows.push({ id: 'c', type: 'email' });
      currentId = 'c';
    });
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => currentId), dispose] as const
    );
    const archive = vi.fn(() => true);
    const marked = nav.markDone(archive);
    await vi.waitFor(() => expect(nav.canPrevious()).toBe(true));
    expect(archive).not.toHaveBeenCalled();
    expect(mocks.open).not.toHaveBeenCalled();
    expect(await marked).toBe(false);
    dispose();
  });
});

describe('after the open thread leaves the list', () => {
  function reactiveSource(initial: string[]) {
    const [rows, setRows] = createSignal(initial);
    disposeSource();
    disposeSource = createRoot((dispose) => {
      registerListNavigationSource(
        {
          id: 'email-split' as SplitId,
          content: () => ({ type: 'component', id: 'mail' }),
          registerEntryStateCaptor: () => () => {},
        },
        {
          viewId: 'mail',
          entities: () =>
            rows().map((id) => ({ id, type: 'email' }) as EntityData),
          hasMore: () => mocks.hasMore,
          loadMore: mocks.loadMore,
        }
      );
      return dispose;
    });
    return setRows;
  }

  it('keeps next and previous on its former neighbours', async () => {
    const setRows = reactiveSource(['a', 'b', 'c']);
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'b'), dispose] as const
    );
    setRows(['a', 'c']);
    expect(nav.canNext()).toBe(true);
    expect(nav.canPrevious()).toBe(true);
    nav.next();
    await vi.waitFor(() =>
      expect(mocks.open).toHaveBeenLastCalledWith(
        expect.objectContaining({ id: 'c' }),
        expect.anything()
      )
    );
    dispose();
  });

  it('pages on after a surviving earlier neighbour when it was last', async () => {
    mocks.hasMore = true;
    const setRows = reactiveSource(['a', 'b']);
    mocks.loadMore.mockImplementation(async () => {
      setRows(['a', 'c']);
      mocks.hasMore = false;
    });
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'b'), dispose] as const
    );
    setRows(['a']);
    nav.next();
    await vi.waitFor(() =>
      expect(mocks.open).toHaveBeenLastCalledWith(
        expect.objectContaining({ id: 'c' }),
        expect.anything()
      )
    );
    expect(mocks.loadMore).toHaveBeenCalledOnce();
    dispose();
  });

  it('does not page through the mailbox when no former neighbour survives', async () => {
    mocks.hasMore = true;
    const setRows = reactiveSource(['a', 'b', 'c']);
    const [nav, dispose] = createRoot(
      (dispose) => [createNavigation(() => 'b'), dispose] as const
    );
    // Every loaded row was archived on another device.
    setRows([]);
    expect(nav.canNext()).toBe(false);
    nav.next();
    await Promise.resolve();
    expect(mocks.loadMore).not.toHaveBeenCalled();
    expect(mocks.open).not.toHaveBeenCalled();
    dispose();
  });
});