familysync/apps/api/tests/lib/listChangeDispatcher.test.ts

/**
 * Integration tests — listChangeDispatcher (Plan 05-05).
 *
 * Asserts that notifyListChange:
 *   - Calls dispatchPush exactly ONCE per subscriber who is NOT the actor,
 *     after a burst of calls coalesces within the window.
 *   - Self-suppression: the actor never receives a push (D-03).
 *   - Access scoping: a third user with no owner/share access is never dispatched.
 *   - Empty audience (no other accessible members or no subscriptions): no dispatch,
 *     no crash.
 *
 * Uses a real dev MariaDB (same pattern as lists.test.ts) for DB seeding.
 * Mocks dispatchPush via vi.doMock to assert recipients without network.
 * Uses a tiny windowMs (10 ms) so the coalescer fires quickly with real timers.
 *
 * Run:
 *   set -a; . .env 2>/dev/null; set +a
 *   export DB_HOST=127.0.0.1
 *   pnpm --filter @familysync/api exec vitest run tests/lib/listChangeDispatcher.test.ts
 */

import { describe, it, expect, vi, beforeEach } from 'vitest'
import { randomUUID } from 'node:crypto'
import { db } from '../../src/db/client.js'
import { users, lists, listShares, pushSubscriptions } from '../../src/db/schema.js'

// ---------------------------------------------------------------------------
// Seed helpers
// ---------------------------------------------------------------------------

async function seedUser(label: string, displayName?: string): Promise<number> {
  const [result] = await db.insert(users).values({
    oidcIss: 'https://auth.test',
    oidcSub: `sub-${label}-${randomUUID()}`,
    displayName: displayName ?? `User ${label}`,
    color: '#4A90D9',
  }).$returningId()
  return result.id
}

async function seedList(ownerId: number, name: string, isShared = true): Promise<number> {
  const [result] = await db.insert(lists).values({ ownerId, name, isShared }).$returningId()
  return result.id
}

async function seedShare(listId: number, userId: number): Promise<void> {
  await db.insert(listShares).values({ listId, userId })
}

async function seedSubscription(userId: number, suffix = ''): Promise<number> {
  const [result] = await db.insert(pushSubscriptions).values({
    userId,
    endpoint: `https://push.example.com/${userId}${suffix}`,
    p256dh: 'fake-p256dh-key',
    auth: 'fake-auth',
  }).$returningId()
  return result.id
}

/** Short wait for real-timer coalescer window + async DB queries to settle. */
function sleep(ms: number): Promise<void> {
  return new Promise<void>((resolve) => setTimeout(resolve, ms))
}

/**
 * Poll a predicate until it passes or the timeout is exceeded.
 * Replaces @testing-library/waitFor — keeps the test deps minimal.
 */
async function pollUntil(
  predicate: () => void,
  timeoutMs = 3000,
  intervalMs = 30,
): Promise<void> {
  const deadline = Date.now() + timeoutMs
  let lastErr: unknown
  while (Date.now() < deadline) {
    try {
      predicate()
      return // predicate passed
    } catch (err) {
      lastErr = err
    }
    await sleep(intervalMs)
  }
  throw lastErr
}

// ---------------------------------------------------------------------------
// Tests
// Use a tiny windowMs (10 ms) so the coalescer fires quickly in real time.
// Use vi.doMock + vi.resetModules before each test so the mock is fresh.
// ---------------------------------------------------------------------------

const WINDOW_MS = 10

describe('notifyListChange — access-scoped, self-suppressed, coalesced (NOTIF-02)', () => {
  beforeEach(() => {
    vi.resetModules()
    // Re-register the dispatchPush mock after each resetModules so fresh
    // dynamic imports of listChangeDispatcher.js get the mocked pushDispatcher.
    vi.doMock('../../src/lib/pushDispatcher.js', () => ({
      dispatchPush: vi.fn().mockResolvedValue(undefined),
    }))
  })

  async function getDispatchPushMock() {
    const { dispatchPush } = await import('../../src/lib/pushDispatcher.js')
    return vi.mocked(dispatchPush)
  }

  it('burst of N calls coalesces into exactly one dispatchPush to the non-actor subscriber', async () => {
    const actorId = await seedUser('actor-burst', 'Alice')
    const otherId = await seedUser('other-burst', 'Bob')
    const listId = await seedList(actorId, 'Groceries')
    await seedShare(listId, otherId)

    // Subscriptions: one for actor, one for other
    await seedSubscription(actorId)
    const otherSubId = await seedSubscription(otherId)

    const mockDispatch = await getDispatchPushMock()
    const { notifyListChange } = await import('../../src/lib/listChangeDispatcher.js')

    // Three rapid calls within the coalesce window
    notifyListChange(listId, actorId, WINDOW_MS)
    notifyListChange(listId, actorId, WINDOW_MS)
    notifyListChange(listId, actorId, WINDOW_MS)

    // Wait for the coalescer window to expire + DB queries to settle
    await pollUntil(() => expect(mockDispatch).toHaveBeenCalledTimes(1))

    // The called subscription must be the other user's subscription
    const [calledSub, notification] = mockDispatch.mock.calls[0]
    expect(calledSub.id).toBe(otherSubId)
    expect(calledSub.userId).toBe(otherId)

    // Notification body must contain actor name and change count
    expect(notification.body).toMatch(/Alice/)
    expect(notification.body).toMatch(/3/)
    // Notification must have a title (D-02 — no item text, just generic copy)
    expect(notification.title).toBeDefined()
    expect(typeof notification.title).toBe('string')
  })

  it('actor is never dispatched to their own subscription (D-03 self-suppression)', async () => {
    const actorId = await seedUser('actor-self-suppress', 'Charlie')
    const listId = await seedList(actorId, 'Private List')
    // Actor subscribes, but there are no other accessible members → audience is empty after D-03
    await seedSubscription(actorId)

    const mockDispatch = await getDispatchPushMock()
    const { notifyListChange } = await import('../../src/lib/listChangeDispatcher.js')

    notifyListChange(listId, actorId, WINDOW_MS)

    // Wait past the window; actor's subscription must never be dispatched
    await sleep(WINDOW_MS + 200)

    expect(mockDispatch).not.toHaveBeenCalled()
  })

  it('unrelated user with no access is never dispatched (T-05-14 access scoping)', async () => {
    const actorId = await seedUser('actor-scope', 'Dave')
    const memberId = await seedUser('member-scope', 'Eve')
    const unrelatedId = await seedUser('unrelated-scope', 'Frank')

    const listId = await seedList(actorId, 'Scoped List')
    await seedShare(listId, memberId)

    await seedSubscription(actorId)
    await seedSubscription(memberId)
    // Unrelated user also has a subscription — must never be dispatched
    await seedSubscription(unrelatedId)

    const mockDispatch = await getDispatchPushMock()
    const { notifyListChange } = await import('../../src/lib/listChangeDispatcher.js')

    notifyListChange(listId, actorId, WINDOW_MS)

    // Wait for coalescer + DB queries to settle
    await pollUntil(() => expect(mockDispatch).toHaveBeenCalledTimes(1))

    // Only member (Eve) should be dispatched; unrelated (Frank) must NOT receive push
    const [calledSub] = mockDispatch.mock.calls[0]
    expect(calledSub.userId).toBe(memberId)
    expect(calledSub.userId).not.toBe(unrelatedId)
  })

  it('empty audience (no other members) → no dispatch, no crash', async () => {
    const actorId = await seedUser('actor-no-other', 'Grace')
    const listId = await seedList(actorId, 'Solo List')
    // No shares; actor-only list
    await seedSubscription(actorId)

    const mockDispatch = await getDispatchPushMock()
    const { notifyListChange } = await import('../../src/lib/listChangeDispatcher.js')

    notifyListChange(listId, actorId, WINDOW_MS)
    await sleep(WINDOW_MS + 200)

    expect(mockDispatch).not.toHaveBeenCalled()
  })

  it('empty audience (non-actor member has no subscription) → no dispatch, no crash', async () => {
    const actorId = await seedUser('actor-no-sub', 'Heidi')
    const otherId = await seedUser('other-no-sub', 'Ivan')

    const listId = await seedList(actorId, 'No Sub List')
    await seedShare(listId, otherId)

    // Actor has a subscription, other does NOT
    await seedSubscription(actorId)
    // Deliberately no subscription for otherId

    const mockDispatch = await getDispatchPushMock()
    const { notifyListChange } = await import('../../src/lib/listChangeDispatcher.js')

    notifyListChange(listId, actorId, WINDOW_MS)
    await sleep(WINDOW_MS + 200)

    // Other has no subscription → no push dispatched
    expect(mockDispatch).not.toHaveBeenCalled()
  })
})