Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

9.6 KB
Raw Blame
import { describe, it, expect, beforeEach, afterAll, vi } from 'vitest';
import { mkdtempSync, rmSync, mkdirSync } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';
import { makePathsProxy } from '../lib/mockPathsDataRoot.js';

const TEST_DATA_ROOT = mkdtempSync(join(tmpdir(), 'message-accounts-test-'));

vi.mock('../lib/fileUtils.js', async (importOriginal) => {
  const actual = await importOriginal();
  return {
    ...makePathsProxy(actual, { dataRoot: TEST_DATA_ROOT }),
    atomicWrite: vi.fn(actual.atomicWrite)
  };
});

vi.mock('../lib/uuid.js', () => ({
  v4: vi.fn().mockReturnValue('msg-uuid-5678'),
}));

const messageAccounts = await import('./messageAccounts.js');
const { atomicWrite } = await import('../lib/fileUtils.js');
const { atomicWrite: persist } = await vi.importActual('../lib/fileUtils.js');
const { v4: uuid } = await import('../lib/uuid.js');

// Pause persistence after its read so competing service calls overlap deterministically.
function holdNextWrite({ fail = false } = {}) {
  const entered = Promise.withResolvers();
  const release = Promise.withResolvers();
  atomicWrite.mockImplementationOnce(async (...args) => {
    entered.resolve();
    await release.promise;
    if (fail) throw new Error('synthetic persistence failure');
    return persist(...args);
  });
  return { entered: entered.promise, release: release.resolve };
}

afterAll(() => rmSync(TEST_DATA_ROOT, { recursive: true, force: true }));

describe('messageAccounts', () => {
  it('derives send capabilities on read without trusting persisted capability flags', async () => {
    await messageAccounts.createAccount({ name: 'Gmail', type: 'gmail' });
    uuid.mockReturnValueOnce('outlook-id');
    await messageAccounts.createAccount({ name: 'Outlook', type: 'outlook' });
    uuid.mockReturnValueOnce('teams-id');
    await messageAccounts.createAccount({ name: 'Teams', type: 'teams' });
    expect((await messageAccounts.listAccounts()).map(({ type, canSend }) => ({ type, canSend }))).toEqual([
      { type: 'gmail', canSend: true }, { type: 'outlook', canSend: true }, { type: 'teams', canSend: true }
    ]);
    expect(await messageAccounts.getAccount('teams-id')).toMatchObject({ type: 'teams', canSend: true, provider: 'playwright' });
  });

  it('derives the offered sync modes and read-state capability per provider (#9968)', async () => {
    await messageAccounts.createAccount({ name: 'Gmail', type: 'gmail' });
    uuid.mockReturnValueOnce('outlook-id');
    await messageAccounts.createAccount({ name: 'Outlook', type: 'outlook' });
    uuid.mockReturnValueOnce('teams-id');
    await messageAccounts.createAccount({ name: 'Teams', type: 'teams' });
    expect((await messageAccounts.listAccounts()).map(({ type, syncModes, hasReadState }) => ({ type, syncModes, hasReadState }))).toEqual([
      { type: 'gmail', syncModes: ['unread', 'full'], hasReadState: true },
      { type: 'outlook', syncModes: ['unread', 'full'], hasReadState: true },
      { type: 'teams', syncModes: ['full'], hasReadState: false }
    ]);
  });

  beforeEach(() => {
    atomicWrite.mockReset().mockImplementation(persist);
    uuid.mockReset().mockReturnValue('msg-uuid-5678');
    rmSync(TEST_DATA_ROOT, { recursive: true, force: true });
    mkdirSync(TEST_DATA_ROOT, { recursive: true });
  });

  describe('createAccount', () => {
    it('creates a gmail account with correct defaults', async () => {
      const acc = await messageAccounts.createAccount({
        name: 'Gmail Work',
        type: 'gmail',
        email: '[email protected]',
      });

      expect(acc.id).toBe('msg-uuid-5678');
      expect(acc.name).toBe('Gmail Work');
      expect(acc.type).toBe('gmail');
      expect(acc.provider).toBe('api');
      expect(acc.email).toBe('[email protected]');
      expect(acc.enabled).toBe(true);
      expect(acc.lastSyncAt).toBeNull();
      expect(acc.lastSyncStatus).toBeNull();
      expect(acc.createdAt).toBeTruthy();
      expect(acc.syncConfig.maxAge).toBe('30d');
      expect(acc.syncConfig.maxMessages).toBe(500);
      expect(acc.syncConfig.syncInterval).toBe(300000);
    });

    it('sets provider to playwright for non-gmail types', async () => {
      const acc = await messageAccounts.createAccount({ name: 'Outlook', type: 'outlook' });
      expect(acc.provider).toBe('playwright');
    });

    it('defaults email to empty string when omitted', async () => {
      const acc = await messageAccounts.createAccount({ name: 'No Email', type: 'gmail' });
      expect(acc.email).toBe('');
    });
  });

  describe('updateAccount', () => {
    it('merges partial updates without overwriting untouched fields', async () => {
      await messageAccounts.createAccount({ name: 'Old Name', type: 'gmail', email: '[email protected]' });
      const updated = await messageAccounts.updateAccount('msg-uuid-5678', { name: 'New Name' });

      expect(updated.name).toBe('New Name');
      expect(updated.email).toBe('[email protected]'); // untouched
    });

    it('returns null for a missing id', async () => {
      const result = await messageAccounts.updateAccount('no-such-id', { name: 'x' });
      expect(result).toBeNull();
    });
  });

  describe('deleteAccount', () => {
    it('removes the account and returns true', async () => {
      await messageAccounts.createAccount({ name: 'Delete Me', type: 'gmail' });
      const result = await messageAccounts.deleteAccount('msg-uuid-5678');
      expect(result).toBe(true);

      const list = await messageAccounts.listAccounts();
      expect(list).toHaveLength(0);
    });

    it('returns false for a missing id', async () => {
      const result = await messageAccounts.deleteAccount('ghost');
      expect(result).toBe(false);
    });
  });

  describe('updateSyncStatus', () => {
    it('stamps lastSyncAt and lastSyncStatus', async () => {
      await messageAccounts.createAccount({ name: 'Sync Me', type: 'gmail' });
      const result = await messageAccounts.updateSyncStatus('msg-uuid-5678', 'ok');

      expect(result.lastSyncStatus).toBe('ok');
      expect(result.lastSyncAt).toBeTruthy();
    });

    it('returns null for an absent id', async () => {
      const result = await messageAccounts.updateSyncStatus('absent-id', 'fail');
      expect(result).toBeNull();
    });
  });
  describe('concurrent persistence', () => {
    it.each(['same account', 'different accounts'])('preserves edits and sync status for %s', async (scope) => {
      uuid.mockReturnValueOnce('account-a').mockReturnValueOnce('account-b');
      await messageAccounts.createAccount({ name: 'Account A', type: 'gmail' });
      await messageAccounts.createAccount({ name: 'Account B', type: 'gmail' });
      const barrier = holdNextWrite();
      const edit = messageAccounts.updateAccount('account-a', { enabled: false });
      await barrier.entered;
      const statusId = scope === 'same account' ? 'account-a' : 'account-b';
      const status = messageAccounts.updateSyncStatus(statusId, 'success');
      barrier.release();
      await Promise.all([edit, status]);
      expect(await messageAccounts.getAccount('account-a')).toMatchObject({ enabled: false });
      expect(await messageAccounts.getAccount(statusId)).toMatchObject({ lastSyncStatus: 'success' });
    });

    it('does not resurrect a deleted account through queued sync metadata writes', async () => {
      const account = await messageAccounts.createAccount({ name: 'Account A', type: 'gmail' });
      const barrier = holdNextWrite();
      const deletion = messageAccounts.deleteAccount(account.id);
      await barrier.entered;
      const metadata = [
        messageAccounts.updateSyncStatus(account.id, 'success'),
        messageAccounts.updateSendAsAliases(account.id, ['[email protected]']),
        messageAccounts.markSentIngested(account.id)
      ];
      barrier.release();
      expect(await deletion).toBe(true);
      expect(await Promise.all(metadata)).toEqual([null, null, null]);
      expect(await messageAccounts.listAccounts()).toEqual([]);
    });

    it('preserves concurrent creates and subsequent alias and coverage changes', async () => {
      uuid.mockReturnValueOnce('account-a').mockReturnValueOnce('account-b');
      const barrier = holdNextWrite();
      const first = messageAccounts.createAccount({ name: 'Account A', type: 'gmail' });
      await barrier.entered;
      const second = messageAccounts.createAccount({ name: 'Account B', type: 'gmail' });
      const aliases = messageAccounts.updateSendAsAliases('account-a', [' [email protected] ']);
      const watermark = messageAccounts.markSentIngested('account-b', { at: '2026-01-01T00:00:00.000Z', partial: true });
      barrier.release();
      await Promise.all([first, second, aliases, watermark]);
      expect(await messageAccounts.listAccounts()).toEqual([
        expect.objectContaining({ id: 'account-a', sendAsAliases: ['[email protected]'] }),
        expect.objectContaining({ id: 'account-b', sentIngestedAt: '2026-01-01T00:00:00.000Z', sentCoveragePartial: true })
      ]);
    });

    it('rejects a failed save and lets a queued write use the last persisted state', async () => {
      const account = await messageAccounts.createAccount({ name: 'Account A', type: 'gmail' });
      const barrier = holdNextWrite({ fail: true });
      const edit = messageAccounts.updateAccount(account.id, { enabled: false });
      const rejected = expect(edit).rejects.toThrow('synthetic persistence failure');
      await barrier.entered;
      const status = messageAccounts.updateSyncStatus(account.id, 'success');
      barrier.release();
      await rejected;
      await status;
      expect(await messageAccounts.getAccount(account.id)).toMatchObject({
        enabled: true, lastSyncStatus: 'success'
      });
    });
  });

});