feat(app): sign-out warns before losing editor work, local copies purged

This commit is contained in:
bchanot committed 2026-11-04 19:58:21 +01:00
1 parent 8b6adcb7df
commit bd4ba338af
12 files changed
+417 -16

No files matched your search

@@ -0,0 +1,49 @@
/** Lot N2: another account signing in purges the previous accounts' copies (ruling R24). */
import { afterEach, describe, expect, it } from 'vitest'
import { act, cleanup, renderHook } from '@testing-library/react'
import { usePurgeForeignCopies } from '@/app/usePurgeForeignCopies'
import { copyKey } from '@/editor/state/recovery'
import { useAuthStore } from '@/state/authStore'
import { fakeUser } from '../helpers/fakeSupabase'
const A = fakeUser({ id: 'aaaaaaaa-0000-0000-0000-000000000001' })
const B = fakeUser({ id: 'bbbbbbbb-0000-0000-0000-000000000002' })
afterEach(() => {
cleanup()
sessionStorage.clear()
useAuthStore.setState({ status: 'signed_out', user: null })
})
function seed() {
sessionStorage.setItem(copyKey(A.id, 'v1'), '{}')
sessionStorage.setItem(copyKey(B.id, 'v1'), '{}')
}
describe('usePurgeForeignCopies', () => {
it('keeps the copies of an expired session and offers them to the same account', () => {
seed()
useAuthStore.setState({ status: 'signed_in', user: A })
renderHook(() => usePurgeForeignCopies())
act(() => useAuthStore.setState({ status: 'signed_out', user: null }))
act(() => useAuthStore.setState({ status: 'signed_in', user: A }))
expect(sessionStorage.getItem(copyKey(A.id, 'v1'))).toBe('{}')
})
it('purges the previous account copies when another account signs in', () => {
sessionStorage.setItem(copyKey(A.id, 'v1'), '{}')
useAuthStore.setState({ status: 'signed_in', user: A })
renderHook(() => usePurgeForeignCopies())
act(() => useAuthStore.setState({ status: 'signed_in', user: B }))
sessionStorage.setItem(copyKey(B.id, 'v1'), '{}')
expect(sessionStorage.getItem(copyKey(A.id, 'v1'))).toBeNull()
expect(sessionStorage.getItem(copyKey(B.id, 'v1'))).toBe('{}')
})
it('purges at mount when copies of another account are already there', () => {
seed()
useAuthStore.setState({ status: 'signed_in', user: B })
renderHook(() => usePurgeForeignCopies())
expect(sessionStorage.getItem(copyKey(A.id, 'v1'))).toBeNull()
})
})
@@ -0,0 +1,87 @@
/** Lot N2: sign-out asks only when something would be lost (contract C43). */
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { cleanup, render, screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { MemoryRouter } from 'react-router-dom'
import SignOutButton from '@/components/shell/SignOutButton'
import { copyKey } from '@/editor/state/recovery'
import { useEditorStore } from '@/editor/state/editorStore'
import { useAuthStore } from '@/state/authStore'
import { useLocaleStore } from '@/state/localeStore'
import { fr } from '@/i18n/fr'
import { fakeUser } from '../helpers/fakeSupabase'
const user = fakeUser()
const OTHER = 'bbbbbbbb-0000-0000-0000-000000000002'
const signOut = vi.fn(() => Promise.resolve())
beforeEach(() => {
useLocaleStore.setState({ locale: 'fr' })
useAuthStore.setState({ status: 'signed_in', user, signOut })
useEditorStore.setState({ unsaved: false, recovery: 'none' })
})
afterEach(() => {
cleanup()
sessionStorage.clear()
signOut.mockClear()
})
const click = () =>
userEvent.click(screen.getByRole('button', { name: fr['shell.sign_out'] }))
function mount() {
render(
<MemoryRouter>
<SignOutButton />
</MemoryRouter>,
)
}
describe('SignOutButton', () => {
it('signs out at once when nothing would be lost', async () => {
mount()
await click()
expect(screen.queryByRole('dialog')).toBeNull()
await waitFor(() => expect(signOut).toHaveBeenCalledTimes(1))
})
it('asks when the editor holds unsaved changes, and cancel keeps everything', async () => {
useEditorStore.setState({ unsaved: true })
sessionStorage.setItem(copyKey(user.id, 'v1'), '{}')
mount()
await click()
expect(screen.getByRole('dialog')).toBeTruthy()
await userEvent.click(
screen.getByRole('button', { name: fr['shell.sign_out_loss_cancel'] }),
)
expect(signOut).not.toHaveBeenCalled()
expect(sessionStorage.getItem(copyKey(user.id, 'v1'))).toBe('{}')
})
it('asks when a pending recovery offer exists', async () => {
useEditorStore.setState({ recovery: 'pending' })
mount()
await click()
expect(screen.getByRole('dialog')).toBeTruthy()
})
it('asks for a copy of its own, then confirming purges only that account and signs out', async () => {
sessionStorage.setItem(copyKey(user.id, 'v1'), '{}')
sessionStorage.setItem(copyKey(OTHER, 'v1'), '{}')
mount()
await click()
await userEvent.click(
screen.getByRole('button', { name: fr['shell.sign_out_loss_confirm'] }),
)
await waitFor(() => expect(signOut).toHaveBeenCalledTimes(1))
expect(sessionStorage.getItem(copyKey(user.id, 'v1'))).toBeNull()
expect(sessionStorage.getItem(copyKey(OTHER, 'v1'))).toBe('{}')
})
it('ignores the copies of another account', async () => {
sessionStorage.setItem(copyKey(OTHER, 'v1'), '{}')
mount()
await click()
expect(screen.queryByRole('dialog')).toBeNull()
})
})
@@ -0,0 +1,44 @@
/** Lot N2: the purge of local recovery copies by account (contract C43, ruling R24). */
import { afterEach, describe, expect, it } from 'vitest'
import {
copyKey,
hasUserCopies,
removeOtherUsersCopies,
removeUserCopies,
} from '@/editor/state/recovery'
const A = 'aaaaaaaa-0000-0000-0000-000000000001'
const B = 'bbbbbbbb-0000-0000-0000-000000000002'
function seed() {
sessionStorage.setItem(copyKey(A, 'v1'), '{}')
sessionStorage.setItem(copyKey(A, 'v2'), '{}')
sessionStorage.setItem(copyKey(B, 'v1'), '{}')
sessionStorage.setItem('osteo:draft', '{}')
}
const keys = () => Object.keys(sessionStorage).sort()
afterEach(() => sessionStorage.clear())
describe('copy purge', () => {
it('sees whether an account holds a copy', () => {
expect(hasUserCopies(A)).toBe(false)
seed()
expect(hasUserCopies(A)).toBe(true)
expect(hasUserCopies('cccccccc')).toBe(false)
})
it('removes every copy of one account and nothing else', () => {
seed()
removeUserCopies(A)
expect(keys()).toEqual([copyKey(B, 'v1'), 'osteo:draft'].sort())
})
it('keeps the signed-in account copies and removes the others', () => {
seed()
removeOtherUsersCopies(A)
expect(keys()).toEqual(
[copyKey(A, 'v1'), copyKey(A, 'v2'), 'osteo:draft'].sort(),
)
})
})