@startsimpli/ui 0.4.110 → 0.4.111

package/src/components/scope/__tests__/scope-switcher.test.tsx

@@ -0,0 +1,338 @@
+/**
+ * <ScopeSwitcher/> (bd startsim-6fceh) — pick a client or a project,
+ * hierarchically, and stay there.
+ *
+ * The engine underneath is pinned in `../../facet-tree/__tests__`; these pin the
+ * switcher's own contract: what the trigger says, that a closed switcher costs
+ * nothing, that "All scopes" CLEARS the bound, that a selection is the server's
+ * own path verbatim, and that searching is a second server read which admits it
+ * when it cannot happen.
+ */
+import * as React from 'react'
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { usePathname, useRouter, useSearchParams } from 'next/navigation'
+
+import { ScopeSwitcher, ScopeSwitcherControlled } from '../ScopeSwitcher'
+import type { ScopeClient, ScopeMatch, ScopeNode } from '../types'
+import type { FacetLevelQuery, Paginated } from '../../facet-tree/types'
+
+const mockedSearchParams = useSearchParams as unknown as jest.Mock
+const mockedRouter = useRouter as unknown as jest.Mock
+const mockedPathname = usePathname as unknown as jest.Mock
+
+function node(path: string, count: number, hasChildren = false): ScopeNode {
+  const segments = path.split('/').filter(Boolean)
+  return { path, name: segments[segments.length - 1] ?? path, count, hasChildren }
+}
+
+function page<T>(results: T[], count = results.length): Paginated<T> {
+  return { count, next: null, previous: null, results }
+}
+
+const LEVELS: Record<string, Paginated<ScopeNode>> = {
+  '/': page([node('/Clients', 1204, true), node('/Internal', 12)]),
+  '/Clients': page([node('/Clients/Acme', 900, true), node('/Clients/Globex', 300)]),
+  '/Clients/Acme': page([node('/Clients/Acme/GCC Weekly', 41)]),
+}
+
+function makeClient(overrides: Partial<ScopeClient> = {}): ScopeClient & {
+  listScopeChildren: jest.Mock
+} {
+  const listScopeChildren = jest.fn(
+    async (query: FacetLevelQuery) => LEVELS[query.under] ?? page<ScopeNode>([]),
+  )
+  return { listScopeChildren, ...overrides } as ScopeClient & { listScopeChildren: jest.Mock }
+}
+
+function open(name = /^Scope:/) {
+  return screen.getByRole('button', { name })
+}
+
+describe('ScopeSwitcher — the trigger', () => {
+  it('says "All scopes" when nothing is in scope', () => {
+    render(<ScopeSwitcherControlled client={makeClient()} value={null} onChange={jest.fn()} />)
+    expect(open()).toHaveTextContent('All scopes')
+    expect(screen.getByRole('button', { name: 'Scope: All scopes' })).toBeTruthy()
+  })
+
+  it('shows the leaf name, with its ancestors underneath to tell two "Weekly"s apart', () => {
+    render(
+      <ScopeSwitcherControlled
+        client={makeClient()}
+        value="/Clients/Acme/GCC Weekly"
+        onChange={jest.fn()}
+      />,
+    )
+    const trigger = open()
+    expect(trigger).toHaveTextContent('GCC Weekly')
+    expect(trigger).toHaveTextContent('Clients / Acme')
+  })
+
+  it('names itself with the FULL path, since the visible label is only a leaf', () => {
+    render(
+      <ScopeSwitcherControlled client={makeClient()} value="/Clients/Acme" onChange={jest.fn()} />,
+    )
+    expect(screen.getByRole('button', { name: 'Scope: /Clients/Acme' })).toBeTruthy()
+  })
+
+  it('takes the control’s own noun from labels, for an app that says "Client"', () => {
+    render(
+      <ScopeSwitcherControlled
+        client={makeClient()}
+        value={null}
+        onChange={jest.fn()}
+        labels={{ control: 'Client', root: 'All clients' }}
+      />,
+    )
+    expect(screen.getByRole('button', { name: 'Client: All clients' })).toBeTruthy()
+  })
+
+  it('costs no round trip until it is opened', () => {
+    const client = makeClient()
+    render(<ScopeSwitcherControlled client={client} value={null} onChange={jest.fn()} />)
+    expect(client.listScopeChildren).not.toHaveBeenCalled()
+  })
+})
+
+describe('ScopeSwitcher — browsing', () => {
+  it('loads the root level on first open, with counts', async () => {
+    const user = userEvent.setup()
+    const client = makeClient()
+    render(<ScopeSwitcherControlled client={client} value={null} onChange={jest.fn()} />)
+
+    await user.click(open())
+
+    expect(await screen.findByRole('button', { name: /^Clients, 1,204 records inside$/ })).toBeTruthy()
+    expect(client.listScopeChildren).toHaveBeenCalledTimes(1)
+    expect(client.listScopeChildren).toHaveBeenCalledWith(
+      expect.objectContaining({ under: '/', page: 1 }),
+    )
+  })
+
+  it('CLEARS the bound for "All scopes" — it does not select a root path', async () => {
+    // A synthetic `/` would narrow to rows that HAVE a scope, and every record is
+    // scope-less until somebody assigns it. Narrowing here would empty the screen
+    // of the person who asked to see everything.
+    const user = userEvent.setup()
+    const onChange = jest.fn()
+    render(
+      <ScopeSwitcherControlled client={makeClient()} value="/Clients" onChange={onChange} />,
+    )
+
+    await user.click(open())
+    await user.click(await screen.findByRole('button', { name: 'All scopes' }))
+
+    expect(onChange).toHaveBeenCalledWith(null)
+    expect(onChange).not.toHaveBeenCalledWith('/')
+  })
+
+  it('hands back the server’s own path, verbatim, and closes', async () => {
+    const user = userEvent.setup()
+    const onChange = jest.fn()
+    render(<ScopeSwitcherControlled client={makeClient()} value={null} onChange={onChange} />)
+
+    await user.click(open())
+    await user.click(await screen.findByRole('button', { name: 'Expand Clients' }))
+    await user.click(await screen.findByRole('button', { name: /^Acme, 900 records inside$/ }))
+
+    expect(onChange).toHaveBeenCalledWith('/Clients/Acme')
+    await waitFor(() =>
+      expect(screen.queryByRole('button', { name: 'All scopes' })).toBeNull(),
+    )
+  })
+
+  it('marks the scope in play as current', async () => {
+    const user = userEvent.setup()
+    render(
+      <ScopeSwitcherControlled client={makeClient()} value="/Internal" onChange={jest.fn()} />,
+    )
+    await user.click(open())
+    const row = await screen.findByRole('button', { name: /^Internal, 12 records inside$/ })
+    expect(row).toHaveAttribute('aria-current', 'true')
+    expect(screen.getByRole('button', { name: 'All scopes' })).not.toHaveAttribute('aria-current')
+  })
+
+  it('says so when the tenant has declared scopes but has none yet', async () => {
+    const user = userEvent.setup()
+    const client = makeClient()
+    client.listScopeChildren.mockResolvedValue(page<ScopeNode>([]))
+    render(<ScopeSwitcherControlled client={client} value={null} onChange={jest.fn()} />)
+
+    await user.click(open())
+    expect(await screen.findByText('No scopes yet')).toBeTruthy()
+    // "All scopes" is still there — an empty tree does not take away the way out.
+    expect(screen.getByRole('button', { name: 'All scopes' })).toBeTruthy()
+  })
+
+  it('tells the app once when the deployment has no facet route at all', async () => {
+    const user = userEvent.setup()
+    const onUnavailable = jest.fn()
+    const client = makeClient()
+    client.listScopeChildren.mockRejectedValue(Object.assign(new Error('no'), { status: 404 }))
+
+    render(
+      <ScopeSwitcherControlled
+        client={client}
+        value={null}
+        onChange={jest.fn()}
+        onUnavailable={onUnavailable}
+      />,
+    )
+    await user.click(open())
+    await waitFor(() => expect(onUnavailable).toHaveBeenCalledTimes(1))
+  })
+})
+
+describe('ScopeSwitcher — searching', () => {
+  const matches: ScopeMatch[] = [
+    { path: '/Clients/Acme/GCC Weekly', name: 'GCC Weekly' },
+    { path: '/Internal/Weekly', name: 'Weekly' },
+  ]
+
+  it('asks the server, and shows each match with its whole path', async () => {
+    const user = userEvent.setup()
+    const searchScopes = jest.fn(async () => page(matches))
+    const client = makeClient({ searchScopes })
+
+    render(<ScopeSwitcherControlled client={client} value={null} onChange={jest.fn()} />)
+    await user.click(open())
+    await user.type(screen.getByLabelText('Search scopes'), 'weekly')
+
+    await waitFor(() =>
+      expect(searchScopes).toHaveBeenCalledWith(expect.objectContaining({ search: 'weekly' })),
+    )
+    expect(
+      await screen.findByRole('button', { name: '/Clients/Acme/GCC Weekly' }),
+    ).toBeTruthy()
+    // A flat result list is exactly where two identically-named scopes meet, so
+    // the path is on screen and not only in the accessible name.
+    expect(screen.getByTitle('/Internal/Weekly')).toBeTruthy()
+  })
+
+  it('selects out of the results without ever expanding the tree', async () => {
+    const user = userEvent.setup()
+    const onChange = jest.fn()
+    const client = makeClient({ searchScopes: jest.fn(async () => page(matches)) })
+
+    render(<ScopeSwitcherControlled client={client} value={null} onChange={onChange} />)
+    await user.click(open())
+    await user.type(screen.getByLabelText('Search scopes'), 'weekly')
+    await user.click(await screen.findByRole('button', { name: '/Internal/Weekly' }))
+
+    expect(onChange).toHaveBeenCalledWith('/Internal/Weekly')
+  })
+
+  it('says when it matched nothing', async () => {
+    const user = userEvent.setup()
+    const client = makeClient({ searchScopes: jest.fn(async () => page<ScopeMatch>([])) })
+
+    render(<ScopeSwitcherControlled client={client} value={null} onChange={jest.fn()} />)
+    await user.click(open())
+    await user.type(screen.getByLabelText('Search scopes'), 'zzz')
+
+    expect(await screen.findByText('No matching scopes')).toBeTruthy()
+  })
+
+  it('ADMITS ITS BOUND when the client cannot search the whole type', async () => {
+    // Filtering the levels already loaded is an honest thing to offer and a
+    // dishonest thing to offer silently: it cannot see a subtree nobody has
+    // expanded, so the control has to say what it is answering about.
+    const user = userEvent.setup()
+    const client = makeClient() // no searchScopes at all
+
+    render(<ScopeSwitcherControlled client={client} value={null} onChange={jest.fn()} />)
+    await user.click(open())
+    await screen.findByRole('button', { name: /^Clients, 1,204 records inside$/ })
+    await user.type(screen.getByLabelText('Search scopes'), 'intern')
+
+    expect(await screen.findByText('Searching the scopes loaded so far.')).toBeTruthy()
+    // A locally-filtered row came out of the tree, so it still carries its count.
+    expect(screen.getByRole('button', { name: '/Internal, 12 records inside' })).toBeTruthy()
+    expect(screen.queryByTitle('/Clients')).toBeNull()
+  })
+
+  it('falls back to the same local filter when the server refuses the search', async () => {
+    const user = userEvent.setup()
+    const searchScopes = jest.fn(async () => {
+      throw Object.assign(new Error('nope'), { status: 400 })
+    })
+    const client = makeClient({ searchScopes })
+
+    render(<ScopeSwitcherControlled client={client} value={null} onChange={jest.fn()} />)
+    await user.click(open())
+    await screen.findByRole('button', { name: /^Clients, 1,204 records inside$/ })
+    await user.type(screen.getByLabelText('Search scopes'), 'intern')
+
+    expect(await screen.findByText('Searching the scopes loaded so far.')).toBeTruthy()
+    expect(screen.getByRole('button', { name: '/Internal, 12 records inside' })).toBeTruthy()
+  })
+
+  it('reports a real search failure instead of quietly narrowing', async () => {
+    const user = userEvent.setup()
+    const searchScopes = jest.fn(async () => {
+      throw Object.assign(new Error('Search is down'), { status: 500 })
+    })
+    render(
+      <ScopeSwitcherControlled
+        client={makeClient({ searchScopes })}
+        value={null}
+        onChange={jest.fn()}
+      />,
+    )
+    await user.click(open())
+    await user.type(screen.getByLabelText('Search scopes'), 'weekly')
+
+    expect(await screen.findByRole('alert')).toHaveTextContent('Search is down')
+  })
+})
+
+describe('ScopeSwitcher — bound to the URL', () => {
+  const replace = jest.fn()
+
+  beforeEach(() => {
+    replace.mockClear()
+    mockedRouter.mockReturnValue({ replace, push: jest.fn() })
+    mockedPathname.mockReturnValue('/drafts')
+    mockedSearchParams.mockReturnValue(new URLSearchParams())
+    window.sessionStorage.clear()
+  })
+
+  it('takes its selection from the query string, with no value prop to go stale', async () => {
+    mockedSearchParams.mockReturnValue(new URLSearchParams('scope=%2FClients%2FAcme'))
+    render(<ScopeSwitcher client={makeClient()} />)
+    expect(await screen.findByRole('button', { name: 'Scope: /Clients/Acme' })).toBeTruthy()
+  })
+
+  it('follows the URL when a soft navigation changes it under a layout', async () => {
+    mockedSearchParams.mockReturnValue(new URLSearchParams('scope=%2FClients%2FAcme'))
+    const client = makeClient()
+    const { rerender } = render(<ScopeSwitcher client={client} remember={false} />)
+    expect(await screen.findByRole('button', { name: 'Scope: /Clients/Acme' })).toBeTruthy()
+
+    mockedSearchParams.mockReturnValue(new URLSearchParams('scope=%2FInternal'))
+    rerender(<ScopeSwitcher client={client} remember={false} />)
+    expect(await screen.findByRole('button', { name: 'Scope: /Internal' })).toBeTruthy()
+  })
+
+  it('writes the chosen scope into the URL, so the view is a link', async () => {
+    const user = userEvent.setup()
+    render(<ScopeSwitcher client={makeClient()} remember={false} />)
+
+    await user.click(await screen.findByRole('button', { name: /^Scope:/ }))
+    await user.click(await screen.findByRole('button', { name: /^Internal, 12 records inside$/ }))
+
+    expect(replace).toHaveBeenCalledWith('/drafts?scope=%2FInternal', { scroll: false })
+  })
+
+  it('writes the reserved "all" value, so "everything" is a link too', async () => {
+    const user = userEvent.setup()
+    mockedSearchParams.mockReturnValue(new URLSearchParams('scope=%2FInternal'))
+    render(<ScopeSwitcher client={makeClient()} remember={false} />)
+
+    await user.click(await screen.findByRole('button', { name: /^Scope:/ }))
+    await user.click(await screen.findByRole('button', { name: 'All scopes' }))
+
+    expect(replace).toHaveBeenCalledWith('/drafts?scope=all', { scroll: false })
+  })
+})

package/src/components/scope/__tests__/use-scope-param.test.tsx

@@ -0,0 +1,265 @@
+/**
+ * The URL binding (bd startsim-6fceh).
+ *
+ * THE TEST THAT MATTERS MOST is "follows the URL on a soft navigation". A Next
+ * layout is not re-rendered on client-side navigation, so anything that reads
+ * the query ONCE — into `useState`, or in a server layout via a middleware
+ * header — renders the previous page's scope under the next page's data. That is
+ * `feedback_no_searchparam_state_in_layouts`, and it is a real outage this repo
+ * has already had. The pin is that a re-render with different params changes the
+ * answer, i.e. the hook derives rather than caches.
+ */
+import * as React from 'react'
+import { render, screen, act } from '@testing-library/react'
+import { usePathname, useRouter, useSearchParams } from 'next/navigation'
+
+import { useScopeParam } from '../useScopeParam'
+
+const mockedSearchParams = useSearchParams as unknown as jest.Mock
+const mockedRouter = useRouter as unknown as jest.Mock
+const mockedPathname = usePathname as unknown as jest.Mock
+
+const replace = jest.fn()
+const push = jest.fn()
+
+function atUrl(query: string, pathname = '/drafts') {
+  mockedSearchParams.mockReturnValue(new URLSearchParams(query))
+  mockedPathname.mockReturnValue(pathname)
+}
+
+let latest: ReturnType<typeof useScopeParam>
+
+function Probe(options: Parameters<typeof useScopeParam>[0] = {}) {
+  latest = useScopeParam(options)
+  return <span data-testid="scope">{latest.scope ?? 'none'}</span>
+}
+
+beforeEach(() => {
+  replace.mockClear()
+  push.mockClear()
+  mockedRouter.mockReturnValue({ replace, push })
+  window.sessionStorage.clear()
+  atUrl('')
+})
+
+describe('useScopeParam — reading', () => {
+  it('reads the scope out of the query string', () => {
+    atUrl('scope=%2FClients%2FAcme')
+    render(<Probe />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('/Clients/Acme')
+  })
+
+  it('treats an absent or blank parameter as no bound at all', () => {
+    atUrl('')
+    const { rerender } = render(<Probe remember={false} />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('none')
+
+    atUrl('scope=')
+    rerender(<Probe remember={false} />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('none')
+  })
+
+  it('FOLLOWS THE URL ON A SOFT NAVIGATION rather than caching the first read', () => {
+    atUrl('scope=%2FClients%2FAcme')
+    const { rerender } = render(<Probe remember={false} />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('/Clients/Acme')
+
+    // The app router pushed new search params under the same mounted component,
+    // which is exactly what a soft nav does to a control living in a layout.
+    atUrl('scope=%2FClients%2FGlobex')
+    rerender(<Probe remember={false} />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('/Clients/Globex')
+  })
+})
+
+describe('useScopeParam — writing', () => {
+  it('writes the full path and keeps every other parameter', () => {
+    atUrl('tab=open&q=acme')
+    render(<Probe remember={false} />)
+
+    act(() => latest.setScope('/Clients/Acme'))
+
+    expect(replace).toHaveBeenCalledWith('/drafts?tab=open&q=acme&scope=%2FClients%2FAcme', {
+      scroll: false,
+    })
+  })
+
+  it('writes the reserved "all" value rather than selecting a root path', () => {
+    // Selecting a synthetic `/` would narrow to rows that HAVE a path, and the
+    // facet read skips rows whose attribute is null — so every unscoped record
+    // would vanish from the screen of whoever picked "all". And DELETING the
+    // parameter would make "I chose everything" indistinguishable from "nobody
+    // has chosen", which is the difference `remember` turns on.
+    atUrl('scope=%2FClients%2FAcme&tab=open')
+    render(<Probe remember={false} />)
+
+    act(() => latest.setScope(null))
+
+    // `set` keeps an existing key where it already was, hence scope first here.
+    expect(replace).toHaveBeenCalledWith('/drafts?scope=all&tab=open', { scroll: false })
+  })
+
+  it('reads the reserved value back out as no bound at all', () => {
+    atUrl('scope=all')
+    render(<Probe remember={false} />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('none')
+    expect(latest.asserted).toBe(true)
+  })
+
+  it('tells an assertion of "everything" apart from a URL that says nothing', () => {
+    atUrl('')
+    const { rerender } = render(<Probe remember={false} />)
+    expect(latest.scope).toBeNull()
+    expect(latest.asserted).toBe(false)
+
+    atUrl('scope=all')
+    rerender(<Probe remember={false} />)
+    expect(latest.scope).toBeNull()
+    expect(latest.asserted).toBe(true)
+  })
+
+  it('can push instead of replace, for an app that wants scope in history', () => {
+    atUrl('')
+    render(<Probe remember={false} history="push" />)
+    act(() => latest.setScope('/Clients/Acme'))
+    expect(push).toHaveBeenCalledWith('/drafts?scope=%2FClients%2FAcme', { scroll: false })
+    expect(replace).not.toHaveBeenCalled()
+  })
+
+  it('honours a custom parameter name', () => {
+    atUrl('client=%2FAcme')
+    render(<Probe param="client" remember={false} />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('/Acme')
+    act(() => latest.setScope('/Globex'))
+    expect(replace).toHaveBeenCalledWith('/drafts?client=%2FGlobex', { scroll: false })
+  })
+})
+
+describe('useScopeParam — withScope', () => {
+  it('carries "all" onto a link too, so everything keeps meaning everything', () => {
+    atUrl('scope=all')
+    render(<Probe remember={false} />)
+    expect(latest.withScope('/topics')).toBe('/topics?scope=all')
+  })
+
+  it('carries the scope onto a link, because <Link> drops the query string', () => {
+    atUrl('scope=%2FClients%2FAcme')
+    render(<Probe remember={false} />)
+    expect(latest.withScope('/topics')).toBe('/topics?scope=%2FClients%2FAcme')
+    expect(latest.withScope('/topics?tab=open')).toBe('/topics?tab=open&scope=%2FClients%2FAcme')
+    expect(latest.withScope('/topics#latest')).toBe('/topics?scope=%2FClients%2FAcme#latest')
+  })
+
+  it('leaves a link that already names a scope alone', () => {
+    atUrl('scope=%2FClients%2FAcme')
+    render(<Probe remember={false} />)
+    expect(latest.withScope('/topics?scope=%2FInternal')).toBe('/topics?scope=%2FInternal')
+  })
+
+  it('is a no-op when the URL asserts nothing', () => {
+    atUrl('')
+    render(<Probe remember={false} />)
+    expect(latest.withScope('/topics')).toBe('/topics')
+  })
+})
+
+describe('useScopeParam — remembering, the safety net', () => {
+  it('restores the last choice onto a route that carries no scope', () => {
+    atUrl('scope=%2FClients%2FAcme')
+    const { unmount } = render(<Probe />)
+    act(() => latest.setScope('/Clients/Acme'))
+    replace.mockClear()
+    unmount()
+
+    // A <Link href="/topics"> that dropped the query.
+    atUrl('', '/topics')
+    render(<Probe />)
+    expect(replace).toHaveBeenCalledWith('/topics?scope=%2FClients%2FAcme', { scroll: false })
+  })
+
+  it('never overrides a scope the URL already names — a shared link wins', () => {
+    atUrl('')
+    const { unmount } = render(<Probe />)
+    act(() => latest.setScope('/Clients/Acme'))
+    replace.mockClear()
+    unmount()
+
+    atUrl('scope=%2FInternal', '/topics')
+    render(<Probe />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('/Internal')
+    expect(replace).not.toHaveBeenCalled()
+  })
+
+  it('remembers "all scopes" as a CHOICE, and restores it as the assertion', () => {
+    atUrl('scope=%2FClients%2FAcme')
+    const { unmount } = render(<Probe />)
+    act(() => latest.setScope(null))
+    replace.mockClear()
+    unmount()
+
+    atUrl('', '/topics')
+    render(<Probe />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('none')
+    expect(replace).toHaveBeenCalledWith('/topics?scope=all', { scroll: false })
+  })
+
+  it('LEAVES A SHARED "everything" LINK ALONE, even for a tab that is scoped', () => {
+    // The case this whole reserved value exists for. Somebody sends "look at all
+    // of it"; without an assertion the reader's own remembered scope would be
+    // written over the top of it and they would read one client's rows under a
+    // link that named none.
+    atUrl('')
+    const { unmount } = render(<Probe />)
+    act(() => latest.setScope('/Clients/Acme'))
+    replace.mockClear()
+    unmount()
+
+    atUrl('scope=all', '/topics')
+    render(<Probe />)
+    expect(screen.getByTestId('scope')).toHaveTextContent('none')
+    expect(replace).not.toHaveBeenCalled()
+  })
+
+  it('attempts the restore at most once, so a declined replace is not a loop', () => {
+    atUrl('')
+    const { unmount } = render(<Probe />)
+    act(() => latest.setScope('/Clients/Acme'))
+    replace.mockClear()
+    unmount()
+
+    // The host never honours the replace, so the params never change. A restore
+    // keyed only on "the URL still has no scope" would fire on every render.
+    atUrl('', '/topics')
+    const { rerender } = render(<Probe />)
+    expect(replace).toHaveBeenCalledTimes(1)
+    rerender(<Probe />)
+    rerender(<Probe />)
+    expect(replace).toHaveBeenCalledTimes(1)
+  })
+
+  it('does nothing at all when remembering is switched off', () => {
+    atUrl('')
+    const { unmount } = render(<Probe remember={false} />)
+    act(() => latest.setScope('/Clients/Acme'))
+    replace.mockClear()
+    unmount()
+
+    atUrl('', '/topics')
+    render(<Probe remember={false} />)
+    expect(replace).not.toHaveBeenCalled()
+  })
+
+  it('survives sessionStorage throwing outright', () => {
+    const spy = jest.spyOn(window.sessionStorage.__proto__, 'setItem').mockImplementation(() => {
+      throw new Error('blocked')
+    })
+    try {
+      atUrl('')
+      render(<Probe />)
+      expect(() => act(() => latest.setScope('/Clients/Acme'))).not.toThrow()
+      expect(replace).toHaveBeenCalled()
+    } finally {
+      spy.mockRestore()
+    }
+  })
+})