create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/starter/src/lib/locator-picker/suggestions.ts

@@ -1,6 +1,9 @@
 import type { LocatorPickerGroupSuggestion, PickedLocatorPayload } from '@/types/locator-picker'
 import type { LocatorGroup, Module } from '@prisma/client'
 
+type SuggestionLocatorGroup = Pick<LocatorGroup, 'id' | 'name' | 'route' | 'moduleId'>
+type SuggestionModule = Pick<Module, 'id' | 'name' | 'parentId'>
+
 function normalizeText(value: string | null | undefined): string {
   return (value ?? '').replace(/\s+/g, ' ').trim()
 }
@@ -33,11 +36,11 @@ export function normalizeRoute(value: string | null | undefined): string {
   }
 }
 
-function buildModulePathMap(modules: Module[]): Map<string, string> {
+function buildModulePathMap(modules: SuggestionModule[]): Map<string, string> {
   const moduleById = new Map(modules.map(moduleRecord => [moduleRecord.id, moduleRecord]))
   const pathByModuleId = new Map<string, string>()
 
-  const buildPath = (moduleRecord: Module): string => {
+  const buildPath = (moduleRecord: SuggestionModule): string => {
     const cached = pathByModuleId.get(moduleRecord.id)
     if (cached) {
       return cached
@@ -77,8 +80,8 @@ export function suggestLocatorName(payload?: PickedLocatorPayload): string {
 export function inferGroupSuggestion(
   routeValue: string,
   pageTitle: string,
-  locatorGroups: LocatorGroup[],
-  modules: Module[],
+  locatorGroups: SuggestionLocatorGroup[],
+  modules: SuggestionModule[],
 ): LocatorPickerGroupSuggestion {
   const route = normalizeRoute(routeValue)
   const exactMatch = locatorGroups.find(group => normalizeRoute(group.route) === route)

package/templates/starter/src/lib/metrics/metric-calculator.test.ts

@@ -0,0 +1,156 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { TestRunTestCaseResult, TestRunTestCaseStatus } from '@prisma/client'
+
+const { mockTestRunTestCaseFindMany, mockTestRunTestCaseFindFirst, mockTestCaseMetricsUpsert } = vi.hoisted(() => ({
+  mockTestRunTestCaseFindMany: vi.fn(),
+  mockTestRunTestCaseFindFirst: vi.fn(),
+  mockTestCaseMetricsUpsert: vi.fn(),
+}))
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    testRunTestCase: {
+      findMany: mockTestRunTestCaseFindMany,
+      findFirst: mockTestRunTestCaseFindFirst,
+    },
+    testCaseMetrics: {
+      findUnique: vi.fn(),
+      upsert: mockTestCaseMetricsUpsert,
+      count: vi.fn(),
+    },
+    testSuiteMetrics: {
+      upsert: vi.fn(),
+      count: vi.fn(),
+    },
+    testRun: {
+      count: vi.fn(),
+      findUnique: vi.fn(),
+    },
+    dashboardMetrics: {
+      findFirst: vi.fn(),
+      update: vi.fn(),
+      create: vi.fn(),
+    },
+  },
+}))
+
+import { recalculateTestCaseMetrics } from './metric-calculator'
+
+function completedCase(result: TestRunTestCaseResult, completedAt: Date) {
+  return {
+    result,
+    testRun: {
+      completedAt,
+    },
+  }
+}
+
+describe('recalculateTestCaseMetrics', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2026-05-12T00:00:00.000Z'))
+    vi.clearAllMocks()
+    mockTestCaseMetricsUpsert.mockResolvedValue({})
+    mockTestRunTestCaseFindFirst.mockResolvedValue(null)
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('summarizes recent runs and records recent execution dates', async () => {
+    const failedAt = new Date('2026-05-11T00:00:00.000Z')
+    const previousFailureAt = new Date('2026-05-10T00:00:00.000Z')
+    const passedAt = new Date('2026-05-09T00:00:00.000Z')
+    mockTestRunTestCaseFindMany.mockResolvedValue([
+      completedCase(TestRunTestCaseResult.FAILED, failedAt),
+      completedCase(TestRunTestCaseResult.FAILED, previousFailureAt),
+      completedCase(TestRunTestCaseResult.PASSED, passedAt),
+    ])
+
+    await recalculateTestCaseMetrics('tc-1')
+
+    expect(mockTestRunTestCaseFindMany).toHaveBeenCalledTimes(1)
+    expect(mockTestRunTestCaseFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          testCaseId: 'tc-1',
+          status: TestRunTestCaseStatus.COMPLETED,
+        }),
+      }),
+    )
+    expect(mockTestCaseMetricsUpsert).toHaveBeenCalledWith({
+      where: { testCaseId: 'tc-1' },
+      create: expect.objectContaining({
+        testCaseId: 'tc-1',
+        lastExecutedAt: failedAt,
+        lastFailedAt: failedAt,
+        lastPassedAt: passedAt,
+        consecutiveFailures: 2,
+        failedRecentRuns: 2,
+        totalRecentRuns: 3,
+        failureRate: 2 / 3,
+        isFlaky: true,
+        isRepeatedlyFailing: false,
+      }),
+      update: expect.objectContaining({
+        lastExecutedAt: failedAt,
+        lastFailedAt: failedAt,
+        lastPassedAt: passedAt,
+        consecutiveFailures: 2,
+        failedRecentRuns: 2,
+        totalRecentRuns: 3,
+        failureRate: 2 / 3,
+        isFlaky: true,
+        isRepeatedlyFailing: false,
+      }),
+    })
+  })
+
+  it('falls back to older executions when recent runs do not provide dates', async () => {
+    const olderPassAt = new Date('2026-04-20T00:00:00.000Z')
+    const olderFailureAt = new Date('2026-04-19T00:00:00.000Z')
+    mockTestRunTestCaseFindMany
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce([completedCase(TestRunTestCaseResult.PASSED, olderPassAt)])
+    mockTestRunTestCaseFindFirst.mockResolvedValue(completedCase(TestRunTestCaseResult.FAILED, olderFailureAt))
+
+    await recalculateTestCaseMetrics('tc-2')
+
+    expect(mockTestRunTestCaseFindMany).toHaveBeenCalledTimes(2)
+    expect(mockTestRunTestCaseFindFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          testCaseId: 'tc-2',
+          result: TestRunTestCaseResult.FAILED,
+        }),
+      }),
+    )
+    expect(mockTestCaseMetricsUpsert).toHaveBeenCalledWith({
+      where: { testCaseId: 'tc-2' },
+      create: expect.objectContaining({
+        testCaseId: 'tc-2',
+        lastExecutedAt: olderPassAt,
+        lastFailedAt: olderFailureAt,
+        lastPassedAt: olderPassAt,
+        consecutiveFailures: 0,
+        failedRecentRuns: 0,
+        totalRecentRuns: 0,
+        failureRate: 0,
+        isFlaky: false,
+        isRepeatedlyFailing: false,
+      }),
+      update: expect.objectContaining({
+        lastExecutedAt: olderPassAt,
+        lastFailedAt: olderFailureAt,
+        lastPassedAt: olderPassAt,
+        consecutiveFailures: 0,
+        failedRecentRuns: 0,
+        totalRecentRuns: 0,
+        failureRate: 0,
+        isFlaky: false,
+        isRepeatedlyFailing: false,
+      }),
+    })
+  })
+})