@startsimpli/ui 0.4.140 → 0.4.142

package/src/components/history/__tests__/record-activity-panel.test.tsx

@@ -0,0 +1,179 @@
+/**
+ * RED for bd startsim-ucg5u — everything one person (or one agent) changed,
+ * across records, over `GET /api/v1/revisions/` (server bd startsim-ivr3n),
+ * composed on the shared ActivityFeedPanel rather than a second feed.
+ *
+ * Contract traps this pins:
+ * - cursor paging, no count, never `?page=`;
+ * - a blank actor/scope is a 400, so empty filters are OMITTED, not sent blank;
+ * - filters are the host's (the URL), the panel only reports changes;
+ * - the person filter's value is the actor's SUB, the label is their address;
+ * - adjacent saves fold only within ONE record — two records never merge.
+ */
+import { render, screen, fireEvent, waitFor, within } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+import { RecordActivityPanel, foldFeed, revisionFeedParams } from '../index'
+import type { RevisionFeedRow } from '../types'
+
+function mount(ui: React.ReactElement) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 0 } } })
+  return render(<QueryClientProvider client={qc}>{ui}</QueryClientProvider>)
+}
+
+const T0 = Date.parse('2026-10-07T12:00:00.000Z')
+const at = (ms: number) => new Date(T0 + ms).toISOString()
+
+function row(id: string, entity: { id: string; type: string; name: string }, over: Partial<RevisionFeedRow> = {}): RevisionFeedRow {
+  return {
+    id,
+    version: 2,
+    action: 'updated',
+    source: 'patch',
+    created_at: at(0),
+    actor_sub: 'u-jurga',
+    actor_label: 'jurga@ogmc.example',
+    actor_kind: 'person',
+    actor_kind_source: 'claim',
+    metadata: { changed: { blog: { before: 'old', after: 'new' } } },
+    entity,
+    ...over,
+  }
+}
+
+const draftA = { id: 'd-a', type: 'draft', name: 'Gulf logistics brief' }
+const draftB = { id: 'd-b', type: 'draft', name: 'Riyadh expansion' }
+
+describe('revisionFeedParams — only what the route accepts, never blank', () => {
+  it('omits blank values and maps nothing it does not know', () => {
+    expect(
+      revisionFeedParams({ actor: '', actor_kind: 'machine', type: 'draft', scope: ' ', since: '2026-10-05T00:00:00.000Z' }),
+    ).toEqual({ actor_kind: 'machine', type: 'draft', since: '2026-10-05T00:00:00.000Z' })
+    expect(revisionFeedParams({ q: 'x', page: '2' } as never)).toEqual({})
+  })
+})
+
+describe('foldFeed — sittings never cross records', () => {
+  it('folds adjacent saves on the SAME record by the same actor', () => {
+    const rows = [
+      row('3', draftA, { version: 3, created_at: at(60_000) }),
+      row('2', draftA, { version: 2, created_at: at(0) }),
+    ]
+    const out = foldFeed(rows)
+    expect(out).toHaveLength(1)
+    expect(out[0]!.sitting.saves).toBe(2)
+  })
+
+  it('never folds two different records together, however close', () => {
+    const rows = [
+      row('3', draftA, { version: 3, created_at: at(1000) }),
+      row('2', draftB, { version: 2, created_at: at(0) }),
+    ]
+    expect(foldFeed(rows)).toHaveLength(2)
+  })
+})
+
+describe('RecordActivityPanel', () => {
+  it('reads by cursor, with only the non-blank filters, and links each row to its record', async () => {
+    const list = jest.fn().mockResolvedValue({ next: null, next_cursor: null, results: [row('1', draftA)] })
+    mount(
+      <RecordActivityPanel
+        client={{ list }}
+        filters={{ actor: 'u-jurga', actor_kind: '' }}
+        onFiltersChange={jest.fn()}
+        recordHref={(e) => `/draft/${e.id}`}
+      />,
+    )
+    const link = await screen.findByRole('link', { name: /Gulf logistics brief/ })
+    expect(link).toHaveAttribute('href', '/draft/d-a')
+    const sent = list.mock.calls[0][0]
+    expect(sent).toMatchObject({ actor: 'u-jurga' })
+    expect(sent).not.toHaveProperty('actor_kind')
+    expect(sent).not.toHaveProperty('page')
+    expect(screen.queryByText(/showing .* of/i)).not.toBeInTheDocument()
+  })
+
+  it('marks a machine row, and leaves a claimed person calm', async () => {
+    const list = jest.fn().mockResolvedValue({
+      next: null,
+      results: [
+        row('2', draftA, { actor_sub: 'svc:n8n-ogmc', actor_label: 'svc:n8n-ogmc', actor_kind: 'machine', created_at: at(3_600_000) }),
+        row('1', draftB),
+      ],
+    })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={jest.fn()} />)
+    const marks = await screen.findAllByTestId('actor-kind')
+    expect(marks).toHaveLength(1)
+    expect(marks[0]).toHaveTextContent(/machine/)
+  })
+
+  it('names the fields changed, and the inline diff opens on expand', async () => {
+    const list = jest.fn().mockResolvedValue({ next: null, results: [row('1', draftA)] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={jest.fn()} />)
+    expect(await screen.findByText(/Edited blog/)).toBeInTheDocument()
+    fireEvent.click(screen.getByRole('button', { name: /blog/ }))
+    expect(await screen.findByText('Before')).toBeInTheDocument()
+  })
+
+  it('the person filter offers subs as values and addresses as labels', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [row('1', draftA)] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={onFiltersChange} />)
+    await screen.findByText(/Edited blog/)
+    const person = screen.getByLabelText(/person/i) as HTMLSelectElement
+    const opt = within(person).getByRole('option', { name: 'jurga@ogmc.example' }) as HTMLOptionElement
+    expect(opt.value).toBe('u-jurga')
+    fireEvent.change(person, { target: { value: 'u-jurga' } })
+    expect(onFiltersChange).toHaveBeenCalledWith({ actor: 'u-jurga' })
+  })
+
+  it('person vs machine is a filter of its own', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={onFiltersChange} />)
+    fireEvent.change(await screen.findByLabelText(/made by/i), { target: { value: 'machine' } })
+    expect(onFiltersChange).toHaveBeenCalledWith({ actor_kind: 'machine' })
+  })
+
+  it('record type comes from the host options', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [] })
+    mount(
+      <RecordActivityPanel
+        client={{ list }}
+        filters={{}}
+        onFiltersChange={onFiltersChange}
+        typeOptions={[{ value: 'topic', label: 'Topics' }, { value: 'draft', label: 'Drafts' }]}
+      />,
+    )
+    fireEvent.change(await screen.findByLabelText(/record type/i), { target: { value: 'draft' } })
+    expect(onFiltersChange).toHaveBeenCalledWith({ type: 'draft' })
+  })
+
+  it('"this week" sets since to the start of the week', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={onFiltersChange} />)
+    fireEvent.click(await screen.findByRole('button', { name: /this week/i }))
+    const arg = onFiltersChange.mock.calls[0][0]
+    // A local Monday midnight, as an instant.
+    expect(new Date(arg.since).getDay()).toBe(1)
+    expect(new Date(arg.since).getHours()).toBe(0)
+    expect(new Date(arg.since).getTime()).toBeLessThanOrEqual(Date.now())
+    expect(Date.now() - new Date(arg.since).getTime()).toBeLessThan(8 * 86_400_000)
+  })
+
+  it('"only their edits" narrows to that actor', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [row('1', draftA)] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={onFiltersChange} />)
+    fireEvent.click(await screen.findByRole('button', { name: /only jurga@ogmc\.example/i }))
+    expect(onFiltersChange).toHaveBeenCalledWith({ actor: 'u-jurga' })
+  })
+
+  it('an empty filtered feed says it is filtered, not that nothing happened', async () => {
+    const list = jest.fn().mockResolvedValue({ next: null, results: [] })
+    mount(<RecordActivityPanel client={{ list }} filters={{ actor_kind: 'machine' }} onFiltersChange={jest.fn()} />)
+    expect(await screen.findByText(/no edits match/i)).toBeInTheDocument()
+  })
+})

package/src/components/history/__tests__/record-history-panel.test.tsx

@@ -217,19 +217,83 @@ describe('RecordHistoryPanel — attempts, truncation and completeness', () => {
     ).toBeInTheDocument()
   })
 
-  it('NEVER claims the trail is complete', async () => {
-    mount(<RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} />)
-    const note = await screen.findByTestId('record-history-incomplete')
-    expect(note).toHaveTextContent(/not recorded yet/i)
-  })
-
   it('an empty history says "no edits recorded", not "never changed"', async () => {
     mount(<RecordHistoryPanel client={clientFor(page([]))} />)
     expect(await screen.findByText('No edits recorded for this record')).toBeInTheDocument()
     expect(screen.queryByText(/never been changed|never changed/i)).not.toBeInTheDocument()
-    // The caveat still stands on an empty panel — a quiet trail is the exact
-    // case a reader would otherwise over-read.
-    expect(screen.getByTestId('record-history-incomplete')).toBeInTheDocument()
+  })
+})
+
+describe('RecordHistoryPanel — what the trail does and does not cover (bd startsim-jkkn7.11/.12)', () => {
+  // bd startsim-jkkn7.6 closed all four silent write paths (annotate,
+  // move-scope, DELETE, the ingestion worker). A caveat that the trail misses
+  // them now describes a gap that does not exist, and teaches a reader to
+  // discount the one surface whose job is to be trusted.
+  it('no longer claims bulk imports, scope moves, annotations or deletions go unrecorded', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} />)
+    await screen.findByText('jurga@ogmc.example')
+    const panel = screen.getByTestId('record-history-panel')
+    expect(panel.textContent).not.toMatch(/bulk imports|scope moves|not recorded yet/i)
+    expect(screen.queryByTestId('record-history-incomplete')).not.toBeInTheDocument()
+  })
+
+  it('an empty history says "No edits recorded" and nothing more when history is on or unknown', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([]))} />)
+    await screen.findByText('No edits recorded for this record')
+    expect(screen.queryByTestId('record-history-incomplete')).not.toBeInTheDocument()
+    expect(screen.queryByTestId('record-history-declared-off')).not.toBeInTheDocument()
+  })
+
+  it('says history is not recorded for this kind of record when the type declares it off', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([]))} historyEnabled={false} />)
+    const note = await screen.findByTestId('record-history-declared-off')
+    expect(note).toHaveTextContent(/history is not recorded for this kind of record/i)
+    // A declaration, not a defect — it must not read like missing data.
+    expect(note.textContent).not.toMatch(/may be missing|error|fail|broken/i)
+    // And the empty state must not suggest edits will appear.
+    expect(screen.queryByText(/will appear here/i)).not.toBeInTheDocument()
+  })
+
+  it('keeps the declared-off disclosure next to rows recorded before it was switched off', async () => {
+    mount(
+      <RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} historyEnabled={false} />,
+    )
+    expect(await screen.findByText('jurga@ogmc.example')).toBeInTheDocument()
+    expect(screen.getByTestId('record-history-declared-off')).toHaveTextContent(
+      /history is not recorded for this kind of record/i,
+    )
+  })
+
+  it('says nothing about a declaration when the type keeps history', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([]))} historyEnabled />)
+    await screen.findByText('No edits recorded for this record')
+    expect(screen.queryByTestId('record-history-declared-off')).not.toBeInTheDocument()
+  })
+})
+
+describe('RevisionFields — the before/after split sizes on its container (bd startsim-jkkn7.12)', () => {
+  it('never decides the split from the VIEWPORT', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} />)
+    fireEvent.click(await screen.findByRole('button', { name: /blog/ }))
+    const before = screen.getByText('Before')
+    const split = before.parentElement!.parentElement!
+    // `sm:`/`md:`/`lg:` are viewport media queries: on a wide screen they force
+    // the two sides next to each other even inside a 370px rail.
+    expect(split.className).not.toMatch(/(^|\s)(sm|md|lg|xl):/)
+    // Stacked by default, side by side only when the CONTAINER has room.
+    expect(split.className).toMatch(/@sm:/)
+    expect(split.closest('.\\@container')).not.toBeNull()
+  })
+
+  it('gives the field list the full card width, not a column beside the timestamp', async () => {
+    // Measured in a 366px rail: the detail sat in the header's left column and
+    // shared the line with "2 minutes ago", losing ~100px it never needed.
+    mount(<RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} />)
+    const fields = await screen.findByTestId('revision-fields')
+    const row = fields.closest('[data-activity-id]')!
+    const time = within(row as HTMLElement).getByText(/ago|\d{1,2}:\d{2}/)
+    // The timestamp's row must not contain the field list.
+    expect(time.parentElement!.contains(fields)).toBe(false)
   })
 })
 
@@ -308,5 +372,89 @@ describe('ActorIdentity — the kind props are additive', () => {
     render(<ActorIdentity actor={{ email: 'a@b.com' }} kind="unknown" />)
     const el = screen.getByTestId('actor-identity')
     expect(el).toHaveAttribute('data-actor-kind', 'unknown')
+    expect(el).toHaveAttribute(
+      'title',
+      'Whether a person or a machine made this change was not recorded.',
+    )
+  })
+})
+
+describe('ActorIdentity — every row with a kind can say it (bd startsim-jkkn7.15)', () => {
+  it('titles a claimed person, the other undecorated case', () => {
+    render(<ActorIdentity actor={{ email: 'malin@ogmc.example' }} kind="person" kindSource="claim" />)
+    expect(screen.getByTestId('actor-identity')).toHaveAttribute(
+      'title',
+      'A person made this change (declared by the sign-in service).',
+    )
+  })
+
+  it('titles a marked machine row on the wrapper too', () => {
+    render(<ActorIdentity actor={{ email: 'svc@x' }} kind="machine" kindSource="claim" />)
+    expect(screen.getByTestId('actor-identity')).toHaveAttribute(
+      'title',
+      'A machine made this change (declared by the sign-in service).',
+    )
+  })
+
+  it('keeps the kind out of the text, because the chip sits inside sentences', () => {
+    render(<ActorIdentity actor={{ email: 'a@b.com' }} kind="unknown" showInitials={false} />)
+    expect(screen.getByTestId('actor-identity')).toHaveTextContent(/^a@b\.com$/)
+  })
+
+  it('adds no title when no kind is passed (older surfaces stay byte-identical)', () => {
+    render(<ActorIdentity actor={{ email: 'a@b.com' }} />)
+    expect(screen.getByTestId('actor-identity')).not.toHaveAttribute('title')
+  })
+
+  it('titles every row in the panel, including unknown and person/claim', async () => {
+    mount(
+      <RecordHistoryPanel
+        windowMs={0}
+        client={clientFor(
+          page([
+            rev({ version: 4, actor_label: 'u4@x', actor_sub: 'u4', actor_kind: 'unknown', actor_kind_source: 'inferred' }),
+            rev({ version: 3, actor_label: 'malin@x', actor_sub: 'u3', created_at: at(-60_000) }),
+            rev({ version: 2, actor_label: 'svc:a', actor_sub: 'svc:a', created_at: at(-120_000), actor_kind: 'machine', actor_kind_source: 'inferred' }),
+            rev({ version: 1, actor_label: 'svc:b', actor_sub: 'svc:b', created_at: at(-180_000), actor_kind: 'machine', actor_kind_source: 'claim' }),
+          ]),
+        )}
+      />,
+    )
+    await screen.findByText('malin@x')
+    const rows = screen.getAllByTestId('actor-identity')
+    expect(rows).toHaveLength(4)
+    for (const row of rows) expect(row.getAttribute('title')).toBeTruthy()
+  })
+})
+
+describe('RecordHistoryPanel — the unrecorded-kind sentence is scoped (bd startsim-jkkn7.15)', () => {
+  it('does not sweep a recorded person into "the rest"', async () => {
+    mount(
+      <RecordHistoryPanel
+        windowMs={0}
+        client={clientFor(
+          page([
+            rev({ version: 2, actor_label: 'u2@x', actor_sub: 'u2', actor_kind: 'unknown', actor_kind_source: 'inferred' }),
+            rev({ version: 1, actor_label: 'malin@x', actor_sub: 'u1', created_at: at(-60_000) }),
+          ]),
+        )}
+      />,
+    )
+    const note = await screen.findByTestId('record-history-unknown-kind')
+    expect(note.textContent).not.toMatch(/for the rest/i)
+    // It says that SOME unmarked entries were recorded as a person, and where
+    // to find out which.
+    expect(note.textContent).toMatch(/some unmarked entries/i)
+    expect(note.textContent).toMatch(/person/i)
+  })
+
+  it('keeps the plain wording when no loaded row is a recorded person', async () => {
+    mount(
+      <RecordHistoryPanel
+        client={clientFor(page([rev({ version: 1, actor_kind: 'unknown', actor_kind_source: 'inferred' })]))}
+      />,
+    )
+    const note = await screen.findByTestId('record-history-unknown-kind')
+    expect(note.textContent).toMatch(/for the rest/i)
   })
 })