create-appraisejs 0.3.0 → 0.3.1-alpha.1

package/templates/starter/src/lib/locator-group-file-utils.ts

@@ -29,7 +29,7 @@ export async function getLocatorGroupFilePath(locatorGroupId: string): Promise<s
   }
 }
 
-export async function generateLocatorGroupContent(locatorGroupId: string): Promise<Record<string, string>> {
+async function generateLocatorGroupContent(locatorGroupId: string): Promise<Record<string, string>> {
   try {
     const locatorGroup = await prisma.locatorGroup.findUnique({
       where: { id: locatorGroupId },
@@ -51,7 +51,7 @@ export async function generateLocatorGroupContent(locatorGroupId: string): Promi
   }
 }
 
-export async function ensureDirectoryExists(filePath: string): Promise<void> {
+async function ensureDirectoryExists(filePath: string): Promise<void> {
   await ensureAutomationWorkspaceReady()
   await fs.mkdir(path.dirname(filePath), { recursive: true })
 }
@@ -144,7 +144,11 @@ async function cleanupEmptyDirectories(filePath: string): Promise<void> {
   let currentDir = path.dirname(filePath)
   const locatorsRoot = getAutomationLocatorsDir()
 
-  while (currentDir.startsWith(locatorsRoot) && currentDir !== locatorsRoot && currentDir !== path.dirname(currentDir)) {
+  while (
+    currentDir.startsWith(locatorsRoot) &&
+    currentDir !== locatorsRoot &&
+    currentDir !== path.dirname(currentDir)
+  ) {
     try {
       const files = await fs.readdir(currentDir)
       if (files.length === 0) {
@@ -176,24 +180,6 @@ export async function createEmptyLocatorGroupFile(locatorGroupId: string): Promi
   }
 }
 
-export async function readLocatorGroupFile(
-  locatorGroupId: string,
-): Promise<{ filePath: string; content: Record<string, string> } | null> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const filePath = await getLocatorGroupFilePath(locatorGroupId)
-    if (!filePath) {
-      return null
-    }
-
-    const fileContent = await fs.readFile(filePath, 'utf-8')
-    return { filePath, content: JSON.parse(fileContent) }
-  } catch (error) {
-    console.error('Error reading locator group file:', error)
-    return null
-  }
-}
-
 export async function updateLocatorMapFile(
   currentLocatorGroupRoute: string,
   newLocatorGroupRoute: string,

package/templates/starter/src/lib/locator-picker/session-manager.ts

@@ -143,8 +143,7 @@ async function cleanupLingeringCompanionSessions(currentSessionId?: string): Pro
     const isTerminal = isTerminalStatus(session.status)
     const shouldTerminate = Boolean(session.companionPid)
     const shouldCloseStaleSession = !session.companionPid && !isTerminal && ageMs > ACTIVE_SESSION_STALE_MS
-    const shouldPruneSessionFile =
-      (isTerminal && ageMs > TERMINAL_SESSION_RETENTION_MS) || shouldCloseStaleSession
+    const shouldPruneSessionFile = (isTerminal && ageMs > TERMINAL_SESSION_RETENTION_MS) || shouldCloseStaleSession
 
     if (shouldTerminate && session.companionPid) {
       await shutdownCompanionProcess(session.companionPid).catch(() => undefined)

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,255 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { TestRunTestCaseResult, TestRunTestCaseStatus } from '@prisma/client'
+
+const {
+  mockTestRunTestCaseFindMany,
+  mockTestRunTestCaseFindFirst,
+  mockTestCaseMetricsUpsert,
+  mockTestCaseCount,
+  mockTestSuiteCount,
+  mockTestRunCount,
+  mockDashboardMetricsFindFirst,
+  mockDashboardMetricsUpdate,
+  mockDashboardMetricsCreate,
+} = vi.hoisted(() => ({
+  mockTestRunTestCaseFindMany: vi.fn(),
+  mockTestRunTestCaseFindFirst: vi.fn(),
+  mockTestCaseMetricsUpsert: vi.fn(),
+  mockTestCaseCount: vi.fn(),
+  mockTestSuiteCount: vi.fn(),
+  mockTestRunCount: vi.fn(),
+  mockDashboardMetricsFindFirst: vi.fn(),
+  mockDashboardMetricsUpdate: vi.fn(),
+  mockDashboardMetricsCreate: vi.fn(),
+}))
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    testRunTestCase: {
+      findMany: mockTestRunTestCaseFindMany,
+      findFirst: mockTestRunTestCaseFindFirst,
+    },
+    testCaseMetrics: {
+      findUnique: vi.fn(),
+      upsert: mockTestCaseMetricsUpsert,
+      count: vi.fn(),
+    },
+    testCase: {
+      count: mockTestCaseCount,
+    },
+    testSuiteMetrics: {
+      upsert: vi.fn(),
+      count: vi.fn(),
+    },
+    testSuite: {
+      count: mockTestSuiteCount,
+    },
+    testRun: {
+      count: mockTestRunCount,
+      findUnique: vi.fn(),
+    },
+    dashboardMetrics: {
+      findFirst: mockDashboardMetricsFindFirst,
+      update: mockDashboardMetricsUpdate,
+      create: mockDashboardMetricsCreate,
+    },
+  },
+}))
+
+import { recalculateTestCaseMetrics, updateDashboardMetrics } 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,
+      }),
+    })
+  })
+})
+
+describe('updateDashboardMetrics', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2026-05-12T00:00:00.000Z'))
+    vi.clearAllMocks()
+    mockTestRunCount.mockResolvedValue(4)
+    mockTestCaseCount.mockResolvedValueOnce(2).mockResolvedValueOnce(1)
+    mockTestSuiteCount.mockResolvedValue(3)
+    mockDashboardMetricsFindFirst.mockResolvedValue({ id: 'dashboard-metrics-1' })
+    mockDashboardMetricsUpdate.mockResolvedValue({})
+    mockDashboardMetricsCreate.mockResolvedValue({})
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('counts attention metrics from live entities instead of orphaned metric rows', async () => {
+    await updateDashboardMetrics()
+
+    expect(mockTestCaseCount).toHaveBeenNthCalledWith(1, {
+      where: {
+        metrics: {
+          is: {
+            isRepeatedlyFailing: true,
+          },
+        },
+      },
+    })
+    expect(mockTestCaseCount).toHaveBeenNthCalledWith(2, {
+      where: {
+        metrics: {
+          is: {
+            isFlaky: true,
+          },
+        },
+      },
+    })
+    expect(mockTestSuiteCount).toHaveBeenCalledWith({
+      where: {
+        OR: [
+          {
+            metrics: {
+              is: null,
+            },
+          },
+          {
+            metrics: {
+              is: {
+                lastExecutedAt: null,
+              },
+            },
+          },
+          {
+            metrics: {
+              is: {
+                lastExecutedAt: {
+                  lt: new Date('2026-05-05T00:00:00.000Z'),
+                },
+              },
+            },
+          },
+        ],
+      },
+    })
+    expect(mockDashboardMetricsUpdate).toHaveBeenCalledWith({
+      where: { id: 'dashboard-metrics-1' },
+      data: expect.objectContaining({
+        failedRecentRunsCount: 4,
+        repeatedlyFailingTestsCount: 2,
+        flakyTestsCount: 1,
+        suitesNotExecutedRecentlyCount: 3,
+      }),
+    })
+  })
+})