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

package/templates/starter/src/services/locator-group/locator-group-service.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it, vi } from 'vitest'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import {
+  checkLocatorGroupNameUnique,
+  createLocatorGroup,
+  deleteLocatorGroups,
+  getLocatorGroupByIdOrThrow,
+  updateLocatorGroup,
+} from './locator-group-service'
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    locatorGroup: {
+      findUnique: vi.fn(),
+      findFirst: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      findMany: vi.fn(),
+      deleteMany: vi.fn(),
+    },
+  },
+}))
+
+vi.mock('@/lib/locator-group-file-utils', () => ({
+  getLocatorGroupFilePath: vi.fn().mockResolvedValue('/tmp/group.json'),
+}))
+
+vi.mock('@/lib/automation/projection-service', () => ({
+  automationProjectionService: {
+    createEmptyLocatorGroup: vi.fn().mockResolvedValue(undefined),
+    syncLocatorMap: vi.fn().mockResolvedValue(undefined),
+    moveLocatorGroup: vi.fn().mockResolvedValue(undefined),
+    renameLocatorGroup: vi.fn().mockResolvedValue(undefined),
+    syncLocatorGroup: vi.fn().mockResolvedValue(true),
+    deleteLocatorMapEntries: vi.fn().mockResolvedValue(undefined),
+    deleteLocatorGroup: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
+import prisma from '@/config/db-config'
+
+describe('getLocatorGroupByIdOrThrow', () => {
+  it('throws when locator group is missing', async () => {
+    vi.mocked(prisma.locatorGroup.findUnique).mockResolvedValue(null)
+    await expect(getLocatorGroupByIdOrThrow('missing')).rejects.toMatchObject({
+      message: 'Locator group not found',
+      statusCode: 404,
+    })
+  })
+})
+
+describe('checkLocatorGroupNameUnique', () => {
+  it('returns false when name is taken', async () => {
+    vi.mocked(prisma.locatorGroup.findFirst).mockResolvedValue({ id: 'lg1' } as never)
+    await expect(checkLocatorGroupNameUnique('Taken')).resolves.toBe(false)
+  })
+
+  it('returns true when name is free', async () => {
+    vi.mocked(prisma.locatorGroup.findFirst).mockResolvedValue(null)
+    await expect(checkLocatorGroupNameUnique('Free')).resolves.toBe(true)
+  })
+})
+
+describe('createLocatorGroup', () => {
+  it('creates the group and syncs its files', async () => {
+    vi.mocked(prisma.locatorGroup.findFirst).mockResolvedValue(null)
+    vi.mocked(prisma.locatorGroup.create).mockResolvedValue({ id: 'group-1', name: 'Home' } as never)
+
+    await expect(
+      createLocatorGroup({
+        name: 'Home',
+        moduleId: 'module-1',
+        route: '/home',
+        locators: ['loc-1'],
+      }),
+    ).resolves.toEqual({ id: 'group-1', name: 'Home' })
+
+    expect(automationProjectionService.createEmptyLocatorGroup).toHaveBeenCalledWith('group-1')
+    expect(automationProjectionService.syncLocatorMap).toHaveBeenCalledWith('Home', '/home')
+  })
+})
+
+describe('updateLocatorGroup', () => {
+  it('renames the group and updates the locator map when the name changes', async () => {
+    vi.mocked(prisma.locatorGroup.findUnique).mockResolvedValue({
+      id: 'group-1',
+      name: 'Old Name',
+      moduleId: 'module-1',
+      route: '/old',
+      module: { id: 'module-1' },
+    } as never)
+    vi.mocked(prisma.locatorGroup.findFirst).mockResolvedValue(null)
+    vi.mocked(prisma.locatorGroup.update).mockResolvedValue({
+      id: 'group-1',
+      name: 'New Name',
+      module: { name: 'Core' },
+    } as never)
+
+    await updateLocatorGroup('group-1', {
+      name: 'New Name',
+      moduleId: 'module-1',
+      route: '/new',
+      locators: ['loc-1'],
+    })
+
+    expect(automationProjectionService.renameLocatorGroup).toHaveBeenCalledWith('group-1', 'New Name', 'Old Name')
+    expect(automationProjectionService.syncLocatorMap).toHaveBeenCalledWith('/old', '/new', 'Old Name', 'New Name')
+  })
+})
+
+describe('deleteLocatorGroups', () => {
+  it('deletes locator map entries, group files, and db records', async () => {
+    vi.mocked(prisma.locatorGroup.findMany).mockResolvedValue([{ name: 'Home' }] as never)
+    vi.mocked(prisma.locatorGroup.deleteMany).mockResolvedValue({ count: 1 } as never)
+
+    await expect(deleteLocatorGroups(['group-1'])).resolves.toEqual(['group-1'])
+    expect(automationProjectionService.deleteLocatorMapEntries).toHaveBeenCalledWith(['Home'])
+    expect(automationProjectionService.deleteLocatorGroup).toHaveBeenCalledWith('group-1')
+    expect(prisma.locatorGroup.deleteMany).toHaveBeenCalledWith({
+      where: { id: { in: ['group-1'] } },
+    })
+  })
+})

package/templates/starter/src/services/locator-group/locator-group-service.ts

@@ -0,0 +1,180 @@
+import prisma from '@/config/db-config'
+import { locatorGroupSchema } from '@/constants/form-opts/locator-group-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import { getLocatorGroupFilePath } from '@/lib/locator-group-file-utils'
+import { ServiceError } from '@/services/shared/errors'
+import type { LocatorGroup } from '@prisma/client'
+import { Prisma } from '@prisma/client'
+import type { z } from 'zod'
+
+const locatorGroupInclude = {
+  module: {
+    select: { name: true },
+  },
+} as const
+
+export type LocatorGroupWithModule = Prisma.LocatorGroupGetPayload<{ include: typeof locatorGroupInclude }>
+
+async function checkUniqueName(name: string, excludeId?: string): Promise<boolean> {
+  const existing = await prisma.locatorGroup.findFirst({
+    where: {
+      name,
+      ...(excludeId && { id: { not: excludeId } }),
+    },
+  })
+  return !!existing
+}
+
+export async function listLocatorGroups(): Promise<LocatorGroupWithModule[]> {
+  return prisma.locatorGroup.findMany({
+    include: locatorGroupInclude,
+  })
+}
+
+export async function getLocatorGroupByIdOrThrow(id: string): Promise<LocatorGroupWithModule> {
+  const locatorGroup = await prisma.locatorGroup.findUnique({
+    where: { id },
+    include: locatorGroupInclude,
+  })
+  if (!locatorGroup) {
+    throw new ServiceError('Locator group not found', 'NOT_FOUND', 404)
+  }
+  return locatorGroup
+}
+
+export async function createLocatorGroup(value: z.infer<typeof locatorGroupSchema>): Promise<LocatorGroup> {
+  const nameExists = await checkUniqueName(value.name)
+  if (nameExists) {
+    throw new ServiceError(
+      'A locator group with this name already exists. Please choose a different name.',
+      'VALIDATION',
+      400,
+    )
+  }
+
+  try {
+    const locatorGroup = await prisma.locatorGroup.create({
+      data: {
+        name: value.name,
+        moduleId: value.moduleId,
+        route: value.route ?? '/',
+        locators: {
+          connect: value.locators?.map(locator => ({ id: locator })) || [],
+        },
+      },
+    })
+
+    await automationProjectionService.createEmptyLocatorGroup(locatorGroup.id)
+    await automationProjectionService.syncLocatorMap(value.name, value.route ?? '/')
+    return locatorGroup
+  } catch (error) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === 'P2002') {
+      throw new ServiceError(
+        'A locator group with this name already exists. Please choose a different name.',
+        'VALIDATION',
+        400,
+      )
+    }
+    throw error
+  }
+}
+
+export async function updateLocatorGroup(
+  id: string | undefined,
+  value: z.infer<typeof locatorGroupSchema>,
+): Promise<LocatorGroupWithModule> {
+  if (!id) {
+    throw new ServiceError('Locator group id is required', 'VALIDATION', 400)
+  }
+
+  const currentLocatorGroup = await prisma.locatorGroup.findUnique({
+    where: { id },
+    include: { module: true },
+  })
+
+  if (!currentLocatorGroup) {
+    throw new ServiceError('Locator group not found', 'NOT_FOUND', 404)
+  }
+
+  if (currentLocatorGroup.name !== value.name) {
+    const nameExists = await checkUniqueName(value.name, id)
+    if (nameExists) {
+      throw new ServiceError(
+        'A locator group with this name already exists. Please choose a different name.',
+        'VALIDATION',
+        400,
+      )
+    }
+  }
+
+  const previousFilePath = await getLocatorGroupFilePath(id)
+  const locatorConnections = value.locators?.map(locator => ({ id: locator })) ?? []
+
+  try {
+    const updatedLocatorGroup = await prisma.locatorGroup.update({
+      where: { id },
+      data: {
+        name: value.name,
+        moduleId: value.moduleId,
+        route: value.route,
+        ...(value.locators !== undefined && {
+          locators: {
+            set: locatorConnections,
+          },
+        }),
+      },
+      include: locatorGroupInclude,
+    })
+
+    const nameChanged = currentLocatorGroup.name !== value.name
+    const moduleChanged = currentLocatorGroup.moduleId !== value.moduleId
+    const routeChanged = currentLocatorGroup.route !== value.route
+
+    if (moduleChanged) {
+      await automationProjectionService.moveLocatorGroup(id, previousFilePath ?? undefined)
+    } else if (nameChanged) {
+      await automationProjectionService.renameLocatorGroup(id, value.name, currentLocatorGroup.name)
+    } else {
+      await automationProjectionService.syncLocatorGroup(id)
+    }
+
+    if (routeChanged || nameChanged) {
+      await automationProjectionService.syncLocatorMap(
+        currentLocatorGroup.route,
+        value.route ?? '/',
+        currentLocatorGroup.name,
+        value.name,
+      )
+    }
+
+    return updatedLocatorGroup
+  } catch (error) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === 'P2002') {
+      throw new ServiceError(
+        'A locator group with this name already exists. Please choose a different name.',
+        'VALIDATION',
+        400,
+      )
+    }
+    throw error
+  }
+}
+
+export async function deleteLocatorGroups(ids: string[]): Promise<string[]> {
+  const locatorGroupsToDelete = await prisma.locatorGroup.findMany({
+    where: { id: { in: ids } },
+    select: { name: true },
+  })
+
+  await automationProjectionService.deleteLocatorMapEntries(locatorGroupsToDelete.map(group => group.name))
+  await Promise.all(ids.map(id => automationProjectionService.deleteLocatorGroup(id)))
+
+  await prisma.locatorGroup.deleteMany({
+    where: { id: { in: ids } },
+  })
+  return ids
+}
+
+export async function checkLocatorGroupNameUnique(name: string, excludeId?: string): Promise<boolean> {
+  return !(await checkUniqueName(name, excludeId))
+}

package/templates/starter/src/services/module/module-service.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it, vi } from 'vitest'
+import { ROOT_MODULE_UUID } from '@/constants/form-opts/module-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import { createModule, deleteModules, getModuleByIdOrThrow, updateModule } from './module-service'
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    module: {
+      findUnique: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      deleteMany: vi.fn(),
+    },
+  },
+}))
+
+vi.mock('@/lib/automation/projection-service', () => ({
+  automationProjectionService: {
+    regenerateAllPathDependentArtifacts: vi.fn().mockResolvedValue(undefined),
+  },
+}))
+
+import prisma from '@/config/db-config'
+
+describe('getModuleByIdOrThrow', () => {
+  it('throws NOT_FOUND when module missing', async () => {
+    vi.mocked(prisma.module.findUnique).mockResolvedValue(null)
+    await expect(getModuleByIdOrThrow('missing')).rejects.toMatchObject({
+      message: 'Module not found',
+      statusCode: 404,
+    })
+  })
+})
+
+describe('createModule', () => {
+  it('normalizes the root parent id and regenerates artifacts', async () => {
+    vi.mocked(prisma.module.create).mockResolvedValue({ id: 'module-1', name: 'Checkout' } as never)
+
+    await expect(
+      createModule({
+        name: 'Checkout',
+        parentId: ROOT_MODULE_UUID,
+      }),
+    ).resolves.toEqual({ id: 'module-1', name: 'Checkout' })
+
+    expect(prisma.module.create).toHaveBeenCalledWith({
+      data: {
+        name: 'Checkout',
+        parentId: null,
+      },
+    })
+    expect(automationProjectionService.regenerateAllPathDependentArtifacts).toHaveBeenCalled()
+  })
+})
+
+describe('updateModule', () => {
+  it('updates the module and regenerates path-dependent artifacts', async () => {
+    vi.mocked(prisma.module.update).mockResolvedValue({ id: 'module-1', name: 'Checkout' } as never)
+
+    await expect(
+      updateModule('module-1', {
+        name: 'Checkout',
+        parentId: 'parent-1',
+      }),
+    ).resolves.toEqual({ id: 'module-1', name: 'Checkout' })
+
+    expect(prisma.module.update).toHaveBeenCalledWith({
+      where: { id: 'module-1' },
+      data: {
+        name: 'Checkout',
+        parentId: 'parent-1',
+      },
+    })
+    expect(automationProjectionService.regenerateAllPathDependentArtifacts).toHaveBeenCalled()
+  })
+})
+
+describe('deleteModules', () => {
+  it('deletes modules and regenerates path-dependent artifacts', async () => {
+    vi.mocked(prisma.module.deleteMany).mockResolvedValue({ count: 2 } as never)
+
+    await deleteModules(['module-1', 'module-2'])
+
+    expect(prisma.module.deleteMany).toHaveBeenCalledWith({
+      where: { id: { in: ['module-1', 'module-2'] } },
+    })
+    expect(automationProjectionService.regenerateAllPathDependentArtifacts).toHaveBeenCalled()
+  })
+})

package/templates/starter/src/services/module/module-service.ts

@@ -0,0 +1,66 @@
+import prisma from '@/config/db-config'
+import { moduleSchema, ROOT_MODULE_UUID } from '@/constants/form-opts/module-form-opts'
+import { automationProjectionService } from '@/lib/automation/projection-service'
+import { ServiceError } from '@/services/shared/errors'
+import type { Module } from '@prisma/client'
+import { Prisma } from '@prisma/client'
+import type { z } from 'zod'
+
+const moduleInclude = {
+  parent: {
+    select: { name: true },
+  },
+} as const
+
+export type ModuleWithParent = Prisma.ModuleGetPayload<{ include: typeof moduleInclude }>
+
+export async function listModules(): Promise<ModuleWithParent[]> {
+  return prisma.module.findMany({
+    include: moduleInclude,
+  })
+}
+
+export async function deleteModules(ids: string[]): Promise<void> {
+  await prisma.module.deleteMany({ where: { id: { in: ids } } })
+  await automationProjectionService.regenerateAllPathDependentArtifacts()
+}
+
+export async function createModule(value: z.infer<typeof moduleSchema>): Promise<Module> {
+  const moduleData = {
+    ...value,
+    parentId: value.parentId === ROOT_MODULE_UUID ? null : value.parentId,
+  }
+  const newModule = await prisma.module.create({ data: moduleData })
+  await automationProjectionService.regenerateAllPathDependentArtifacts()
+  return newModule
+}
+
+export async function getModuleByIdOrThrow(id: string): Promise<ModuleWithParent> {
+  const moduleData = await prisma.module.findUnique({
+    where: { id },
+    include: moduleInclude,
+  })
+  if (!moduleData) {
+    throw new ServiceError('Module not found', 'NOT_FOUND', 404)
+  }
+  return moduleData
+}
+
+export async function updateModule(
+  id: string | undefined,
+  value: z.infer<typeof moduleSchema>,
+): Promise<Module> {
+  if (!id) {
+    throw new ServiceError('Module id is required', 'VALIDATION', 400)
+  }
+  const moduleData = {
+    ...value,
+    parentId: value.parentId === ROOT_MODULE_UUID ? null : value.parentId,
+  }
+  const updatedModule = await prisma.module.update({
+    where: { id },
+    data: moduleData,
+  })
+  await automationProjectionService.regenerateAllPathDependentArtifacts()
+  return updatedModule
+}

package/templates/starter/src/services/report/report-service.test.ts

@@ -0,0 +1,244 @@
+import path from 'path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { TagType, TestRunTestCaseStatus } from '@prisma/client'
+import { RECENT_PERIOD_DAYS } from '@/services/shared/constants'
+
+const {
+  mockReportFindUnique,
+  mockReportFindFirst,
+  mockReportCreate,
+  mockReportFeatureCreate,
+  mockReportFeatureTagCreate,
+  mockReportScenarioCreate,
+  mockReportScenarioTagCreate,
+  mockReportStepCreate,
+  mockReportHookCreate,
+  mockReportTestCaseCreate,
+  mockTestRunFindUnique,
+  mockTestCaseFindMany,
+  mockTestCaseMetricsFindMany,
+  mockTestSuiteMetricsFindMany,
+  mockUpdateTestSuiteMetrics,
+} = vi.hoisted(() => ({
+  mockReportFindUnique: vi.fn(),
+  mockReportFindFirst: vi.fn(),
+  mockReportCreate: vi.fn(),
+  mockReportFeatureCreate: vi.fn(),
+  mockReportFeatureTagCreate: vi.fn(),
+  mockReportScenarioCreate: vi.fn(),
+  mockReportScenarioTagCreate: vi.fn(),
+  mockReportStepCreate: vi.fn(),
+  mockReportHookCreate: vi.fn(),
+  mockReportTestCaseCreate: vi.fn(),
+  mockTestRunFindUnique: vi.fn(),
+  mockTestCaseFindMany: vi.fn(),
+  mockTestCaseMetricsFindMany: vi.fn(),
+  mockTestSuiteMetricsFindMany: vi.fn(),
+  mockUpdateTestSuiteMetrics: vi.fn(),
+}))
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    report: {
+      findUnique: mockReportFindUnique,
+      findFirst: mockReportFindFirst,
+      create: mockReportCreate,
+    },
+    reportFeature: { create: mockReportFeatureCreate },
+    reportFeatureTag: { create: mockReportFeatureTagCreate },
+    reportScenario: { create: mockReportScenarioCreate },
+    reportScenarioTag: { create: mockReportScenarioTagCreate },
+    reportStep: { create: mockReportStepCreate },
+    reportHook: { create: mockReportHookCreate },
+    reportTestCase: { create: mockReportTestCaseCreate },
+    testRun: { findUnique: mockTestRunFindUnique },
+    testCase: { findMany: mockTestCaseFindMany },
+    testCaseMetrics: { findMany: mockTestCaseMetricsFindMany },
+    testSuiteMetrics: { findMany: mockTestSuiteMetricsFindMany },
+  },
+}))
+
+vi.mock('@/lib/metrics/metric-calculator', () => ({
+  updateTestSuiteMetrics: mockUpdateTestSuiteMetrics,
+}))
+
+vi.mock('@/lib/automation/automation-path-roots', () => ({
+  resolveStoredPath: vi.fn((storedPath: string) => storedPath),
+  toProjectRelativePath: vi.fn((storedPath: string) => storedPath),
+}))
+
+import {
+  getAllTestCaseMetricsForFilter,
+  getAllTestSuiteMetricsForFilter,
+  getReportByIdOrThrow,
+  storeReportFromFileService,
+} from './report-service'
+
+const fixturePath = path.resolve(
+  process.cwd(),
+  'src/tests/reports/cucumber-b4087079-b7f9-415e-a93b-223a8c9be966-1771525057078.json',
+)
+
+function createIdentifierTag(name: string) {
+  return {
+    id: name,
+    name,
+    tagExpression: `@${name}`,
+    type: TagType.IDENTIFIER,
+  }
+}
+
+describe('storeReportFromFileService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockReportCreate.mockResolvedValue({ id: 'report-1' })
+    mockReportFeatureCreate.mockResolvedValue({ id: 'feature-1' })
+    mockReportScenarioCreate.mockResolvedValue({ id: 'scenario-1' })
+    mockReportStepCreate.mockResolvedValue({ id: 'step-1' })
+    mockReportHookCreate.mockResolvedValue({ id: 'hook-1' })
+    mockReportTestCaseCreate.mockResolvedValue({ id: 'rtc-1' })
+  })
+
+  it('stores a parsed cucumber report, links scenarios to test run test cases, and updates suite metrics', async () => {
+    mockTestRunFindUnique.mockResolvedValue({
+      id: 'db-run-1',
+      runId: 'run-1',
+      name: 'Nightly',
+      completedAt: new Date('2025-02-01T00:00:00.000Z'),
+      startedAt: new Date('2025-01-31T23:00:00.000Z'),
+      testCases: [
+        {
+          id: 'trtc-1',
+          testCaseId: 'tc-1',
+          testSuiteId: 'suite-1',
+          status: TestRunTestCaseStatus.PENDING,
+          testCase: {
+            id: 'tc-1',
+            title: 'Login',
+            tags: [createIdentifierTag('tc_2d328a936cf4c446')],
+          },
+          testSuite: {
+            id: 'suite-1',
+            name: 'Login Suite',
+            tags: [createIdentifierTag('ts_login')],
+          },
+        },
+      ],
+    })
+
+    const outcome = await storeReportFromFileService('run-1', fixturePath)
+
+    expect(outcome).toEqual({ success: true, reportId: 'report-1' })
+    expect(mockReportCreate).toHaveBeenCalledWith({
+      data: {
+        name: 'Test Run Report - Nightly',
+        description: 'Report for test run: Nightly',
+        reportPath: fixturePath,
+        testRunId: 'db-run-1',
+      },
+    })
+    expect(mockReportFeatureCreate).toHaveBeenCalledTimes(1)
+    expect(mockReportScenarioCreate).toHaveBeenCalledTimes(1)
+    expect(mockReportStepCreate).toHaveBeenCalledTimes(6)
+    expect(mockReportHookCreate).toHaveBeenCalledTimes(2)
+    expect(mockReportTestCaseCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        reportId: 'report-1',
+        testCaseId: 'tc-1',
+        testRunTestCaseId: 'trtc-1',
+        reportScenarioId: 'scenario-1',
+        duration: expect.any(String),
+      }),
+    })
+    expect(mockUpdateTestSuiteMetrics).toHaveBeenCalledWith('suite-1', new Date('2025-02-01T00:00:00.000Z'))
+  })
+
+  it('returns file_not_found when the report file does not exist', async () => {
+    await expect(storeReportFromFileService('run-1', '/missing/report.json')).resolves.toEqual({
+      success: false,
+      reason: 'file_not_found',
+      message: 'Report file not found at /missing/report.json',
+    })
+  })
+
+  it('returns test_run_not_found when the run cannot be loaded', async () => {
+    mockTestRunFindUnique.mockResolvedValue(null)
+
+    await expect(storeReportFromFileService('run-1', fixturePath)).resolves.toEqual({
+      success: false,
+      reason: 'test_run_not_found',
+      message: 'Test run not found for runId: run-1',
+    })
+  })
+})
+
+describe('getReportByIdOrThrow', () => {
+  it('throws when the report is missing', async () => {
+    mockReportFindUnique.mockResolvedValue(null)
+
+    await expect(getReportByIdOrThrow('missing')).rejects.toMatchObject({
+      message: 'Report not found',
+      statusCode: 404,
+    })
+  })
+})
+
+describe('getAllTestCaseMetricsForFilter', () => {
+  const baseRows = [
+    { id: 'm1', isRepeatedlyFailing: true, isFlaky: false, testCase: {} },
+    { id: 'm2', isRepeatedlyFailing: false, isFlaky: true, testCase: {} },
+    { id: 'm3', isRepeatedlyFailing: false, isFlaky: false, testCase: {} },
+  ]
+
+  beforeEach(() => {
+    mockTestCaseMetricsFindMany.mockResolvedValue(baseRows)
+  })
+
+  it('returns all rows when filter is empty', async () => {
+    const r = await getAllTestCaseMetricsForFilter('')
+    expect(r).toHaveLength(3)
+  })
+
+  it('filters to repeatedly failing when requested', async () => {
+    const r = await getAllTestCaseMetricsForFilter('repeatedlyFailing')
+    expect(r.map(x => x.id)).toEqual(['m1'])
+  })
+
+  it('filters to flaky when requested', async () => {
+    const r = await getAllTestCaseMetricsForFilter('flaky')
+    expect(r.map(x => x.id)).toEqual(['m2'])
+  })
+})
+
+describe('getAllTestSuiteMetricsForFilter', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2025-06-15T12:00:00.000Z'))
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('returns all rows when filter is not notExecutedRecently', async () => {
+    const rows = [{ id: 's1', lastExecutedAt: new Date('2025-06-14'), testSuite: {} }]
+    mockTestSuiteMetricsFindMany.mockResolvedValue(rows)
+
+    const r = await getAllTestSuiteMetricsForFilter('')
+    expect(r).toHaveLength(1)
+  })
+
+  it('keeps suites never executed or last run before the recent window', async () => {
+    const old = new Date('2025-06-01T12:00:00.000Z')
+    const recent = new Date('2025-06-10T12:00:00.000Z')
+    mockTestSuiteMetricsFindMany.mockResolvedValue([
+      { id: 'a', lastExecutedAt: null, testSuite: {} },
+      { id: 'b', lastExecutedAt: old, testSuite: {} },
+      { id: 'c', lastExecutedAt: recent, testSuite: {} },
+    ])
+
+    const r = await getAllTestSuiteMetricsForFilter('notExecutedRecently')
+    expect(r.map(x => x.id).sort()).toEqual(['a', 'b'])
+    expect(RECENT_PERIOD_DAYS).toBe(7)
+  })
+})