create-appraisejs 0.2.0 → 0.3.0-alpha.0

package/templates/default/src/actions/reports/report-actions.ts

@@ -1,615 +1,78 @@
 'use server'
 
 import { ActionResponse } from '@/types/form/actionHandler'
-import prisma from '@/config/db-config'
-import { parseCucumberReport, getStepStatusEnum, getStepKeywordEnum } from '@/lib/test-run/report-parser'
-import { Prisma } from '@prisma/client'
-import { existsSync } from 'fs'
-import { updateTestSuiteMetrics } from '@/lib/metrics/metric-calculator'
-import { resolveStoredPath, toProjectRelativePath } from '@/lib/automation/paths'
-import { findMatchingTestRunTestCase } from '@/lib/test-run/matching'
-
-/**
- * Type for report with all relations from getAllReportsAction
- */
-type ReportWithRelations = Prisma.ReportGetPayload<{
-  include: {
-    testRun: {
-      include: {
-        environment: true
-        tags: true
-      }
-    }
-    testCases: {
-      include: {
-        testRunTestCase: {
-          include: {
-            testCase: {
-              include: {
-                tags: true
-              }
-            }
-            testSuite: true
-          }
-        }
-        reportScenario: {
-          include: {
-            reportFeature: true
-          }
-        }
-      }
-    }
-  }
-}>
-
-/**
- * Type for report with all relations from getReportByIdAction
- */
-type ReportDetailWithRelations = Prisma.ReportGetPayload<{
-  include: {
-    testRun: {
-      include: {
-        environment: true
-        tags: true
-      }
-    }
-    features: {
-      include: {
-        tags: true
-        scenarios: {
-          include: {
-            tags: true
-            steps: true
-            hooks: true
-          }
-        }
-      }
-    }
-    testCases: {
-      include: {
-        testRunTestCase: {
-          include: {
-            testCase: {
-              include: {
-                tags: true
-              }
-            }
-            testSuite: true
-          }
-        }
-        reportScenario: {
-          include: {
-            reportFeature: true
-          }
-        }
-      }
-    }
-  }
-}>
-
-/**
- * Stores a cucumber.json report in the database
- * Parses the report file and creates all related records (features, scenarios, steps, hooks, tags)
- *
- * @param testRunId - The test run ID (runId, not id)
- * @param reportPath - Path to the cucumber.json file
- * @returns ActionResponse indicating success or failure
- */
-export async function storeReportFromFile(testRunId: string, reportPath: string): Promise<ActionResponse> {
+import {
+  getAllTestCaseMetricsForFilter,
+  getAllTestSuiteMetricsForFilter,
+  getReportByIdOrThrow,
+  listReports,
+} from '@/services/report/report-service'
+import { ServiceError, serviceErrorToActionResponse, unknownErrorToActionResponse } from '@/services/shared/errors'
+
+export async function getAllReportsAction(): Promise<ActionResponse> {
   try {
-    const resolvedReportPath = resolveStoredPath(reportPath)
-
-    // Check if file exists
-    if (!existsSync(resolvedReportPath)) {
-      console.warn(`[ReportActions] Report file not found at ${reportPath} for testRunId: ${testRunId}`)
-      return {
-        status: 404,
-        error: `Report file not found at ${reportPath}`,
-      }
-    }
-
-    // Find the test run
-    const testRun = await prisma.testRun.findUnique({
-      where: { runId: testRunId },
-      include: {
-        testCases: {
-          include: {
-            testCase: {
-              include: {
-                tags: true,
-              },
-            },
-            testSuite: {
-              include: {
-                tags: true,
-              },
-            },
-          },
-        },
-      },
-    })
-
-    if (!testRun) {
-      return {
-        status: 404,
-        error: `Test run not found for runId: ${testRunId}`,
-      }
-    }
-
-    // Parse the report
-    const parsedReport = await parseCucumberReport(resolvedReportPath)
-
-    // Create Report record
-    const report = await prisma.report.create({
-      data: {
-        name: `Test Run Report - ${testRun.name}`,
-        description: `Report for test run: ${testRun.name}`,
-        reportPath: toProjectRelativePath(reportPath),
-        testRunId: testRun.id,
-      },
-    })
-
-    // Track test case IDs that were matched and executed
-    const executedSuiteIds = new Set<string>()
-    const executedLegacyTestCaseIds = new Set<string>()
-
-    // Process each feature
-    for (const feature of parsedReport.features) {
-      // Create ReportFeature
-      const reportFeature = await prisma.reportFeature.create({
-        data: {
-          reportId: report.id,
-          name: feature.name,
-          description: feature.description,
-          uri: feature.uri,
-          line: feature.line,
-          keyword: feature.keyword,
-        },
-      })
-
-      // Create feature tags
-      for (const tag of feature.tags) {
-        await prisma.reportFeatureTag.create({
-          data: {
-            reportFeatureId: reportFeature.id,
-            tagName: tag.name,
-            line: tag.line,
-          },
-        })
-      }
-
-      // Process each scenario
-      for (const scenario of feature.scenarios) {
-        // Create ReportScenario
-        const reportScenario = await prisma.reportScenario.create({
-          data: {
-            reportFeatureId: reportFeature.id,
-            name: scenario.name,
-            description: scenario.description,
-            line: scenario.line,
-            keyword: scenario.keyword,
-            type: scenario.type,
-            cucumberId: scenario.cucumberId,
-          },
-        })
-
-        // Create scenario tags
-        for (const tag of scenario.tags) {
-          await prisma.reportScenarioTag.create({
-            data: {
-              reportScenarioId: reportScenario.id,
-              tagName: tag.name,
-              line: tag.line,
-            },
-          })
-        }
-
-        // Create steps
-        for (const step of scenario.steps) {
-          await prisma.reportStep.create({
-            data: {
-              reportScenarioId: reportScenario.id,
-              keyword: getStepKeywordEnum(step.keyword),
-              line: step.line,
-              name: step.name,
-              matchLocation: step.matchLocation,
-              status: getStepStatusEnum(step.status),
-              duration: String(step.duration),
-              errorMessage: step.errorMessage,
-              errorTrace: step.errorTrace,
-              screenshotPath: step.screenshotPath ? toProjectRelativePath(step.screenshotPath) : null,
-              hidden: step.hidden,
-              order: step.order,
-            },
-          })
-        }
-
-        // Create hooks
-        for (const hook of scenario.hooks) {
-          await prisma.reportHook.create({
-            data: {
-              reportScenarioId: reportScenario.id,
-              keyword: getStepKeywordEnum(hook.keyword),
-              status: getStepStatusEnum(hook.status),
-              duration: String(hook.duration),
-              errorMessage: hook.errorMessage,
-              errorTrace: hook.errorTrace,
-              hidden: hook.hidden,
-            },
-          })
-        }
-
-        // Try to match scenario to test case
-        // Method 1: Extract test case title from scenario name (format: "[Title] Description")
-        const matchedTestCase = findMatchingTestRunTestCase(testRun.testCases, {
-          scenarioName: scenario.name,
-          scenarioTags: scenario.tags.map(tag => tag.name),
-        })
-
-        // If we found a matching test case, create ReportTestCase link
-        if (matchedTestCase) {
-          if (matchedTestCase.testSuiteId) {
-            executedSuiteIds.add(matchedTestCase.testSuiteId)
-          } else {
-            executedLegacyTestCaseIds.add(matchedTestCase.testCaseId)
-          }
-
-          // Calculate scenario duration
-          const scenarioDuration =
-            scenario.steps.reduce((total, step) => total + step.duration, 0) +
-            scenario.hooks.reduce((total, hook) => total + hook.duration, 0)
-
-          await prisma.reportTestCase.create({
-            data: {
-              reportId: report.id,
-              testCaseId: matchedTestCase.testCaseId,
-              testRunTestCaseId: matchedTestCase.id,
-              reportScenarioId: reportScenario.id,
-              duration: String(scenarioDuration),
-            },
-          })
-        }
-      }
-    }
-
-    // Update test suite metrics for all test suites that had test cases executed
-    // This serves as a backup to ensure metrics are updated even if updateTestSuitesForTestRun missed some
-    if (executedSuiteIds.size > 0 || executedLegacyTestCaseIds.size > 0) {
-      try {
-        const executedAt = testRun.completedAt || testRun.startedAt || new Date()
-        const allSuiteIds = new Set(executedSuiteIds)
-
-        if (executedLegacyTestCaseIds.size > 0) {
-          const legacyTestCases = await prisma.testCase.findMany({
-            where: {
-              id: {
-                in: Array.from(executedLegacyTestCaseIds),
-              },
-            },
-            include: {
-              TestSuite: true,
-            },
-          })
-
-          legacyTestCases.forEach(testCase => {
-            testCase.TestSuite.forEach(testSuite => {
-              allSuiteIds.add(testSuite.id)
-            })
-          })
-        }
-
-        for (const suiteId of allSuiteIds) {
-          await updateTestSuiteMetrics(suiteId, executedAt)
-        }
-
-        if (allSuiteIds.size > 0) {
-          console.log(
-            `[ReportActions] Updated test suite metrics for ${allSuiteIds.size} executed suite(s)`,
-          )
-        }
-      } catch (error) {
-        console.error(
-          `[ReportActions] Error updating test suite metrics after storing report: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        )
-        // Don't fail the report storage if metrics update fails
-      }
-    }
+    const reports = await listReports()
 
     return {
       status: 200,
-      message: 'Report stored successfully',
-      data: { reportId: report.id },
-    }
-  } catch (error) {
-    console.error(`[ReportActions] Error storing report from file ${reportPath}:`, error)
-    return {
-      status: 500,
-      error: `Failed to store report: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    }
-  }
-}
-
-/**
- * Gets all reports from the database
- */
-export const getAllReportsAction = async (): Promise<ActionResponse> => {
-  try {
-    const reports = await prisma.report.findMany({
-      include: {
-        testRun: {
-          include: {
-            environment: true,
-            tags: true,
-          },
-        },
-        testCases: {
-          include: {
-            testRunTestCase: {
-              include: {
-                testCase: {
-                  include: {
-                    tags: true,
-                  },
-                },
-                testSuite: true,
-              },
-            },
-            reportScenario: {
-              include: {
-                reportFeature: true,
-              },
-            },
-          },
-        },
-      },
-      orderBy: {
-        createdAt: 'desc',
-      },
-    })
-
-    return {
-      status: 200,
-      data: reports as ReportWithRelations[],
+      success: true,
+      data: reports,
     }
   } catch (error) {
     console.error('[ReportActions] Error fetching all reports:', error)
-    return {
-      status: 500,
-      error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    }
+    return unknownErrorToActionResponse(error)
   }
 }
 
-/**
- * Gets a report by ID with all related data
- */
-export const getReportByIdAction = async (reportId: string): Promise<ActionResponse> => {
+export async function getReportByIdAction(reportId: string): Promise<ActionResponse> {
   try {
-    const report = await prisma.report.findUnique({
-      where: { id: reportId },
-      include: {
-        testRun: {
-          include: {
-            environment: true,
-            tags: true,
-          },
-        },
-        features: {
-          include: {
-            tags: true,
-            scenarios: {
-              include: {
-                tags: true,
-                steps: {
-                  orderBy: {
-                    order: 'asc',
-                  },
-                },
-                hooks: true,
-              },
-            },
-          },
-        },
-        testCases: {
-          include: {
-            testRunTestCase: {
-              include: {
-                testCase: {
-                  include: {
-                    tags: true,
-                  },
-                },
-                testSuite: true,
-              },
-            },
-            reportScenario: {
-              include: {
-                reportFeature: true,
-                tags: true,
-                steps: {
-                  orderBy: {
-                    order: 'asc',
-                  },
-                },
-                hooks: true,
-              },
-            },
-          },
-        },
-      },
-    })
-
-    if (!report) {
-      return {
-        status: 404,
-        error: 'Report not found',
-      }
-    }
+    const report = await getReportByIdOrThrow(reportId)
 
     return {
       status: 200,
-      data: report as ReportDetailWithRelations,
+      success: true,
+      data: report,
     }
   } catch (error) {
     console.error(`[ReportActions] Error fetching report ${reportId}:`, error)
-    return {
-      status: 500,
-      error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    }
-  }
-}
-
-/**
- * Gets a report by test run ID
- */
-export const getReportByTestRunIdAction = async (testRunId: string): Promise<ActionResponse> => {
-  try {
-    // Find test run by runId
-    const testRun = await prisma.testRun.findUnique({
-      where: { runId: testRunId },
-      select: { id: true },
-    })
-
-    if (!testRun) {
-      return {
-        status: 404,
-        error: 'Test run not found',
-      }
-    }
-
-    // Find report by testRun.id
-    const report = await prisma.report.findFirst({
-      where: { testRunId: testRun.id },
-      include: {
-        testRun: {
-          include: {
-            environment: true,
-            tags: true,
-          },
-        },
-        features: {
-          include: {
-            tags: true,
-            scenarios: {
-              include: {
-                tags: true,
-                steps: {
-                  orderBy: {
-                    order: 'asc',
-                  },
-                },
-                hooks: true,
-              },
-            },
-          },
-        },
-        testCases: {
-          include: {
-            testRunTestCase: {
-              include: {
-                testCase: {
-                  include: {
-                    tags: true,
-                  },
-                },
-                testSuite: true,
-              },
-            },
-            reportScenario: {
-              include: {
-                reportFeature: true,
-              },
-            },
-          },
-        },
-      },
-    })
-
-    if (!report) {
-      return {
-        status: 404,
-        error: 'Report not found for this test run',
-      }
-    }
-
-    return {
-      status: 200,
-      data: report as ReportDetailWithRelations,
-    }
-  } catch (error) {
-    console.error(`[ReportActions] Error fetching report for testRunId ${testRunId}:`, error)
-    return {
-      status: 500,
-      error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    if (error instanceof ServiceError) {
+      return serviceErrorToActionResponse(error)
     }
+    return unknownErrorToActionResponse(error)
   }
 }
 
-/**
- * Gets the test case metrics for a report
- */
-export const getAllTestCaseMetricsAction = async (filter: string): Promise<ActionResponse> => {
+export async function getAllTestCaseMetricsAction(filter: string): Promise<ActionResponse> {
   try {
-    let testCaseMetrics = await prisma.testCaseMetrics.findMany({
-      include: {
-        testCase: {
-          include: {
-            tags: true,
-          },
-        },
-      },
-    })
-    if (filter === 'repeatedlyFailing') {
-      testCaseMetrics = testCaseMetrics.filter(tc => tc.isRepeatedlyFailing)
-    } else if (filter === 'flaky') {
-      testCaseMetrics = testCaseMetrics.filter(tc => tc.isFlaky)
-    }
+    const testCaseMetrics = await getAllTestCaseMetricsForFilter(filter)
     return {
       status: 200,
+      success: true,
       data: testCaseMetrics,
     }
   } catch (error) {
     console.error(`[ReportActions] Error fetching all test case metrics:`, error)
     return {
       status: 500,
+      success: false,
       error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
     }
   }
 }
 
-/**
- * Gets the test suite metrics for a report
- */
-export const getAllTestSuiteMetricsAction = async (filter: string): Promise<ActionResponse> => {
+export async function getAllTestSuiteMetricsAction(filter: string): Promise<ActionResponse> {
   try {
-    let testSuiteMetrics = await prisma.testSuiteMetrics.findMany({
-      include: {
-        testSuite: {
-          include: {
-            tags: true,
-            testCases: true,
-          },
-        },
-      },
-    })
-    if (filter === 'notExecutedRecently') {
-      // Calculate the date threshold for recent runs (7 days ago)
-      const recentPeriodDate = new Date()
-      recentPeriodDate.setDate(recentPeriodDate.getDate() - 7)
-
-      // Filter for suites that have never been executed OR were executed more than 7 days ago
-      testSuiteMetrics = testSuiteMetrics.filter(
-        ts => ts.lastExecutedAt === null || ts.lastExecutedAt < recentPeriodDate,
-      )
-    }
+    const testSuiteMetrics = await getAllTestSuiteMetricsForFilter(filter)
     return {
       status: 200,
+      success: true,
       data: testSuiteMetrics,
     }
   } catch (error) {
     console.error(`[ReportActions] Error fetching all test suite metrics:`, error)
     return {
       status: 500,
+      success: false,
       error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
     }
   }

package/templates/default/src/actions/settings/sync-actions.test.ts

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('next/cache', () => ({
+  revalidatePath: vi.fn(),
+}))
+
+vi.mock('@/lib/sync/sync-executor', () => ({
+  runRequestedSync: vi.fn(),
+}))
+
+vi.mock('@/lib/sync/sync-pending-counts', () => ({
+  getSyncPendingCounts: vi.fn(),
+}))
+
+import { revalidatePath } from 'next/cache'
+import { runRequestedSync } from '@/lib/sync/sync-executor'
+import { runSyncAction } from './sync-actions'
+
+describe('runSyncAction', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('rejects an invalid sync request id without executing anything', async () => {
+    const result = await runSyncAction('not-a-sync-target')
+
+    expect(result).toEqual({
+      requestedScriptId: 'not-a-sync-target',
+      executedScriptIds: [],
+      success: false,
+      exitCode: 400,
+      durationMs: 0,
+      cause: 'Invalid sync target requested.',
+    })
+    expect(runRequestedSync).not.toHaveBeenCalled()
+    expect(revalidatePath).not.toHaveBeenCalled()
+  })
+
+  it('revalidates settings after a successful sync request', async () => {
+    vi.mocked(runRequestedSync).mockResolvedValue({
+      requestedScriptId: 'sync-tags',
+      executedScriptIds: ['sync-tags'],
+      success: true,
+      durationMs: 12,
+    })
+
+    const result = await runSyncAction('sync-tags')
+
+    expect(result).toEqual({
+      requestedScriptId: 'sync-tags',
+      executedScriptIds: ['sync-tags'],
+      success: true,
+      durationMs: 12,
+    })
+    expect(runRequestedSync).toHaveBeenCalledWith('sync-tags')
+    expect(revalidatePath).toHaveBeenCalledWith('/settings')
+  })
+})