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.6 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest';
import type { SyncSourceEvent } from '../collab/source';
import {
  WebsocketConnectionState,
  WebsocketEvent,
  type WebsocketEventListener,
} from '../websocket';
import { FromPeer, type FromRemote, type IFromPeer } from './generated/schema';
import type { SyncSocket } from './socket';
import { SyncServiceSource, TIMEOUTS } from './source';

type AnyListener = WebsocketEventListener<
  WebsocketEvent,
  IFromPeer,
  FromRemote
>;

// Minimal in-memory SyncSocket. Drives the class through deliver()/fireReconnect().
class FakeSocket implements SyncSocket {
  connectionState = WebsocketConnectionState.Connecting;
  sent: IFromPeer[] = [];
  heartbeats = 0;
  reconnects = 0;
  closed = false;
  private msg = new Set<AnyListener>();
  private openListeners = new Set<AnyListener>();
  private recon = new Set<AnyListener>();
  private closeListeners = new Set<AnyListener>();
  private retryListeners = new Set<AnyListener>();
  private heartbeatMissedListeners = new Set<AnyListener>();

  send(message: IFromPeer) {
    this.sent.push(message);
    return true;
  }
  startHeartbeat() {
    this.heartbeats++;
  }
  reconnectIfDisconnected() {
    this.reconnects++;
  }
  close() {
    this.closed = true;
  }
  addEventListener<K extends WebsocketEvent>(
    type: K,
    listener: WebsocketEventListener<K, IFromPeer, FromRemote>
  ) {
    if (type === WebsocketEvent.Message) this.msg.add(listener as AnyListener);
    else if (type === WebsocketEvent.Open)
      this.openListeners.add(listener as AnyListener);
    else if (type === WebsocketEvent.Reconnect)
      this.recon.add(listener as AnyListener);
    else if (type === WebsocketEvent.Close)
      this.closeListeners.add(listener as AnyListener);
    else if (type === WebsocketEvent.retry)
      this.retryListeners.add(listener as AnyListener);
    else if (type === WebsocketEvent.HeartbeatMissed)
      this.heartbeatMissedListeners.add(listener as AnyListener);
  }
  removeEventListener<K extends WebsocketEvent>(
    _type: K,
    listener: WebsocketEventListener<K, IFromPeer, FromRemote>
  ) {
    this.msg.delete(listener as AnyListener);
    this.openListeners.delete(listener as AnyListener);
    this.recon.delete(listener as AnyListener);
    this.closeListeners.delete(listener as AnyListener);
    this.retryListeners.delete(listener as AnyListener);
    this.heartbeatMissedListeners.delete(listener as AnyListener);
  }

  // test drivers
  deliver(data: FromRemote) {
    const event = { data } as Parameters<AnyListener>[1];
    for (const listener of [...this.msg]) listener(this as never, event);
  }
  fireReconnect() {
    this.connectionState = WebsocketConnectionState.Open;
    const event = {} as Parameters<AnyListener>[1];
    for (const listener of [...this.recon]) listener(this as never, event);
  }
  fireOpen() {
    this.connectionState = WebsocketConnectionState.Open;
    const event = {} as Parameters<AnyListener>[1];
    for (const listener of [...this.openListeners])
      listener(this as never, event);
  }
  fireClose(code: number, reason: string) {
    const event = {
      code,
      reason,
      wasClean: false,
    } as Parameters<AnyListener>[1];
    for (const listener of [...this.closeListeners])
      listener(this as never, event);
  }
  fireRetry(retries: number, backoff: number) {
    const event = {
      detail: { retries, backoff },
    } as Parameters<AnyListener>[1];
    for (const listener of [...this.retryListeners])
      listener(this as never, event);
  }
}

const GUARDS = {
  isRemoteInitialSync: () => false,
  isRemoteUpdate: () => false,
  isRemoteAwareness: () => false,
  isRemoteSnapshot: () => false,
  isRemoteUpdateAck: () => false,
  isRemoteUpdateSince: () => false,
};

const remote = {
  initialSync: (snapshot: Uint8Array, awareness: Uint8Array) =>
    ({
      ...GUARDS,
      isRemoteInitialSync: () => true,
      value: { snapshot, awareness },
    }) as unknown as FromRemote,
  update: (update: Uint8Array) =>
    ({
      ...GUARDS,
      isRemoteUpdate: () => true,
      value: { update },
    }) as unknown as FromRemote,
  awareness: (awareness: Uint8Array) =>
    ({
      ...GUARDS,
      isRemoteAwareness: () => true,
      value: { awareness },
    }) as unknown as FromRemote,
  snapshot: (snapshot: Uint8Array) =>
    ({
      ...GUARDS,
      isRemoteSnapshot: () => true,
      value: { snapshot },
    }) as unknown as FromRemote,
  ack: (id: string) =>
    ({
      ...GUARDS,
      isRemoteUpdateAck: () => true,
      value: { id },
    }) as unknown as FromRemote,
};

const snap = new Uint8Array([1, 2, 3]);
const aw = new Uint8Array([4, 5]);
const flush = () => new Promise((resolve) => setTimeout(resolve));

describe('SyncServiceSource', () => {
  it('resolves doInitialSync and starts heartbeat on RemoteInitialSync', async () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1');
    const pending = src.doInitialSync();
    ws.deliver(remote.initialSync(snap, aw));
    expect((await pending)._unsafeUnwrap()).toEqual({
      snapshot: snap,
      awareness: aw,
    });
    expect(ws.heartbeats).toBe(1);
  });

  it('recovers a first sync arriving after offline bootstrap timed out and acknowledges queued edits', async () => {
    vi.useFakeTimers();
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1', { newId: () => 'late-op' });
    try {
      const events: SyncSourceEvent[] = [];
      src.listen((event) => events.push(event));
      await vi.advanceTimersByTimeAsync(TIMEOUTS.INITIAL_SYNC + 1);
      expect((await src.doInitialSync()).isErr()).toBe(true);
      expect(await src.pushUpdate([snap])).toBe(false);
      ws.deliver(remote.initialSync(snap, aw));
      expect(events).toEqual([
        { type: 'reconnect', snapshot: snap, awareness: aw },
      ]);
      expect(ws.heartbeats).toBe(1);
      const delivered = src.pushUpdate([snap]);
      ws.deliver(remote.ack('late-op'));
      expect(await delivered).toBe(true);
    } finally {
      src.cleanup();
      vi.useRealTimers();
    }
  });

  it('acknowledges queued edits when a reconnect waiter receives the first sync after bootstrap timed out', async () => {
    vi.useFakeTimers();
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1', {
      newId: () => 'reconnect-op',
    });
    try {
      const events: SyncSourceEvent[] = [];
      src.listen((event) => events.push(event));
      await vi.advanceTimersByTimeAsync(TIMEOUTS.INITIAL_SYNC + 1);
      expect((await src.doInitialSync()).isErr()).toBe(true);
      expect(await src.pushUpdate([snap])).toBe(false);

      ws.fireReconnect();
      ws.deliver(remote.initialSync(snap, aw));
      await vi.advanceTimersByTimeAsync(0);
      expect(events).toEqual([
        { type: 'reconnect', snapshot: snap, awareness: aw },
      ]);
      expect(ws.heartbeats).toBe(1);
      const delivered = src.pushUpdate([snap]);
      expect(ws.sent).toHaveLength(1);
      ws.deliver(remote.ack('reconnect-op'));
      expect(await delivered).toBe(true);
    } finally {
      src.cleanup();
      vi.useRealTimers();
    }
  });

  it('accepts a reconnect snapshot even after its waiter expired', async () => {
    vi.useFakeTimers();
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1');
    try {
      ws.deliver(remote.initialSync(snap, aw));
      await src.doInitialSync();
      const events: SyncSourceEvent[] = [];
      src.listen((event) => events.push(event));
      ws.fireReconnect();
      await vi.advanceTimersByTimeAsync(TIMEOUTS.INITIAL_SYNC + 1);
      ws.deliver(remote.initialSync(snap, aw));
      expect(events).toEqual([
        { type: 'reconnect', snapshot: snap, awareness: aw },
      ]);
    } finally {
      src.cleanup();
      vi.useRealTimers();
    }
  });

  it('maps RemoteUpdate to an update event', () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1');
    const events: SyncSourceEvent[] = [];
    src.listen((e) => events.push(e));
    const bytes = new Uint8Array([9]);
    ws.deliver(remote.update(bytes));
    expect(events).toEqual([{ type: 'update', update: bytes }]);
  });

  it('buffers events that arrive before the first listener attaches', () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1');
    const bytes = new Uint8Array([7]);
    ws.deliver(remote.update(bytes)); // no listener yet
    const events: SyncSourceEvent[] = [];
    src.listen((e) => events.push(e));
    expect(events).toEqual([{ type: 'update', update: bytes }]);
  });

  it('drops events arriving after the last listener detaches instead of buffering', () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1');
    const events: SyncSourceEvent[] = [];
    const unsubscribe = src.listen((e) => events.push(e));
    unsubscribe();

    ws.deliver(remote.update(new Uint8Array([7]))); // engine stopped — dropped

    const eventsAfterRestart: SyncSourceEvent[] = [];
    src.listen((e) => eventsAfterRestart.push(e));
    expect(events).toEqual([]);
    expect(eventsAfterRestart).toEqual([]);
  });

  it('pushUpdate resolves false before initial sync', async () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1');
    expect(await src.pushUpdate([new Uint8Array([1])])).toBe(false);
  });

  it('pushUpdate resolves true when a matching ack arrives', async () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1', { newId: () => 'id-1' });
    ws.deliver(remote.initialSync(snap, aw));
    await src.doInitialSync();

    const acked = src.pushUpdate([new Uint8Array([1])]);
    expect(ws.sent).toHaveLength(1); // the FromPeer update went out
    ws.deliver(remote.ack('id-1'));
    expect(await acked).toBe(true);
  });

  it('requests mandatory comment validation and still waits for its acknowledgement', async () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1', { newId: () => 'comment-1' });
    ws.deliver(remote.initialSync(snap, aw));
    await src.doInitialSync();
    const update = new Uint8Array([1]);
    const acked = src.pushUpdate([update], { commentOnly: true });
    expect(ws.sent).toEqual([
      FromPeer.fromPeerCommentUpdate({ updates: [update], id: 'comment-1' }),
    ]);
    ws.deliver(remote.ack('comment-1'));
    expect(await acked).toBe(true);
  });

  it('releases unacknowledged edits on disconnect before a fast resubscribe', async () => {
    vi.useFakeTimers();
    try {
      const ws = new FakeSocket();
      const src = new SyncServiceSource(ws, 'doc1', { newId: () => 'retry' });
      ws.deliver(remote.initialSync(snap, aw));
      await src.doInitialSync();
      let delivered: boolean | undefined;
      void src.pushUpdate([new Uint8Array([1])]).then((result) => {
        delivered = result;
      });
      ws.fireClose(1012, 'restart');
      await vi.advanceTimersByTimeAsync(0);
      expect(delivered).toBe(false);
      expect(await src.pushUpdate([new Uint8Array([1])])).toBe(false);
      ws.fireReconnect();
      ws.deliver(remote.initialSync(snap, aw));
      const retried = src.pushUpdate([new Uint8Array([1])]);
      ws.deliver(remote.ack('retry'));
      expect(await retried).toBe(true);
      src.cleanup();
    } finally {
      vi.useRealTimers();
    }
  });

  it('pushUpdate resolves false when the ack times out', async () => {
    vi.useFakeTimers();
    try {
      const ws = new FakeSocket();
      const src = new SyncServiceSource(ws, 'doc1', { newId: () => 'id-1' });
      ws.deliver(remote.initialSync(snap, aw));
      await src.doInitialSync();

      const acked = src.pushUpdate([new Uint8Array([1])]);
      await vi.advanceTimersByTimeAsync(TIMEOUTS.ACK + 1);
      expect(await acked).toBe(false);
    } finally {
      vi.useRealTimers();
    }
  });

  it('matches concurrent acks to the right pushUpdate, even out of order', async () => {
    let n = 0;
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1', { newId: () => `id-${++n}` });
    ws.deliver(remote.initialSync(snap, aw));
    await src.doInitialSync();

    const first = src.pushUpdate([new Uint8Array([1])]); // id-1
    const second = src.pushUpdate([new Uint8Array([2])]); // id-2
    ws.deliver(remote.ack('id-2')); // ack the second one first
    ws.deliver(remote.ack('id-1'));
    expect(await first).toBe(true);
    expect(await second).toBe(true);
  });

  it('pushAwareness sends only while the socket is open', () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1');

    ws.connectionState = WebsocketConnectionState.Reconnecting;
    src.pushAwareness(new Uint8Array([1]));
    expect(ws.sent).toHaveLength(0); // dropped while not open

    ws.connectionState = WebsocketConnectionState.Open;
    src.pushAwareness(new Uint8Array([2]));
    expect(ws.sent).toHaveLength(1); // sent once open
  });

  it('requestSnapshot resolves with the snapshot bytes', async () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1');
    const pending = src.requestSnapshot();
    const bytes = new Uint8Array([42]);
    ws.deliver(remote.snapshot(bytes));
    expect((await pending)._unsafeUnwrap()).toEqual(bytes);
  });

  it('re-syncs and emits reconnect after a Reconnect event', async () => {
    const ws = new FakeSocket();
    const src = new SyncServiceSource(ws, 'doc1');
    const events: SyncSourceEvent[] = [];
    src.listen((e) => events.push(e));

    ws.fireReconnect();
    expect(ws.heartbeats).toBe(1); // heartbeat restarted on reconnect
    ws.deliver(remote.initialSync(snap, aw));
    await flush();

    expect(events).toContainEqual({
      type: 'reconnect',
      snapshot: snap,
      awareness: aw,
    });
  });
});