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

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

@@ -118,6 +118,10 @@ type TestCaseFromFs = {
   steps: ParsedStep[]
 }
 
+type CollapsedTestCaseFromFs = TestCaseFromFs & {
+  expectedSuiteIdentities: Set<string>
+}
+
 type ParameterMatch = {
   name: string
   value: string
@@ -739,14 +743,21 @@ export function countModuleMismatches(
   return count
 }
 
-function countEnvironmentMismatches(
+export function countEnvironmentMismatches(
   filesystemEnvironments: EnvironmentData[],
-  dbEnvironments: Array<{ name: string }>,
+  dbEnvironments: Array<{
+    name: string
+    baseUrl: string
+    apiBaseUrl: string | null
+    username: string | null
+    password: string | null
+    _count?: { testRuns: number }
+  }>,
 ): number {
   const fsByNormalizedName = new Map(
     filesystemEnvironments.map(environment => [getEnvironmentIdentityKey(environment.name), environment]),
   )
-  const dbByNormalizedName = new Map<string, { name: string }>()
+  const dbByNormalizedName = new Map<string, (typeof dbEnvironments)[number]>()
 
   for (const environment of dbEnvironments) {
     const normalizedName = getEnvironmentIdentityKey(environment.name)
@@ -760,11 +771,22 @@ function countEnvironmentMismatches(
     const existing = dbByNormalizedName.get(getEnvironmentIdentityKey(environment.name))
     if (!existing) {
       count++
+      continue
+    }
+
+    if (
+      existing.baseUrl !== environment.baseUrl ||
+      (existing.apiBaseUrl ?? null) !== environment.apiBaseUrl ||
+      (existing.username ?? null) !== environment.username ||
+      (existing.password ?? null) !== environment.password
+    ) {
+      count++
     }
   }
 
   for (const environment of dbEnvironments) {
-    if (!fsByNormalizedName.has(getEnvironmentIdentityKey(environment.name))) {
+    const canDelete = (environment._count?.testRuns ?? 0) === 0
+    if (canDelete && !fsByNormalizedName.has(getEnvironmentIdentityKey(environment.name))) {
       count++
     }
   }
@@ -822,10 +844,15 @@ export function countTemplateStepMismatches(
     parameters: Array<{ name: string; order: number; type: StepParameterType }>
   }>,
 ): number {
+  const filesystemStepsBySignature = new Map<string, TemplateStepFromFs>()
   const dbBySignature = groupRecordsByKey(dbSteps, step => step.signature)
   let count = 0
 
   for (const item of filesystemSteps) {
+    filesystemStepsBySignature.set(item.step.signature, item)
+  }
+
+  for (const item of filesystemStepsBySignature.values()) {
     const expectedType =
       item.groupType === TemplateStepGroupType.ACTION ? TemplateStepType.ACTION : TemplateStepType.ASSERTION
 
@@ -849,16 +876,20 @@ export function countTemplateStepMismatches(
   return count
 }
 
-function countLocatorGroupMismatches(
+export function countLocatorGroupMismatches(
   filesystemGroups: LocatorGroupFromFs[],
   dbGroups: Array<{ name: string; route: string; moduleId: string }>,
   modulePathMap: Map<string, string>,
 ): number {
-  const fsByName = new Map(filesystemGroups.map(group => [group.name, group]))
+  const fsByName = new Map<string, LocatorGroupFromFs>()
   const dbByName = new Map(dbGroups.map(group => [group.name, group]))
   let count = 0
 
   for (const group of filesystemGroups) {
+    fsByName.set(group.name, group)
+  }
+
+  for (const group of fsByName.values()) {
     const existing = dbByName.get(group.name)
     if (!existing) {
       count++
@@ -932,10 +963,15 @@ export function countTestSuiteMismatches(
   const dbByKey = groupRecordsByKey(dbSuites, suite =>
     getTestSuiteSyncIdentity(suite.name, modulePathMap.get(suite.moduleId) ?? '/'),
   )
+  const filesystemSuitesByKey = new Map<string, TestSuiteFromFs>()
   let count = 0
 
   for (const suite of filesystemSuites) {
     const suiteKey = getTestSuiteSyncIdentity(suite.name, suite.modulePath)
+    filesystemSuitesByKey.set(suiteKey, suite)
+  }
+
+  for (const [suiteKey, suite] of filesystemSuitesByKey) {
     const fsTagExpressions = suite.tags.map(normalizeTagExpression)
     const hasMatch = (dbByKey.get(suiteKey) ?? []).some(existing => {
       const dbTagExpressions = existing.tags.map(tag => normalizeTagExpression(tag.tagExpression))
@@ -1017,9 +1053,29 @@ export function countTestCaseMismatches(
     parameters: Array<{ name: string; order: number; type: StepParameterType }>
   }>,
 ): number {
+  const filesystemTestCasesByIdentifier = new Map<string, CollapsedTestCaseFromFs>()
   const dbByIdentifier = new Map<string, Array<(typeof dbTestCases)[number]>>()
   let count = 0
 
+  for (const testCase of filesystemTestCases) {
+    const expectedSuiteIdentity = getTestSuiteSyncIdentity(testCase.testSuiteName, testCase.modulePath)
+    const existing = filesystemTestCasesByIdentifier.get(testCase.identifierTag)
+
+    if (existing) {
+      existing.expectedSuiteIdentities.add(expectedSuiteIdentity)
+      filesystemTestCasesByIdentifier.set(testCase.identifierTag, {
+        ...testCase,
+        expectedSuiteIdentities: existing.expectedSuiteIdentities,
+      })
+      continue
+    }
+
+    filesystemTestCasesByIdentifier.set(testCase.identifierTag, {
+      ...testCase,
+      expectedSuiteIdentities: new Set([expectedSuiteIdentity]),
+    })
+  }
+
   for (const testCase of dbTestCases) {
     const identifierTag = testCase.tags.find(tag => tag.type === TagType.IDENTIFIER)
     if (!identifierTag) {
@@ -1036,22 +1092,23 @@ export function countTestCaseMismatches(
     dbByIdentifier.set(normalizedIdentifier, [testCase])
   }
 
-  for (const testCase of filesystemTestCases) {
-    const expectedSuiteIdentity = getTestSuiteSyncIdentity(testCase.testSuiteName, testCase.modulePath)
+  for (const testCase of filesystemTestCasesByIdentifier.values()) {
     const normalizedFilterTags = testCase.filterTags.map(normalizeTagExpression)
     const hasMatch = (dbByIdentifier.get(testCase.identifierTag) ?? []).some(existing => {
       const existingFilterTags = existing.tags
         .filter(tag => tag.type === TagType.FILTER)
         .map(tag => normalizeTagExpression(tag.tagExpression))
-      const isLinkedToExpectedSuite = existing.TestSuite.some(
-        suite =>
-          getTestSuiteSyncIdentity(suite.name, modulePathMap.get(suite.moduleId) ?? '/') === expectedSuiteIdentity,
+      const existingSuiteIdentities = new Set(
+        existing.TestSuite.map(suite => getTestSuiteSyncIdentity(suite.name, modulePathMap.get(suite.moduleId) ?? '/')),
+      )
+      const isLinkedToExpectedSuites = Array.from(testCase.expectedSuiteIdentities).every(identity =>
+        existingSuiteIdentities.has(identity),
       )
 
       return (
         existing.title === testCase.title &&
         existing.description === testCase.description &&
-        isLinkedToExpectedSuite &&
+        isLinkedToExpectedSuites &&
         sameStringSet(existingFilterTags, normalizedFilterTags) &&
         !hasProjectedTestCaseStepMismatch(testCase.steps, existing.steps, dbTemplateSteps)
       )
@@ -1093,7 +1150,18 @@ export async function getSyncPendingCounts(): Promise<SyncPendingCounts> {
       dbTestCases,
     ] = await Promise.all([
       getAllModulesWithPaths(),
-      prisma.environment.findMany({ select: { name: true } }),
+      prisma.environment.findMany({
+        select: {
+          name: true,
+          baseUrl: true,
+          apiBaseUrl: true,
+          username: true,
+          password: true,
+          _count: {
+            select: { testRuns: true },
+          },
+        },
+      }),
       prisma.tag.findMany({ select: { name: true, type: true } }),
       prisma.templateStepGroup.findMany({ select: { name: true, description: true, type: true } }),
       prisma.templateStep.findMany({

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

@@ -13,7 +13,7 @@ function getAutomationLocatorsDir(baseDir: string): string {
 }
 
 export function getAutomationLocatorMapPath(baseDir: string): string {
-  return join(baseDir, 'automation', 'mapping', 'locator-map.json')
+  return toPosixPath(join(baseDir, 'automation', 'mapping', 'locator-map.json'))
 }
 
 export function extractModulePathFromAutomationFile(

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

@@ -1,7 +1,14 @@
-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
+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/blank/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/blank/src/lib/test-run/log-formatter.ts

@@ -1,83 +1,82 @@
-/**
- * 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
+}