@cucumber/query 12.1.2 → 13.0.0

package/src/Query.ts

@@ -1,6 +1,29 @@
 import * as messages from '@cucumber/messages'
-import { getWorstTestStepResult } from '@cucumber/messages'
-import { ArrayMultimap } from '@teppeis/multimaps'
+import {
+  Duration,
+  Feature,
+  getWorstTestStepResult,
+  GherkinDocument,
+  Pickle,
+  PickleStep,
+  Rule,
+  Scenario,
+  Step,
+  TestCase,
+  TestCaseFinished,
+  TestCaseStarted,
+  TestRunFinished,
+  TestRunStarted,
+  TestStep,
+  TestStepFinished,
+  TestStepResult,
+  TestStepResultStatus,
+  TimeConversion
+} from '@cucumber/messages'
+import {ArrayMultimap} from '@teppeis/multimaps'
+import {Lineage, NamingStrategy} from "./Lineage";
+import assert from 'assert';
+import { comparatorBy, comparatorById, comparatorByStatus } from './helpers'
 
 export default class Query {
   private readonly testStepResultByPickleId = new ArrayMultimap<string, messages.TestStepResult>()
@@ -8,9 +31,7 @@ export default class Query {
     string,
     messages.TestStepResult
   >()
-  private readonly testStepById = new Map<string, messages.TestStep>()
   private readonly testCaseByPickleId = new Map<string, messages.TestCase>()
-  private readonly testCaseByTestCaseId = new Map<string, messages.TestCase>()
   private readonly pickleIdByTestStepId = new Map<string, string>()
   private readonly pickleStepIdByTestStepId = new Map<string, string>()
   private readonly testStepResultsbyTestStepId = new ArrayMultimap<
@@ -19,64 +40,189 @@ export default class Query {
   >()
   private readonly testStepIdsByPickleStepId = new ArrayMultimap<string, string>()
   private readonly hooksById = new Map<string, messages.Hook>()
-
   private readonly attachmentsByTestStepId = new ArrayMultimap<string, messages.Attachment>()
-
   private readonly stepMatchArgumentsListsByPickleStepId = new Map<
     string,
     readonly messages.StepMatchArgumentsList[]
   >()
 
+  private testRunStarted: TestRunStarted
+  private testRunFinished: TestRunFinished
+  private readonly testCaseStarted: Array<TestCaseStarted> = []
+  private readonly lineageById: Map<string, Lineage> = new Map()
+  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()
+
   public update(envelope: messages.Envelope) {
+    if (envelope.gherkinDocument) {
+      this.updateGherkinDocument(envelope.gherkinDocument)
+    }
+    if (envelope.pickle) {
+      this.updatePickle(envelope.pickle)
+    }
+    if (envelope.hook) {
+      this.hooksById.set(envelope.hook.id, envelope.hook)
+    }
+    if (envelope.testRunStarted) {
+      this.testRunStarted = envelope.testRunStarted
+    }
     if (envelope.testCase) {
-      this.testCaseByTestCaseId.set(envelope.testCase.id, envelope.testCase)
-      this.testCaseByPickleId.set(envelope.testCase.pickleId, envelope.testCase)
-      for (const testStep of envelope.testCase.testSteps) {
-        this.testStepById.set(testStep.id, testStep)
-        this.pickleIdByTestStepId.set(testStep.id, envelope.testCase.pickleId)
-        this.pickleStepIdByTestStepId.set(testStep.id, testStep.pickleStepId)
-        this.testStepIdsByPickleStepId.put(testStep.pickleStepId, testStep.id)
-        this.stepMatchArgumentsListsByPickleStepId.set(
+      this.updateTestCase(envelope.testCase)
+    }
+    if (envelope.testCaseStarted) {
+      this.updateTestCaseStarted(envelope.testCaseStarted)
+    }
+    if (envelope.attachment) {
+      this.attachmentsByTestStepId.put(envelope.attachment.testStepId, envelope.attachment)
+    }
+    if (envelope.testStepFinished) {
+      this.updateTestStepFinished(envelope.testStepFinished)
+    }
+    if (envelope.testCaseFinished) {
+      this.updateTestCaseFinished(envelope.testCaseFinished)
+    }
+    if (envelope.testRunFinished) {
+      this.testRunFinished = envelope.testRunFinished
+    }
+  }
+
+  private updateGherkinDocument(gherkinDocument: GherkinDocument) {
+    if (gherkinDocument.feature) {
+      this.updateFeature(gherkinDocument.feature, {
+        gherkinDocument,
+      })
+    }
+  }
+
+  private updateFeature(feature: Feature, lineage: Lineage) {
+    feature.children.forEach((featureChild) => {
+      if (featureChild.background) {
+        this.updateSteps(featureChild.background.steps)
+      }
+      if (featureChild.scenario) {
+        this.updateScenario(featureChild.scenario, {
+          ...lineage,
+          feature,
+        })
+      }
+      if (featureChild.rule) {
+        this.updateRule(featureChild.rule, {
+          ...lineage,
+          feature,
+        })
+      }
+    })
+  }
+
+  private updateRule(rule: Rule, lineage: Lineage) {
+    rule.children.forEach((ruleChild) => {
+      if (ruleChild.background) {
+        this.updateSteps(ruleChild.background.steps)
+      }
+      if (ruleChild.scenario) {
+        this.updateScenario(ruleChild.scenario, {
+          ...lineage,
+          rule,
+        })
+      }
+    })
+  }
+
+  private updateScenario(scenario: Scenario, lineage: Lineage) {
+    this.lineageById.set(scenario.id, {
+      ...lineage,
+      scenario,
+    })
+    scenario.examples.forEach((examples, examplesIndex) => {
+      this.lineageById.set(examples.id, {
+        ...lineage,
+        scenario,
+        examples,
+        examplesIndex,
+      })
+      examples.tableBody.forEach((example, exampleIndex) => {
+        this.lineageById.set(example.id, {
+          ...lineage,
+          scenario,
+          examples,
+          examplesIndex,
+          example,
+          exampleIndex,
+        })
+      })
+    })
+    this.updateSteps(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)
+
+    this.testCaseByPickleId.set(testCase.pickleId, testCase)
+    testCase.testSteps.forEach((testStep) => {
+      this.testStepById.set(testStep.id, testStep)
+      this.pickleIdByTestStepId.set(testStep.id, testCase.pickleId)
+      this.pickleStepIdByTestStepId.set(testStep.id, testStep.pickleStepId)
+      this.testStepIdsByPickleStepId.put(testStep.pickleStepId, testStep.id)
+      this.stepMatchArgumentsListsByPickleStepId.set(
           testStep.pickleStepId,
           testStep.stepMatchArgumentsLists
-        )
-      }
-    }
+      )
+    })
+  }
+
+  private updateTestCaseStarted(testCaseStarted: TestCaseStarted) {
+    this.testCaseStarted.push(testCaseStarted)
 
     /*
     when a test case attempt starts besides the first one, clear all existing results
     and attachments for that test case, so we always report on the latest attempt
-    TODO keep track of results and attachments from all attempts, expand API accordingly
+    (applies to legacy pickle-oriented query methods only)
      */
-    if (envelope.testCaseStarted && envelope.testCaseStarted.attempt > 0) {
-      const testCase = this.testCaseByTestCaseId.get(envelope.testCaseStarted.testCaseId)
-      this.testStepResultByPickleId.delete(testCase.pickleId)
-      for (const testStep of testCase.testSteps) {
-        this.testStepResultsByPickleStepId.delete(testStep.pickleStepId)
-        this.testStepResultsbyTestStepId.delete(testStep.id)
-        this.attachmentsByTestStepId.delete(testStep.id)
-      }
+    const testCase = this.testCaseById.get(testCaseStarted.testCaseId)
+    this.testStepResultByPickleId.delete(testCase.pickleId)
+    for (const testStep of testCase.testSteps) {
+      this.testStepResultsByPickleStepId.delete(testStep.pickleStepId)
+      this.testStepResultsbyTestStepId.delete(testStep.id)
+      this.attachmentsByTestStepId.delete(testStep.id)
     }
+  }
 
-    if (envelope.testStepFinished) {
-      const pickleId = this.pickleIdByTestStepId.get(envelope.testStepFinished.testStepId)
-      this.testStepResultByPickleId.put(pickleId, envelope.testStepFinished.testStepResult)
+  private updateTestStepFinished(testStepFinished: TestStepFinished) {
+    this.testStepFinishedByTestCaseStartedId.put(
+        testStepFinished.testCaseStartedId,
+        testStepFinished
+    )
 
-      const testStep = this.testStepById.get(envelope.testStepFinished.testStepId)
-      this.testStepResultsByPickleStepId.put(
+    const pickleId = this.pickleIdByTestStepId.get(testStepFinished.testStepId)
+    this.testStepResultByPickleId.put(pickleId, testStepFinished.testStepResult)
+    const testStep = this.testStepById.get(testStepFinished.testStepId)
+    this.testStepResultsByPickleStepId.put(
         testStep.pickleStepId,
-        envelope.testStepFinished.testStepResult
-      )
-      this.testStepResultsbyTestStepId.put(testStep.id, envelope.testStepFinished.testStepResult)
-    }
-
-    if (envelope.hook) {
-      this.hooksById.set(envelope.hook.id, envelope.hook)
-    }
+        testStepFinished.testStepResult
+    )
+    this.testStepResultsbyTestStepId.put(testStep.id, testStepFinished.testStepResult)
+  }
 
-    if (envelope.attachment) {
-      this.attachmentsByTestStepId.put(envelope.attachment.testStepId, envelope.attachment)
-    }
+  private updateTestCaseFinished(testCaseFinished: TestCaseFinished) {
+    this.testCaseFinishedByTestCaseStartedId.set(
+        testCaseFinished.testCaseStartedId,
+        testCaseFinished
+    )
   }
 
   /**
@@ -212,4 +358,164 @@ export default class Query {
     }
     return result
   }
+
+  /* new common interface with Java starts here */
+
+  public countMostSevereTestStepResultStatus(): Record<TestStepResultStatus, number> {
+    const result: Record<TestStepResultStatus, number> = {
+      [TestStepResultStatus.AMBIGUOUS]: 0,
+      [TestStepResultStatus.FAILED]: 0,
+      [TestStepResultStatus.PASSED]: 0,
+      [TestStepResultStatus.PENDING]: 0,
+      [TestStepResultStatus.SKIPPED]: 0,
+      [TestStepResultStatus.UNDEFINED]: 0,
+      [TestStepResultStatus.UNKNOWN]: 0,
+    }
+    for (const testCaseStarted of this.findAllTestCaseStarted()) {
+      const mostSevereResult = this.findTestStepFinishedAndTestStepBy(testCaseStarted)
+        .map(([testStepFinished]) => testStepFinished.testStepResult)
+        .sort(comparatorByStatus)
+        .at(-1)
+      if (mostSevereResult) {
+        result[mostSevereResult.status]++
+      }
+    }
+    return result
+  }
+
+  public countTestCasesStarted(): number {
+    return this.findAllTestCaseStarted().length
+  }
+
+  public findAllPickles(): ReadonlyArray<Pickle> {
+    const pickles = [...this.pickleById.values()]
+    return pickles.sort(comparatorById)
+  }
+
+  public findAllPickleSteps(): ReadonlyArray<PickleStep> {
+    const pickleSteps = [...this.pickleStepById.values()]
+    return pickleSteps.sort(comparatorById)
+  }
+
+  public findAllTestCaseStarted(): ReadonlyArray<TestCaseStarted> {
+    return this.testCaseStarted.filter((testCaseStarted) => {
+      const testCaseFinished = this.testCaseFinishedByTestCaseStartedId.get(testCaseStarted.id)
+      // only include if not yet finished OR won't be retried
+      return !testCaseFinished?.willBeRetried
+    })
+  }
+
+  public findAllTestCaseStartedGroupedByFeature(): Map<Feature | undefined, ReadonlyArray<TestCaseStarted>> {
+    const results = new Map();
+    this.findAllTestCaseStarted()
+        .map(testCaseStarted => ([this.findLineageBy(testCaseStarted), testCaseStarted] as const))
+        .sort(([a], [b]) => comparatorBy(a.gherkinDocument, b.gherkinDocument, "uri"))
+        .forEach(([{feature}, testCaseStarted]) => {
+          results.set(feature, [...results.get(feature) ?? [], testCaseStarted])
+        })
+    return results
+  }
+
+  public findAllTestSteps(): ReadonlyArray<TestStep> {
+    const testSteps = [...this.testStepById.values()]
+    return testSteps.sort(comparatorById)
+  }
+
+  public findFeatureBy(testCaseStarted: TestCaseStarted): Feature | undefined {
+    return this.findLineageBy(testCaseStarted)?.feature
+  }
+
+  public findMostSevereTestStepResultBy(testCaseStarted: TestCaseStarted): TestStepResult | undefined {
+    return this.findTestStepFinishedAndTestStepBy(testCaseStarted)
+      .map(([testStepFinished]) => testStepFinished.testStepResult)
+      .sort(comparatorByStatus)
+      .at(-1)
+  }
+
+  public findNameOf(pickle: Pickle, namingStrategy: NamingStrategy): string {
+    const lineage = this.findLineageBy(pickle)
+    return lineage ? namingStrategy.reduce(lineage, pickle) : pickle.name
+  }
+
+  public findPickleBy(testCaseStarted: TestCaseStarted): Pickle | undefined {
+    const testCase = this.findTestCaseBy(testCaseStarted)
+    assert.ok(testCase, 'Expected to find TestCase from TestCaseStarted')
+    return this.pickleById.get(testCase.pickleId)
+  }
+
+  public findPickleStepBy(testStep: TestStep): PickleStep | undefined {
+    assert.ok(testStep.pickleStepId, 'Expected TestStep to have a pickleStepId')
+    return this.pickleStepById.get(testStep.pickleStepId)
+  }
+
+  public findStepBy(pickleStep: PickleStep): Step | undefined {
+    const [astNodeId] = pickleStep.astNodeIds
+    assert.ok('Expected PickleStep to have an astNodeId')
+    return this.stepById.get(astNodeId)
+  }
+
+  public findTestCaseBy(testCaseStarted: TestCaseStarted): TestCase | undefined {
+    return this.testCaseById.get(testCaseStarted.testCaseId)
+  }
+
+  public findTestCaseDurationBy(testCaseStarted: TestCaseStarted): Duration | undefined {
+    const testCaseFinished = this.findTestCaseFinishedBy(testCaseStarted)
+    if (!testCaseFinished) {
+      return undefined
+    }
+    return TimeConversion.millisecondsToDuration(
+        TimeConversion.timestampToMillisecondsSinceEpoch(testCaseFinished.timestamp) -
+        TimeConversion.timestampToMillisecondsSinceEpoch(testCaseStarted.timestamp)
+    )
+  }
+
+  public findTestCaseFinishedBy(testCaseStarted: TestCaseStarted): TestCaseFinished | undefined {
+    return this.testCaseFinishedByTestCaseStartedId.get(testCaseStarted.id)
+  }
+
+  public findTestRunDuration(): Duration | undefined {
+    if (!this.testRunStarted || !this.testRunFinished) {
+      return undefined
+    }
+    return TimeConversion.millisecondsToDuration(
+        TimeConversion.timestampToMillisecondsSinceEpoch(this.testRunFinished.timestamp) -
+        TimeConversion.timestampToMillisecondsSinceEpoch(this.testRunStarted.timestamp)
+    )
+  }
+
+  public findTestRunFinished(): TestRunFinished | undefined {
+    return this.testRunFinished
+  }
+
+  public findTestRunStarted(): TestRunStarted | undefined {
+    return this.testRunStarted
+  }
+
+  public findTestStepBy(testStepFinished: TestStepFinished): TestStep | undefined {
+    return this.testStepById.get(testStepFinished.testStepId)
+  }
+
+  public findTestStepsFinishedBy(testCaseStarted: TestCaseStarted): ReadonlyArray<TestStepFinished> {
+    // multimaps `get` implements `getOrDefault([])` behaviour internally
+    return [...this.testStepFinishedByTestCaseStartedId.get(testCaseStarted.id)]
+  }
+
+  public 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]
+        })
+  }
+
+  private findLineageBy(element: Pickle | TestCaseStarted) {
+    const pickle = "testCaseId" in element ? this.findPickleBy(element) : element
+    const deepestAstNodeId = pickle.astNodeIds.at(-1)
+    assert.ok(deepestAstNodeId, 'Expected Pickle to have at least one astNodeId')
+    return this.lineageById.get(deepestAstNodeId)
+  }
 }

package/src/acceptance.spec.ts

@@ -0,0 +1,164 @@
+import assert from 'node:assert'
+import fs from 'node:fs'
+import * as path from 'node:path'
+import {pipeline, Writable} from 'node:stream'
+import util from 'node:util'
+
+import {NdjsonToMessageStream} from '@cucumber/message-streams'
+import {Duration, Envelope, TestRunFinished, TestRunStarted, TestStepResultStatus} from '@cucumber/messages'
+import {glob} from 'glob'
+
+import Query from './Query'
+import {
+    namingStrategy,
+    NamingStrategyExampleName,
+    NamingStrategyFeatureName,
+    NamingStrategyLength
+} from './Lineage'
+
+const asyncPipeline = util.promisify(pipeline)
+const TESTDATA_PATH = path.join(__dirname, '..', '..', 'testdata')
+
+describe('Acceptance Tests', async () => {
+    const fixtureFiles = glob.sync(`*.query-results.json`, {
+        cwd: TESTDATA_PATH,
+        absolute: true
+    })
+
+    for (const fixtureFile of fixtureFiles) {
+        const [suiteName] = path.basename(fixtureFile).split('.')
+        const ndjsonFile = fixtureFile.replace('.query-results.json', '.ndjson')
+
+        it(suiteName, async () => {
+            const query = new Query()
+
+            await asyncPipeline(
+                fs.createReadStream(ndjsonFile, { encoding: 'utf-8' }),
+                new NdjsonToMessageStream(),
+                new Writable({
+                    objectMode: true,
+                    write(envelope: Envelope, _: BufferEncoding, callback) {
+                        query.update(envelope)
+                        callback()
+                    },
+                })
+            )
+
+            const expectedResults: ResultsFixture = {
+                ...defaults,
+                ...JSON.parse(fs.readFileSync(fixtureFile, {
+                    encoding: 'utf-8',
+                }))
+            }
+
+            const actualResults: ResultsFixture = JSON.parse(JSON.stringify({
+                countMostSevereTestStepResultStatus: query.countMostSevereTestStepResultStatus(),
+                countTestCasesStarted: query.countTestCasesStarted(),
+                findAllPickles: query.findAllPickles().length,
+                findAllPickleSteps: query.findAllPickleSteps().length,
+                findAllTestCaseStarted: query.findAllTestCaseStarted().length,
+                findAllTestSteps: query.findAllTestSteps().length,
+                findAllTestCaseStartedGroupedByFeature: [...query.findAllTestCaseStartedGroupedByFeature().entries()]
+                    .map(([feature, testCaseStarteds]) => [feature.name, testCaseStarteds.map(testCaseStarted => testCaseStarted.id)]),
+                findFeatureBy: query.findAllTestCaseStarted()
+                    .map(testCaseStarted => query.findFeatureBy(testCaseStarted))
+                    .map(feature => feature?.name),
+                findMostSevereTestStepResultBy: query.findAllTestCaseStarted()
+                    .map(testCaseStarted => query.findMostSevereTestStepResultBy(testCaseStarted))
+                    .map(testStepResult => testStepResult?.status),
+                findNameOf: {
+                    long : query.findAllPickles().map(pickle => query.findNameOf(pickle, namingStrategy(NamingStrategyLength.LONG))),
+                    excludeFeatureName : query.findAllPickles().map(pickle => query.findNameOf(pickle, namingStrategy(NamingStrategyLength.LONG, NamingStrategyFeatureName.EXCLUDE))),
+                    longPickleName : query.findAllPickles().map(pickle => query.findNameOf(pickle, namingStrategy(NamingStrategyLength.LONG, NamingStrategyFeatureName.INCLUDE, NamingStrategyExampleName.PICKLE))),
+                    short : query.findAllPickles().map(pickle => query.findNameOf(pickle, namingStrategy(NamingStrategyLength.SHORT))),
+                    shortPickleName : query.findAllPickles().map(pickle => query.findNameOf(pickle, namingStrategy(NamingStrategyLength.SHORT, NamingStrategyFeatureName.INCLUDE, NamingStrategyExampleName.PICKLE)))
+                },
+                findPickleBy: query.findAllTestCaseStarted()
+                    .map(testCaseStarted => query.findPickleBy(testCaseStarted))
+                    .map(pickle => pickle?.name),
+                findPickleStepBy: query.findAllTestSteps()
+                    .map(testStep => query.findPickleStepBy(testStep))
+                    .map(pickleStep => pickleStep?.text),
+                findStepBy: query.findAllPickleSteps()
+                    .map(pickleStep => query.findStepBy(pickleStep))
+                    .map(step => step?.text),
+                findTestCaseBy: query.findAllTestCaseStarted()
+                    .map(testCaseStarted => query.findTestCaseBy(testCaseStarted))
+                    .map(testCase => testCase?.id),
+                findTestCaseDurationBy: query.findAllTestCaseStarted()
+                    .map(testCaseStarted => query.findTestCaseDurationBy(testCaseStarted)),
+                findTestCaseFinishedBy: query.findAllTestCaseStarted()
+                    .map(testCaseStarted => query.findTestCaseFinishedBy(testCaseStarted))
+                    .map(testCaseFinished => testCaseFinished?.testCaseStartedId),
+                findTestRunDuration: query.findTestRunDuration(),
+                findTestRunFinished: query.findTestRunFinished(),
+                findTestRunStarted: query.findTestRunStarted(),
+                findTestStepBy: query.findAllTestCaseStarted()
+                    .flatMap(testCaseStarted => query.findTestStepsFinishedBy(testCaseStarted))
+                    .map(testStepFinished => query.findTestStepBy(testStepFinished))
+                    .map(testStep => testStep?.id),
+                findTestStepsFinishedBy: query.findAllTestCaseStarted()
+                    .map(testCaseStarted => query.findTestStepsFinishedBy(testCaseStarted))
+                    .map(testStepFinisheds => testStepFinisheds.map(testStepFinished => testStepFinished?.testStepId)),
+                findTestStepFinishedAndTestStepBy: query.findAllTestCaseStarted()
+                    .flatMap(testCaseStarted => query.findTestStepFinishedAndTestStepBy(testCaseStarted))
+                    .map(([testStepFinished, testStep]) => ([testStepFinished.testStepId, testStep.id]))
+            }))
+
+            assert.deepStrictEqual(actualResults, expectedResults)
+        })
+    }
+})
+
+interface ResultsFixture {
+    countMostSevereTestStepResultStatus: Record<TestStepResultStatus, number>,
+    countTestCasesStarted: number,
+    findAllPickles: number,
+    findAllPickleSteps: number,
+    findAllTestCaseStarted: number,
+    findAllTestSteps: number,
+    findAllTestCaseStartedGroupedByFeature: Array<[string, string[]]>,
+    findFeatureBy: Array<string>,
+    findMostSevereTestStepResultBy: Array<TestStepResultStatus>,
+    findNameOf: {
+        long: Array<string>,
+        excludeFeatureName: Array<string>,
+        longPickleName: Array<string>,
+        short: Array<string>,
+        shortPickleName: Array<string>
+    },
+    findPickleBy: Array<string>,
+    findPickleStepBy: Array<string>,
+    findStepBy: Array<string>,
+    findTestCaseBy: Array<string>,
+    findTestCaseDurationBy: Array<Duration>,
+    findTestCaseFinishedBy: Array<string>,
+    findTestRunDuration: Duration,
+    findTestRunFinished: TestRunFinished,
+    findTestRunStarted: TestRunStarted,
+    findTestStepBy: Array<string>,
+    findTestStepsFinishedBy: Array<Array<string>>
+    findTestStepFinishedAndTestStepBy: Array<[string, string]>
+}
+
+const defaults: Partial<ResultsFixture> = {
+    findAllTestCaseStartedGroupedByFeature: [],
+    findFeatureBy: [],
+    findMostSevereTestStepResultBy: [],
+    findNameOf: {
+        long: [],
+        excludeFeatureName: [],
+        longPickleName: [],
+        short: [],
+        shortPickleName: []
+    },
+    findPickleBy: [],
+    findPickleStepBy: [],
+    findStepBy: [],
+    findTestCaseBy: [],
+    findTestCaseDurationBy: [],
+    findTestCaseFinishedBy: [],
+    findTestStepBy: [],
+    findTestStepsFinishedBy: [],
+    findTestStepFinishedAndTestStepBy: []
+}

package/src/helpers.spec.ts

@@ -0,0 +1,15 @@
+import assert from 'node:assert'
+import { comparatorByStatus } from './helpers'
+import { TestStepResult, TestStepResultStatus } from '@cucumber/messages'
+
+describe('comparatorByStatus', () => {
+  function resultWithStatus(status: TestStepResultStatus) {
+    return { status } as TestStepResult
+  }
+
+  it('puts the more severe status after the less severe', () => {
+    assert.strictEqual(comparatorByStatus(resultWithStatus(TestStepResultStatus.PASSED), resultWithStatus(TestStepResultStatus.FAILED)), -1)
+    assert.strictEqual(comparatorByStatus(resultWithStatus(TestStepResultStatus.FAILED), resultWithStatus(TestStepResultStatus.PASSED)), 1)
+    assert.strictEqual(comparatorByStatus(resultWithStatus(TestStepResultStatus.FAILED), resultWithStatus(TestStepResultStatus.FAILED)), 0)
+  })
+})

package/src/helpers.ts

@@ -0,0 +1,41 @@
+import { TestStepResult, TestStepResultStatus } from '@cucumber/messages'
+
+interface WithId {
+    id: string | number
+}
+
+export function comparatorById(a: WithId, b: WithId) {
+    return comparatorBy(a, b, "id")
+}
+
+export function comparatorBy(a: any, b: any, key: string) {
+    if ( a[key] < b[key] ){
+        return -1;
+    }
+    if ( a[key] > b[key] ){
+        return 1;
+    }
+    return 0;
+}
+
+export function comparatorByStatus(a: TestStepResult, b: TestStepResult) {
+    if (ordinal(a.status) < ordinal(b.status)) {
+        return -1;
+    }
+    if (ordinal(a.status) > ordinal(b.status) ){
+        return 1;
+    }
+    return 0;
+}
+
+function ordinal(status: TestStepResultStatus) {
+    return [
+        TestStepResultStatus.UNKNOWN,
+        TestStepResultStatus.PASSED,
+        TestStepResultStatus.SKIPPED,
+        TestStepResultStatus.PENDING,
+        TestStepResultStatus.UNDEFINED,
+        TestStepResultStatus.AMBIGUOUS,
+        TestStepResultStatus.FAILED,
+    ].indexOf(status)
+}

package/tsconfig.build.json

@@ -11,5 +11,10 @@
     "target": "es6",
     "module": "commonjs"
   },
-  "include": ["src", "test", "package.json"]
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "src/**/*.spec.*"
+  ]
 }