@prenta/admin 2.6.0 → 2.7.0

package/src/__tests__/lib/job-drawer.test.ts

@@ -0,0 +1,493 @@
+import { describe, expect, it } from 'vitest'
+import type { Job, JobEvent, JobReviewItem } from '@prenta/core'
+import {
+  approveAllMessage,
+  approveAllStoppedMessage,
+  appendReviewItems,
+  capWait,
+  charLimit,
+  detailsJson,
+  drawerTabs,
+  foldIds,
+  formatEventTime,
+  linkParts,
+  mergeReviewItems,
+  operationLabel,
+  overviewSentence,
+  shownAttempts,
+  timeline,
+  type FoldMemory,
+  type TimelineRow,
+} from '../../lib/job-drawer.js'
+import type { JobRow } from '../../lib/job-view.js'
+
+const NOW = Date.parse('2026-10-20T14:00:00.000Z')
+const MIN = 60_000
+
+function row(overrides: Partial<JobRow>): JobRow {
+  return {
+    id: 'job',
+    type: 'batch-ai',
+    title: 'Job',
+    scope: 'Scope',
+    state: 'queued',
+    status: overrides.state ?? 'queued',
+    cancelling: false,
+    done: 0,
+    total: 42,
+    attempts: 0,
+    maxAttempts: 3,
+    error: null,
+    retryIn: 0,
+    queuePos: 0,
+    cancelledBy: null,
+    pending: 0,
+    items: false,
+    review: 'review',
+    took: null,
+    by: 'Brandon West',
+    created: '19 min ago',
+    ...overrides,
+  }
+}
+
+function job(overrides: Partial<Job> = {}): Job {
+  return {
+    id: 'job_417',
+    type: 'batch-ai',
+    status: 'queued',
+    title: 'Rewrite meta descriptions',
+    scope: '42 posts',
+    runAt: new Date(NOW).toISOString(),
+    attempts: 0,
+    maxAttempts: 3,
+    progress: { done: 0, total: 42, unit: 'documents', cursor: null, completed: 0 },
+    lastError: null,
+    explain: null,
+    summary: null,
+    lockedAt: null,
+    cancelRequestedAt: null,
+    cancelledBy: null,
+    createdBy: { id: 'u1', name: 'Brandon West', initials: 'BW' },
+    createdAt: new Date(NOW - 19 * MIN).toISOString(),
+    updatedAt: new Date(NOW).toISOString(),
+    finishedAt: null,
+    usage: { tokensIn: 0, tokensOut: 0 },
+    payload: {
+      operation: 'meta',
+      instruction: null,
+      source: 'blog',
+      statusFilter: 'all',
+      documentIds: ['a', 'b'],
+      review: 'review',
+      onApprove: 'draft',
+    },
+    ...overrides,
+  }
+}
+
+describe('drawerTabs', () => {
+  it('has Review for batch AI, Results for scans, neither for an unknown type', () => {
+    const ids = (type: string, canReview = true) => drawerTabs(type, canReview).map((tab) => tab.id)
+    expect(ids('batch-ai')).toEqual(['overview', 'review', 'activity', 'details'])
+    expect(ids('batch-ai', false)).toEqual(['overview', 'activity', 'details'])
+    expect(ids('seo-scan')).toEqual(['overview', 'results', 'activity', 'details'])
+    expect(ids('content-health')).toEqual(['overview', 'results', 'activity', 'details'])
+    expect(ids('sitemap')).toEqual(['overview', 'activity', 'details'])
+  })
+})
+
+describe('overviewSentence', () => {
+  it('copies the kit per state', () => {
+    expect(overviewSentence(row({ state: 'running', done: 19 }), job(), NOW)).toBe(
+      'Running slice 20 of 42 now. Each slice applies the operation to one document. When the worker’s 20 seconds are up, the job yields and continues on the next run. Yielding isn’t a failure and doesn’t use a retry.',
+    )
+    expect(overviewSentence(row({ done: 19 }), job(), NOW)).toBe(
+      '19 of 42 documents done. It’s waiting for the next worker run, about once a minute.',
+    )
+    expect(overviewSentence(row({ queuePos: 2 }), job(), NOW)).toBe(
+      'Waiting for the worker. 2 jobs are ahead of it.',
+    )
+    expect(overviewSentence(row({ queuePos: 1 }), job(), NOW)).toBe(
+      'Waiting for the worker. 1 job is ahead of it.',
+    )
+    expect(overviewSentence(row({}), job(), NOW)).toBe(
+      'Waiting for the worker. It starts on the next run.',
+    )
+    expect(overviewSentence(row({ error: 'Boom', attempts: 1, retryIn: 32 }), job(), NOW)).toBe(
+      'The last slice threw an error, so the job will try again in 32 seconds. Retries wait 30 seconds, then double each time, up to 15 minutes. After 3 attempts it’s marked failed.',
+    )
+    expect(overviewSentence(row({ state: 'dead', done: 7, total: 30 }), job(), NOW)).toBe(
+      'Stopped after 3 attempts at document 8. The last error is kept below. Retrying resets the attempt count and continues from where it stopped.',
+    )
+    expect(
+      overviewSentence(
+        row({ state: 'cancelled', done: 12, total: 30, cancelledBy: 'Dana Cole' }),
+        job(),
+        NOW,
+      ),
+    ).toBe('Cancelled by Dana Cole after 12 of 30 documents. Work already done was kept.')
+    expect(overviewSentence(row({ state: 'running', cancelling: true }), job(), NOW)).toBe(
+      'Stopping when the current slice finishes, usually within 20 seconds.',
+    )
+    expect(overviewSentence(row({ state: 'succeeded', pending: 1 }), job(), NOW)).toBe(
+      'Finished. 1 AI change is waiting for approval. Nothing is applied until someone approves it.',
+    )
+  })
+
+  it('keeps "SEO" capitalised and says "page" for a scan', () => {
+    const scan = row({ type: 'seo-scan', state: 'running', done: 100, total: 340 })
+    expect(overviewSentence(scan, job({ type: 'seo-scan' }), NOW)).toContain(
+      'Each slice audits the next batch of pages. Sends the SEO digest when the run finishes.',
+    )
+    expect(
+      overviewSentence(row({ type: 'seo-scan', state: 'dead', done: 99 }), job(), NOW),
+    ).toContain('at page 100.')
+  })
+
+  it('counts slices from the type’s slice size', () => {
+    const done = (type: string, total: number) =>
+      overviewSentence(row({ type, state: 'succeeded', total, took: '17 min' }), job({ type }), NOW)
+    expect(done('content-health', 412)).toBe('Finished in 17 min across 17 slices.')
+    expect(done('seo-scan', 340)).toBe('Finished in 17 min across 4 slices.')
+    expect(done('batch-ai', 1)).toBe('Finished in 17 min across 1 slice.')
+    expect(done('sitemap', 9)).toBe('Finished in 17 min.')
+  })
+
+  it('says a cancel whose worker stopped ends on the next run', () => {
+    const stale = row({
+      state: 'queued',
+      status: 'running',
+      cancelling: true,
+      error: 'Worker stopped mid-slice',
+    })
+    expect(overviewSentence(stale, job(), NOW)).toBe(
+      'Its last slice stopped without finishing. It stops on the next worker run, within a minute.',
+    )
+  })
+
+  it('shows a usage cap’s message while the job waits it out', () => {
+    const waiting = job({
+      runAt: new Date(Date.UTC(2026, 10, 1)).toISOString(),
+      progress: {
+        done: 9,
+        total: 42,
+        unit: 'documents',
+        cursor: '9',
+        completed: 9,
+        message: 'This month’s AI budget is used up',
+      },
+    })
+    const sentence = overviewSentence(row({ done: 9 }), waiting, NOW)
+    expect(sentence).toMatch(
+      // In local time, so 1 Nov 00:00 UTC can be 31 Oct.
+      /^9 of 42 documents done\. Paused for a usage limit\. This month’s AI budget is used up\. It continues \w{3} \d{1,2} \w{3} \d\d:\d\d\.$/,
+    )
+    // The next tick, or a job without a message, isn't a cap.
+    expect(capWait(job({ progress: { ...waiting.progress } }), row({ done: 9 }), NOW)).toBeNull()
+    expect(
+      capWait({ ...waiting, progress: { ...waiting.progress, message: '' } }, row({}), NOW),
+    ).toBeNull()
+    expect(capWait(waiting, row({ error: 'Boom' }), NOW)).toBeNull()
+  })
+})
+
+describe('shownAttempts', () => {
+  it('shows the attempt in hand, or the attempts used while retrying and once failed', () => {
+    expect(shownAttempts(row({ state: 'running', attempts: 0 }))).toBe(1)
+    expect(shownAttempts(row({ state: 'running', attempts: 1 }))).toBe(2)
+    expect(shownAttempts(row({ error: 'Boom', attempts: 1 }))).toBe(1)
+    expect(shownAttempts(row({ state: 'dead', attempts: 3 }))).toBe(3)
+    expect(shownAttempts(row({ state: 'succeeded', attempts: 0 }))).toBe(1)
+    expect(shownAttempts(row({}))).toBe(0)
+  })
+})
+
+describe('operationLabel', () => {
+  it('reads the kit’s OPS labels', () => {
+    expect(operationLabel('meta')).toBe('Rewrite meta descriptions')
+    expect(operationLabel('links')).toBe('Add internal links')
+    expect(operationLabel('nope')).toBeNull()
+  })
+})
+
+describe('formatEventTime', () => {
+  it('reads like the kit’s activity times', () => {
+    const at = (ms: number) => new Date(NOW - ms).toISOString()
+    expect(formatEventTime(at(2_000), NOW)).toBe('now')
+    expect(formatEventTime(at(-3_000), NOW)).toBe('now')
+    expect(formatEventTime(at(6_000), NOW)).toBe('6s ago')
+    expect(formatEventTime(at(19 * MIN), NOW)).toBe('19m ago')
+    expect(formatEventTime('not a date', NOW)).toBe('now')
+  })
+})
+
+describe('timeline', () => {
+  const at = (minutes: number) => new Date(NOW - minutes * MIN).toISOString()
+  const titles = (rows: TimelineRow[]) =>
+    rows.map((entry) =>
+      entry.kind === 'entry' ? entry.entry.title : `${entry.entries.length} earlier slices`,
+    )
+
+  it('keeps the running and oldest starts, two finished slices, then folds the rest', () => {
+    const events: JobEvent[] = [{ at: at(0), kind: 'claimed', message: 'Slice started' }]
+    for (let n = 1; n <= 5; n++) {
+      events.push(
+        {
+          at: at(n),
+          kind: 'yielded',
+          message: 'Slice finished',
+          detail: `Processed ${19 - n} of 42`,
+        },
+        { at: at(n + 0.2), kind: 'claimed', message: 'Slice started' },
+      )
+    }
+    events.push({ at: at(19), kind: 'queued', message: 'Queued' })
+    const rows = timeline(events, job(), row({ state: 'running' }))
+    expect(titles(rows)).toEqual([
+      'Slice started',
+      'Slice finished',
+      'Slice finished',
+      '3 earlier slices',
+      'Slice started',
+      'Queued',
+    ])
+    expect(rows[0]).toMatchObject({ kind: 'entry', entry: { tone: 'run' } })
+    expect(rows[1]).toMatchObject({ kind: 'entry', entry: { tone: 'ok' } })
+    expect(rows.at(-1)).toMatchObject({ entry: { detail: 'Brandon West started it' } })
+  })
+
+  it('never folds failures, and keeps a start that names a later attempt', () => {
+    const events: JobEvent[] = [
+      {
+        at: at(1),
+        kind: 'retry_scheduled',
+        message: 'Retry scheduled',
+        detail: 'Next try in 30s.',
+      },
+      {
+        at: at(1.1),
+        kind: 'slice_failed',
+        message: 'Slice failed',
+        detail: 'ImageFetchError',
+        durationMs: 4100,
+      },
+      { at: at(1.2), kind: 'claimed', message: 'Slice started', detail: 'Attempt 2 of 3' },
+      { at: at(2), kind: 'yielded', message: 'Paused for a usage limit', detail: 'Budget spent.' },
+    ]
+    const rows = timeline(events, job(), row({ error: 'ImageFetchError', attempts: 1 }))
+    expect(
+      rows.map((entry) => entry.kind === 'entry' && [entry.entry.title, entry.entry.tone]),
+    ).toEqual([
+      ['Retry scheduled', 'warn'],
+      ['Slice failed', 'err'],
+      ['Slice started', 'none'],
+      ['Paused for a usage limit', 'warn'],
+    ])
+    expect(rows[1]).toMatchObject({ entry: { detail: 'ImageFetchError · 4.1s' } })
+    // A usage-limit pause isn't called "yielded".
+    expect(rows[3]).toMatchObject({ entry: { detail: 'Budget spent.' } })
+  })
+
+  it('keeps every key, and the fold’s id, when newer events arrive', () => {
+    const finished = (minutes: number): JobEvent => ({
+      at: at(minutes),
+      kind: 'yielded',
+      message: 'Slice finished',
+    })
+    const older: JobEvent[] = [
+      finished(1),
+      finished(2),
+      finished(3),
+      finished(4),
+      // Two events at the same moment stay apart.
+      { at: at(19), kind: 'queued', message: 'Queued' },
+      { at: at(19), kind: 'queued', message: 'Queued' },
+    ]
+    const keys = (rows: TimelineRow[]) =>
+      rows.flatMap((entry) =>
+        entry.kind === 'entry' ? [entry.entry.key] : entry.entries.map((e) => e.key),
+      )
+    const memory: FoldMemory = { entries: new Map(), next: 0 }
+    const before = timeline(older, job(), row({ state: 'running' }))
+    const idsBefore = foldIds(before, memory)
+    const after = timeline([finished(0), ...older], job(), row({ state: 'running' }))
+    const idsAfter = foldIds(after, memory)
+    expect(new Set(keys(before)).size).toBe(keys(before).length)
+    // Every row shown before keeps its key; the fold grew at its newer edge.
+    expect(keys(after)).toEqual(expect.arrayContaining(keys(before)))
+    expect(idsBefore).toEqual(['fold-0'])
+    expect(idsAfter).toEqual(['fold-0'])
+    const fold = after.find((entry) => entry.kind === 'group')
+    expect(fold?.kind === 'group' && fold.entries.length).toBe(3)
+  })
+
+  // A long job (P-18 review): 20 slices, a failure and a retry, then 50 more,
+  // seen through the newest-50 window as it slides. The older fold shrinks
+  // away; that mustn't close the open fold or open the other one.
+  it.each([
+    ['the newer fold', 0],
+    ['the older fold', 1],
+  ])('keeps %s open, and no other, as the newest 50 slide', (_, opened) => {
+    let tick = 0
+    const event = (kind: JobEvent['kind'], message: string, detail?: string): JobEvent => ({
+      at: new Date(NOW - 200 * MIN + tick++ * 1000).toISOString(),
+      kind,
+      message,
+      ...(detail ? { detail } : {}),
+    })
+    const history: JobEvent[] = [event('queued', 'Queued')]
+    const slice = (n: number) =>
+      history.push(event('claimed', 'Slice started'), event('yielded', 'Slice finished', `s${n}`))
+    for (let n = 1; n <= 20; n++) slice(n)
+    history.push(
+      event('claimed', 'Slice started'),
+      event('slice_failed', 'Slice failed', 'Boom'),
+      event('retry_scheduled', 'Retry scheduled', 'Next try in 30s.'),
+    )
+    for (let n = 21; n <= 70; n++) slice(n)
+
+    const memory: FoldMemory = { entries: new Map(), next: 0 }
+    let open = new Set<string>()
+    let tracked: Set<string> | null = null
+    let folds = 0
+    let shrank = false
+    for (let length = 45; length <= history.length; length++) {
+      const rows = timeline(history.slice(0, length).slice(-50), job(), row({}))
+      const groups = rows.filter((entry) => entry.kind === 'group')
+      const ids = foldIds(rows, memory, open)
+      if (groups.length < folds) shrank = true
+      folds = groups.length
+      if (!tracked) {
+        if (groups.length < 2) continue
+        open = new Set([ids[opened]!])
+        tracked = new Set(groups[opened]!.entries.map((entry) => entry.key))
+        continue
+      }
+      const still = groups.findIndex((group) =>
+        group.entries.some((entry) => tracked!.has(entry.key)),
+      )
+      const openNow = ids.map((id) => open.has(id))
+      expect(openNow.filter(Boolean), `${length} events`).toHaveLength(still === -1 ? 0 : 1)
+      if (still === -1) break
+      expect(openNow[still], `${length} events`).toBe(true)
+      tracked = new Set(groups[still]!.entries.map((entry) => entry.key))
+    }
+    expect(tracked).not.toBeNull()
+    expect(shrank).toBe(true)
+  })
+
+  it('makes up the kit’s two rows for a job with no events', () => {
+    const rows = timeline([], job(), row({ state: 'succeeded', took: '17 min' }))
+    expect(rows).toEqual([
+      {
+        kind: 'entry',
+        entry: expect.objectContaining({ title: 'Finished', detail: 'Took 17 min', tone: 'ok' }),
+      },
+      {
+        kind: 'entry',
+        entry: expect.objectContaining({ title: 'Queued', detail: 'Brandon West' }),
+      },
+    ])
+  })
+})
+
+describe('detailsJson', () => {
+  it('counts the frozen document ids instead of listing them', () => {
+    const raw = JSON.parse(detailsJson(job()))
+    expect(raw.payload.documentIds).toBe('[2 ids]')
+    expect(raw.id).toBe('job_417')
+    expect(JSON.parse(detailsJson(job({ payload: { trigger: 'cron' } }))).payload).toEqual({
+      trigger: 'cron',
+    })
+  })
+})
+
+describe('linkParts', () => {
+  it('splits a link suggestion around its link', () => {
+    expect(linkParts('Learn more <a href="/about">about us</a> before you call.')).toEqual({
+      before: 'Learn more ',
+      anchor: 'about us',
+      href: '/about',
+      after: ' before you call.',
+    })
+  })
+
+  it('reads only the markup the server writes', () => {
+    expect(linkParts('<a href="//evil.example">x</a>')).toBeNull()
+    expect(linkParts('<a href="/x" onclick="y">x</a>')).toBeNull()
+    expect(linkParts('<a href="javascript:alert(1)">x</a>')).toBeNull()
+    expect(linkParts('No link here')).toBeNull()
+  })
+})
+
+describe('charLimit', () => {
+  it('limits meta descriptions to 155', () => {
+    expect(charLimit('metaDescription')).toBe(155)
+    expect(charLimit('excerpt')).toBeNull()
+  })
+})
+
+describe('mergeReviewItems / appendReviewItems', () => {
+  const change = (id: string, status: JobReviewItem['status'] = 'pending'): JobReviewItem => ({
+    id,
+    jobId: 'job',
+    documentId: id,
+    documentTitle: id,
+    url: '',
+    field: 'metaDescription',
+    before: '',
+    after: id,
+    editedAfter: null,
+    status,
+    decidedBy: null,
+    decidedAt: null,
+    appliedRevisionId: null,
+  })
+
+  it('takes the fresh read, except changes decided here after it began', () => {
+    const loaded = [change('a', 'approved'), change('b', 'rejected')]
+    const fresh = [change('a'), change('b'), change('c')]
+    expect(mergeReviewItems(fresh, loaded, new Set(['a'])).map((x) => x.status)).toEqual([
+      'approved',
+      'pending',
+      'pending',
+    ])
+  })
+
+  it('appends a page without repeating a change', () => {
+    expect(
+      appendReviewItems([change('a'), change('b')], [change('b'), change('c')]).map((x) => x.id),
+    ).toEqual(['a', 'b', 'c'])
+  })
+})
+
+describe('approveAllMessage', () => {
+  it('copies the kit’s toast, and says what stayed in review', () => {
+    expect(approveAllMessage({ approved: 6, remaining: 0 }, 'publish')).toEqual({
+      title: '6 changes approved · published',
+    })
+    expect(approveAllMessage({ approved: 1, remaining: 2 }, 'draft')).toEqual({
+      title: '1 change approved · saved as drafts',
+      description:
+        '2 changes stayed in review. Changes to published documents need Publish, so approve those one at a time.',
+    })
+    expect(approveAllMessage({ approved: 0, remaining: 1 }, 'publish')).toEqual({
+      title: 'No changes were approved',
+      description: '1 change stayed in review. They couldn’t be applied.',
+    })
+  })
+})
+
+describe('approveAllStoppedMessage', () => {
+  it('says approve all stopped to keep the edits', () => {
+    expect(approveAllStoppedMessage(0, 1)).toEqual({
+      title: 'Approve all stopped',
+      description:
+        '1 edited change couldn’t be approved, so nothing else was, and the AI’s text doesn’t replace an edit. Each change says why.',
+    })
+    expect(approveAllStoppedMessage(2, 3).description).toMatch(
+      /^2 edited changes approved\. 3 edited changes couldn’t be approved/,
+    )
+  })
+})