create-appraisejs 0.2.0-alpha.6 → 0.3.0-alpha.0

package/templates/default/src/app/api/test-runs/[runId]/trace/[testCaseId]/route.test.ts

@@ -0,0 +1,135 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { NextRequest } from 'next/server'
+
+const { mockAccess, mockFindUnique, mockGetProcess, mockSpawn } = vi.hoisted(() => ({
+  mockAccess: vi.fn(),
+  mockFindUnique: vi.fn(),
+  mockGetProcess: vi.fn(),
+  mockSpawn: vi.fn(),
+}))
+
+vi.mock('fs', () => ({
+  promises: {
+    access: mockAccess,
+  },
+}))
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    testRun: {
+      findUnique: mockFindUnique,
+    },
+  },
+}))
+
+vi.mock('@/lib/process/task-spawner', () => ({
+  taskSpawner: {
+    getProcess: mockGetProcess,
+    spawn: mockSpawn,
+  },
+}))
+
+vi.mock('@/lib/automation/automation-path-roots', () => ({
+  resolveStoredPath: vi.fn((storedPath: string) => `/resolved/${storedPath}`),
+}))
+
+import { GET, POST } from './route'
+
+describe('trace route', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('returns 404 when the run is missing on GET', async () => {
+    mockFindUnique.mockResolvedValue(null)
+
+    const response = await GET(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1'), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(404)
+    await expect(response.json()).resolves.toEqual({ error: 'Test run not found' })
+  })
+
+  it('returns 404 when the test case is not part of the run on GET', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [],
+    })
+
+    const response = await GET(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1'), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(404)
+    await expect(response.json()).resolves.toEqual({ error: 'Test case not found in this test run' })
+  })
+
+  it('returns viewer status when the process exists on GET', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [{ id: 'trtc-1' }],
+    })
+    mockGetProcess.mockReturnValue({ isRunning: true })
+
+    const response = await GET(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1'), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({
+      isRunning: true,
+      processName: 'trace-viewer-trtc-1',
+    })
+  })
+
+  it('returns 400 when no trace path is stored on POST', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [{ id: 'trtc-1', tracePath: null }],
+    })
+
+    const response = await POST(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1', { method: 'POST' }), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(400)
+    await expect(response.json()).resolves.toEqual({ error: 'No trace path available for this test case' })
+  })
+
+  it('returns 404 when the trace file is missing on POST', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [{ id: 'trtc-1', tracePath: 'trace.zip', testCase: { id: 'tc-1' } }],
+    })
+    mockAccess.mockRejectedValue(new Error('missing'))
+
+    const response = await POST(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1', { method: 'POST' }), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(404)
+    await expect(response.json()).resolves.toEqual({ error: 'Trace file not found at path: trace.zip' })
+  })
+
+  it('spawns the trace viewer when the trace file exists on POST', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [{ id: 'trtc-1', tracePath: 'trace.zip', testCase: { id: 'tc-1' } }],
+    })
+    mockAccess.mockResolvedValue(undefined)
+    mockSpawn.mockResolvedValue({ name: 'trace-viewer-trtc-1' })
+
+    const response = await POST(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1', { method: 'POST' }), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(mockSpawn).toHaveBeenCalledWith('npx', ['playwright', 'show-trace', '/resolved/trace.zip'], {
+      streamLogs: true,
+      prefixLogs: true,
+      logPrefix: 'trace-viewer-trtc-1',
+      captureOutput: false,
+    })
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({
+      success: true,
+      message: 'Trace viewer launched successfully',
+      processName: 'trace-viewer-trtc-1',
+    })
+  })
+})

package/templates/default/src/app/api/test-runs/[runId]/trace/[testCaseId]/route.ts

@@ -1,146 +1,146 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { promises as fs } from 'fs'
-import { taskSpawner } from '@/lib/process/task-spawner'
-import prisma from '@/config/db-config'
-import { resolveStoredPath } from '@/lib/automation/paths'
-
-// Ensure this route runs in Node.js runtime (not Edge) for singleton to work
-export const runtime = 'nodejs'
-
-/**
- * GET handler for checking if trace viewer is running
- *
- * This endpoint checks if a trace viewer process is currently running for a test case.
- */
-export async function GET(
-  request: NextRequest,
-  { params }: { params: Promise<{ runId: string; testCaseId: string }> },
-) {
-  const { runId, testCaseId } = await params
-
-  try {
-    // Verify test run exists
-    const testRun = await prisma.testRun.findUnique({
-      where: { runId },
-      include: {
-        testCases: {
-          where: { id: testCaseId },
-        },
-      },
-    })
-
-    if (!testRun) {
-      return NextResponse.json({ error: 'Test run not found' }, { status: 404 })
-    }
-
-    // Verify test case belongs to this test run
-    const testRunTestCase = testRun.testCases.find(tc => tc.id === testCaseId)
-    if (!testRunTestCase) {
-      return NextResponse.json({ error: 'Test case not found in this test run' }, { status: 404 })
-    }
-
-    // Check if trace viewer process is running
-    const processName = `trace-viewer-${testCaseId}`
-    const process = taskSpawner.getProcess(processName)
-    const isRunning = process?.isRunning ?? false
-
-    return NextResponse.json({
-      isRunning,
-      processName: isRunning ? processName : null,
-    })
-  } catch (error) {
-    console.error(
-      `[TraceViewer] Error checking trace viewer status for runId: ${runId}, testCaseId: ${testCaseId}:`,
-      error,
-    )
-    return NextResponse.json(
-      {
-        error: `Failed to check trace viewer status: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      },
-      { status: 500 },
-    )
-  }
-}
-
-/**
- * POST handler for spawning Playwright trace viewer
- *
- * This endpoint spawns a process to open the Playwright trace viewer for a failed test scenario.
- * The process is self-closing and doesn't require cleanup.
- *
- * Security: Verifies test run and test case exist and belong together before allowing access.
- * TODO: Add user authentication check when authentication is implemented.
- */
-export async function POST(
-  request: NextRequest,
-  { params }: { params: Promise<{ runId: string; testCaseId: string }> },
-) {
-  const { runId, testCaseId } = await params
-
-  try {
-    // Verify test run exists
-    const testRun = await prisma.testRun.findUnique({
-      where: { runId },
-      include: {
-        testCases: {
-          where: { id: testCaseId },
-          include: {
-            testCase: true,
-          },
-        },
-      },
-    })
-
-    if (!testRun) {
-      return NextResponse.json({ error: 'Test run not found' }, { status: 404 })
-    }
-
-    // Verify test case belongs to this test run
-    const testRunTestCase = testRun.testCases.find(tc => tc.id === testCaseId)
-    if (!testRunTestCase) {
-      return NextResponse.json({ error: 'Test case not found in this test run' }, { status: 404 })
-    }
-
-    // Get trace path from database
-    const tracePath = testRunTestCase.tracePath
-    if (!tracePath) {
-      return NextResponse.json({ error: 'No trace path available for this test case' }, { status: 400 })
-    }
-
-    const absoluteTracePath = resolveStoredPath(tracePath)
-
-    // Validate trace file exists
-    try {
-      await fs.access(absoluteTracePath)
-    } catch {
-      return NextResponse.json({ error: `Trace file not found at path: ${tracePath}` }, { status: 404 })
-    }
-
-    // Spawn playwright show-trace command
-    // The process is self-closing when the user closes the trace viewer
-    const spawnedProcess = await taskSpawner.spawn('npx', ['playwright', 'show-trace', absoluteTracePath], {
-      streamLogs: true,
-      prefixLogs: true,
-      logPrefix: `trace-viewer-${testCaseId}`,
-      captureOutput: false, // No need to capture output for trace viewer
-    })
-
-    console.log(
-      `[TraceViewer] Spawned trace viewer process for testCaseId: ${testCaseId}, tracePath: ${absoluteTracePath}`,
-    )
-
-    return NextResponse.json({
-      success: true,
-      message: 'Trace viewer launched successfully',
-      processName: spawnedProcess.name,
-    })
-  } catch (error) {
-    console.error(`[TraceViewer] Error spawning trace viewer for runId: ${runId}, testCaseId: ${testCaseId}:`, error)
-    return NextResponse.json(
-      {
-        error: `Failed to spawn trace viewer: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      },
-      { status: 500 },
-    )
-  }
-}
+import { NextRequest, NextResponse } from 'next/server'
+import { promises as fs } from 'fs'
+import { taskSpawner } from '@/lib/process/task-spawner'
+import prisma from '@/config/db-config'
+import { resolveStoredPath } from '@/lib/automation/automation-path-roots'
+
+// Ensure this route runs in Node.js runtime (not Edge) for singleton to work
+export const runtime = 'nodejs'
+
+/**
+ * GET handler for checking if trace viewer is running
+ *
+ * This endpoint checks if a trace viewer process is currently running for a test case.
+ */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ runId: string; testCaseId: string }> },
+) {
+  const { runId, testCaseId } = await params
+
+  try {
+    // Verify test run exists
+    const testRun = await prisma.testRun.findUnique({
+      where: { runId },
+      include: {
+        testCases: {
+          where: { id: testCaseId },
+        },
+      },
+    })
+
+    if (!testRun) {
+      return NextResponse.json({ error: 'Test run not found' }, { status: 404 })
+    }
+
+    // Verify test case belongs to this test run
+    const testRunTestCase = testRun.testCases.find(tc => tc.id === testCaseId)
+    if (!testRunTestCase) {
+      return NextResponse.json({ error: 'Test case not found in this test run' }, { status: 404 })
+    }
+
+    // Check if trace viewer process is running
+    const processName = `trace-viewer-${testCaseId}`
+    const process = taskSpawner.getProcess(processName)
+    const isRunning = process?.isRunning ?? false
+
+    return NextResponse.json({
+      isRunning,
+      processName: isRunning ? processName : null,
+    })
+  } catch (error) {
+    console.error(
+      `[TraceViewer] Error checking trace viewer status for runId: ${runId}, testCaseId: ${testCaseId}:`,
+      error,
+    )
+    return NextResponse.json(
+      {
+        error: `Failed to check trace viewer status: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      },
+      { status: 500 },
+    )
+  }
+}
+
+/**
+ * POST handler for spawning Playwright trace viewer
+ *
+ * This endpoint spawns a process to open the Playwright trace viewer for a failed test scenario.
+ * The process is self-closing and doesn't require cleanup.
+ *
+ * Security: Verifies test run and test case exist and belong together before allowing access.
+ * TODO: Add user authentication check when authentication is implemented.
+ */
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ runId: string; testCaseId: string }> },
+) {
+  const { runId, testCaseId } = await params
+
+  try {
+    // Verify test run exists
+    const testRun = await prisma.testRun.findUnique({
+      where: { runId },
+      include: {
+        testCases: {
+          where: { id: testCaseId },
+          include: {
+            testCase: true,
+          },
+        },
+      },
+    })
+
+    if (!testRun) {
+      return NextResponse.json({ error: 'Test run not found' }, { status: 404 })
+    }
+
+    // Verify test case belongs to this test run
+    const testRunTestCase = testRun.testCases.find(tc => tc.id === testCaseId)
+    if (!testRunTestCase) {
+      return NextResponse.json({ error: 'Test case not found in this test run' }, { status: 404 })
+    }
+
+    // Get trace path from database
+    const tracePath = testRunTestCase.tracePath
+    if (!tracePath) {
+      return NextResponse.json({ error: 'No trace path available for this test case' }, { status: 400 })
+    }
+
+    const absoluteTracePath = resolveStoredPath(tracePath)
+
+    // Validate trace file exists
+    try {
+      await fs.access(absoluteTracePath)
+    } catch {
+      return NextResponse.json({ error: `Trace file not found at path: ${tracePath}` }, { status: 404 })
+    }
+
+    // Spawn playwright show-trace command
+    // The process is self-closing when the user closes the trace viewer
+    const spawnedProcess = await taskSpawner.spawn('npx', ['playwright', 'show-trace', absoluteTracePath], {
+      streamLogs: true,
+      prefixLogs: true,
+      logPrefix: `trace-viewer-${testCaseId}`,
+      captureOutput: false, // No need to capture output for trace viewer
+    })
+
+    console.log(
+      `[TraceViewer] Spawned trace viewer process for testCaseId: ${testCaseId}, tracePath: ${absoluteTracePath}`,
+    )
+
+    return NextResponse.json({
+      success: true,
+      message: 'Trace viewer launched successfully',
+      processName: spawnedProcess.name,
+    })
+  } catch (error) {
+    console.error(`[TraceViewer] Error spawning trace viewer for runId: ${runId}, testCaseId: ${testCaseId}:`, error)
+    return NextResponse.json(
+      {
+        error: `Failed to spawn trace viewer: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      },
+      { status: 500 },
+    )
+  }
+}