@startsimpli/integrations 0.1.4 → 0.1.5

package/src/__tests__/corpus-pages.test.tsx

@@ -0,0 +1,479 @@
+/**
+ * The two corpus composers, rendered (bd startsim-768w.38.6, startsim-768w.38.7).
+ *
+ * THE RULE THIS SUITE ENFORCES, and it is the same rule the connections suite
+ * enforces one level down: no per-vendor anything. So the central case here runs
+ * the whole Library against a corpus whose ONLY connected source is Dropbox and
+ * asserts the screen is just as complete — badge, filter, detail, long-form
+ * section, freshness, empty states. A screen that renders meeting notes well and
+ * files badly is a failed design even though it would demo fine on Monday.
+ *
+ * The second rule is CLAUDE.md rule 8: every filter and every page turn is a
+ * SERVER round trip. The fixture api records the queries it was handed, so
+ * "the browser filtered it" is a detectable, and failing, outcome.
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import { AskPage } from '../components/pages/AskPage';
+import { LibraryPage } from '../components/pages/LibraryPage';
+import { askCorpus } from '../corpus/ask';
+import {
+  createFixtureCorpusApi,
+  createFixtureLlm,
+  FIXTURE_DOCUMENTS,
+  FIXTURE_ORG,
+} from '../corpus/fixtures';
+import type {
+  AskRequest,
+  CorpusApi,
+  CorpusAskApi,
+  DocumentQuery,
+  SourceDocument,
+  SourceFreshness,
+} from '../corpus/types';
+
+const SCOPE = { orgId: FIXTURE_ORG };
+
+function ownDocuments(): SourceDocument[] {
+  return FIXTURE_DOCUMENTS.filter((document) => document.scope.orgId === FIXTURE_ORG);
+}
+
+/** A corpus with exactly ONE connected source, whichever one is named. */
+function singleSourceCorpus(source: string, freshness: SourceFreshness) {
+  const documents = ownDocuments().filter((document) => document.source === source);
+  const queries: Array<[string, unknown]> = [];
+  const api = createFixtureCorpusApi({
+    scope: SCOPE,
+    documents,
+    moneyEvents: [],
+    sources: [freshness],
+    defaultPageSize: 20,
+    onQuery: (endpoint, query) => queries.push([endpoint, query]),
+  });
+  return { api, documents, queries };
+}
+
+// ---------------------------------------------------------------------------
+//  THE GENERIC TEST
+// ---------------------------------------------------------------------------
+
+describe('LibraryPage — the only connected source is Dropbox', () => {
+  const freshness: SourceFreshness = {
+    source: 'dropbox',
+    label: 'Dropbox',
+    documentCount: 1,
+    lastSyncedAt: '2026-08-02T06:00:00Z',
+    status: 'stale',
+    detail: 'Last sync was more than 26 hours ago.',
+  };
+
+  it('renders a complete screen with no meeting anywhere in it', async () => {
+    const { api } = singleSourceCorpus('dropbox', freshness);
+    render(<LibraryPage api={api} scope={SCOPE} />);
+
+    // A row, with its source as a visible badge.
+    expect(await screen.findByText(/Master Services Agreement/)).toBeInTheDocument();
+    expect(screen.getAllByText('Dropbox').length).toBeGreaterThan(0);
+
+    // The source filter is DATA — Dropbox is an option because it exists.
+    expect(screen.getByRole('option', { name: 'Dropbox' })).toBeInTheDocument();
+
+    // Freshness is on the screen, and says the uncomfortable thing.
+    expect(screen.getByText('Stale')).toBeInTheDocument();
+    expect(screen.getByText(/more than 26 hours ago/)).toBeInTheDocument();
+
+    // Nothing in the chrome assumes a meeting.
+    expect(screen.queryByText(/transcript/i)).not.toBeInTheDocument();
+    expect(screen.queryByText(/attendee/i)).not.toBeInTheDocument();
+    expect(screen.queryByText(/meeting/i)).not.toBeInTheDocument();
+  });
+
+  it('opens a file’s detail with its long-form text under the SOURCE’s own label', async () => {
+    const user = userEvent.setup();
+    const { api } = singleSourceCorpus('dropbox', freshness);
+    render(<LibraryPage api={api} scope={SCOPE} />);
+
+    await user.click(await screen.findByText(/Master Services Agreement/));
+
+    const detail = await screen.findByRole('region', { name: 'Record detail' });
+    // "Extracted text" for a PDF, exactly where "Transcript" sits for a meeting.
+    // The composer never learned which is which.
+    expect(within(detail).getByText('Extracted text')).toBeInTheDocument();
+    expect(within(detail).getByText(/Open in Dropbox/)).toBeInTheDocument();
+    expect(within(detail).getByRole('button', { name: /Acme Robotics/ })).toBeInTheDocument();
+  });
+});
+
+describe('LibraryPage — the same screen, Granola only', () => {
+  it('renders long-form under Granola’s word for it, from the same code', async () => {
+    const user = userEvent.setup();
+    const { api } = singleSourceCorpus('granola', {
+      source: 'granola', label: 'Granola', documentCount: 4,
+      lastSyncedAt: '2026-08-07T06:00:00Z', status: 'ok',
+    });
+    render(<LibraryPage api={api} scope={SCOPE} />);
+
+    await user.click(await screen.findByText('Acme <> StartSimpli weekly sync'));
+    const detail = await screen.findByRole('region', { name: 'Record detail' });
+    expect(within(detail).getByText('Transcript')).toBeInTheDocument();
+  });
+});
+
+// ---------------------------------------------------------------------------
+//  server-side everything
+// ---------------------------------------------------------------------------
+
+describe('LibraryPage — filtering and paging are SERVER round trips', () => {
+  it('sends the search term to the server instead of filtering the page', async () => {
+    const user = userEvent.setup();
+    const queries: DocumentQuery[] = [];
+    const api = createFixtureCorpusApi({
+      scope: SCOPE,
+      onQuery: (endpoint, query) => { if (endpoint === 'documents') queries.push(query as DocumentQuery); },
+    });
+    render(<LibraryPage api={api} scope={SCOPE} />);
+
+    await screen.findByText('Library');
+    await user.type(screen.getByRole('searchbox'), 'renewal');
+    await user.click(screen.getByRole('button', { name: 'Search' }));
+
+    await waitFor(() => expect(queries.some((query) => query.search === 'renewal')).toBe(true));
+  });
+
+  it('asks the server for the next page rather than slicing a loaded list', async () => {
+    const user = userEvent.setup();
+    const queries: DocumentQuery[] = [];
+    const api = createFixtureCorpusApi({
+      scope: SCOPE,
+      defaultPageSize: 2,
+      onQuery: (endpoint, query) => { if (endpoint === 'documents') queries.push(query as DocumentQuery); },
+    });
+    render(<LibraryPage api={api} scope={SCOPE} pageSize={2} />);
+
+    await screen.findByText(/page 1 of 3/);
+    await user.click(screen.getByRole('button', { name: 'Next' }));
+
+    await waitFor(() => expect(queries.some((query) => query.page === 2)).toBe(true));
+    expect(await screen.findByText(/page 2 of 3/)).toBeInTheDocument();
+  });
+
+  it('returns to page 1 when a filter changes', async () => {
+    const user = userEvent.setup();
+    const queries: DocumentQuery[] = [];
+    const api = createFixtureCorpusApi({
+      scope: SCOPE,
+      defaultPageSize: 2,
+      onQuery: (endpoint, query) => { if (endpoint === 'documents') queries.push(query as DocumentQuery); },
+    });
+    render(<LibraryPage api={api} scope={SCOPE} pageSize={2} />);
+
+    await screen.findByText(/page 1 of 3/);
+    await user.click(screen.getByRole('button', { name: 'Next' }));
+    await screen.findByText(/page 2 of 3/);
+
+    await user.selectOptions(screen.getByLabelText('Source'), 'dropbox');
+
+    // Page 3 of the old result set is not page 3 of the new one; keeping it
+    // silently renders an empty list over a filter that worked.
+    await waitFor(() => {
+      const last = queries[queries.length - 1];
+      expect(last.source).toBe('dropbox');
+      expect(last.page).toBe(1);
+    });
+  });
+
+  it('says so on screen when the server ignored a filter it was sent', async () => {
+    const user = userEvent.setup();
+    // A backend that pages but does not search — which is what the tenant
+    // entities endpoint does TODAY. Rendering the unfiltered list under a
+    // filled-in search box is a lie the user cannot catch.
+    const base = createFixtureCorpusApi({ scope: SCOPE });
+    const api: CorpusApi = {
+      ...base,
+      async listDocuments(query) {
+        const page = await base.listDocuments({ ...query, search: undefined });
+        return { ...page, appliedFilters: [] };
+      },
+    };
+    render(<LibraryPage api={api} scope={SCOPE} />);
+
+    await screen.findByText('Library');
+    await user.type(screen.getByRole('searchbox'), 'renewal');
+    await user.click(screen.getByRole('button', { name: 'Search' }));
+
+    expect(await screen.findByText(/does not filter by search yet/)).toBeInTheDocument();
+  });
+});
+
+describe('LibraryPage — the nothings', () => {
+  it('tells an unconnected tenant to connect a source', async () => {
+    const api = createFixtureCorpusApi({ scope: SCOPE, documents: [], moneyEvents: [], sources: [] });
+    render(<LibraryPage api={api} scope={SCOPE} />);
+    expect(await screen.findByText(/Connect a source/)).toBeInTheDocument();
+  });
+
+  it('names the failing source when a connected tenant has nothing', async () => {
+    const api = createFixtureCorpusApi({
+      scope: SCOPE,
+      documents: [],
+      moneyEvents: [],
+      sources: [{
+        source: 'gdrive', label: 'Google Drive', documentCount: 0,
+        lastSyncedAt: '2026-08-06T07:30:00Z', status: 'error',
+        detail: 'The vendor rejected this key (401).',
+      }],
+    });
+    render(<LibraryPage api={api} scope={SCOPE} />);
+    // "No results" would send the user to the wrong place entirely.
+    expect(await screen.findByText(/Google Drive.*failing to sync/)).toBeInTheDocument();
+  });
+
+  it('renders a record that arrived with no text at all', async () => {
+    const user = userEvent.setup();
+    const api = createFixtureCorpusApi({ scope: SCOPE });
+    render(<LibraryPage api={api} scope={SCOPE} />);
+
+    await user.click(await screen.findByText(/Board prep/));
+    const detail = await screen.findByRole('region', { name: 'Record detail' });
+    expect(within(detail).getByText(/arrived with no text/)).toBeInTheDocument();
+  });
+
+  it('reads a refusal as a refusal, not as an empty corpus', async () => {
+    const api = createFixtureCorpusApi({ scope: SCOPE });
+    api.listDocuments = async () => {
+      throw Object.assign(new Error('nope'), { status: 403 });
+    };
+    render(<LibraryPage api={api} scope={SCOPE} />);
+    expect(await screen.findByRole('alert')).toHaveTextContent(/do not have access/i);
+  });
+});
+
+describe('LibraryPage — a record from another workspace never renders', () => {
+  it('never draws a foreign row in the LIST, and says the API returned one', async () => {
+    // The row is the leak. Its title and preview are on screen before anyone
+    // clicks, so guarding only the detail panel guards nothing.
+    const foreign = FIXTURE_DOCUMENTS.find((document) => document.id === 'nw_contract_44')!;
+    const api = createFixtureCorpusApi({ scope: SCOPE, leakScope: true, documents: [foreign] });
+    render(<LibraryPage api={api} scope={SCOPE} />);
+
+    expect(await screen.findByRole('alert')).toHaveTextContent(/belonging to another workspace/);
+    expect(screen.queryByText(/2,750/)).not.toBeInTheDocument();
+    expect(screen.queryByText(/Northwind terms/)).not.toBeInTheDocument();
+    // The list is EMPTY, not "one row we chose not to expand".
+    expect(screen.getByText(/Nothing has arrived yet/)).toBeInTheDocument();
+  });
+
+  it('keeps warning about a leaking API after paging past the offending page', async () => {
+    const user = userEvent.setup();
+    // The foreign row sorts first, so it lands on page 1 and page 2 is clean. A
+    // warning that vanishes on page 2 reads as "fixed", which it is not.
+    const api = createFixtureCorpusApi({ scope: SCOPE, leakScope: true, defaultPageSize: 3 });
+    render(<LibraryPage api={api} scope={SCOPE} pageSize={3} />);
+
+    expect(await screen.findByRole('alert')).toHaveTextContent(/belonging to another workspace/);
+    await user.click(screen.getByRole('button', { name: 'Next' }));
+
+    await screen.findByText(/page 2 of/);
+    expect(screen.getByRole('alert')).toHaveTextContent(/belonging to another workspace/);
+  });
+
+  it('refuses to display a foreign record even when one is deep-linked', async () => {
+    const foreign = FIXTURE_DOCUMENTS.find((document) => document.id === 'nw_contract_44')!;
+    const api = createFixtureCorpusApi({ scope: SCOPE, leakScope: true, documents: [foreign] });
+    render(<LibraryPage api={api} scope={SCOPE} initialDocumentId="nw_contract_44" />);
+
+    const alerts = await screen.findAllByRole('alert');
+    expect(alerts.some((node) => /belongs to another workspace/.test(node.textContent ?? ''))).toBe(true);
+    expect(screen.queryByText(/2,750/)).not.toBeInTheDocument();
+  });
+});
+
+// ---------------------------------------------------------------------------
+//  AskPage
+// ---------------------------------------------------------------------------
+
+/** The route an app would wire: `askCorpus` behind a promise. */
+function askApiOver(api: CorpusApi, extra: Partial<CorpusAskApi> = {}): CorpusAskApi {
+  return {
+    ask: (request: AskRequest) => askCorpus(request, { corpus: api, llm: createFixtureLlm() }),
+    ...extra,
+  };
+}
+
+describe('AskPage — an answer is only an answer when it is traceable', () => {
+  it('renders the answer with a citation per record, clickable through to it', async () => {
+    const user = userEvent.setup();
+    const onOpenDocument = vi.fn();
+    render(
+      <AskPage
+        api={askApiOver(createFixtureCorpusApi({ scope: SCOPE }))}
+        scope={SCOPE}
+        onOpenDocument={onOpenDocument}
+      />,
+    );
+
+    await user.type(screen.getByRole('textbox'), 'Acme renewal rate and seats');
+    await user.click(screen.getByRole('button', { name: 'Ask' }));
+
+    const answer = await screen.findByRole('region', { name: 'Answer' });
+    expect(within(answer).getByText(/source/)).toBeInTheDocument();
+
+    const citation = within(answer).getByRole('button', { name: /Master Services Agreement/ });
+    await user.click(citation);
+    expect(onOpenDocument).toHaveBeenCalledWith('dbx_9812f0');
+  });
+
+  it('warns loudly when the model produced text it cannot trace', async () => {
+    const user = userEvent.setup();
+    const api: CorpusAskApi = {
+      async ask() {
+        return {
+          status: 'uncited',
+          answer: 'You agreed four thousand a month.',
+          citations: [],
+          considered: [],
+          unresolvedCitations: [],
+          droppedOutOfScope: 0,
+          provider: { provider: 'openai', model: 'gpt-x', live: true },
+        };
+      },
+    };
+    render(<AskPage api={api} scope={SCOPE} />);
+
+    await user.type(screen.getByRole('textbox'), 'what did we agree');
+    await user.click(screen.getByRole('button', { name: 'Ask' }));
+
+    const alert = await screen.findByRole('alert');
+    expect(alert).toHaveTextContent(/could not be traced/i);
+    expect(alert).toHaveTextContent(/would sign/i);
+    // The text is still shown — hiding it is its own kind of lying.
+    expect(screen.getByText(/four thousand/)).toBeInTheDocument();
+  });
+
+  it('names invented citations rather than dropping them quietly', async () => {
+    const user = userEvent.setup();
+    const api: CorpusAskApi = {
+      async ask() {
+        return {
+          status: 'answered',
+          answer: 'Twelve months.',
+          citations: [{
+            documentId: 'dbx_9812f0',
+            document: FIXTURE_DOCUMENTS.find((d) => d.id === 'dbx_9812f0')!,
+            quote: 'twelve (12) months',
+          }],
+          considered: [],
+          unresolvedCitations: ['not_invented_01'],
+          droppedOutOfScope: 0,
+          provider: { provider: 'openai', model: 'gpt-x', live: true },
+        };
+      },
+    };
+    render(<AskPage api={api} scope={SCOPE} />);
+
+    await user.type(screen.getByRole('textbox'), 'how long is the term');
+    await user.click(screen.getByRole('button', { name: 'Ask' }));
+
+    expect(await screen.findByText(/never given to it/)).toBeInTheDocument();
+    expect(screen.getByText(/not_invented_01/)).toBeInTheDocument();
+  });
+
+  it('says when the answer came from a stub rather than a live model', async () => {
+    const user = userEvent.setup();
+    render(<AskPage api={askApiOver(createFixtureCorpusApi({ scope: SCOPE }))} scope={SCOPE} />);
+
+    await user.type(screen.getByRole('textbox'), 'Acme renewal');
+    await user.click(screen.getByRole('button', { name: 'Ask' }));
+
+    expect(await screen.findByText(/no live model was called/)).toBeInTheDocument();
+  });
+
+  it('reports a leaking data API on the answer itself', async () => {
+    const user = userEvent.setup();
+    render(
+      <AskPage
+        api={askApiOver(createFixtureCorpusApi({ scope: SCOPE, leakScope: true }))}
+        scope={SCOPE}
+      />,
+    );
+
+    await user.type(screen.getByRole('textbox'), 'Acme renewal rate and seats');
+    await user.click(screen.getByRole('button', { name: 'Ask' }));
+
+    expect(await screen.findByText(/from another workspace were returned/)).toBeInTheDocument();
+  });
+
+  it('renders "nothing found" as its own state, not as an empty answer', async () => {
+    const user = userEvent.setup();
+    render(<AskPage api={askApiOver(createFixtureCorpusApi({ scope: SCOPE }))} scope={SCOPE} />);
+
+    await user.type(screen.getByRole('textbox'), 'Northwind');
+    await user.click(screen.getByRole('button', { name: 'Ask' }));
+
+    expect(await screen.findByText('No answer from your records')).toBeInTheDocument();
+    expect(screen.queryByText(/2,750/)).not.toBeInTheDocument();
+  });
+
+  it('shows the records it searched but did not cite', async () => {
+    const user = userEvent.setup();
+    const api: CorpusAskApi = {
+      async ask() {
+        const full = await askCorpus(
+          { question: 'Acme renewal rate and seats', mode: 'ask', scope: SCOPE },
+          { corpus: createFixtureCorpusApi({ scope: SCOPE }), llm: createFixtureLlm() },
+        );
+        return { ...full, citations: full.citations.slice(0, 1) };
+      },
+    };
+    render(<AskPage api={api} scope={SCOPE} />);
+
+    await user.type(screen.getByRole('textbox'), 'Acme renewal rate and seats');
+    await user.click(screen.getByRole('button', { name: 'Ask' }));
+
+    expect(await screen.findByText(/were searched but not cited/)).toBeInTheDocument();
+  });
+});
+
+describe('AskPage — generate', () => {
+  it('saves a cited draft back into the corpus', async () => {
+    const user = userEvent.setup();
+    const saveDraft: NonNullable<CorpusAskApi['saveDraft']> = vi.fn(async () => FIXTURE_DOCUMENTS[0]);
+    const savedCitations = () =>
+      (saveDraft as unknown as { mock: { calls: Array<[{ citations: string[] }]> } }).mock.calls[0][0]
+        .citations;
+    render(
+      <AskPage
+        api={askApiOver(createFixtureCorpusApi({ scope: SCOPE }), { saveDraft })}
+        scope={SCOPE}
+        initialMode="generate"
+      />,
+    );
+
+    await user.type(screen.getAllByRole('textbox')[0], 'Draft a renewal letter for Acme Robotics');
+    await user.click(screen.getByRole('button', { name: 'Generate draft' }));
+
+    await user.click(await screen.findByRole('button', { name: 'Save to library' }));
+    await waitFor(() => expect(saveDraft).toHaveBeenCalled());
+    expect(savedCitations().length).toBeGreaterThan(0);
+    expect(await screen.findByText('Saved to your library')).toBeInTheDocument();
+  });
+
+  it('offers no Save control when the deployment cannot write', async () => {
+    const user = userEvent.setup();
+    render(
+      <AskPage
+        api={askApiOver(createFixtureCorpusApi({ scope: SCOPE }))}
+        scope={SCOPE}
+        initialMode="generate"
+      />,
+    );
+
+    await user.type(screen.getAllByRole('textbox')[0], 'Draft a renewal letter');
+    await user.click(screen.getByRole('button', { name: 'Generate draft' }));
+
+    await screen.findByRole('region', { name: 'Answer' });
+    expect(screen.queryByRole('button', { name: 'Save to library' })).not.toBeInTheDocument();
+  });
+});