#399

frontend/src/pages/posts/PostImportResultPage.test.tsx

@@ -1,402 +1,48 @@
-import { act, fireEvent, render, screen, waitFor } from '@testing-library/react'
-import { HelmetProvider } from 'react-helmet-async'
-import { MemoryRouter, Route, Routes } from 'react-router-dom'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { render, screen } from '@testing-library/react'
+import { MemoryRouter, Navigate, Route, Routes } from 'react-router-dom'
+import { describe, expect, it } from 'vitest'
 
-import {
-  loadPostImportSession,
-  savePostImportSession,
-} from '@/lib/postImportSession'
-import PostImportResultPage from '@/pages/posts/PostImportResultPage'
-import { buildUser } from '@/test/factories'
-import { buildPostImportRow } from '@/test/postImportFactories'
-import { originalCreatedAtString } from '@/lib/utils'
+describe ('legacy post import routes', () => {
+  it ('redirects /posts/import to /posts/new', () => {
+    render (
+        <MemoryRouter initialEntries={['/posts/import']}>
+          <Routes>
+            <Route path="/posts/import" element={<Navigate to="/posts/new" replace/>}/>
+            <Route path="/posts/new" element={<div>SOURCE ROUTE</div>}/>
+          </Routes>
+        </MemoryRouter>)
 
-import type { PostImportRow } from '@/lib/postImportSession'
-import type { DialogueFormAction, DialogueFormControls } from '@/lib/dialogues/useDialogue'
-
-const api = vi.hoisted (() => ({
-  apiGet: vi.fn (),
-  apiPost: vi.fn (),
-}))
-
-const toastApi = vi.hoisted (() => ({
-  toast: vi.fn (),
-}))
-
-const dialogue = vi.hoisted (() => ({
-  form: vi.fn (() => Promise.resolve ()),
-}))
-
-vi.mock ('@/components/ui/use-toast', () => toastApi)
-vi.mock ('@/lib/api', () => api)
-vi.mock ('@/lib/dialogues/useDialogue', () => ({
-  default: () => dialogue,
-}))
-
-describe ('PostImportResultPage', () => {
-  beforeEach (() => {
-    sessionStorage.clear ()
-    vi.clearAllMocks ()
-    globalThis.URL.createObjectURL = vi.fn (() => 'blob:preview')
-    globalThis.URL.revokeObjectURL = vi.fn ()
-    api.apiGet.mockResolvedValue (new Blob (['img'], { type: 'image/png' }))
+    expect (screen.getByText ('SOURCE ROUTE')).toBeInTheDocument ()
   })
 
-  it ('shows edit and retry only for recoverable failures and shows warnings', () => {
-    savePostImportSession ('result-session', {
-      source: '',
-      repairMode: 'failed',
-      rows: [
-        buildPostImportRow ({
-          sourceRow: 1,
-          attributes: { title: 'recoverable row' },
-          importStatus: 'failed',
-          recoverable: true,
-          importErrors: { base: ['recoverable failed'] } }),
-        buildPostImportRow ({
-          sourceRow: 2,
-          attributes: { title: 'hard failed row' },
-          importStatus: 'failed',
-          importErrors: { base: ['hard failed'] } }),
-        buildPostImportRow ({
-          sourceRow: 3,
-          attributes: {
-            title: 'created row',
-            originalCreatedFrom: '2024-01-01T00:00:00Z',
-            originalCreatedBefore: '2024-01-02T00:00:00Z' },
-          importStatus: 'created',
-          createdPostId: 3,
-          fieldWarnings: {
-            thumbnailBase: ['サムネール画像を取得できませんでした．'] } })] })
-
+  it ('redirects legacy review routes to /posts/new', () => {
     render (
-        <HelmetProvider>
-          <MemoryRouter initialEntries={['/posts/import/result-session/result']}>
-            <Routes>
-              <Route
-                  path="/posts/import/:sessionId/result"
-                  element={<PostImportResultPage user={buildUser ()}/>}/>
-            </Routes>
-          </MemoryRouter>
-        </HelmetProvider>)
+        <MemoryRouter initialEntries={['/posts/import/legacy/review']}>
+          <Routes>
+            <Route
+                path="/posts/import/:sessionId/review"
+                element={<Navigate to="/posts/new" replace/>}/>
+            <Route path="/posts/new" element={<div>SOURCE ROUTE</div>}/>
+          </Routes>
+        </MemoryRouter>)
 
-    expect (screen.getAllByRole ('button', { name: '編輯' })).toHaveLength (1)
-    expect (screen.getAllByRole ('button', { name: '再試行' })).toHaveLength (1)
-    expect (screen.getByText ('サムネール画像を取得できませんでした．'))
-        .toBeInTheDocument ()
-    expect (screen.getByText (
-        originalCreatedAtString ('2024-01-01T00:00:00Z', '2024-01-02T00:00:00Z'),
-    )).toBeInTheDocument ()
+    expect (screen.getByText ('SOURCE ROUTE')).toBeInTheDocument ()
   })
 
-  it ('shows hour-precision original-created ranges with the shared utility output', () => {
-    const from = '2024-01-01T12:00:00Z'
-    const before = '2024-01-01T13:00:00Z'
-    savePostImportSession ('result-hour-range', {
-      source: '',
-      repairMode: 'all',
-      rows: [buildPostImportRow ({
-        sourceRow: 1,
-        importStatus: 'created',
-        createdPostId: 1,
-        attributes: {
-          title: 'created row',
-          originalCreatedFrom: from,
-          originalCreatedBefore: before } })] })
-
+  it ('redirects legacy result routes to /posts', () => {
     render (
-        <HelmetProvider>
-          <MemoryRouter initialEntries={['/posts/import/result-hour-range/result']}>
-            <Routes>
-              <Route
-                  path="/posts/import/:sessionId/result"
-                  element={<PostImportResultPage user={buildUser ()}/>}/>
-            </Routes>
-          </MemoryRouter>
-        </HelmetProvider>)
+        <MemoryRouter initialEntries={['/posts/import/legacy/result']}>
+          <Routes>
+            <Route
+                path="/posts/import/:sessionId/result"
+                element={<Navigate to="/posts" replace/>}/>
+            <Route
+                path="/posts/new/:sessionId/result"
+                element={<Navigate to="/posts" replace/>}/>
+            <Route path="/posts" element={<div>POSTS ROUTE</div>}/>
+          </Routes>
+        </MemoryRouter>)
 
-    expect (screen.getByText (originalCreatedAtString (from, before))).toBeInTheDocument ()
-  })
-
-  it ('keeps recoverable pending rows actionable and hides actions for hard failures', () => {
-    savePostImportSession ('result-pending', {
-      source: '',
-      repairMode: 'failed',
-      rows: [
-        buildPostImportRow ({
-          sourceRow: 1,
-          importStatus: 'pending',
-          recoverable: true,
-          validationErrors: { title: ['invalid'] } }),
-        buildPostImportRow ({
-          sourceRow: 2,
-          importStatus: 'pending',
-          recoverable: true }),
-        buildPostImportRow ({
-          sourceRow: 3,
-          importStatus: 'failed',
-          importErrors: { base: ['hard failed'] } })] })
-
-    render (
-        <HelmetProvider>
-          <MemoryRouter initialEntries={['/posts/import/result-pending/result']}>
-            <Routes>
-              <Route
-                  path="/posts/import/:sessionId/result"
-                  element={<PostImportResultPage user={buildUser ()}/>}/>
-            </Routes>
-          </MemoryRouter>
-        </HelmetProvider>)
-
-    expect (screen.getAllByRole ('button', { name: '編輯' })).toHaveLength (1)
-    expect (screen.getAllByRole ('button', { name: '再試行' })).toHaveLength (1)
-    expect (screen.getByText ('invalid')).toBeInTheDocument ()
-    expect (screen.getByText ('hard failed')).toBeInTheDocument ()
-  })
-
-  it ('disables editing, retry, and navigation while retry is running', async () => {
-    let resolveValidation: ((value: { rows: PostImportRow[] }) => void) | null = null
-    savePostImportSession ('result-retry-busy', {
-      source: '',
-      repairMode: 'failed',
-      rows: [
-        buildPostImportRow ({
-          sourceRow: 1,
-          importStatus: 'failed',
-          recoverable: true,
-          importErrors: { base: ['failed'] } }),
-        buildPostImportRow ({
-          sourceRow: 2,
-          importStatus: 'failed',
-          recoverable: true,
-          importErrors: { base: ['failed'] } })] })
-    api.apiPost.mockImplementationOnce (() =>
-        new Promise<{ rows: PostImportRow[] }> (resolve => {
-          resolveValidation = resolve
-        }))
-    api.apiPost.mockResolvedValueOnce ({
-      created: 0,
-      skipped: 0,
-      failed: 0,
-      rows: [] })
-
-    render (
-        <HelmetProvider>
-          <MemoryRouter initialEntries={['/posts/import/result-retry-busy/result']}>
-            <Routes>
-              <Route
-                  path="/posts/import/:sessionId/result"
-                  element={<PostImportResultPage user={buildUser ()}/>}/>
-            </Routes>
-          </MemoryRouter>
-        </HelmetProvider>)
-
-    fireEvent.click (screen.getAllByRole ('button', { name: '再試行' })[0])
-
-    await waitFor (() => {
-      screen.getAllByRole ('button', { name: '編輯' }).forEach (button => {
-        expect (button).toBeDisabled ()
-      })
-      screen.getAllByRole ('button', { name: '再試行' }).forEach (button => {
-        expect (button).toBeDisabled ()
-      })
-      expect (screen.getByRole ('button', { name: '確認画面へ戻る' })).toBeDisabled ()
-      expect (screen.getByRole ('button', { name: '新しい URL リストを入力' })).toBeDisabled ()
-    })
-
-    resolveValidation?.({ rows: [buildPostImportRow ({ sourceRow: 1 })] })
-  })
-
-  it ('persists retry success to sessionStorage', async () => {
-    savePostImportSession ('result-retry-success', {
-      source: '',
-      repairMode: 'failed',
-      rows: [buildPostImportRow ({
-        sourceRow: 1,
-        importStatus: 'failed',
-        recoverable: true,
-        importErrors: { base: ['failed'] } })] })
-    api.apiPost
-        .mockResolvedValueOnce ({
-          rows: [buildPostImportRow ({
-            sourceRow: 1,
-            importStatus: 'pending',
-            recoverable: true })] })
-        .mockResolvedValueOnce ({
-          created: 1,
-          skipped: 0,
-          failed: 0,
-          rows: [{
-            sourceRow: 1,
-            status: 'created',
-            post: { id: 10 } }] })
-
-    render (
-        <HelmetProvider>
-          <MemoryRouter initialEntries={['/posts/import/result-retry-success/result']}>
-            <Routes>
-              <Route
-                  path="/posts/import/:sessionId/result"
-                  element={<PostImportResultPage user={buildUser ()}/>}/>
-            </Routes>
-          </MemoryRouter>
-        </HelmetProvider>)
-
-    fireEvent.click (screen.getByRole ('button', { name: '再試行' }))
-
-    await waitFor (() => {
-      expect (loadPostImportSession ('result-retry-success')?.rows[0]?.importStatus)
-          .toBe ('created')
-    })
-  })
-
-  it ('keeps edited recoverable rows in session and retries with the edited values', async () => {
-    savePostImportSession ('result-edit-retry', {
-      source: '',
-      repairMode: 'failed',
-      rows: [buildPostImportRow ({
-        sourceRow: 1,
-        attributes: { title: 'old title' },
-        importStatus: 'failed',
-        recoverable: true,
-        importErrors: { base: ['failed'] } })] })
-    api.apiPost
-        .mockResolvedValueOnce ({
-          rows: [buildPostImportRow ({
-            sourceRow: 1,
-            attributes: { title: 'edited title' },
-            importStatus: 'pending',
-            recoverable: true })] })
-        .mockResolvedValueOnce ({
-          rows: [buildPostImportRow ({
-            sourceRow: 1,
-            attributes: { title: 'edited title' },
-            importStatus: 'pending',
-            recoverable: true })] })
-        .mockResolvedValueOnce ({
-          created: 1,
-          skipped: 0,
-          failed: 0,
-          rows: [{
-            sourceRow: 1,
-            status: 'created',
-            post: { id: 11 } }] })
-    dialogue.form.mockImplementationOnce (async options => {
-      let actions: DialogueFormAction[] = []
-      const controls: DialogueFormControls = {
-        close: vi.fn (),
-        confirm: vi.fn (),
-        setActions: next => {
-          actions = next
-        } }
-
-      render (options.body (controls))
-      await waitFor (() => expect (actions.length).toBe (2))
-      fireEvent.change (screen.getByDisplayValue ('old title'), {
-        target: { value: 'edited title' } })
-      await act (async () => {
-        await actions.find (action => action.label === '編輯内容を保存')?.onSelect ()
-      })
-    })
-
-    render (
-        <HelmetProvider>
-          <MemoryRouter initialEntries={['/posts/import/result-edit-retry/result']}>
-            <Routes>
-              <Route
-                  path="/posts/import/:sessionId/result"
-                  element={<PostImportResultPage user={buildUser ()}/>}/>
-            </Routes>
-          </MemoryRouter>
-        </HelmetProvider>)
-
-    fireEvent.click (screen.getByRole ('button', { name: '編輯' }))
-
-    await waitFor (() => {
-      const saved = loadPostImportSession ('result-edit-retry')
-      expect (saved?.rows[0]?.attributes.title).toBe ('edited title')
-      expect (saved?.rows[0]?.importStatus).toBe ('pending')
-    })
-
-    fireEvent.click (screen.getByRole ('button', { name: '再試行' }))
-
-    await waitFor (() => {
-      expect (api.apiPost.mock.calls[2]?.[1]?.rows?.[0]?.attributes?.title)
-          .toBe ('edited title')
-    })
-  })
-
-  it ('persists restored failed state when retry fails', async () => {
-    savePostImportSession ('result-retry-failure', {
-      source: '',
-      repairMode: 'failed',
-      rows: [buildPostImportRow ({
-        sourceRow: 1,
-        importStatus: 'failed',
-        recoverable: true,
-        importErrors: { base: ['failed'] } })] })
-    api.apiPost.mockRejectedValueOnce (new Error ('network error'))
-
-    render (
-        <HelmetProvider>
-          <MemoryRouter initialEntries={['/posts/import/result-retry-failure/result']}>
-            <Routes>
-              <Route
-                  path="/posts/import/:sessionId/result"
-                  element={<PostImportResultPage user={buildUser ()}/>}/>
-            </Routes>
-          </MemoryRouter>
-        </HelmetProvider>)
-
-    fireEvent.click (screen.getByRole ('button', { name: '再試行' }))
-
-    await waitFor (() => {
-      const saved = loadPostImportSession ('result-retry-failure')
-      expect (saved?.rows[0]?.importStatus).toBe ('failed')
-      expect (saved?.rows[0]?.recoverable).toBe (true)
-    })
-  })
-
-  it ('restores the failed row when the retry import response is incomplete', async () => {
-    savePostImportSession ('result-retry-missing-row', {
-      source: '',
-      repairMode: 'failed',
-      rows: [buildPostImportRow ({
-        sourceRow: 1,
-        importStatus: 'failed',
-        recoverable: true,
-        importErrors: { base: ['failed'] } })] })
-    api.apiPost
-        .mockResolvedValueOnce ({
-          rows: [buildPostImportRow ({
-            sourceRow: 1,
-            importStatus: 'pending',
-            recoverable: true })] })
-        .mockResolvedValueOnce ({
-          created: 1,
-          skipped: 0,
-          failed: 0,
-          rows: [] })
-
-    render (
-        <HelmetProvider>
-          <MemoryRouter initialEntries={['/posts/import/result-retry-missing-row/result']}>
-            <Routes>
-              <Route
-                  path="/posts/import/:sessionId/result"
-                  element={<PostImportResultPage user={buildUser ()}/>}/>
-            </Routes>
-          </MemoryRouter>
-        </HelmetProvider>)
-
-    fireEvent.click (screen.getByRole ('button', { name: '再試行' }))
-
-    await waitFor (() => {
-      const saved = loadPostImportSession ('result-retry-missing-row')
-      expect (saved?.rows[0]?.importStatus).toBe ('failed')
-      expect (toastApi.toast).toHaveBeenCalledWith (
-          expect.objectContaining ({ title: '登録結果が不完全でした' }))
-    })
+    expect (screen.getByText ('POSTS ROUTE')).toBeInTheDocument ()
   })
 })