create-appraisejs 0.3.0 → 0.3.1-alpha.1

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

@@ -18,7 +18,7 @@ import { promises as fs } from 'fs'
 import { updateTestCaseMetrics, updateMetricsForTestRun } from '@/lib/metrics/metric-calculator'
 import { getAutomationReportRunDir, resolveStoredPath } from '@/lib/automation/automation-path-roots'
 import { ensureTestSuiteIdentifierTags } from '@/lib/test-suite-identifier-service'
-import { getIdentifierTagByPrefix } from '@/lib/tag-utils'
+import { getIdentifierTagByPrefix } from '@/lib/tag-filters'
 import { findMatchingTestRunTestCase } from '@/lib/test-run/matching'
 import { storeReportFromFileService } from '@/services/report/report-service'
 import {
@@ -100,6 +100,12 @@ export async function listTestSuiteTestCases() {
 
 type TestRunTestCaseLink = { testCaseId: string; testSuiteId?: string | null }
 
+type ResolvedTestRunFilters = {
+  tagExpression: string | null
+  tags: Tag[]
+  testRunTestCases: TestRunTestCaseLink[]
+}
+
 async function resolveTagExpressionAndTestCases(value: TestRunFormValue): Promise<{
   tagExpression: string
   tags: Tag[]
@@ -118,161 +124,178 @@ async function resolveTagExpressionAndTestCases(value: TestRunFormValue): Promis
   const isFilteringByTestSuites = value.testSuites.length > 0 && value.tags.length === 0
 
   if (!isFilteringByTags && !isFilteringByTestSuites) {
-    throw new ServiceError(
-      'Either tags or test suites must be provided to filter the test run.',
-      'VALIDATION',
-      400,
-    )
+    throw new ServiceError('Either tags or test suites must be provided to filter the test run.', 'VALIDATION', 400)
   }
 
-  let tags: Tag[] = []
-  let tagExpression: string | null = null
-  let testRunTestCases: TestRunTestCaseLink[] = []
+  const { tagExpression, tags, testRunTestCases } = isFilteringByTags
+    ? await resolveTaggedTestRunFilters(value.tags)
+    : await resolveSuiteTestRunFilters(value.testSuites)
 
-  if (isFilteringByTags) {
-    tags = await prisma.tag.findMany({
-      where: { id: { in: value.tags } },
-    })
+  if (!tagExpression) {
+    throw new ServiceError('No executable tests were resolved from the selected filters.', 'VALIDATION', 400)
+  }
+
+  return { tagExpression, tags, testRunTestCases, environment }
+}
 
-    tagExpression = buildOrExpression(tags.map(tag => `(${tag.tagExpression})`))
+async function resolveTaggedTestRunFilters(tagIds: string[]): Promise<ResolvedTestRunFilters> {
+  const tags = await prisma.tag.findMany({
+    where: { id: { in: tagIds } },
+  })
 
-    const tagFilteredTestCases = await prisma.testCase.findMany({
-      where: {
-        OR: [
-          {
-            tags: {
-              some: { id: { in: value.tags } },
-            },
+  const tagExpression = buildOrExpression(tags.map(tag => `(${tag.tagExpression})`))
+  const tagFilteredTestCases = await prisma.testCase.findMany({
+    where: {
+      OR: [
+        {
+          tags: {
+            some: { id: { in: tagIds } },
           },
-          {
-            TestSuite: {
-              some: {
-                tags: {
-                  some: { id: { in: value.tags } },
-                },
+        },
+        {
+          TestSuite: {
+            some: {
+              tags: {
+                some: { id: { in: tagIds } },
               },
             },
           },
-        ],
-      },
-    })
+        },
+      ],
+    },
+  })
 
-    testRunTestCases = tagFilteredTestCases.map(tc => ({
-      testCaseId: tc.id,
+  return {
+    tagExpression,
+    tags,
+    testRunTestCases: tagFilteredTestCases.map(testCase => ({
+      testCaseId: testCase.id,
       testSuiteId: null,
-    }))
-  } else if (isFilteringByTestSuites) {
-    await ensureTestSuiteIdentifierTags(value.testSuites.map(testSuite => testSuite.testSuiteId))
-
-    const selectedSuites = await prisma.testSuite.findMany({
-      where: {
-        id: {
-          in: value.testSuites.map(testSuite => testSuite.testSuiteId),
-        },
+    })),
+  }
+}
+
+async function resolveSuiteTestRunFilters(value: TestRunFormValue['testSuites']): Promise<ResolvedTestRunFilters> {
+  await ensureTestSuiteIdentifierTags(value.map(testSuite => testSuite.testSuiteId))
+
+  const selectedSuites = await prisma.testSuite.findMany({
+    where: {
+      id: {
+        in: value.map(testSuite => testSuite.testSuiteId),
       },
-      include: {
-        tags: true,
-        testCases: {
-          include: {
-            tags: true,
-          },
+    },
+    include: {
+      tags: true,
+      testCases: {
+        include: {
+          tags: true,
         },
       },
-    })
+    },
+  })
 
-    if (selectedSuites.length !== value.testSuites.length) {
-      throw new ServiceError('One or more selected test suites could not be found.', 'VALIDATION', 400)
-    }
+  if (selectedSuites.length !== value.length) {
+    throw new ServiceError('One or more selected test suites could not be found.', 'VALIDATION', 400)
+  }
 
-    const selectedSuiteById = new Map(selectedSuites.map(testSuite => [testSuite.id, testSuite]))
-    const suiteClauses: string[] = []
+  const selectedSuiteById = new Map(selectedSuites.map(testSuite => [testSuite.id, testSuite]))
+  const suiteClauses: string[] = []
+  const testRunTestCases: TestRunTestCaseLink[] = []
 
-    for (const suiteSelection of value.testSuites) {
-      const selectedSuite = selectedSuiteById.get(suiteSelection.testSuiteId)
-      if (!selectedSuite) {
-        continue
-      }
+  for (const suiteSelection of value) {
+    const suiteResult = resolveSuiteSelectionFilter(selectedSuiteById.get(suiteSelection.testSuiteId), suiteSelection)
+    if (!suiteResult) {
+      continue
+    }
 
-      if (selectedSuite.testCases.length === 0) {
-        continue
-      }
+    suiteClauses.push(suiteResult.clause)
+    testRunTestCases.push(...suiteResult.testRunTestCases)
+  }
 
-      const normalizedSelection = normalizeSuiteSelection(
-        suiteSelection,
-        selectedSuite.testCases.map(testCase => testCase.id),
-      )
+  return {
+    tagExpression: buildOrExpression(suiteClauses.map(clause => `(${clause})`)),
+    tags: [],
+    testRunTestCases,
+  }
+}
 
-      if (!normalizedSelection) {
-        continue
+function resolveSuiteSelectionFilter(
+  selectedSuite:
+    | {
+        id: string
+        name: string
+        tags: Tag[]
+        testCases: Array<{ id: string; title: string; tags: Tag[] }>
       }
+    | undefined,
+  suiteSelection: TestRunFormValue['testSuites'][number],
+): { clause: string; testRunTestCases: TestRunTestCaseLink[] } | null {
+  if (!selectedSuite || selectedSuite.testCases.length === 0) {
+    return null
+  }
 
-      const suiteIdentifierTag = getIdentifierTagByPrefix(selectedSuite.tags, 'ts_')
-      if (!suiteIdentifierTag) {
-        throw new ServiceError(
-          `Test suite "${selectedSuite.name}" does not have an identifier tag.`,
-          'VALIDATION',
-          400,
-        )
-      }
+  const normalizedSelection = normalizeSuiteSelection(
+    suiteSelection,
+    selectedSuite.testCases.map(testCase => testCase.id),
+  )
 
-      if (normalizedSelection.runAll) {
-        suiteClauses.push(`(${suiteIdentifierTag.tagExpression})`)
-        testRunTestCases.push(
-          ...selectedSuite.testCases.map(testCase => ({
-            testCaseId: testCase.id,
-            testSuiteId: selectedSuite.id,
-          })),
-        )
-        continue
-      }
+  if (!normalizedSelection) {
+    return null
+  }
 
-      const selectedTestCases = selectedSuite.testCases.filter(testCase =>
-        normalizedSelection.testCaseIds.includes(testCase.id),
-      )
+  const suiteIdentifierTag = getIdentifierTagByPrefix(selectedSuite.tags, 'ts_')
+  if (!suiteIdentifierTag) {
+    throw new ServiceError(`Test suite "${selectedSuite.name}" does not have an identifier tag.`, 'VALIDATION', 400)
+  }
 
-      if (selectedTestCases.length === 0) {
-        throw new ServiceError(
-          `Test suite "${selectedSuite.name}" requires at least one selected test case.`,
-          'VALIDATION',
-          400,
-        )
-      }
+  if (normalizedSelection.runAll) {
+    return {
+      clause: `(${suiteIdentifierTag.tagExpression})`,
+      testRunTestCases: selectedSuite.testCases.map(testCase => ({
+        testCaseId: testCase.id,
+        testSuiteId: selectedSuite.id,
+      })),
+    }
+  }
 
-      const missingIdentifierTestCase = selectedTestCases.find(
-        testCase => !getIdentifierTagByPrefix(testCase.tags, 'tc_'),
-      )
-      if (missingIdentifierTestCase) {
-        throw new ServiceError(
-          `Test case "${missingIdentifierTestCase.title}" does not have an identifier tag.`,
-          'VALIDATION',
-          400,
-        )
-      }
+  return resolvePartialSuiteSelectionFilter(selectedSuite, normalizedSelection.testCaseIds, suiteIdentifierTag)
+}
 
-      const testCaseTagExpressions = selectedTestCases.map(testCase => {
-        const identifierTag = getIdentifierTagByPrefix(testCase.tags, 'tc_')
-        return identifierTag!.tagExpression
-      })
+function resolvePartialSuiteSelectionFilter(
+  selectedSuite: {
+    id: string
+    name: string
+    testCases: Array<{ id: string; title: string; tags: Tag[] }>
+  },
+  selectedTestCaseIds: string[],
+  suiteIdentifierTag: Tag,
+): { clause: string; testRunTestCases: TestRunTestCaseLink[] } {
+  const selectedTestCases = selectedSuite.testCases.filter(testCase => selectedTestCaseIds.includes(testCase.id))
 
-      suiteClauses.push(
-        `(${suiteIdentifierTag.tagExpression}) and (${testCaseTagExpressions.map(tag => `(${tag})`).join(' or ')})`,
-      )
-      testRunTestCases.push(
-        ...selectedTestCases.map(testCase => ({
-          testCaseId: testCase.id,
-          testSuiteId: selectedSuite.id,
-        })),
-      )
+  if (selectedTestCases.length === 0) {
+    throw new ServiceError(
+      `Test suite "${selectedSuite.name}" requires at least one selected test case.`,
+      'VALIDATION',
+      400,
+    )
+  }
+
+  const testCaseTagExpressions = selectedTestCases.map(testCase => {
+    const identifierTag = getIdentifierTagByPrefix(testCase.tags, 'tc_')
+    if (!identifierTag) {
+      throw new ServiceError(`Test case "${testCase.title}" does not have an identifier tag.`, 'VALIDATION', 400)
     }
 
-    tagExpression = buildOrExpression(suiteClauses.map(clause => `(${clause})`))
-  }
+    return identifierTag.tagExpression
+  })
 
-  if (!tagExpression) {
-    throw new ServiceError('No executable tests were resolved from the selected filters.', 'VALIDATION', 400)
+  return {
+    clause: `(${suiteIdentifierTag.tagExpression}) and (${testCaseTagExpressions.map(tag => `(${tag})`).join(' or ')})`,
+    testRunTestCases: selectedTestCases.map(testCase => ({
+      testCaseId: testCase.id,
+      testSuiteId: selectedSuite.id,
+    })),
   }
-
-  return { tagExpression, tags, testRunTestCases, environment }
 }
 
 export type UpdateScenarioStatusResult =
@@ -412,7 +435,11 @@ async function persistLogsAndUpdateRunStatus(args: {
   }
 }
 
-async function storeReportAfterRunIfNeeded(testRunDbId: string, runId: string, reportPath: string | null | undefined): Promise<void> {
+async function storeReportAfterRunIfNeeded(
+  testRunDbId: string,
+  runId: string,
+  reportPath: string | null | undefined,
+): Promise<void> {
   const finalTestRunStatus = await prisma.testRun.findUnique({
     where: { id: testRunDbId },
     select: { status: true },
@@ -660,12 +687,15 @@ export async function deleteTestRunsByIds(ids: string[]): Promise<void> {
       reportPath: true,
       testCases: {
         select: {
+          testCaseId: true,
           tracePath: true,
         },
       },
     },
   })
 
+  const deletedRunTestCaseIds = testRuns.flatMap(testRun => testRun.testCases.map(testCase => testCase.testCaseId))
+
   for (const testRun of testRuns) {
     await fs.rm(getAutomationReportRunDir(testRun.runId), { recursive: true, force: true })
 
@@ -703,7 +733,9 @@ export async function deleteTestRunsByIds(ids: string[]): Promise<void> {
     },
   })
 
-  const allAffectedTestCaseIds = [...new Set(allRecentTestRunTestCases.map(trtc => trtc.testCaseId))]
+  const allAffectedTestCaseIds = [
+    ...new Set([...deletedRunTestCaseIds, ...allRecentTestRunTestCases.map(trtc => trtc.testCaseId)]),
+  ]
 
   if (allAffectedTestCaseIds.length > 0) {
     await recalculateMetricsForTestCases(allAffectedTestCaseIds)

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

@@ -1,11 +1,7 @@
 import { describe, expect, it, vi } from 'vitest'
 import { TagType } from '@prisma/client'
 import { automationProjectionService } from '@/lib/automation/projection-service'
-import {
-  createTestSuiteFromInput,
-  deleteTestSuitesByIds,
-  updateTestSuiteFromInput,
-} from './test-suite-service'
+import { createTestSuiteFromInput, deleteTestSuitesByIds, updateTestSuiteFromInput } from './test-suite-service'
 
 vi.mock('@/config/db-config', () => ({
   default: {

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

@@ -65,6 +65,7 @@ export async function getTestSuiteByIdOrThrow(id: string) {
   const testSuite = await prisma.testSuite.findUnique({
     where: { id },
     include: {
+      module: true,
       testCases: true,
       tags: {
         where: {
@@ -133,10 +134,7 @@ export async function deleteTestSuitesByIds(ids: string[]): Promise<void> {
   }
 }
 
-export async function updateTestSuiteFromInput(
-  value: z.infer<typeof testSuiteSchema>,
-  id: string,
-): Promise<void> {
+export async function updateTestSuiteFromInput(value: z.infer<typeof testSuiteSchema>, id: string): Promise<void> {
   const currentTestSuite = await prisma.testSuite.findUnique({
     where: { id },
     include: {

package/templates/starter/src/test/motion-react-vitest-mocks.ts

@@ -0,0 +1,18 @@
+import { createElement, Fragment, type HTMLAttributes, type ReactNode } from 'react'
+
+function MotionDiv({ children, ...props }: HTMLAttributes<HTMLDivElement>) {
+  return createElement('div', props, children)
+}
+
+export const motionReactVitestMock = {
+  AnimatePresence: ({ children }: { children: ReactNode }) => createElement(Fragment, null, children),
+  LazyMotion: ({ children }: { children: ReactNode }) => createElement(Fragment, null, children),
+  domAnimation: {},
+  motion: {
+    div: MotionDiv,
+  },
+}
+
+export const motionReactMVitestMock = {
+  div: MotionDiv,
+}

package/templates/starter/src/test/setup-motion-react-mocks.ts

@@ -0,0 +1,4 @@
+import { vi } from 'vitest'
+
+vi.mock('motion/react', () => import('@/test/motion-react-vitest-mocks').then(m => m.motionReactVitestMock))
+vi.mock('motion/react-m', () => import('@/test/motion-react-vitest-mocks').then(m => m.motionReactMVitestMock))

package/templates/starter/src/types/diagram/diagram.ts

@@ -1,6 +1,7 @@
 import { StepParameterType } from '@prisma/client'
 
 export type NodeData = {
+  nodeId?: string
   order: number
   label: string
   gherkinStep?: string
@@ -18,6 +19,7 @@ export type NodeData = {
 export type NodeOrderMap = Record<string, NodeData>
 
 export type TemplateTestCaseNodeData = {
+  nodeId?: string
   order: number
   label: string
   gherkinStep?: string
@@ -32,3 +34,9 @@ export type TemplateTestCaseNodeData = {
 }
 
 export type TemplateTestCaseNodeOrderMap = Record<string, TemplateTestCaseNodeData>
+
+export type FlowBlock = {
+  id: string
+  name: string
+  nodeIds: string[]
+}

package/templates/starter/src/types/diagram/template-step.ts

@@ -1,8 +1,11 @@
-import { TemplateStep, TemplateStepGroup } from '@prisma/client'
+import { TemplateStep, TemplateStepGroup, TemplateStepParameter } from '@prisma/client'
+
+export type TemplateStepParameterSummary = Pick<TemplateStepParameter, 'id' | 'name'>
 
 /** Template step with optional group relation (e.g. from getAllTemplateStepsAction). */
 export type TemplateStepWithGroup = TemplateStep & {
-  templateStepGroup?: TemplateStepGroup
+  templateStepGroup?: TemplateStepGroup | null
+  parameters?: TemplateStepParameterSummary[]
 }
 
 /** Returns the group name in title case for display (e.g. "navigation" -> "Navigation"). */

package/templates/starter/src/types/form/actionHandler.ts

@@ -1,9 +1,5 @@
 /** Payload types for action `data` fields. */
-export type ActionResponseData =
-  | Record<string, unknown>
-  | Record<string, unknown>[]
-  | unknown[]
-  | unknown
+export type ActionResponseData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | unknown
 
 /**
  * Server Action JSON return shape.

package/templates/starter/src/types/report.ts

@@ -0,0 +1,84 @@
+import type { Prisma } from '@prisma/client'
+
+export 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
+          }
+        }
+      }
+    }
+  }
+}>
+
+export type ReportDetailWithRelations = Prisma.ReportGetPayload<{
+  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
+          }
+        }
+      }
+    }
+  }
+}>

package/templates/starter/tsconfig.json

@@ -20,12 +20,12 @@
       "@locator-picker-companion/*": ["./packages/locator-picker-companion/src/*"]
     }
   },
-  "include": [
-    "next-env.d.ts",
-    "**/*.ts",
-    "**/*.tsx",
-    ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts"
-  ],
-  "exclude": ["node_modules", "packages/create-appraisejs", "packages/appraisejs", "templates/starter"]
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", ".next/dev/types/**/*.ts"],
+  "exclude": [
+    "node_modules",
+    "packages/create-appraisejs",
+    "packages/appraisejs",
+    "templates/starter",
+    "templates/blank"
+  ]
 }

package/templates/blank/src/app/(base)/test-cases/create-from-template/template-selection-form.test.tsx

@@ -1,87 +0,0 @@
-// @vitest-environment jsdom
-
-import { render, screen, waitFor } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import React from 'react'
-import { describe, expect, it, vi } from 'vitest'
-
-import TemplateSelectionForm from './template-selection-form'
-
-const { push } = vi.hoisted(() => ({
-  push: vi.fn(),
-}))
-
-vi.mock('next/navigation', () => ({
-  useRouter: () => ({
-    push,
-  }),
-}))
-
-vi.mock('@/components/ui/select', async () => {
-  const ReactModule = await import('react')
-
-  const SelectContext = ReactModule.createContext<{
-    value: string
-    onValueChange: (value: string) => void
-  }>({
-    value: '',
-    onValueChange: () => {},
-  })
-
-  return {
-    Select: ({
-      value,
-      onValueChange,
-      children,
-    }: {
-      value: string
-      onValueChange: (value: string) => void
-      children: React.ReactNode
-    }) => <SelectContext.Provider value={{ value, onValueChange }}>{children}</SelectContext.Provider>,
-    SelectTrigger: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
-    SelectValue: ({ placeholder }: { placeholder?: string }) => <span>{placeholder}</span>,
-    SelectContent: ({
-      children,
-    }: {
-      children: React.ReactNode
-    }) => {
-      const { value, onValueChange } = ReactModule.useContext(SelectContext)
-
-      return (
-        <select aria-label="Template Test Case" value={value} onChange={event => onValueChange(event.target.value)}>
-          <option value="">Select a template test case</option>
-          {children}
-        </select>
-      )
-    },
-    SelectItem: ({ value, children }: { value: string; children: React.ReactNode }) => (
-      <option value={value}>{children}</option>
-    ),
-  }
-})
-
-describe('TemplateSelectionForm', () => {
-  it('navigates to the generate route after a template is selected', async () => {
-    const user = userEvent.setup()
-
-    render(<TemplateSelectionForm templateTestCases={[{ id: 'template-1', name: 'Login flow' }]} />)
-
-    await user.selectOptions(screen.getByRole('combobox', { name: 'Template Test Case' }), 'template-1')
-    await user.click(screen.getByRole('button', { name: 'Next' }))
-
-    await waitFor(() => {
-      expect(push).toHaveBeenCalledWith('/test-cases/create-from-template/generate/template-1')
-    })
-  })
-
-  it('shows validation feedback when no template is selected', async () => {
-    const user = userEvent.setup()
-
-    render(<TemplateSelectionForm templateTestCases={[{ id: 'template-1', name: 'Login flow' }]} />)
-
-    await user.click(screen.getByRole('button', { name: 'Next' }))
-
-    expect(push).not.toHaveBeenCalled()
-    expect(screen.getByText('Template test case is required')).toBeInTheDocument()
-  })
-})