crawler-plugin/frontend-vue/tests/modules-similar-asin.test.ts

import { test } from 'node:test'
import assert from 'node:assert/strict'
import { http } from '../src/shared/api/http.ts'
import {
  parseSimilarAsin,
  getSimilarAsinDashboard,
  getSimilarAsinHistory,
  getSimilarAsinTaskProgressBatch,
  activateSimilarAsinTask,
  deleteSimilarAsinTask,
  deleteSimilarAsinHistory,
  getSimilarAsinResultDownloadUrl,
  type SimilarAsinTaskBatchVo,
} from '../src/shared/api/types/modules/similar-asin.ts'

function setupWindow() {
  ;(globalThis as Record<string, unknown>).window = {
    localStorage: { getItem: () => '42' },
    location: { origin: 'http://localhost' },
  }
}

function mockRequest(
  t: Parameters<typeof test>[1] extends (t: infer T) => unknown ? T : never,
  impl: (config: { url?: string; method?: string; params?: Record<string, unknown>; data?: unknown; timeout?: number }) => Promise<unknown>,
) {
  t.mock.method(http, 'request', impl as never)
}

const okResponse = (data: unknown) => Promise.resolve({ data: { success: true, message: 'ok', data } })

test('test_similar_asin_parse_url_payload', async (t) => {
  setupWindow()
  let captured: { url?: string; method?: string; data?: unknown } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ taskId: 1, totalRows: 1, acceptedRows: 1, droppedRows: 0, items: [] })
  })
  await parseSimilarAsin([{ fileKey: 'k1' }], 'api-key-1', true, true)
  assert.equal(captured.url, '/newApi/api/similar-asin/parse')
  assert.equal(captured.method, 'POST')
  assert.deepEqual(captured.data, {
    user_id: 42,
    files: [{ fileKey: 'k1' }],
    api_key: 'api-key-1',
    img_switch: true,
    category_switch: true,
  })
})

test('test_similar_asin_parse_defaults', async (t) => {
  setupWindow()
  let captured: { data?: unknown } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ taskId: 1, totalRows: 1, acceptedRows: 1, droppedRows: 0, items: [] })
  })
  await parseSimilarAsin([{ fileKey: 'k1' }])
  assert.deepEqual(captured.data, {
    user_id: 42,
    files: [{ fileKey: 'k1' }],
    api_key: undefined,
    img_switch: false,
    category_switch: false,
  })
})

test('test_similar_asin_dashboard', async (t) => {
  setupWindow()
  let captured: { url?: string; params?: Record<string, unknown> } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ pendingTaskCount: 1, processedTaskCount: 2, successTaskCount: 1, failedTaskCount: 1 })
  })
  const result = await getSimilarAsinDashboard()
  assert.equal(captured.url, '/newApi/api/similar-asin/dashboard')
  assert.deepEqual(captured.params, { user_id: 42 })
  assert.equal(result.successTaskCount, 1)
})

test('test_similar_asin_history', async (t) => {
  setupWindow()
  let captured: { url?: string; params?: Record<string, unknown> } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ items: [] })
  })
  await getSimilarAsinHistory()
  assert.equal(captured.url, '/newApi/api/similar-asin/history')
  assert.deepEqual(captured.params, { user_id: 42, limit: 50 })
})

test('test_similar_asin_progress_batch_timeout', async (t) => {
  setupWindow()
  let captured: { url?: string; method?: string; data?: unknown; timeout?: number } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ items: [], missingTaskIds: [] })
  })
  const result = await getSimilarAsinTaskProgressBatch([5, 3])
  assert.equal(captured.url, '/newApi/api/similar-asin/tasks/progress/batch')
  assert.equal(captured.method, 'POST')
  assert.deepEqual(captured.data, { taskIds: [3, 5] })
  assert.equal(captured.timeout, 10000)
  assert.deepEqual(result, { items: [], missingTaskIds: [] })

  const empty = await getSimilarAsinTaskProgressBatch([])
  assert.deepEqual(empty as SimilarAsinTaskBatchVo, { items: [], missingTaskIds: [] })
})

test('test_similar_asin_activate', async (t) => {
  setupWindow()
  let captured: { url?: string; method?: string } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse(null)
  })
  await activateSimilarAsinTask(7)
  assert.equal(captured.url, '/newApi/api/similar-asin/tasks/7/activate?user_id=42')
  assert.equal(captured.method, 'POST')
})

test('test_similar_asin_delete_task_history', async (t) => {
  setupWindow()
  const calls: { url?: string; method?: string; params?: Record<string, unknown> }[] = []
  mockRequest(t, (config) => {
    calls.push(config)
    return okResponse(null)
  })
  await deleteSimilarAsinTask(7)
  await deleteSimilarAsinHistory(9)
  assert.equal(calls[0].url, '/newApi/api/similar-asin/tasks/7')
  assert.equal(calls[0].method, 'DELETE')
  assert.deepEqual(calls[0].params, { user_id: 42 })
  assert.equal(calls[1].url, '/newApi/api/similar-asin/history/9')
  assert.equal(calls[1].method, 'DELETE')
  assert.deepEqual(calls[1].params, { user_id: 42 })
})

test('test_similar_asin_download_url', async (t) => {
  setupWindow()
  const url = getSimilarAsinResultDownloadUrl(7)
  assert.equal(url, 'http://localhost/newApi/api/similar-asin/results/7/download?user_id=42')
})

test('test_similar_asin_export_compat', async (t) => {
  setupWindow()
  const fromJavaModules = await import('../src/shared/api/java-modules.ts')
  const fromSimilar = await import('../src/shared/api/types/modules/similar-asin.ts')
  const names = [
    'parseSimilarAsin', 'getSimilarAsinDashboard', 'getSimilarAsinHistory',
    'getSimilarAsinTaskProgressBatch', 'activateSimilarAsinTask',
    'deleteSimilarAsinTask', 'deleteSimilarAsinHistory', 'getSimilarAsinResultDownloadUrl',
  ]
  for (const name of names) {
    assert.equal(fromJavaModules[name], fromSimilar[name], `${name} 应为同一引用`)
  }
  const row = { rowIndex: 1, sourceId: 's1', displayId: 'd1', asin: 'B001', country: 'US' }
  assert.equal(row.asin, 'B001')
  assert.equal(fromJavaModules.UploadedFileRef, undefined)
})