create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/blank/src/services/report/report-service.ts

@@ -1,78 +1,35 @@
 import prisma from '@/config/db-config'
-import { parseCucumberReport, getStepStatusEnum, getStepKeywordEnum } from '@/lib/test-run/report-parser'
-import { Prisma } from '@prisma/client'
+import {
+  parseCucumberReport,
+  getStepStatusEnum,
+  getStepKeywordEnum,
+  type ParsedReport,
+} from '@/lib/test-run/report-parser'
+import type { Prisma } from '@prisma/client'
 import { existsSync } from 'fs'
 import { updateTestSuiteMetrics } from '@/lib/metrics/metric-calculator'
 import { resolveStoredPath, toProjectRelativePath } from '@/lib/automation/automation-path-roots'
 import { findMatchingTestRunTestCase } from '@/lib/test-run/matching'
 import { RECENT_PERIOD_DAYS } from '@/services/shared/constants'
 import { ServiceError } from '@/services/shared/errors'
+import type { ReportDetailWithRelations, ReportWithRelations } from '@/types/report'
 
-export 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
-          }
-        }
-      }
-    }
-  }
-}>
+export type StoreReportOutcome =
+  | { success: true; reportId: string }
+  | { success: false; reason: 'file_not_found' | 'test_run_not_found' | 'storage_failed'; message: string }
 
-export type ReportDetailWithRelations = Prisma.ReportGetPayload<{
+type ReportStorageTestRun = Prisma.TestRunGetPayload<{
   include: {
-    testRun: {
-      include: {
-        environment: true
-        tags: true
-      }
-    }
-    features: {
-      include: {
-        tags: true
-        scenarios: {
-          include: {
-            tags: true
-            steps: true
-            hooks: true
-          }
-        }
-      }
-    }
     testCases: {
       include: {
-        testRunTestCase: {
+        testCase: {
           include: {
-            testCase: {
-              include: {
-                tags: true
-              }
-            }
-            testSuite: true
+            tags: true
           }
         }
-        reportScenario: {
+        testSuite: {
           include: {
-            reportFeature: true
+            tags: true
           }
         }
       }
@@ -80,9 +37,13 @@ export type ReportDetailWithRelations = Prisma.ReportGetPayload<{
   }
 }>
 
-export type StoreReportOutcome =
-  | { success: true; reportId: string }
-  | { success: false; reason: 'file_not_found' | 'test_run_not_found' | 'storage_failed'; message: string }
+type ParsedReportFeature = ParsedReport['features'][number]
+type ParsedReportScenario = ParsedReportFeature['scenarios'][number]
+
+type ExecutedTestCaseSets = {
+  suiteIds: Set<string>
+  legacyTestCaseIds: Set<string>
+}
 
 export async function listReports(): Promise<ReportWithRelations[]> {
   const reports = await prisma.report.findMany({
@@ -183,209 +144,260 @@ export async function getReportByIdOrThrow(reportId: string): Promise<ReportDeta
   return report as ReportDetailWithRelations
 }
 
-/**
- * Persists a cucumber.json report and linked graph into the database.
- */
-export async function storeReportFromFileService(testRunId: string, reportPath: string): Promise<StoreReportOutcome> {
-  try {
-    const resolvedReportPath = resolveStoredPath(reportPath)
-
-    if (!existsSync(resolvedReportPath)) {
-      console.warn(`[ReportService] Report file not found at ${reportPath} for testRunId: ${testRunId}`)
-      return {
-        success: false,
-        reason: 'file_not_found',
-        message: `Report file not found at ${reportPath}`,
-      }
-    }
-
-    const testRun = await prisma.testRun.findUnique({
-      where: { runId: testRunId },
-      include: {
-        testCases: {
-          include: {
-            testCase: {
-              include: {
-                tags: true,
-              },
+async function getReportStorageTestRun(testRunId: string) {
+  return prisma.testRun.findUnique({
+    where: { runId: testRunId },
+    include: {
+      testCases: {
+        include: {
+          testCase: {
+            include: {
+              tags: true,
             },
-            testSuite: {
-              include: {
-                tags: true,
-              },
+          },
+          testSuite: {
+            include: {
+              tags: true,
             },
           },
         },
       },
+    },
+  })
+}
+
+async function createReportShell(testRun: ReportStorageTestRun, reportPath: string) {
+  return prisma.report.create({
+    data: {
+      name: `Test Run Report - ${testRun.name}`,
+      description: `Report for test run: ${testRun.name}`,
+      reportPath: toProjectRelativePath(reportPath),
+      testRunId: testRun.id,
+    },
+  })
+}
+
+async function createReportFeature(reportId: string, feature: ParsedReportFeature) {
+  const reportFeature = await prisma.reportFeature.create({
+    data: {
+      reportId,
+      name: feature.name,
+      description: feature.description,
+      uri: feature.uri,
+      line: feature.line,
+      keyword: feature.keyword,
+    },
+  })
+
+  for (const tag of feature.tags) {
+    await prisma.reportFeatureTag.create({
+      data: {
+        reportFeatureId: reportFeature.id,
+        tagName: tag.name,
+        line: tag.line,
+      },
     })
+  }
 
-    if (!testRun) {
-      return {
-        success: false,
-        reason: 'test_run_not_found',
-        message: `Test run not found for runId: ${testRunId}`,
-      }
-    }
+  return reportFeature
+}
 
-    const parsedReport = await parseCucumberReport(resolvedReportPath)
+async function createReportScenario(reportFeatureId: string, scenario: ParsedReportScenario) {
+  const reportScenario = await prisma.reportScenario.create({
+    data: {
+      reportFeatureId,
+      name: scenario.name,
+      description: scenario.description,
+      line: scenario.line,
+      keyword: scenario.keyword,
+      type: scenario.type,
+      cucumberId: scenario.cucumberId,
+    },
+  })
 
-    const report = await prisma.report.create({
+  for (const tag of scenario.tags) {
+    await prisma.reportScenarioTag.create({
       data: {
-        name: `Test Run Report - ${testRun.name}`,
-        description: `Report for test run: ${testRun.name}`,
-        reportPath: toProjectRelativePath(reportPath),
-        testRunId: testRun.id,
+        reportScenarioId: reportScenario.id,
+        tagName: tag.name,
+        line: tag.line,
       },
     })
+  }
 
-    const executedSuiteIds = new Set<string>()
-    const executedLegacyTestCaseIds = new Set<string>()
-
-    for (const feature of parsedReport.features) {
-      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,
-        },
-      })
-
-      for (const tag of feature.tags) {
-        await prisma.reportFeatureTag.create({
-          data: {
-            reportFeatureId: reportFeature.id,
-            tagName: tag.name,
-            line: tag.line,
-          },
-        })
-      }
+  return reportScenario
+}
 
-      for (const scenario of feature.scenarios) {
-        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,
-          },
-        })
-
-        for (const tag of scenario.tags) {
-          await prisma.reportScenarioTag.create({
-            data: {
-              reportScenarioId: reportScenario.id,
-              tagName: tag.name,
-              line: tag.line,
-            },
-          })
-        }
+async function createReportScenarioExecutionRows(reportScenarioId: string, scenario: ParsedReportScenario) {
+  for (const step of scenario.steps) {
+    await prisma.reportStep.create({
+      data: {
+        reportScenarioId,
+        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,
+      },
+    })
+  }
 
-        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,
-            },
-          })
-        }
+  for (const hook of scenario.hooks) {
+    await prisma.reportHook.create({
+      data: {
+        reportScenarioId,
+        keyword: getStepKeywordEnum(hook.keyword),
+        status: getStepStatusEnum(hook.status),
+        duration: String(hook.duration),
+        errorMessage: hook.errorMessage,
+        errorTrace: hook.errorTrace,
+        hidden: hook.hidden,
+      },
+    })
+  }
+}
 
-        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,
-            },
-          })
-        }
+function getScenarioDuration(scenario: ParsedReportScenario) {
+  return (
+    scenario.steps.reduce((total, step) => total + step.duration, 0) +
+    scenario.hooks.reduce((total, hook) => total + hook.duration, 0)
+  )
+}
 
-        const matchedTestCase = findMatchingTestRunTestCase(testRun.testCases, {
-          scenarioName: scenario.name,
-          scenarioTags: scenario.tags.map(tag => tag.name),
-        })
+async function linkReportScenarioToTestCase(
+  reportId: string,
+  reportScenarioId: string,
+  scenario: ParsedReportScenario,
+  testRun: ReportStorageTestRun,
+  executedTestCases: ExecutedTestCaseSets,
+) {
+  const matchedTestCase = findMatchingTestRunTestCase(testRun.testCases, {
+    scenarioName: scenario.name,
+    scenarioTags: scenario.tags.map(tag => tag.name),
+  })
 
-        if (matchedTestCase) {
-          if (matchedTestCase.testSuiteId) {
-            executedSuiteIds.add(matchedTestCase.testSuiteId)
-          } else {
-            executedLegacyTestCaseIds.add(matchedTestCase.testCaseId)
-          }
+  if (!matchedTestCase) {
+    return
+  }
 
-          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),
-            },
-          })
-        }
-      }
+  if (matchedTestCase.testSuiteId) {
+    executedTestCases.suiteIds.add(matchedTestCase.testSuiteId)
+  } else {
+    executedTestCases.legacyTestCaseIds.add(matchedTestCase.testCaseId)
+  }
+
+  await prisma.reportTestCase.create({
+    data: {
+      reportId,
+      testCaseId: matchedTestCase.testCaseId,
+      testRunTestCaseId: matchedTestCase.id,
+      reportScenarioId,
+      duration: String(getScenarioDuration(scenario)),
+    },
+  })
+}
+
+async function createParsedReportGraph(reportId: string, parsedReport: ParsedReport, testRun: ReportStorageTestRun) {
+  const executedTestCases: ExecutedTestCaseSets = {
+    suiteIds: new Set<string>(),
+    legacyTestCaseIds: new Set<string>(),
+  }
+
+  for (const feature of parsedReport.features) {
+    const reportFeature = await createReportFeature(reportId, feature)
+
+    for (const scenario of feature.scenarios) {
+      const reportScenario = await createReportScenario(reportFeature.id, scenario)
+      await createReportScenarioExecutionRows(reportScenario.id, scenario)
+      await linkReportScenarioToTestCase(reportId, reportScenario.id, scenario, testRun, executedTestCases)
     }
+  }
 
-    if (executedSuiteIds.size > 0 || executedLegacyTestCaseIds.size > 0) {
-      try {
-        const executedAt = testRun.completedAt || testRun.startedAt || new Date()
-        const allSuiteIds = new Set(executedSuiteIds)
+  return executedTestCases
+}
 
-        if (executedLegacyTestCaseIds.size > 0) {
-          const legacyTestCases = await prisma.testCase.findMany({
-            where: {
-              id: {
-                in: Array.from(executedLegacyTestCaseIds),
-              },
-            },
-            include: {
-              TestSuite: true,
-            },
-          })
+async function getLegacySuiteIds(testCaseIds: Set<string>) {
+  if (testCaseIds.size === 0) {
+    return []
+  }
 
-          legacyTestCases.forEach(testCase => {
-            testCase.TestSuite.forEach(testSuite => {
-              allSuiteIds.add(testSuite.id)
-            })
-          })
-        }
+  const legacyTestCases = await prisma.testCase.findMany({
+    where: {
+      id: {
+        in: Array.from(testCaseIds),
+      },
+    },
+    include: {
+      TestSuite: true,
+    },
+  })
 
-        for (const suiteId of allSuiteIds) {
-          await updateTestSuiteMetrics(suiteId, executedAt)
-        }
+  return legacyTestCases.flatMap(testCase => testCase.TestSuite.map(testSuite => testSuite.id))
+}
 
-        if (allSuiteIds.size > 0) {
-          console.log(`[ReportService] Updated test suite metrics for ${allSuiteIds.size} executed suite(s)`)
-        }
-      } catch (error) {
-        console.error(
-          `[ReportService] Error updating test suite metrics after storing report: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        )
+async function updateExecutedSuiteMetrics(testRun: ReportStorageTestRun, executedTestCases: ExecutedTestCaseSets) {
+  if (executedTestCases.suiteIds.size === 0 && executedTestCases.legacyTestCaseIds.size === 0) {
+    return
+  }
+
+  try {
+    const executedAt = testRun.completedAt || testRun.startedAt || new Date()
+    const allSuiteIds = new Set(executedTestCases.suiteIds)
+    const legacySuiteIds = await getLegacySuiteIds(executedTestCases.legacyTestCaseIds)
+
+    legacySuiteIds.forEach(suiteId => allSuiteIds.add(suiteId))
+
+    for (const suiteId of allSuiteIds) {
+      await updateTestSuiteMetrics(suiteId, executedAt)
+    }
+
+    if (allSuiteIds.size > 0) {
+      console.log(`[ReportService] Updated test suite metrics for ${allSuiteIds.size} executed suite(s)`)
+    }
+  } catch (error) {
+    console.error(
+      `[ReportService] Error updating test suite metrics after storing report: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+/**
+ * Persists a cucumber.json report and linked graph into the database.
+ */
+export async function storeReportFromFileService(testRunId: string, reportPath: string): Promise<StoreReportOutcome> {
+  try {
+    const resolvedReportPath = resolveStoredPath(reportPath)
+
+    if (!existsSync(resolvedReportPath)) {
+      console.warn(`[ReportService] Report file not found at ${reportPath} for testRunId: ${testRunId}`)
+      return {
+        success: false,
+        reason: 'file_not_found',
+        message: `Report file not found at ${reportPath}`,
       }
     }
 
+    const testRun = await getReportStorageTestRun(testRunId)
+
+    if (!testRun) {
+      return {
+        success: false,
+        reason: 'test_run_not_found',
+        message: `Test run not found for runId: ${testRunId}`,
+      }
+    }
+
+    const parsedReport = await parseCucumberReport(resolvedReportPath)
+    const report = await createReportShell(testRun, reportPath)
+    const executedTestCases = await createParsedReportGraph(report.id, parsedReport, testRun)
+    await updateExecutedSuiteMetrics(testRun, executedTestCases)
+
     return { success: true, reportId: report.id }
   } catch (error) {
     console.error(`[ReportService] Error storing report from file ${reportPath}:`, error)