log.test.ts

import { beforeEach, describe, expect, it, vi } from 'vitest';
import {
  __resetActivityEventLog,
  appendEvent,
  getAllEvents,
  getEventsForOffer,
  getEventsSince,
  getLatestSeq,
  onAppend,
} from './log';
import type { ActivityEventInput, OfferSnapshot } from './types';

const snapshot: OfferSnapshot = {
  id: 'offer-a',
  scenario_key: 'tracking',
  _bucket: 'pending',
  _createdAtMinutesAgo: 5,
  _startedAtMinutesAgo: 5,
  _lastCompletedAtMinutesAgo: null,
  _eventCompletedAtMinutesAgo: [],
  title: 'Seed',
  icon_url: '',
  images: { default: null, medium: null, large: null },
  assets: { images: {}, video_url: null, screenshots: [] },
  description: '',
  secondary_description: '',
  additional_information: '',
  detailed_highlights: null,
  supported_platforms: [],
  offer_status: 'new',
  payout: '1.00',
  requirements: '',
  redirect_url: '',
  categories: [],
  events: [],
  support_url: null,
  partner_slug: 'demo',
  metric_value: null,
  payout_boost_factor: null,
  featured_copy: null,
  user_offer_activity: { status: null },
  offer_progress_state: null,
};

function created(offerId: string, overrides?: Partial<OfferSnapshot>): ActivityEventInput {
  return {
    kind: 'offer_created',
    actor: { kind: 'system' },
    offer_id: offerId,
    payload: { ...snapshot, ...overrides, id: offerId },
  };
}

beforeEach(() => {
  __resetActivityEventLog();
});

describe('activity event log', () => {
  it('starts empty after reset', () => {
    expect(getAllEvents()).toEqual([]);
    expect(getLatestSeq()).toBe(0);
  });

  it('assigns monotonically increasing seq on append', () => {
    const first = appendEvent(created('offer-1'));
    const second = appendEvent(created('offer-2'));
    expect(first.seq).toBe(1);
    expect(second.seq).toBe(2);
    expect(getLatestSeq()).toBe(2);
  });

  it('stamps an ISO timestamp when not supplied', () => {
    const event = appendEvent(created('offer-1'));
    expect(event.at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
  });

  it('preserves the caller-supplied `at` timestamp when given', () => {
    const event = appendEvent({ ...created('offer-1'), at: '2026-01-01T00:00:00.000Z' });
    expect(event.at).toBe('2026-01-01T00:00:00.000Z');
  });

  it('returns only events strictly after the supplied seq', () => {
    appendEvent(created('offer-1'));
    appendEvent(created('offer-2'));
    appendEvent(created('offer-3'));
    expect(getEventsSince(0).map((e) => e.seq)).toEqual([1, 2, 3]);
    expect(getEventsSince(1).map((e) => e.seq)).toEqual([2, 3]);
    expect(getEventsSince(3)).toEqual([]);
  });

  it('filters events by offer_id', () => {
    appendEvent(created('offer-1'));
    appendEvent(created('offer-2'));
    appendEvent({
      kind: 'offer_updated',
      actor: { kind: 'system' },
      offer_id: 'offer-1',
      patch: { title: 'Renamed' },
    });
    const events = getEventsForOffer('offer-1');
    expect(events.map((e) => e.kind)).toEqual(['offer_created', 'offer_updated']);
  });

  it('reset clears events and resets seq', () => {
    appendEvent(created('offer-1'));
    appendEvent(created('offer-2'));
    __resetActivityEventLog();
    expect(getAllEvents()).toEqual([]);
    expect(getLatestSeq()).toBe(0);
    const next = appendEvent(created('offer-3'));
    expect(next.seq).toBe(1);
  });

  it('notifies onAppend listeners after each append', () => {
    const listener = vi.fn();
    const unsubscribe = onAppend(listener);

    const event = appendEvent(created('offer-notify'));
    expect(listener).toHaveBeenCalledTimes(1);
    expect(listener.mock.calls[0][0]).toEqual(event);

    unsubscribe();
    appendEvent(created('offer-silent'));
    expect(listener).toHaveBeenCalledTimes(1);
  });
});