create-appraisejs 0.3.1-alpha.0 → 0.3.1-alpha.1

package/templates/blank/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/blank/src/lib/metrics/metric-calculator.test.ts

@@ -1,10 +1,26 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { TestRunTestCaseResult, TestRunTestCaseStatus } from '@prisma/client'
 
-const { mockTestRunTestCaseFindMany, mockTestRunTestCaseFindFirst, mockTestCaseMetricsUpsert } = vi.hoisted(() => ({
+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', () => ({
@@ -18,23 +34,29 @@ vi.mock('@/config/db-config', () => ({
       upsert: mockTestCaseMetricsUpsert,
       count: vi.fn(),
     },
+    testCase: {
+      count: mockTestCaseCount,
+    },
     testSuiteMetrics: {
       upsert: vi.fn(),
       count: vi.fn(),
     },
+    testSuite: {
+      count: mockTestSuiteCount,
+    },
     testRun: {
-      count: vi.fn(),
+      count: mockTestRunCount,
       findUnique: vi.fn(),
     },
     dashboardMetrics: {
-      findFirst: vi.fn(),
-      update: vi.fn(),
-      create: vi.fn(),
+      findFirst: mockDashboardMetricsFindFirst,
+      update: mockDashboardMetricsUpdate,
+      create: mockDashboardMetricsCreate,
     },
   },
 }))
 
-import { recalculateTestCaseMetrics } from './metric-calculator'
+import { recalculateTestCaseMetrics, updateDashboardMetrics } from './metric-calculator'
 
 function completedCase(result: TestRunTestCaseResult, completedAt: Date) {
   return {
@@ -154,3 +176,80 @@ describe('recalculateTestCaseMetrics', () => {
     })
   })
 })
+
+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,
+      }),
+    })
+  })
+})

package/templates/blank/src/lib/metrics/metric-calculator.ts

@@ -57,9 +57,7 @@ function getRecentPeriodDate(): Date {
 
 function summarizeRecentTestCaseRuns(recentTestRunTestCases: CompletedTestRunTestCase[]): TestCaseMetricSummary {
   const totalRecentRuns = recentTestRunTestCases.length
-  const failedRecentRuns = recentTestRunTestCases.filter(
-    trtc => trtc.result === TestRunTestCaseResult.FAILED,
-  ).length
+  const failedRecentRuns = recentTestRunTestCases.filter(trtc => trtc.result === TestRunTestCaseResult.FAILED).length
   const failureRate = totalRecentRuns > 0 ? failedRecentRuns / totalRecentRuns : 0
   const consecutiveFailures = countConsecutiveFailures(recentTestRunTestCases)
 
@@ -138,14 +136,8 @@ export async function updateTestCaseMetrics(
 
     const recentTestRunTestCases = await findRecentCompletedTestRunTestCases(testCaseId, recentPeriodDate)
 
-    const {
-      totalRecentRuns,
-      failedRecentRuns,
-      failureRate,
-      isFlaky,
-      consecutiveFailures,
-      isRepeatedlyFailing,
-    } = summarizeRecentTestCaseRuns(recentTestRunTestCases)
+    const { totalRecentRuns, failedRecentRuns, failureRate, isFlaky, consecutiveFailures, isRepeatedlyFailing } =
+      summarizeRecentTestCaseRuns(recentTestRunTestCases)
 
     // Determine which date fields to update
     const updateData: {
@@ -194,10 +186,7 @@ export async function updateTestCaseMetrics(
  * @param testSuiteId - The test suite ID
  * @param executedAt - When the test suite was executed
  */
-export async function updateTestSuiteMetrics(
-  testSuiteId: string,
-  executedAt: Date,
-): Promise<void> {
+export async function updateTestSuiteMetrics(testSuiteId: string, executedAt: Date): Promise<void> {
   try {
     await prisma.testSuiteMetrics.upsert({
       where: { testSuiteId },
@@ -220,10 +209,7 @@ export async function updateTestSuiteMetrics(
  * @param testRunId - The test run ID
  * @param executedAt - When the test run was executed
  */
-async function updateTestSuitesForTestRun(
-  testRunId: string,
-  executedAt: Date,
-): Promise<void> {
+async function updateTestSuitesForTestRun(testRunId: string, executedAt: Date): Promise<void> {
   try {
     // Get all test cases in the test run
     const testRunTestCases = await prisma.testRunTestCase.findMany({
@@ -290,31 +276,52 @@ export async function updateDashboardMetrics(): Promise<void> {
       },
     })
 
-    // Count repeatedly failing tests
-    const repeatedlyFailingTestsCount = await prisma.testCaseMetrics.count({
+    // Count repeatedly failing live tests
+    const repeatedlyFailingTestsCount = await prisma.testCase.count({
       where: {
-        isRepeatedlyFailing: true,
+        metrics: {
+          is: {
+            isRepeatedlyFailing: true,
+          },
+        },
       },
     })
 
-    // Count flaky tests
-    const flakyTestsCount = await prisma.testCaseMetrics.count({
+    // Count flaky live tests
+    const flakyTestsCount = await prisma.testCase.count({
       where: {
-        isFlaky: true,
+        metrics: {
+          is: {
+            isFlaky: true,
+          },
+        },
       },
     })
 
-    // Count suites not executed recently
-    const suitesNotExecutedRecentlyCount = await prisma.testSuiteMetrics.count({
+    // Count live suites with no execution metrics or stale execution metrics
+    const suitesNotExecutedRecentlyCount = await prisma.testSuite.count({
       where: {
         OR: [
           {
-            lastExecutedAt: {
-              lt: recentPeriodDate,
+            metrics: {
+              is: null,
             },
           },
           {
-            lastExecutedAt: null,
+            metrics: {
+              is: {
+                lastExecutedAt: null,
+              },
+            },
+          },
+          {
+            metrics: {
+              is: {
+                lastExecutedAt: {
+                  lt: recentPeriodDate,
+                },
+              },
+            },
           },
         ],
       },
@@ -364,11 +371,7 @@ export async function recalculateTestCaseMetrics(testCaseId: string): Promise<vo
     const recentTestRunTestCases = await findRecentCompletedTestRunTestCases(testCaseId, recentPeriodDate)
 
     const metricSummary = summarizeRecentTestCaseRuns(recentTestRunTestCases)
-    const recalculatedDates = await resolveRecalculatedMetricDates(
-      testCaseId,
-      recentPeriodDate,
-      recentTestRunTestCases,
-    )
+    const recalculatedDates = await resolveRecalculatedMetricDates(testCaseId, recentPeriodDate, recentTestRunTestCases)
     const updateData = buildRecalculatedMetricUpdateData(metricSummary, recalculatedDates)
 
     // Upsert the metrics
@@ -572,11 +575,7 @@ export async function updateMetricsForTestRun(testRunId: string): Promise<void>
     // Update metrics for all test cases in the run
     for (const testRunTestCase of testRun.testCases) {
       if (testRunTestCase.status === TestRunTestCaseStatus.COMPLETED) {
-        await updateTestCaseMetrics(
-          testRunTestCase.testCaseId,
-          testRunTestCase.result,
-          executedAt,
-        )
+        await updateTestCaseMetrics(testRunTestCase.testCaseId, testRunTestCase.result, executedAt)
       }
     }
 

package/templates/blank/src/lib/sync/sync-executor.ts

@@ -64,10 +64,7 @@ function parseSyncFailureCause(result: ScriptExecutionOutput | { error: unknown
     return result.error instanceof Error ? result.error.message : String(result.error)
   }
 
-  return selectMostRelevantLine([
-    ...normalizeOutputLines(result.stderr),
-    ...normalizeOutputLines(result.stdout),
-  ])
+  return selectMostRelevantLine([...normalizeOutputLines(result.stderr), ...normalizeOutputLines(result.stdout)])
 }
 
 async function executeSyncScript(scriptId: SyncScriptId): Promise<ScriptExecutionOutput> {

package/templates/blank/src/lib/sync/sync-pending-counts.test.ts

@@ -1,12 +1,8 @@
 import { describe, expect, it } from 'vitest'
+import { StepParameterType, TagType, TemplateStepGroupType, TemplateStepIcon, TemplateStepType } from '@prisma/client'
 import {
-  StepParameterType,
-  TagType,
-  TemplateStepGroupType,
-  TemplateStepIcon,
-  TemplateStepType,
-} from '@prisma/client'
-import {
+  countEnvironmentMismatches,
+  countLocatorGroupMismatches,
   countModuleMismatches,
   countTagMismatches,
   countTemplateStepGroupMismatches,
@@ -25,6 +21,40 @@ describe('sync pending counts', () => {
     expect(count).toBe(0)
   })
 
+  it('counts environment value changes but not deletions the sync script skips', () => {
+    const count = countEnvironmentMismatches(
+      [
+        {
+          name: 'Local',
+          baseUrl: 'http://localhost:3000',
+          apiBaseUrl: null,
+          username: 'demo@example.com',
+          password: null,
+        },
+      ],
+      [
+        {
+          name: 'Local',
+          baseUrl: 'http://localhost:3001',
+          apiBaseUrl: null,
+          username: 'demo@example.com',
+          password: null,
+          _count: { testRuns: 0 },
+        },
+        {
+          name: 'Historic',
+          baseUrl: 'https://old.example.com',
+          apiBaseUrl: null,
+          username: null,
+          password: null,
+          _count: { testRuns: 2 },
+        },
+      ],
+    )
+
+    expect(count).toBe(1)
+  })
+
   it('ignores DB-only standalone filter tags when filesystem tags are already satisfied', () => {
     const count = countTagMismatches(
       [{ name: 'smoke', tagExpression: '@smoke', type: TagType.FILTER }],
@@ -99,6 +129,59 @@ describe('sync pending counts', () => {
     expect(count).toBe(0)
   })
 
+  it('collapses duplicate filesystem template-step signatures to the script final state', () => {
+    const count = countTemplateStepMismatches(
+      [
+        {
+          groupName: 'Actions',
+          groupType: TemplateStepGroupType.ACTION,
+          step: {
+            jsdoc: {
+              name: 'Old duplicate',
+              description: 'First parsed copy',
+              icon: TemplateStepIcon.MOUSE,
+            },
+            signature: 'click {string}',
+            functionDefinition: '',
+            normalizedFunctionDefinition: "When('click {string}', async function () {});",
+            parameters: [],
+            keyword: 'When',
+          },
+        },
+        {
+          groupName: 'Actions',
+          groupType: TemplateStepGroupType.ACTION,
+          step: {
+            jsdoc: {
+              name: 'Click button',
+              description: 'Final parsed copy',
+              icon: TemplateStepIcon.MOUSE,
+            },
+            signature: 'click {string}',
+            functionDefinition: '',
+            normalizedFunctionDefinition: "When('click {string}', async function () {});",
+            parameters: [],
+            keyword: 'When',
+          },
+        },
+      ],
+      [
+        {
+          signature: 'click {string}',
+          name: 'Click button',
+          description: 'Final parsed copy',
+          functionDefinition: "When('click {string}', async function () {});",
+          icon: TemplateStepIcon.MOUSE,
+          type: TemplateStepType.ACTION,
+          templateStepGroup: { name: 'Actions' },
+          parameters: [],
+        },
+      ],
+    )
+
+    expect(count).toBe(0)
+  })
+
   it('matches test suites by generated filesystem key instead of raw DB name', () => {
     const count = countTestSuiteMismatches(
       [
@@ -147,6 +230,63 @@ describe('sync pending counts', () => {
     expect(count).toBe(0)
   })
 
+  it('collapses duplicate filesystem locator-group names to the script final state', () => {
+    const count = countLocatorGroupMismatches(
+      [
+        {
+          name: 'Login Page',
+          route: '/first',
+          modulePath: '/auth',
+        },
+        {
+          name: 'Login Page',
+          route: '/login',
+          modulePath: '/auth',
+        },
+      ],
+      [
+        {
+          name: 'Login Page',
+          route: '/login',
+          moduleId: 'module-auth',
+        },
+      ],
+      new Map([['module-auth', '/auth']]),
+    )
+
+    expect(count).toBe(0)
+  })
+
+  it('collapses duplicate filesystem test-suite identities to the script final state', () => {
+    const count = countTestSuiteMismatches(
+      [
+        {
+          name: 'user-login-suite',
+          description: 'First parsed copy',
+          modulePath: '/auth',
+          tags: ['@smoke'],
+        },
+        {
+          name: 'user-login-suite',
+          description: 'Final parsed copy',
+          modulePath: '/auth',
+          tags: ['@smoke', '@regression'],
+        },
+      ],
+      [
+        {
+          name: 'User Login Suite',
+          description: 'Final parsed copy',
+          moduleId: 'module-auth',
+          tags: [{ tagExpression: '@smoke' }, { tagExpression: '@regression' }],
+        },
+      ],
+      new Map([['module-auth', '/auth']]),
+    )
+
+    expect(count).toBe(0)
+  })
+
   it('matches projected test cases against generated feature-file output', () => {
     const count = countTestCaseMismatches(
       [
@@ -261,4 +401,58 @@ describe('sync pending counts', () => {
 
     expect(count).toBe(0)
   })
+
+  it('collapses duplicate filesystem test-case identifiers to the script final state', () => {
+    const count = countTestCaseMismatches(
+      [
+        {
+          identifierTag: '@tc_login',
+          title: 'Login',
+          description: 'Runs the login flow',
+          testSuiteName: 'login-smoke',
+          modulePath: '/auth',
+          filterTags: ['@demo'],
+          steps: [{ order: 1, keyword: 'Given', text: 'open the login page' }],
+        },
+        {
+          identifierTag: '@tc_login',
+          title: 'Login',
+          description: 'Runs the login flow',
+          testSuiteName: 'login-regression',
+          modulePath: '/auth',
+          filterTags: ['@auth', '@demo'],
+          steps: [{ order: 1, keyword: 'Given', text: 'open the login page' }],
+        },
+      ],
+      [
+        {
+          title: 'Login',
+          description: 'Runs the login flow',
+          tags: [
+            { tagExpression: '@tc_login', type: TagType.IDENTIFIER },
+            { tagExpression: '@auth', type: TagType.FILTER },
+            { tagExpression: '@demo', type: TagType.FILTER },
+          ],
+          TestSuite: [
+            { name: 'Login Smoke', moduleId: 'module-auth' },
+            { name: 'Login Regression', moduleId: 'module-auth' },
+          ],
+          steps: [
+            {
+              order: 1,
+              gherkinStep: 'Given open the login page',
+              label: 'open the login page',
+              icon: TemplateStepIcon.NAVIGATION,
+              TemplateStep: { signature: 'open the login page' },
+              parameters: [],
+            },
+          ],
+        },
+      ],
+      new Map([['module-auth', '/auth']]),
+      [{ signature: 'open the login page', parameters: [] }],
+    )
+
+    expect(count).toBe(0)
+  })
 })