output steps

Author: davidjgoss

javascript/package-lock.json

@@ -22,6 +22,7 @@
   "dependencies": {
     "@cucumber/gherkin-utils": "^9.0.0",
     "@cucumber/query": "^12.2.0",
+    "@teppeis/multimaps": "^3.0.0",
     "xmlbuilder": "^15.1.1"
   },
   "devDependencies": {

javascript/package.json

@@ -2,41 +2,56 @@ import * as assert from 'node:assert'
 
 import {
   Envelope,
+  Feature,
   getWorstTestStepResult,
+  GherkinDocument,
   Pickle,
+  PickleStep,
+  Step,
   TestCase,
   TestCaseFinished,
   TestCaseStarted,
   TestRunFinished,
   TestRunStarted,
+  TestStep,
+  TestStepFinished,
   TestStepResultStatus,
   TimeConversion,
 } from '@cucumber/messages'
-import { Query as CucumberQuery } from '@cucumber/query'
+import { ArrayMultimap } from '@teppeis/multimaps'
 
-export class ExtendedQuery extends CucumberQuery {
+export class ExtendedQuery {
   private testRunStarted: TestRunStarted
   private testRunFinished: TestRunFinished
   private testCaseStarted: Array<TestCaseStarted> = []
+  private readonly stepById: Map<string, Step> = new Map()
   private readonly pickleById: Map<string, Pickle> = new Map()
+  private readonly pickleStepById: Map<string, PickleStep> = new Map()
   private readonly testCaseById: Map<string, TestCase> = new Map()
+  private readonly testStepById: Map<string, TestStep> = new Map()
   private readonly testCaseFinishedByTestCaseStartedId: Map<string, TestCaseFinished> = new Map()
+  private readonly testStepFinishedByTestCaseStartedId: ArrayMultimap<string, TestStepFinished> =
+    new ArrayMultimap()
 
   update(envelope: Envelope) {
-    super.update(envelope)
-
+    if (envelope.gherkinDocument) {
+      this.updateGherkinDocument(envelope.gherkinDocument)
+    }
     if (envelope.pickle) {
-      this.pickleById.set(envelope.pickle.id, envelope.pickle)
+      this.updatePickle(envelope.pickle)
     }
     if (envelope.testRunStarted) {
       this.testRunStarted = envelope.testRunStarted
     }
     if (envelope.testCase) {
-      this.testCaseById.set(envelope.testCase.id, envelope.testCase)
+      this.updateTestCase(envelope.testCase)
     }
     if (envelope.testCaseStarted) {
       this.updateTestCaseStarted(envelope.testCaseStarted)
     }
+    if (envelope.testStepFinished) {
+      this.updateTestStepFinished(envelope.testStepFinished)
+    }
     if (envelope.testCaseFinished) {
       this.updateTestCaseFinished(envelope.testCaseFinished)
     }
@@ -45,6 +60,47 @@ export class ExtendedQuery extends CucumberQuery {
     }
   }
 
+  private updateGherkinDocument(gherkinDocument: GherkinDocument) {
+    if (gherkinDocument.feature) {
+      this.updateFeature(gherkinDocument.feature)
+    }
+  }
+
+  private updateFeature(feature: Feature) {
+    feature.children.forEach((featureChild) => {
+      if (featureChild.background) {
+        this.updateSteps(featureChild.background.steps)
+      }
+      if (featureChild.scenario) {
+        this.updateSteps(featureChild.scenario.steps)
+      }
+      if (featureChild.rule) {
+        featureChild.rule.children.forEach((ruleChild) => {
+          if (ruleChild.background) {
+            this.updateSteps(ruleChild.background.steps)
+          }
+          if (ruleChild.scenario) {
+            this.updateSteps(ruleChild.scenario.steps)
+          }
+        })
+      }
+    })
+  }
+
+  private updateSteps(steps: ReadonlyArray<Step>) {
+    steps.forEach((step) => this.stepById.set(step.id, step))
+  }
+
+  private updatePickle(pickle: Pickle) {
+    this.pickleById.set(pickle.id, pickle)
+    pickle.steps.forEach((pickleStep) => this.pickleStepById.set(pickleStep.id, pickleStep))
+  }
+
+  private updateTestCase(testCase: TestCase) {
+    this.testCaseById.set(testCase.id, testCase)
+    testCase.testSteps.forEach((testStep) => this.testStepById.set(testStep.id, testStep))
+  }
+
   private updateTestCaseStarted(testCaseStarted: TestCaseStarted) {
     // ensure this replaces any previous attempt for the same test case
     this.testCaseStarted = [
@@ -55,13 +111,26 @@ export class ExtendedQuery extends CucumberQuery {
     ]
   }
 
+  private updateTestStepFinished(testStepFinished: TestStepFinished) {
+    this.testStepFinishedByTestCaseStartedId.put(
+      testStepFinished.testCaseStartedId,
+      testStepFinished
+    )
+  }
+
   private updateTestCaseFinished(testCaseFinished: TestCaseFinished) {
     this.testCaseFinishedByTestCaseStartedId.set(
       testCaseFinished.testCaseStartedId,
       testCaseFinished
     )
   }
 
+  findStepBy(pickleStep: PickleStep) {
+    const [astNodeId] = pickleStep.astNodeIds
+    assert.ok('Expected PickleStep to have an astNodeId')
+    return this.stepById.get(astNodeId)
+  }
+
   findPickleBy(testCaseStarted: TestCaseStarted) {
     const testCase = this.findTestCaseBy(testCaseStarted)
     if (!testCase) {
@@ -70,6 +139,11 @@ export class ExtendedQuery extends CucumberQuery {
     return this.pickleById.get(testCase.pickleId)
   }
 
+  findPickleStepBy(testStep: TestStep) {
+    assert.ok(testStep.pickleStepId, 'Expected TestStep to have a pickleStepId')
+    return this.pickleStepById.get(testStep.pickleStepId)
+  }
+
   findAllTestCaseStarted(): ReadonlyArray<TestCaseStarted> {
     return [...this.testCaseStarted]
   }
@@ -93,6 +167,22 @@ export class ExtendedQuery extends CucumberQuery {
     )
   }
 
+  findTestStepBy(testStepFinished: TestStepFinished) {
+    return this.testStepById.get(testStepFinished.testStepId)
+  }
+
+  findTestStepFinishedAndTestStepBy(
+    testCaseStarted: TestCaseStarted
+  ): ReadonlyArray<[TestStepFinished, TestStep]> {
+    return this.testStepFinishedByTestCaseStartedId
+      .get(testCaseStarted.id)
+      .map((testStepFinished) => {
+        const testStep = this.findTestStepBy(testStepFinished)
+        assert.ok(testStep, 'Expected to find TestStep by TestStepFinished')
+        return [testStepFinished, testStep]
+      })
+  }
+
   findTestRunDuration() {
     if (!this.testRunStarted || !this.testRunFinished) {
       return undefined
@@ -114,13 +204,11 @@ export class ExtendedQuery extends CucumberQuery {
       [TestStepResultStatus.UNKNOWN]: 0,
     }
     for (const testCaseStarted of this.testCaseStarted) {
-      const testCase = this.findTestCaseBy(testCaseStarted)
-      assert.ok(testCase, 'Expected to find TestCase for TestCaseStarted')
-      const statusesFromSteps = testCase.testSteps.map((testStep) => {
-        return getWorstTestStepResult(this.getTestStepResults(testStep.id))
-      })
-      const overallStatus = getWorstTestStepResult(statusesFromSteps)
-      result[overallStatus.status]++
+      const testStepResults = this.findTestStepFinishedAndTestStepBy(testCaseStarted).map(
+        ([testStepFinished]) => testStepFinished.testStepResult
+      )
+      const mostSevereResult = getWorstTestStepResult(testStepResults)
+      result[mostSevereResult.status]++
     }
     return result
   }

javascript/src/ExtendedQuery.ts

@@ -1,8 +1,8 @@
-import { TestStepResultStatus } from '@cucumber/messages'
+import { PickleStep, Step, TestStepResultStatus } from '@cucumber/messages'
 import { expect, use } from 'chai'
 import chaiAlmost from 'chai-almost'
 
-import { countStatuses, durationToSeconds } from './helpers.js'
+import { countStatuses, durationToSeconds, formatStep } from './helpers.js'
 
 use(chaiAlmost())
 
@@ -43,4 +43,16 @@ describe('helpers', () => {
       )
     })
   })
+
+  describe('formatStep', () => {
+    it('formats a step', () => {
+      expect(
+        formatStep(
+          { keyword: 'Given ' } as Step,
+          { text: 'I have 42 cukes in my belly' } as PickleStep,
+          TestStepResultStatus.PASSED
+        )
+      ).to.eq('Given I have 42 cukes in my belly...........................................passed')
+    })
+  })
 })

javascript/src/helpers.spec.ts

@@ -1,4 +1,10 @@
-import { Duration, TestStepResultStatus, TimeConversion } from '@cucumber/messages'
+import {
+  Duration,
+  PickleStep,
+  Step,
+  TestStepResultStatus,
+  TimeConversion,
+} from '@cucumber/messages'
 
 export function durationToSeconds(duration?: Duration) {
   if (!duration) {
@@ -15,3 +21,11 @@ export function countStatuses(
     .filter(([status]) => predicate(status as TestStepResultStatus))
     .reduce((prev, [, curr]) => prev + curr, 0)
 }
+
+export function formatStep(step: Step, pickleStep: PickleStep, status: TestStepResultStatus) {
+  let text = `${step.keyword.trim()} ${pickleStep.text.trim()}.`
+  do {
+    text += '.'
+  } while (text.length < 76)
+  return text + status.toLowerCase()
+}

javascript/src/helpers.ts

@@ -1,10 +1,11 @@
+import * as assert from 'node:assert'
+
 import { Query as GherkinQuery } from '@cucumber/gherkin-utils'
-import { Envelope, TestCaseStarted, TestStepResultStatus } from '@cucumber/messages'
+import { Envelope, TestStepResultStatus } from '@cucumber/messages'
 import xmlbuilder from 'xmlbuilder'
 
 import { ExtendedQuery } from './ExtendedQuery.js'
-import { countStatuses, durationToSeconds } from './helpers.js'
-import * as assert from 'node:assert'
+import { countStatuses, durationToSeconds, formatStep } from './helpers.js'
 
 export default {
   type: 'formatter',
@@ -39,6 +40,7 @@ export default {
             name: testCase.name,
             time: testCase.time,
           })
+          element.ele('system-out', {}).cdata(testCase.output)
         }
 
         write(builder.end({ pretty: true }))
@@ -60,6 +62,7 @@ interface TestCase {
   classname: string
   name: string
   time: number
+  output: string
 }
 
 function makeReport(query: ExtendedQuery): Report {
@@ -85,6 +88,18 @@ function makeTestCases(query: ExtendedQuery): ReadonlyArray<TestCase> {
       classname: pickle.uri,
       name: pickle.name,
       time: durationToSeconds(query.findTestCaseDurationBy(testCaseStarted)),
+      output: query
+        .findTestStepFinishedAndTestStepBy(testCaseStarted)
+        // filter out hooks
+        .filter(([, testStep]) => !!testStep.pickleStepId)
+        .map(([testStepFinished, testStep]) => {
+          const pickleStep = query.findPickleStepBy(testStep)
+          assert.ok(pickleStep, 'Expected to find PickleStep by TestStep')
+          const gherkinStep = query.findStepBy(pickleStep)
+          assert.ok(gherkinStep, 'Expected to find Step by PickleStep')
+          return formatStep(gherkinStep, pickleStep, testStepFinished.testStepResult.status)
+        })
+        .join('\n'),
     }
   })
 }