Unit test case

Author: vishnuv688

packages/app/src/components/workbench/compare.ts

@@ -808,9 +808,12 @@ export class DevtoolsCompare extends Element {
         : isFailureSite
           ? step?.error?.matcherResult?.actual
           : undefined
-    const assertionMessage = isFailureSite
+    const rawAssertion = isFailureSite
       ? step?.error?.matcherResult?.message || step?.error?.message
       : undefined
+    const assertionMessage = rawAssertion
+      ? cleanErrorMessage(rawAssertion)
+      : undefined
     // Fallback: extract the expected from the Cucumber step text.
     const stepText = step?.fullTitle || step?.title || ''
     const fallbackExpected =

packages/app/tests/compareUtils.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest'
+
+import {
+  pairSteps,
+  commandsEqual,
+  classifyDivergence,
+  extractExpectedFromStepText,
+  safeJson
+} from '../src/components/workbench/compare/compareUtils.js'
+
+const cmd = (
+  command: string,
+  args: unknown[] = [],
+  extra: Record<string, unknown> = {}
+) =>
+  ({
+    command,
+    args,
+    result: null,
+    timestamp: 0,
+    callSource: '',
+    ...extra
+  }) as never
+
+describe('compareUtils', () => {
+  it('commandsEqual ignores `result` (W3C element refs drift across sessions) but catches command/args/error diffs', () => {
+    // Identical → equal
+    expect(commandsEqual(cmd('url', ['/a']), cmd('url', ['/a']))).toBe(true)
+    // Same call but a different element-ref in result → still equal
+    const refA = cmd('$', ['#x'], {
+      result: { 'element-6066-11e4-a52e-4f735466cecf': 'a' }
+    })
+    const refB = cmd('$', ['#x'], {
+      result: { 'element-6066-11e4-a52e-4f735466cecf': 'b' }
+    })
+    expect(commandsEqual(refA, refB)).toBe(true)
+    // Real divergences
+    expect(commandsEqual(cmd('url'), cmd('click'))).toBe(false)
+    expect(commandsEqual(cmd('url', ['/a']), cmd('url', ['/b']))).toBe(false)
+    expect(
+      commandsEqual(
+        cmd('click', [], { error: { message: 'boom' } }),
+        cmd('click')
+      )
+    ).toBe(false)
+    // Missing side
+    expect(commandsEqual(undefined, cmd('url'))).toBe(false)
+  })
+
+  it('classifyDivergence labels every kind correctly', () => {
+    expect(classifyDivergence(cmd('url'), cmd('url'))).toBe('none')
+    expect(classifyDivergence(cmd('url'), undefined)).toBe('missing')
+    expect(classifyDivergence(cmd('url'), cmd('click'))).toBe('commandName')
+    expect(classifyDivergence(cmd('url', ['/a']), cmd('url', ['/b']))).toBe(
+      'args'
+    )
+    expect(
+      classifyDivergence(
+        cmd('click', [], { error: { message: 'boom' } }),
+        cmd('click')
+      )
+    ).toBe('error')
+  })
+
+  it('pairSteps locks the fork bit once execution diverges and handles uneven lengths', () => {
+    const pairs = pairSteps(
+      [cmd('url'), cmd('a'), cmd('b'), cmd('c')],
+      [cmd('url'), cmd('X'), cmd('Y')]
+    )
+    expect(pairs.map((p) => p.divergent)).toEqual([false, true, true, true])
+    expect(pairs[3].baseline?.command).toBe('c')
+    expect(pairs[3].latest).toBeUndefined()
+  })
+
+  it('extractExpectedFromStepText pulls the parameterized tail from Cucumber Then steps', () => {
+    expect(
+      extractExpectedFromStepText(
+        '1: Then I should see a flash message saying You logged in!'
+      )
+    ).toBe('You logged in!')
+    expect(extractExpectedFromStepText('')).toBeUndefined()
+  })
+
+  it('safeJson stringifies, truncates long output, and survives cyclic refs', () => {
+    expect(safeJson({ a: 1 })).toBe('{"a":1}')
+    const truncated = safeJson('x'.repeat(2000))
+    expect(truncated.endsWith('…')).toBe(true)
+    const cyclic: Record<string, unknown> = {}
+    cyclic.self = cyclic
+    expect(safeJson(cyclic)).toBe('[object Object]')
+  })
+})

packages/backend/tests/baseline/utils.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest'
+import { toMs, pickMin, pickMax } from '../../src/baseline/utils.js'
+
+describe('baseline/utils', () => {
+  it('toMs coerces Date / ISO / number to ms and rejects garbage', () => {
+    const ms = 1700000000000
+    expect(toMs(ms)).toBe(ms)
+    expect(toMs(new Date(ms))).toBe(ms)
+    expect(toMs('2025-01-15T10:00:00.000Z')).toBe(
+      Date.parse('2025-01-15T10:00:00.000Z')
+    )
+    expect(toMs(null)).toBeUndefined()
+    expect(toMs('not-a-date')).toBeUndefined()
+  })
+
+  it('pickMin / pickMax tolerate undefined on either side', () => {
+    expect(pickMin(undefined, 5)).toBe(5)
+    expect(pickMin(7, 3)).toBe(3)
+    expect(pickMin(undefined, undefined)).toBeUndefined()
+    expect(pickMax(7, undefined)).toBe(7)
+    expect(pickMax(3, 8)).toBe(8)
+  })
+})

packages/backend/tests/baselineStore.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+
+import { baselineStore } from '../src/baselineStore.js'
+
+const SUITE_UID = 'suite-1'
+const TEST_UID = 'test-1'
+
+function suite(opts: {
+  start: number
+  end?: number
+  state?: 'passed' | 'failed' | 'pending' | 'running'
+  childState?: 'passed' | 'failed'
+  childError?: { message: string }
+}) {
+  return [
+    {
+      [SUITE_UID]: {
+        uid: SUITE_UID,
+        title: 'My Suite',
+        file: '/spec.ts',
+        start: opts.start,
+        end: opts.end,
+        state: opts.state,
+        tests: [
+          {
+            uid: TEST_UID,
+            title: 'should do a thing',
+            fullTitle: 'My Suite should do a thing',
+            start: opts.start,
+            end: opts.end,
+            state: opts.childState,
+            error: opts.childError
+          }
+        ],
+        suites: []
+      }
+    }
+  ]
+}
+
+describe('baselineStore', () => {
+  beforeEach(() => {
+    baselineStore.resetActiveRun()
+    baselineStore.clearAll()
+  })
+
+  it('filters commands to the test time window and ignores commands outside it', () => {
+    baselineStore.recordEvent('commands', [
+      { timestamp: 100, command: 'before', args: [] },
+      { timestamp: 250, command: 'inside', args: [] },
+      { timestamp: 900, command: 'after', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 200, end: 300 }))
+
+    const snap = baselineStore.snapshot(TEST_UID, 'test')!
+    expect(snap.commands.map((c) => c.command)).toEqual(['inside'])
+    expect(baselineStore.snapshot('does-not-exist', 'test')).toBeUndefined()
+  })
+
+  it('replaces (not unions) the time window when a new run is detected', () => {
+    baselineStore.recordEvent(
+      'suites',
+      suite({
+        start: 100,
+        end: 200,
+        state: 'failed',
+        childState: 'failed',
+        childError: { message: 'old failure' }
+      })
+    )
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'first-run', args: [] }
+    ])
+    // Incoming.start > previous.end → isNewRun
+    baselineStore.recordEvent(
+      'suites',
+      suite({ start: 500, end: 600, state: 'passed', childState: 'passed' })
+    )
+    baselineStore.recordEvent('commands', [
+      { timestamp: 550, command: 'second-run', args: [] }
+    ])
+
+    const snap = baselineStore.snapshot(TEST_UID, 'test')!
+    expect(snap.window).toEqual({ start: 500, end: 600 })
+    expect(snap.commands.map((c) => c.command)).toEqual(['second-run'])
+    // State + error reset on the new run — no stale failure leak.
+    expect(snap.test.state).toBe('passed')
+    expect(snap.test.error).toBeUndefined()
+  })
+
+  it("rolls a failing descendant's state + error up to a suite-scope snapshot", () => {
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'click', args: [] }
+    ])
+    baselineStore.recordEvent(
+      'suites',
+      suite({
+        start: 100,
+        end: 200,
+        childState: 'failed',
+        childError: { message: 'expected X, got Y' }
+      })
+    )
+
+    const snap = baselineStore.snapshot(SUITE_UID, 'suite')!
+    expect(snap.test.state).toBe('failed')
+    expect(snap.test.error?.message).toBe('expected X, got Y')
+    expect(snap.steps?.[0]).toMatchObject({
+      uid: TEST_UID,
+      state: 'failed'
+    })
+  })
+
+  it('preserve refuses an empty-command snapshot (the 409 case)', () => {
+    baselineStore.recordEvent('suites', suite({ start: 100, end: 200 }))
+    expect(baselineStore.preserve(TEST_UID, 'test')).toBeUndefined()
+    expect(baselineStore.get(TEST_UID)).toBeUndefined()
+  })
+
+  it('preserve stores; clearAll wipes every baseline and returns their uids', () => {
+    baselineStore.recordEvent('commands', [
+      { timestamp: 150, command: 'click', args: [] }
+    ])
+    baselineStore.recordEvent('suites', suite({ start: 100, end: 200 }))
+
+    const attempt = baselineStore.preserve(TEST_UID, 'test')!
+    expect(baselineStore.get(TEST_UID)).toBe(attempt)
+
+    expect(baselineStore.clearAll()).toEqual([TEST_UID])
+    expect(baselineStore.get(TEST_UID)).toBeUndefined()
+  })
+})