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.

5.7 KB
Raw Blame
import { createRoot, createSignal } from 'solid-js';
import { afterEach, expect, it, vi } from 'vitest';
import type { LocalDraft } from '../core/local-draft';
import { createComposeContext } from '../tests/capabilities';
import { createDraftSyncStatus } from './draft-sync-status';

const disposers: (() => void)[] = [];
afterEach(() => disposers.splice(0).forEach((dispose) => dispose()));
const draft: LocalDraft = {
  key: 'draft',
  accountId: 'owner',
  generation: 'generation',
  draftId: 'draft',
  revision: 1,
  acknowledgedRevision: 0,
  content: { subject: 'Keep this' },
  attachments: [],
  status: 'deleting',
  updatedAt: 1,
  latestAttemptId: 'delete',
  queuedAttemptId: 'old-save',
};

it('offers retry discard when a crash interrupted deletion before admission', async () => {
  const context = createComposeContext();
  context.drafts.saveLocalDraft = vi.fn();
  context.drafts.readDraft = vi.fn(async () => ({
    local: draft,
    persistence: 'queued' as const,
  }));
  const recover = vi.fn(async () => {});
  context.drafts.recoverSynchronization = recover;
  const discard = vi.fn(async () => {
    expect(recover).toHaveBeenCalledOnce();
  });
  const status = createRoot((dispose) => {
    disposers.push(dispose);
    return createDraftSyncStatus({
      drafts: context.drafts,
      connectivity: context.connectivity,
      draftId: () => 'draft',
      localSaveState: () => 'saved',
      retry: vi.fn(),
      discard,
    });
  });
  expect(status.state()).toBeUndefined();
  await vi.waitFor(() => expect(status.state()?.action).toBe('retry-discard'));
  expect(context.drafts.readDraft).toHaveBeenCalledWith('draft', {
    attachments: false,
  });
  status.retry();
  await vi.waitFor(() => expect(discard).toHaveBeenCalledOnce());
});

it('shows a failed status read without throwing into the composer error boundary', async () => {
  const context = createComposeContext();
  context.drafts.saveLocalDraft = vi.fn();
  context.drafts.readDraft = vi.fn(async () => {
    throw new Error('Disk unavailable');
  });
  const status = createRoot((dispose) => {
    disposers.push(dispose);
    return createDraftSyncStatus({
      drafts: context.drafts,
      connectivity: context.connectivity,
      draftId: () => 'draft',
      localSaveState: () => 'saved',
      retry: vi.fn(),
      discard: vi.fn(),
    });
  });
  await vi.waitFor(() =>
    expect(status.state()?.message).toBe('Unable to read local draft status.')
  );
  expect(status.state()?.failed).toBe(true);
});

it('stays silent once a failed save recovers', async () => {
  const context = createComposeContext();
  const [local, setLocal] = createSignal<LocalDraft>({
    ...draft,
    status: 'failed',
  });
  const [disk, setDisk] = createSignal<'saving' | 'saved' | 'failed'>('saved');
  let changed = () => {};
  context.drafts.saveLocalDraft = vi.fn();
  context.drafts.readDraft = vi.fn(async () => ({
    local: local(),
    persistence: 'queued' as const,
  }));
  context.drafts.watchDrafts = (callback) => {
    changed = callback;
    return () => {};
  };
  const retry = vi.fn(async () => {});
  const status = createRoot((dispose) => {
    disposers.push(dispose);
    return createDraftSyncStatus({
      drafts: context.drafts,
      connectivity: context.connectivity,
      draftId: () => 'draft',
      localSaveState: disk,
      retry,
      discard: vi.fn(),
    });
  });
  await vi.waitFor(() =>
    expect(status.state()).toMatchObject({ failed: true, action: 'retry' })
  );
  setLocal({ ...draft, status: 'synced' });
  changed();
  await vi.waitFor(() => expect(status.state()).toBeUndefined());
  setDisk('failed');
  expect(status.state()).toMatchObject({ failed: true, action: 'retry' });
  status.retry();
  await vi.waitFor(() => expect(retry).toHaveBeenCalledOnce());
});

it('offers retry for server failures while newer edits remain saved locally', async () => {
  const context = createComposeContext();
  context.drafts.saveLocalDraft = vi.fn();
  context.drafts.readDraft = vi.fn(async () => ({
    local: { ...draft, status: 'failed' as const },
    persistence: 'queued' as const,
  }));
  const status = createRoot((dispose) => {
    disposers.push(dispose);
    return createDraftSyncStatus({
      drafts: context.drafts,
      connectivity: context.connectivity,
      draftId: () => 'draft',
      localSaveState: () => 'saving',
      retry: vi.fn(),
      discard: vi.fn(),
    });
  });
  await vi.waitFor(() =>
    expect(status.state()).toMatchObject({ failed: true, action: 'retry' })
  );
});

it('keeps local edits visible with an actionable synchronization status during recovery', async () => {
  const context = createComposeContext();
  const [availability, setAvailability] = createSignal<
    'unavailable' | 'recovering' | 'recovery-required' | 'ready'
  >('unavailable');
  context.drafts.syncAvailability = availability;
  context.drafts.saveLocalDraft = vi.fn();
  context.drafts.readDraft = vi.fn(async () => ({
    local: { ...draft, status: 'dirty' as const },
    persistence: 'queued' as const,
  }));
  const status = createRoot((dispose) => {
    disposers.push(dispose);
    return createDraftSyncStatus({
      drafts: context.drafts,
      connectivity: context.connectivity,
      draftId: () => 'draft',
      localSaveState: () => 'saved',
      retry: vi.fn(),
      discard: vi.fn(),
    });
  });
  await vi.waitFor(() =>
    expect(status.state()?.message).toBe(
      'Saved on this device; waiting to sync'
    )
  );
  expect(status.state()?.action).toBe('retry');
  setAvailability('recovering');
  expect(status.state()?.action).toBeUndefined();
  setAvailability('recovery-required');
  expect(status.state()?.action).toBe('reload');
  setAvailability('ready');
  expect(status.state()).toBeUndefined();
});