create-appraisejs 0.2.0 → 0.3.0-alpha.1

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

@@ -1,616 +0,0 @@
-'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> {
-  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
-      }
-    }
-
-    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[],
-    }
-  } catch (error) {
-    console.error('[ReportActions] Error fetching all reports:', error)
-    return {
-      status: 500,
-      error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    }
-  }
-}
-
-/**
- * Gets a report by ID with all related data
- */
-export const getReportByIdAction = async (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',
-      }
-    }
-
-    return {
-      status: 200,
-      data: report as ReportDetailWithRelations,
-    }
-  } 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'}`,
-    }
-  }
-}
-
-/**
- * Gets the test case metrics for a report
- */
-export const getAllTestCaseMetricsAction = async (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)
-    }
-    return {
-      status: 200,
-      data: testCaseMetrics,
-    }
-  } catch (error) {
-    console.error(`[ReportActions] Error fetching all test case metrics:`, error)
-    return {
-      status: 500,
-      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> => {
-  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,
-      )
-    }
-    return {
-      status: 200,
-      data: testSuiteMetrics,
-    }
-  } catch (error) {
-    console.error(`[ReportActions] Error fetching all test suite metrics:`, error)
-    return {
-      status: 500,
-      error: `Server error occurred: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    }
-  }
-}