#399

frontend/src/lib/postImportRows.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest'
+
+import { creatableImportRows,
+	 initialisePreviewRows,
+	 mergeImportResults,
+	 mergeValidatedImportRows,
+	 processableImportRows,
+	 resultSummaryCounts,
+	 retryImportRow,
+	 reviewSummaryCounts } from '@/lib/postImportSession'
+import { buildPostImportRow } from '@/test/postImportFactories'
+
+describe ('post import row state', () => {
+  it ('separates processable existing rows from creatable rows', () => {
+    const ready = buildPostImportRow ({ sourceRow: 1 })
+    const existing = buildPostImportRow ({
+      sourceRow: 2,
+      skipReason: 'existing',
+      existingPostId: 20 })
+    const invalid = buildPostImportRow ({
+      sourceRow: 3,
+      status: 'error',
+      validationErrors: { url: ['invalid'] } })
+    const created = buildPostImportRow ({
+      sourceRow: 4,
+      importStatus: 'created',
+      createdPostId: 40 })
+    const rows = [ready, existing, invalid, created]
+
+    expect (processableImportRows (rows)).toEqual ([ready, existing])
+    expect (creatableImportRows (rows)).toEqual ([ready])
+    expect (reviewSummaryCounts (rows)).toEqual ({
+      total: 4,
+      submittable: 1,
+      skipPlanned: 1 })
+  })
+
+  it ('preserves terminal rows while merging validation results', () => {
+    const created = buildPostImportRow ({
+      sourceRow: 1,
+      importStatus: 'created',
+      createdPostId: 10,
+      attributes: { title: 'created title' } })
+    const pending = buildPostImportRow ({
+      sourceRow: 2,
+      fieldWarnings: { title: ['old warning'] },
+      provenance: { title: 'manual' },
+      attributes: { title: 'manual title' } })
+    const validated = [
+      buildPostImportRow ({ sourceRow: 1, attributes: { title: 'changed' } }),
+      buildPostImportRow ({
+	sourceRow: 2,
+	fieldWarnings: { title: ['fetch warning'], tags: ['tag warning'] },
+	provenance: { title: 'manual' },
+	attributes: { title: 'manual title' } })]
+
+    const result = mergeValidatedImportRows ([created, pending], validated)
+
+    expect (result[0]).toBe (created)
+    expect (result[1]?.fieldWarnings).toEqual ({ tags: ['tag warning'] })
+  })
+
+  it ('updates the reset snapshot only after metadata URL changes', () => {
+    const current = buildPostImportRow ({
+      attributes: { title: 'manual title' },
+      metadataUrl: 'https://example.com/old' })
+    const validated = buildPostImportRow ({
+      attributes: { title: 'new metadata title' },
+      metadataUrl: 'https://example.com/new',
+      fieldWarnings: { title: ['warning'] },
+      baseWarnings: ['base warning'] })
+
+    const result = mergeValidatedImportRows ([current], [validated])[0]
+
+    expect (result?.resetSnapshot).toMatchObject ({
+      attributes: { title: 'new metadata title' },
+      fieldWarnings: { title: ['warning'] },
+      baseWarnings: ['base warning'],
+      metadataUrl: 'https://example.com/new' })
+  })
+
+  it ('merges result states and clears incompatible post identifiers', () => {
+    const created = mergeImportResults ([buildPostImportRow ({
+      skipReason: 'existing',
+      existingPostId: 2 })], [{
+      sourceRow: 1,
+      status: 'created',
+      post: { id: 3 } }])[0]
+    const skipped = mergeImportResults ([buildPostImportRow ({
+      createdPostId: 3,
+      importStatus: 'created' })], [{
+      sourceRow: 1,
+      status: 'skipped',
+      existingPostId: 4 }])[0]
+    const failed = mergeImportResults ([buildPostImportRow ({
+      skipReason: 'existing',
+      existingPostId: 4 })], [{
+      sourceRow: 1,
+      status: 'failed',
+      errors: { base: ['failure'] } }])[0]
+
+    expect (created).toMatchObject ({
+      importStatus: 'created',
+      createdPostId: 3,
+      existingPostId: undefined,
+      skipReason: undefined })
+    expect (skipped).toMatchObject ({
+      importStatus: 'skipped',
+      existingPostId: 4,
+      createdPostId: undefined,
+      skipReason: 'existing' })
+    expect (failed).toMatchObject ({
+      importStatus: 'failed',
+      createdPostId: undefined,
+      existingPostId: undefined,
+      skipReason: undefined,
+      importErrors: { base: ['failure'] } })
+  })
+
+  it ('retries only the selected failed row and counts results exclusively', () => {
+    const rows = [
+      buildPostImportRow ({ sourceRow: 1, importStatus: 'created', createdPostId: 1 }),
+      buildPostImportRow ({ sourceRow: 2, importStatus: 'skipped',
+	existingPostId: 2, skipReason: 'existing' }),
+      buildPostImportRow ({ sourceRow: 3, importStatus: 'failed',
+	importErrors: { base: ['failed'] } })]
+
+    expect (resultSummaryCounts (rows)).toEqual ({ created: 1, skipped: 1, failed: 1 })
+    expect (retryImportRow (rows, 3)[2]).toMatchObject ({
+      importStatus: 'pending',
+      importErrors: undefined })
+  })
+
+  it ('copies reset snapshot values instead of sharing mutable records', () => {
+    const row = buildPostImportRow ({ fieldWarnings: { title: ['warning'] } })
+    const initialised = initialisePreviewRows ([row])[0]
+    expect (initialised).toBeDefined ()
+    if (initialised == null)
+      return
+
+    initialised.attributes.title = 'changed'
+    initialised.fieldWarnings.title?.push ('another')
+
+    expect (initialised.resetSnapshot.attributes.title).toBe ('')
+    expect (initialised.resetSnapshot.fieldWarnings.title).toEqual (['warning'])
+  })
+})

frontend/src/lib/postImportSourceValidation.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest'
+
+import { countImportSourceLines, validateImportSource } from '@/lib/postImportSession'
+
+describe ('post import source validation', () => {
+  it ('counts trimmed non-empty CRLF and LF rows', () => {
+    expect (countImportSourceLines (' one \r\n\r\n two\n')).toBe (2)
+  })
+
+  it ('reports invalid protocols and malformed URLs with original line numbers', () => {
+    const issues = validateImportSource (
+        '\nftp://example.com/file\nhttps://exa mple.com/path')
+
+    expect (issues).toEqual ([
+      {
+	sourceRow: 2,
+	message: 'HTTP または HTTPS の URL ではありません．',
+	url: 'ftp://example.com/file' },
+      {
+	sourceRow: 3,
+	message: 'URL の形式が不正です．',
+	url: 'https://exa mple.com/path' }])
+  })
+
+  it ('detects duplicates after frontend URL normalisation', () => {
+    const issues = validateImportSource (
+        'https://EXAMPLE.com/path/\nhttps://example.com/path')
+
+    expect (issues).toEqual ([{
+      sourceRow: 2,
+      message: '1 行目と同じ URL です．',
+      url: 'https://example.com/path' }])
+  })
+
+  it ('rejects oversized URLs and rows beyond the maximum count', () => {
+    const oversized = `https://example.com/${ 'a'.repeat (20 * 1024) }`
+    const tooMany = Array.from (
+        { length: 101 },
+        (_, index) => `https://example.com/${ index }`).join ('\n')
+
+    expect (validateImportSource (oversized)[0]).toMatchObject ({
+      sourceRow: 1,
+      message: 'URL が長すぎます．' })
+    expect (validateImportSource (tooMany).at (-1)).toEqual ({
+      sourceRow: 101,
+      message: '取込件数は 100 件までです．',
+      url: 'https://example.com/100' })
+  })
+})

frontend/src/lib/postImportStorage.test.ts

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { cleanupExpiredPostImportSessions,
+	 clearPostImportSourceDraft,
+	 loadPostImportSession,
+	 loadPostImportSourceDraft,
+	 savePostImportSession,
+	 savePostImportSourceDraft } from '@/lib/postImportSession'
+import { buildPostImportRow } from '@/test/postImportFactories'
+
+describe ('post import storage', () => {
+  beforeEach (() => {
+    sessionStorage.clear ()
+    vi.useRealTimers ()
+  })
+
+  it ('round-trips a valid session and source draft', () => {
+    const row = buildPostImportRow ({
+      importStatus: 'skipped',
+      skipReason: 'existing',
+      existingPostId: 10 })
+
+    expect (savePostImportSession ('session', {
+      source: row.url,
+      rows: [row],
+      repairMode: 'all' })).toBe (true)
+    expect (loadPostImportSession ('session')).toMatchObject ({
+      version: 2,
+      source: row.url,
+      rows: [{
+	importStatus: 'skipped',
+	skipReason: 'existing',
+	existingPostId: 10 }] })
+
+    expect (savePostImportSourceDraft ('https://example.com')).toBe (true)
+    expect (loadPostImportSourceDraft ()).toEqual ({ source: 'https://example.com' })
+    clearPostImportSourceDraft ()
+    expect (loadPostImportSourceDraft ()).toEqual ({ source: '' })
+  })
+
+  it ('rejects inconsistent post IDs and terminal statuses', () => {
+    const session = {
+      version: 2,
+      savedAt: new Date ().toISOString (),
+      source: '',
+      repairMode: 'all',
+      rows: [buildPostImportRow ()] }
+    const invalidRows = [
+      { ...session.rows[0], skipReason: 'existing', existingPostId: undefined },
+      { ...session.rows[0], existingPostId: 2, skipReason: undefined },
+      { ...session.rows[0], importStatus: 'created', createdPostId: undefined },
+      { ...session.rows[0], importStatus: 'failed', createdPostId: 3 }]
+
+    for (const [index, row] of invalidRows.entries ())
+      {
+	sessionStorage.setItem (`post-import-session:invalid-${ index }`, JSON.stringify ({
+	  ...session,
+	  rows: [row] }))
+	expect (loadPostImportSession (`invalid-${ index }`)).toBeNull ()
+      }
+  })
+
+  it ('rejects invalid attribute, provenance, tag-source, and snapshot data', () => {
+    const row = buildPostImportRow ()
+    const invalidRows = [
+      { ...row, attributes: { title: [] } },
+      { ...row, attributes: { unknown: 'value' } },
+      { ...row, provenance: { title: 'mapped' } },
+      { ...row, tagSources: { mapped: 'tag' } },
+      { ...row, resetSnapshot: { ...row.resetSnapshot,
+	fieldWarnings: { title: 'warning' } } }]
+
+    invalidRows.forEach ((invalidRow, index) => {
+      sessionStorage.setItem (`post-import-session:shape-${ index }`, JSON.stringify ({
+	version: 2,
+	savedAt: new Date ().toISOString (),
+	source: '',
+	rows: [invalidRow],
+	repairMode: 'all' }))
+      expect (loadPostImportSession (`shape-${ index }`)).toBeNull ()
+    })
+  })
+
+  it ('removes expired and malformed sessions without touching current sessions', () => {
+    const current = {
+      version: 2,
+      savedAt: new Date ().toISOString (),
+      source: '',
+      rows: [buildPostImportRow ()],
+      repairMode: 'all' }
+    const expired = {
+      ...current,
+      savedAt: new Date (Date.now () - 25 * 60 * 60 * 1000).toISOString () }
+    sessionStorage.setItem ('post-import-session:current', JSON.stringify (current))
+    sessionStorage.setItem ('post-import-session:expired', JSON.stringify (expired))
+    sessionStorage.setItem ('post-import-session:malformed', '{')
+
+    cleanupExpiredPostImportSessions ()
+
+    expect (sessionStorage.getItem ('post-import-session:current')).not.toBeNull ()
+    expect (sessionStorage.getItem ('post-import-session:expired')).toBeNull ()
+    expect (sessionStorage.getItem ('post-import-session:malformed')).toBeNull ()
+  })
+
+  it ('reports storage access failures without throwing', () => {
+    const onError = vi.fn ()
+    vi.spyOn (Storage.prototype, 'setItem').mockImplementation (() => {
+      throw new DOMException ('quota')
+    })
+
+    expect (savePostImportSourceDraft ('source', onError)).toBe (false)
+    expect (onError).toHaveBeenCalledWith ('ブラウザへ保存できませんでした．')
+  })
+})