create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/starter/src/lib/sync/sync-registry.ts

@@ -92,7 +92,7 @@ const syncScriptDefinitionMap = new Map<SyncScriptId, (typeof syncScriptDefiniti
   syncScriptDefinitions.map(definition => [definition.id, definition]),
 )
 
-export function isSyncScriptId(value: string): value is SyncScriptId {
+function isSyncScriptId(value: string): value is SyncScriptId {
   return syncScriptDefinitionMap.has(value as SyncScriptId)
 }
 
@@ -110,7 +110,7 @@ export function getSyncScriptDefinition(scriptId: SyncScriptId) {
   return definition
 }
 
-export function resolveSyncExecutionOrder(requestedScriptId: SyncScriptId): SyncScriptId[] {
+function resolveSyncExecutionOrder(requestedScriptId: SyncScriptId): SyncScriptId[] {
   const visiting = new Set<SyncScriptId>()
   const visited = new Set<SyncScriptId>()
   const executionOrder: SyncScriptId[] = []

package/templates/starter/src/lib/tag-filters.ts

@@ -0,0 +1,11 @@
+import { Tag, TagType } from '@prisma/client'
+
+type TagShape = Pick<Tag, 'name' | 'tagExpression' | 'type'>
+
+export function getIdentifierTagByPrefix<T extends TagShape>(tags: T[], prefix: 'tc_' | 'ts_'): T | undefined {
+  return tags.find(tag => tag.type === TagType.IDENTIFIER && tag.name.startsWith(prefix))
+}
+
+export function getFilterTags<T extends TagShape>(tags: T[]): T[] {
+  return tags.filter(tag => tag.type === TagType.FILTER)
+}

package/templates/starter/src/lib/tag-identifiers.ts

@@ -0,0 +1,18 @@
+import { TagType } from '@prisma/client'
+
+function isIdentifierTagName(name: string): boolean {
+  return name.startsWith('tc_') || name.startsWith('ts_')
+}
+
+function isIdentifierTagExpression(tagExpression: string): boolean {
+  const normalized = tagExpression.startsWith('@') ? tagExpression.slice(1) : tagExpression
+  return isIdentifierTagName(normalized)
+}
+
+export function getTagTypeFromName(name: string): TagType {
+  return isIdentifierTagName(name) ? TagType.IDENTIFIER : TagType.FILTER
+}
+
+export function getTagTypeFromExpression(tagExpression: string): TagType {
+  return isIdentifierTagExpression(tagExpression) ? TagType.IDENTIFIER : TagType.FILTER
+}

package/templates/starter/src/lib/tag-utils.ts

@@ -1,28 +1,2 @@
-import { Tag, TagType } from '@prisma/client'
-
-type TagShape = Pick<Tag, 'name' | 'tagExpression' | 'type'>
-
-export function isIdentifierTagName(name: string): boolean {
-  return name.startsWith('tc_') || name.startsWith('ts_')
-}
-
-export function isIdentifierTagExpression(tagExpression: string): boolean {
-  const normalized = tagExpression.startsWith('@') ? tagExpression.slice(1) : tagExpression
-  return isIdentifierTagName(normalized)
-}
-
-export function getTagTypeFromName(name: string): TagType {
-  return isIdentifierTagName(name) ? TagType.IDENTIFIER : TagType.FILTER
-}
-
-export function getTagTypeFromExpression(tagExpression: string): TagType {
-  return isIdentifierTagExpression(tagExpression) ? TagType.IDENTIFIER : TagType.FILTER
-}
-
-export function getIdentifierTagByPrefix<T extends TagShape>(tags: T[], prefix: 'tc_' | 'ts_'): T | undefined {
-  return tags.find(tag => tag.type === TagType.IDENTIFIER && tag.name.startsWith(prefix))
-}
-
-export function getFilterTags<T extends TagShape>(tags: T[]): T[] {
-  return tags.filter(tag => tag.type === TagType.FILTER)
-}
+export * from './tag-filters'
+export * from './tag-identifiers'

package/templates/starter/src/lib/template-automation-paths.ts

@@ -0,0 +1,34 @@
+import { join, relative } from 'path'
+
+function toPosixPath(value: string): string {
+  return value.replace(/\\/g, '/')
+}
+
+function getAutomationFeaturesDir(baseDir: string): string {
+  return join(baseDir, 'automation', 'features')
+}
+
+function getAutomationLocatorsDir(baseDir: string): string {
+  return join(baseDir, 'automation', 'locators')
+}
+
+export function getAutomationLocatorMapPath(baseDir: string): string {
+  return join(baseDir, 'automation', 'mapping', 'locator-map.json')
+}
+
+export function extractModulePathFromAutomationFile(
+  filePath: string,
+  baseDir: string,
+  automationSubdir: 'features' | 'locators',
+): string {
+  const automationBaseDir =
+    automationSubdir === 'features' ? getAutomationFeaturesDir(baseDir) : getAutomationLocatorsDir(baseDir)
+  const normalizedBaseDir = toPosixPath(automationBaseDir).replace(/\/$/, '')
+  const normalizedFilePath = toPosixPath(filePath)
+  const relativePath = normalizedFilePath.startsWith(`${normalizedBaseDir}/`)
+    ? normalizedFilePath.slice(normalizedBaseDir.length + 1)
+    : toPosixPath(relative(automationBaseDir, filePath))
+  const pathParts = relativePath.split('/').filter(part => part && part !== '')
+  const moduleParts = pathParts.slice(0, -1)
+  return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/'
+}

package/templates/starter/src/lib/template-path-exclusions.ts

@@ -0,0 +1,34 @@
+const EXCLUDED_DIRS = new Set(['node_modules', '.next', '.git', 'dist'])
+const EXCLUDED_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.tsbuildinfo'])
+const EXCLUDED_PATH_PREFIXES = ['automation/reports/']
+const EXCLUDED_FILENAMES = new Set(['.DS_Store'])
+
+function toPosixPath(value: string): string {
+  return value.replace(/\\/g, '/')
+}
+
+export function shouldExcludeTemplatePath(relativePath: string): boolean {
+  const normalizedPath = toPosixPath(relativePath)
+  const parts = normalizedPath.split('/')
+
+  if (parts.some(part => EXCLUDED_DIRS.has(part))) return true
+  if (parts.some(part => EXCLUDED_FILENAMES.has(part))) return true
+  if (EXCLUDED_PATH_PREFIXES.some(prefix => normalizedPath.startsWith(prefix))) return true
+
+  const ext = normalizedPath.endsWith('.sqlite3')
+    ? '.sqlite3'
+    : normalizedPath.endsWith('.sqlite')
+      ? '.sqlite'
+      : normalizedPath.endsWith('.tsbuildinfo')
+        ? '.tsbuildinfo'
+        : normalizedPath.slice(normalizedPath.lastIndexOf('.'))
+
+  return EXCLUDED_EXTENSIONS.has(ext)
+}
+
+export function shouldBackfillLegacyEnvironmentConfig(
+  targetHasEnvironmentsFile: boolean,
+  legacyEnvironmentsDirExists: boolean,
+): boolean {
+  return !targetHasEnvironmentsFile && legacyEnvironmentsDirExists
+}

package/templates/starter/src/lib/template-sync-utils.d.ts

@@ -1,7 +1,7 @@
-export declare function shouldExcludeTemplatePath(relativePath: string): boolean;
-export declare function shouldBackfillLegacyEnvironmentConfig(targetHasEnvironmentsFile: boolean, legacyEnvironmentsDirExists: boolean): boolean;
-export declare function getAutomationFeaturesDir(baseDir: string): string;
-export declare function getAutomationLocatorsDir(baseDir: string): string;
-export declare function getAutomationLocatorMapPath(baseDir: string): string;
-export declare function extractModulePathFromAutomationFile(filePath: string, baseDir: string, automationSubdir: 'features' | 'locators'): string;
+export declare function shouldExcludeTemplatePath(relativePath: string): boolean;
+export declare function shouldBackfillLegacyEnvironmentConfig(targetHasEnvironmentsFile: boolean, legacyEnvironmentsDirExists: boolean): boolean;
+export declare function getAutomationFeaturesDir(baseDir: string): string;
+export declare function getAutomationLocatorsDir(baseDir: string): string;
+export declare function getAutomationLocatorMapPath(baseDir: string): string;
+export declare function extractModulePathFromAutomationFile(filePath: string, baseDir: string, automationSubdir: 'features' | 'locators'): string;
 //# sourceMappingURL=template-sync-utils.d.ts.map

package/templates/starter/src/lib/template-sync-utils.ts

@@ -1,65 +1,2 @@
-import { join, relative } from 'path'
-
-const EXCLUDED_DIRS = new Set(['node_modules', '.next', '.git', 'dist'])
-const EXCLUDED_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.tsbuildinfo'])
-const EXCLUDED_PATH_PREFIXES = ['automation/reports/']
-const EXCLUDED_FILENAMES = new Set(['.DS_Store'])
-
-function toPosixPath(value: string): string {
-  return value.replace(/\\/g, '/')
-}
-
-export function shouldExcludeTemplatePath(relativePath: string): boolean {
-  const normalizedPath = toPosixPath(relativePath)
-  const parts = normalizedPath.split('/')
-
-  if (parts.some(part => EXCLUDED_DIRS.has(part))) return true
-  if (parts.some(part => EXCLUDED_FILENAMES.has(part))) return true
-  if (EXCLUDED_PATH_PREFIXES.some(prefix => normalizedPath.startsWith(prefix))) return true
-
-  const ext = normalizedPath.endsWith('.sqlite3')
-    ? '.sqlite3'
-    : normalizedPath.endsWith('.sqlite')
-      ? '.sqlite'
-      : normalizedPath.endsWith('.tsbuildinfo')
-        ? '.tsbuildinfo'
-        : normalizedPath.slice(normalizedPath.lastIndexOf('.'))
-
-  return EXCLUDED_EXTENSIONS.has(ext)
-}
-
-export function shouldBackfillLegacyEnvironmentConfig(
-  targetHasEnvironmentsFile: boolean,
-  legacyEnvironmentsDirExists: boolean,
-): boolean {
-  return !targetHasEnvironmentsFile && legacyEnvironmentsDirExists
-}
-
-export function getAutomationFeaturesDir(baseDir: string): string {
-  return join(baseDir, 'automation', 'features')
-}
-
-export function getAutomationLocatorsDir(baseDir: string): string {
-  return join(baseDir, 'automation', 'locators')
-}
-
-export function getAutomationLocatorMapPath(baseDir: string): string {
-  return join(baseDir, 'automation', 'mapping', 'locator-map.json')
-}
-
-export function extractModulePathFromAutomationFile(
-  filePath: string,
-  baseDir: string,
-  automationSubdir: 'features' | 'locators',
-): string {
-  const automationBaseDir =
-    automationSubdir === 'features' ? getAutomationFeaturesDir(baseDir) : getAutomationLocatorsDir(baseDir)
-  const normalizedBaseDir = toPosixPath(automationBaseDir).replace(/\/$/, '')
-  const normalizedFilePath = toPosixPath(filePath)
-  const relativePath = normalizedFilePath.startsWith(`${normalizedBaseDir}/`)
-    ? normalizedFilePath.slice(normalizedBaseDir.length + 1)
-    : toPosixPath(relative(automationBaseDir, filePath))
-  const pathParts = relativePath.split('/').filter(part => part && part !== '')
-  const moduleParts = pathParts.slice(0, -1)
-  return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/'
-}
+export { extractModulePathFromAutomationFile, getAutomationLocatorMapPath } from './template-automation-paths'
+export { shouldBackfillLegacyEnvironmentConfig, shouldExcludeTemplatePath } from './template-path-exclusions'

package/templates/starter/src/lib/test-case-utils.ts

@@ -1,6 +1,6 @@
-import crypto from 'crypto'
-
-export function generateUniqueTestCaseIdentifier(): string {
-  const id = crypto.randomBytes(8).toString('hex')
-  return `tc_${id}`
-}
+import crypto from 'crypto'
+
+export function generateUniqueTestCaseIdentifier(): string {
+  const id = crypto.randomBytes(8).toString('hex')
+  return `tc_${id}`
+}

package/templates/starter/src/lib/test-run/log-formatter.ts

@@ -1,83 +1,83 @@
-/**
- * Log formatting utilities for storing and retrieving test run logs
- */
-
-export interface LogEntry {
-  type: 'stdout' | 'stderr' | 'status'
-  message: string
-  timestamp: Date
-}
-
-/**
- * Formats log entries into a single text string for storage in the database
- * Format: [timestamp] [TYPE] message
- * 
- * @param logs - Array of log entries to format
- * @returns Formatted log string
- */
-export function formatLogsForStorage(logs: LogEntry[]): string {
-  return logs
-    .map(log => {
-      const timestamp = log.timestamp.toISOString()
-      const type = log.type.toUpperCase()
-      // Escape newlines in message to preserve them in the formatted string
-      const escapedMessage = log.message.replace(/\n/g, '\\n')
-      return `[${timestamp}] [${type}] ${escapedMessage}`
-    })
-    .join('\n')
-}
-
-/**
- * Parses formatted log text back into an array of LogEntry objects
- * 
- * @param formattedLogs - Formatted log string from database
- * @returns Array of log entries
- */
-export function parseLogsFromStorage(formattedLogs: string): LogEntry[] {
-  if (!formattedLogs || formattedLogs.trim() === '') {
-    return []
-  }
-
-  const lines = formattedLogs.split('\n')
-  const parsedLogs: LogEntry[] = []
-
-  for (const line of lines) {
-    if (!line.trim()) continue
-
-    try {
-      // Match format: [timestamp] [TYPE] message
-      const match = line.match(/^\[([^\]]+)\] \[([^\]]+)\] (.+)$/)
-      
-      if (match) {
-        const [, timestampStr, typeStr, message] = match
-        const timestamp = new Date(timestampStr)
-        const type = typeStr.toLowerCase() as 'stdout' | 'stderr' | 'status'
-        
-        // Unescape newlines in message
-        const unescapedMessage = message.replace(/\\n/g, '\n')
-        
-        // Validate type
-        if (type === 'stdout' || type === 'stderr' || type === 'status') {
-          parsedLogs.push({
-            type,
-            message: unescapedMessage,
-            timestamp: isNaN(timestamp.getTime()) ? new Date() : timestamp,
-          })
-        }
-      } else {
-        // Fallback: treat as stdout if format doesn't match
-        parsedLogs.push({
-          type: 'stdout',
-          message: line,
-          timestamp: new Date(),
-        })
-      }
-    } catch (error) {
-      // Skip malformed lines
-      console.error('[LogFormatter] Error parsing log line:', line, error)
-    }
-  }
-
-  return parsedLogs
-}
-
+/**
+ * Log formatting utilities for storing and retrieving test run logs
+ */
+
+export interface LogEntry {
+  type: 'stdout' | 'stderr' | 'status'
+  message: string
+  timestamp: Date
+}
+
+/**
+ * Formats log entries into a single text string for storage in the database
+ * Format: [timestamp] [TYPE] message
+ * 
+ * @param logs - Array of log entries to format
+ * @returns Formatted log string
+ */
+export function formatLogsForStorage(logs: LogEntry[]): string {
+  return logs
+    .map(log => {
+      const timestamp = log.timestamp.toISOString()
+      const type = log.type.toUpperCase()
+      // Escape newlines in message to preserve them in the formatted string
+      const escapedMessage = log.message.replace(/\n/g, '\\n')
+      return `[${timestamp}] [${type}] ${escapedMessage}`
+    })
+    .join('\n')
+}
+
+/**
+ * Parses formatted log text back into an array of LogEntry objects
+ * 
+ * @param formattedLogs - Formatted log string from database
+ * @returns Array of log entries
+ */
+export function parseLogsFromStorage(formattedLogs: string): LogEntry[] {
+  if (!formattedLogs || formattedLogs.trim() === '') {
+    return []
+  }
+
+  const lines = formattedLogs.split('\n')
+  const parsedLogs: LogEntry[] = []
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+
+    try {
+      // Match format: [timestamp] [TYPE] message
+      const match = line.match(/^\[([^\]]+)\] \[([^\]]+)\] (.+)$/)
+      
+      if (match) {
+        const [, timestampStr, typeStr, message] = match
+        const timestamp = new Date(timestampStr)
+        const type = typeStr.toLowerCase() as 'stdout' | 'stderr' | 'status'
+        
+        // Unescape newlines in message
+        const unescapedMessage = message.replace(/\\n/g, '\n')
+        
+        // Validate type
+        if (type === 'stdout' || type === 'stderr' || type === 'status') {
+          parsedLogs.push({
+            type,
+            message: unescapedMessage,
+            timestamp: isNaN(timestamp.getTime()) ? new Date() : timestamp,
+          })
+        }
+      } else {
+        // Fallback: treat as stdout if format doesn't match
+        parsedLogs.push({
+          type: 'stdout',
+          message: line,
+          timestamp: new Date(),
+        })
+      }
+    } catch (error) {
+      // Skip malformed lines
+      console.error('[LogFormatter] Error parsing log line:', line, error)
+    }
+  }
+
+  return parsedLogs
+}
+

package/templates/starter/src/lib/test-run/matching.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest'
+import { TagType, TestRunTestCaseStatus } from '@prisma/client'
+import { findMatchingTestRunTestCase } from '@/lib/test-run/matching'
+
+const identifierTag = (tagExpression: string) => ({
+  name: tagExpression.slice(1),
+  tagExpression,
+  type: TagType.IDENTIFIER,
+})
+
+const runTestCase = (
+  overrides: Partial<Parameters<typeof findMatchingTestRunTestCase>[0][number]> & {
+    id: string
+    title: string
+    suiteTag?: string
+    testCaseTag?: string
+  },
+) => ({
+  id: overrides.id,
+  status: overrides.status ?? TestRunTestCaseStatus.PENDING,
+  testSuiteId: overrides.testSuiteId ?? 'suite-1',
+  testCase: {
+    id: `case-${overrides.id}`,
+    title: overrides.title,
+    tags: overrides.testCaseTag ? [identifierTag(overrides.testCaseTag)] : [],
+  },
+  testSuite: overrides.suiteTag
+    ? {
+        id: overrides.testSuiteId ?? 'suite-1',
+        name: 'Smoke Suite',
+        tags: [identifierTag(overrides.suiteTag)],
+      }
+    : null,
+})
+
+describe('findMatchingTestRunTestCase', () => {
+  it('prefers suite and test case identifier tags over scenario titles', () => {
+    const suiteOnlyMatch = runTestCase({
+      id: 'suite-only',
+      title: 'Checkout',
+      suiteTag: '@ts_checkout',
+      testCaseTag: '@tc_wrong',
+    })
+    const exactIdentifierMatch = runTestCase({
+      id: 'exact',
+      title: 'Different title',
+      suiteTag: '@ts_checkout',
+      testCaseTag: '@tc_pay',
+    })
+
+    const match = findMatchingTestRunTestCase([suiteOnlyMatch, exactIdentifierMatch], {
+      scenarioName: '[Checkout] Pay with card',
+      scenarioTags: ['ts_checkout', '@tc_pay'],
+    })
+
+    expect(match).toBe(exactIdentifierMatch)
+  })
+
+  it('falls back to bracketed scenario titles and chooses an unfinished candidate first', () => {
+    const completedCandidate = runTestCase({
+      id: 'completed',
+      status: TestRunTestCaseStatus.COMPLETED,
+      title: 'Checkout',
+    })
+    const pendingCandidate = runTestCase({
+      id: 'pending',
+      status: TestRunTestCaseStatus.PENDING,
+      title: 'Checkout',
+    })
+
+    const match = findMatchingTestRunTestCase([completedCandidate, pendingCandidate], {
+      scenarioName: '[Checkout] Pay with card',
+    })
+
+    expect(match).toBe(pendingCandidate)
+  })
+})

package/templates/starter/src/lib/test-run/matching.ts

@@ -1,5 +1,5 @@
 import { TagType, TestRunTestCaseStatus } from '@prisma/client'
-import { getIdentifierTagByPrefix } from '@/lib/tag-utils'
+import { getIdentifierTagByPrefix } from '@/lib/tag-filters'
 
 type TagLike = {
   name: string
@@ -41,7 +41,7 @@ function consumeCandidate<T extends MatchableRunTestCase>(candidates: T[]): T |
   return unconsumed ?? candidates[0]
 }
 
-export function extractTestCaseTitleFromScenarioName(scenarioName: string): string | null {
+function extractTestCaseTitleFromScenarioName(scenarioName: string): string | null {
   const bracketMatch = scenarioName.match(/^\[([^\]]+)\]/)
   if (bracketMatch) {
     return bracketMatch[1].trim()

package/templates/starter/src/lib/test-run/report-parser.test.ts

@@ -0,0 +1,113 @@
+import { readFile } from 'fs/promises'
+import { StepKeyword, StepStatus } from '@prisma/client'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { getStepKeywordEnum, getStepStatusEnum, parseCucumberReport } from '@/lib/test-run/report-parser'
+
+vi.mock('fs/promises', () => ({
+  readFile: vi.fn(),
+}))
+
+describe('parseCucumberReport', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+  })
+
+  it('maps cucumber features, hooks, errors, and screenshot attachments', async () => {
+    vi.mocked(readFile).mockResolvedValueOnce(
+      JSON.stringify([
+        {
+          description: 'Feature description',
+          elements: [
+            {
+              description: 'Scenario description',
+              id: 'checkout;pay-with-card',
+              keyword: 'Scenario',
+              line: 7,
+              name: 'Pay with card',
+              steps: [
+                {
+                  keyword: 'Before',
+                  result: { duration: 1, status: 'passed' },
+                },
+                {
+                  embeddings: [
+                    {
+                      data: JSON.stringify({ screenshotPath: 'screenshots/pay-card.png' }),
+                      mime_type: 'application/vnd.appraisejs.report-step-screenshot+json',
+                    },
+                  ],
+                  keyword: 'Given ',
+                  line: 9,
+                  match: { location: 'steps/payment.ts:12' },
+                  name: 'I am on checkout',
+                  result: {
+                    duration: 10,
+                    error_message: 'Expected checkout page\n    at steps/payment.ts:12:3',
+                    status: 'failed',
+                  },
+                },
+              ],
+              tags: [{ line: 6, name: '@tc_pay' }],
+              type: 'scenario',
+            },
+          ],
+          id: 'checkout',
+          keyword: 'Feature',
+          line: 1,
+          name: 'Checkout',
+          tags: [{ line: 1, name: '@ts_checkout' }],
+          uri: 'features/checkout.feature',
+        },
+      ]),
+    )
+
+    const report = await parseCucumberReport('/tmp/cucumber.json')
+
+    expect(report.features[0]).toMatchObject({
+      description: 'Feature description',
+      keyword: 'Feature',
+      line: 1,
+      name: 'Checkout',
+      scenarios: [
+        {
+          cucumberId: 'checkout;pay-with-card',
+          hooks: [{ duration: 1, hidden: false, keyword: 'Before', status: 'passed' }],
+          name: 'Pay with card',
+          steps: [
+            {
+              duration: 10,
+              errorMessage: 'Expected checkout page',
+              errorTrace: 'at steps/payment.ts:12:3',
+              keyword: 'Given',
+              line: 9,
+              matchLocation: 'steps/payment.ts:12',
+              name: 'I am on checkout',
+              order: 1,
+              screenshotPath: 'screenshots/pay-card.png',
+              status: 'failed',
+            },
+          ],
+        },
+      ],
+      tags: [{ line: 1, name: '@ts_checkout' }],
+      uri: 'features/checkout.feature',
+    })
+  })
+
+  it('wraps read and parse failures with report path context', async () => {
+    vi.mocked(readFile).mockRejectedValueOnce(new Error('permission denied'))
+
+    await expect(parseCucumberReport('/tmp/missing.json')).rejects.toThrow(
+      'Failed to parse cucumber report at /tmp/missing.json: permission denied',
+    )
+  })
+})
+
+describe('report parser enum helpers', () => {
+  it('maps unknown statuses and keywords to safe defaults', () => {
+    expect(getStepStatusEnum('passed')).toBe(StepStatus.PASSED)
+    expect(getStepStatusEnum('unknown')).toBe(StepStatus.PENDING)
+    expect(getStepKeywordEnum(' Then ')).toBe(StepKeyword.THEN)
+    expect(getStepKeywordEnum('Eventually')).toBe(StepKeyword.GIVEN)
+  })
+})