@cucumber/query 14.7.0 → 15.0.1

package/src/Query.ts

@@ -3,7 +3,6 @@ import {
   Attachment,
   Duration,
   Feature,
-  getWorstTestStepResult,
   GherkinDocument,
   Hook,
   Location,
@@ -37,26 +36,6 @@ import { assert, statusOrdinal } from './helpers'
 import { Lineage } from './Lineage'
 
 export default class Query {
-  private readonly testStepResultByPickleId = new ArrayMultimap<string, messages.TestStepResult>()
-  private readonly testStepResultsByPickleStepId = new ArrayMultimap<
-    string,
-    messages.TestStepResult
-  >()
-  private readonly testCaseByPickleId = new Map<string, messages.TestCase>()
-  private readonly pickleIdByTestStepId = new Map<string, string>()
-  private readonly pickleStepIdByTestStepId = new Map<string, string>()
-  private readonly testStepResultsbyTestStepId = new ArrayMultimap<
-    string,
-    messages.TestStepResult
-  >()
-  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 meta: Meta
   private testRunStarted: TestRunStarted
   private testRunFinished: TestRunFinished
@@ -65,6 +44,7 @@ export default class Query {
   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 hookById: Map<string, Hook> = new Map()
   private readonly stepDefinitionById: Map<string, StepDefinition> = new Map()
   private readonly testCaseById: Map<string, TestCase> = new Map()
   private readonly testStepById: Map<string, TestStep> = new Map()
@@ -95,7 +75,7 @@ export default class Query {
       this.updatePickle(envelope.pickle)
     }
     if (envelope.hook) {
-      this.hooksById.set(envelope.hook.id, envelope.hook)
+      this.hookById.set(envelope.hook.id, envelope.hook)
     }
     if (envelope.stepDefinition) {
       this.stepDefinitionById.set(envelope.stepDefinition.id, envelope.stepDefinition)
@@ -149,6 +129,7 @@ export default class Query {
   private updateFeature(feature: Feature, lineage: Lineage) {
     feature.children.forEach((featureChild) => {
       if (featureChild.background) {
+        lineage.background = featureChild.background
         this.updateSteps(featureChild.background.steps)
       }
       if (featureChild.scenario) {
@@ -169,6 +150,7 @@ export default class Query {
   private updateRule(rule: Rule, lineage: Lineage) {
     rule.children.forEach((ruleChild) => {
       if (ruleChild.background) {
+        lineage.ruleBackground = ruleChild.background
         this.updateSteps(ruleChild.background.steps)
       }
       if (ruleChild.scenario) {
@@ -228,37 +210,13 @@ export default class Query {
 
   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.testCaseStartedById.set(testCaseStarted.id, 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
-    (applies to legacy pickle-oriented query methods only)
-     */
-    const testCase = this.testCaseById.get(testCaseStarted.testCaseId)
-    if (testCase) {
-      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)
-      }
-    }
   }
 
   private updateTestStepStarted(testStepStarted: TestStepStarted) {
@@ -266,9 +224,6 @@ export default class Query {
   }
 
   private updateAttachment(attachment: Attachment) {
-    if (attachment.testStepId) {
-      this.attachmentsByTestStepId.put(attachment.testStepId, attachment)
-    }
     if (attachment.testCaseStartedId) {
       this.attachmentsByTestCaseStartedId.put(attachment.testCaseStartedId, attachment)
     }
@@ -282,12 +237,6 @@ export default class Query {
       testStepFinished.testCaseStartedId,
       testStepFinished
     )
-
-    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, testStepFinished.testStepResult)
-    this.testStepResultsbyTestStepId.put(testStep.id, testStepFinished.testStepResult)
   }
 
   private updateTestCaseFinished(testCaseFinished: TestCaseFinished) {
@@ -305,146 +254,6 @@ export default class Query {
     this.undefinedParameterTypes.push(undefinedParameterType)
   }
 
-  /**
-   * Gets all the results for multiple pickle steps
-   * @param pickleStepIds
-   */
-  public getPickleStepTestStepResults(
-    pickleStepIds: readonly string[]
-  ): readonly messages.TestStepResult[] {
-    if (pickleStepIds.length === 0) {
-      return [
-        {
-          status: messages.TestStepResultStatus.UNKNOWN,
-          duration: messages.TimeConversion.millisecondsToDuration(0),
-        },
-      ]
-    }
-    return pickleStepIds.reduce((testStepResults: messages.TestStepResult[], pickleId) => {
-      return testStepResults.concat(this.testStepResultsByPickleStepId.get(pickleId))
-    }, [])
-  }
-
-  /**
-   * Gets all the results for multiple pickles
-   * @param pickleIds
-   */
-  public getPickleTestStepResults(
-    pickleIds: readonly string[]
-  ): readonly messages.TestStepResult[] {
-    if (pickleIds.length === 0) {
-      return [
-        {
-          status: messages.TestStepResultStatus.UNKNOWN,
-          duration: messages.TimeConversion.millisecondsToDuration(0),
-        },
-      ]
-    }
-    return pickleIds.reduce((testStepResults: messages.TestStepResult[], pickleId) => {
-      return testStepResults.concat(this.testStepResultByPickleId.get(pickleId))
-    }, [])
-  }
-
-  /**
-   * Gets all the attachments for multiple pickle steps
-   * @param pickleStepIds
-   */
-  public getPickleStepAttachments(
-    pickleStepIds: readonly string[]
-  ): readonly messages.Attachment[] {
-    return this.getTestStepsAttachments(
-      pickleStepIds.reduce((testStepIds: string[], pickleStepId: string) => {
-        return testStepIds.concat(this.testStepIdsByPickleStepId.get(pickleStepId))
-      }, [])
-    )
-  }
-
-  public getTestStepsAttachments(testStepIds: readonly string[]): readonly messages.Attachment[] {
-    return testStepIds.reduce((attachments: messages.Attachment[], testStepId) => {
-      return attachments.concat(this.attachmentsByTestStepId.get(testStepId))
-    }, [])
-  }
-
-  /**
-   * Get StepMatchArguments for a pickle step
-   * @param pickleStepId
-   */
-  public getStepMatchArgumentsLists(
-    pickleStepId: string
-  ): readonly messages.StepMatchArgumentsList[] | undefined {
-    return this.stepMatchArgumentsListsByPickleStepId.get(pickleStepId)
-  }
-
-  public getHook(hookId: string): messages.Hook {
-    return this.hooksById.get(hookId)
-  }
-
-  public getBeforeHookSteps(pickleId: string): readonly messages.TestStep[] {
-    const hookSteps: messages.TestStep[] = []
-
-    this.identifyHookSteps(
-      pickleId,
-      (hook) => hookSteps.push(hook),
-      () => null
-    )
-    return hookSteps
-  }
-
-  public getAfterHookSteps(pickleId: string): readonly messages.TestStep[] {
-    const hookSteps: messages.TestStep[] = []
-
-    this.identifyHookSteps(
-      pickleId,
-      () => null,
-      (hook) => hookSteps.push(hook)
-    )
-    return hookSteps
-  }
-
-  private identifyHookSteps(
-    pickleId: string,
-    onBeforeHookFound: (hook: messages.TestStep) => void,
-    onAfterHookFound: (hook: messages.TestStep) => void
-  ): void {
-    const testCase = this.testCaseByPickleId.get(pickleId)
-
-    if (!testCase) {
-      return
-    }
-
-    let pickleStepFound = false
-
-    for (const step of testCase.testSteps) {
-      if (step.hookId) {
-        if (pickleStepFound) {
-          onAfterHookFound(step)
-        } else {
-          onBeforeHookFound(step)
-        }
-      } else {
-        pickleStepFound = true
-      }
-    }
-  }
-
-  public getTestStepResults(testStepId: string): messages.TestStepResult[] {
-    return this.testStepResultsbyTestStepId.get(testStepId)
-  }
-
-  public getStatusCounts(
-    pickleIds: readonly string[]
-  ): Partial<Record<messages.TestStepResultStatus, number>> {
-    const result: Partial<Record<messages.TestStepResultStatus, number>> = {}
-    for (const pickleId of pickleIds) {
-      const testStepResult = getWorstTestStepResult(this.getPickleTestStepResults([pickleId]))
-      const count = result[testStepResult.status] || 0
-      result[testStepResult.status] = count + 1
-    }
-    return result
-  }
-
-  /* new common interface with Java starts here */
-
   public countMostSevereTestStepResultStatus(): Record<TestStepResultStatus, number> {
     const result: Record<TestStepResultStatus, number> = {
       [TestStepResultStatus.AMBIGUOUS]: 0,
@@ -514,6 +323,44 @@ export default class Query {
     )
   }
 
+  public findAllTestCaseStartedOrderBy<T>(
+    findOrderBy: (query: Query, testCaseStarted: TestCaseStarted) => T | undefined,
+    order: (a: T, b: T) => number
+  ): ReadonlyArray<TestCaseStarted> {
+    const withOrderBy = this.findAllTestCaseStarted().map((testCaseStarted) => ({
+      testCaseStarted,
+      orderBy: findOrderBy(this, testCaseStarted),
+    }))
+
+    const sorted = withOrderBy.sort((a, b) => {
+      if (a.orderBy === undefined && b.orderBy === undefined) return 0
+      if (a.orderBy === undefined) return 1
+      if (b.orderBy === undefined) return -1
+      return order(a.orderBy, b.orderBy)
+    })
+
+    return sorted.map((item) => item.testCaseStarted)
+  }
+
+  public findAllTestCaseFinishedOrderBy<T>(
+    findOrderBy: (query: Query, testCaseFinished: TestCaseFinished) => T | undefined,
+    order: (a: T, b: T) => number
+  ): ReadonlyArray<TestCaseFinished> {
+    const withOrderBy = this.findAllTestCaseFinished().map((testCaseFinished) => ({
+      testCaseFinished,
+      orderBy: findOrderBy(this, testCaseFinished),
+    }))
+
+    const sorted = withOrderBy.sort((a, b) => {
+      if (a.orderBy === undefined && b.orderBy === undefined) return 0
+      if (a.orderBy === undefined) return 1
+      if (b.orderBy === undefined) return -1
+      return order(a.orderBy, b.orderBy)
+    })
+
+    return sorted.map((item) => item.testCaseFinished)
+  }
+
   public findAllTestSteps(): ReadonlyArray<TestStep> {
     return [...this.testStepById.values()]
   }
@@ -559,7 +406,7 @@ export default class Query {
     if (!item.hookId) {
       return undefined
     }
-    return this.hooksById.get(item.hookId)
+    return this.hookById.get(item.hookId)
   }
 
   public findMeta(): Meta | undefined {

package/src/acceptance.spec.ts

@@ -1,16 +1,23 @@
 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 { Writable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
 
-// eslint-disable-next-line n/no-extraneous-import
 import { NdjsonToMessageStream } from '@cucumber/message-streams'
-import { Envelope } from '@cucumber/messages'
+import { Envelope, Pickle } from '@cucumber/messages'
 
 import Query from './Query'
 
-const asyncPipeline = util.promisify(pipeline)
+const reversePickleComparator = (a: Pickle, b: Pickle): number => {
+  if (a.uri !== b.uri) {
+    return b.uri.localeCompare(a.uri)
+  }
+  if (a.location.line !== b.location.line) {
+    return b.location.line - a.location.line
+  }
+  return b.location.column - a.location.column
+}
 
 describe('Acceptance Tests', async () => {
   const sources = [
@@ -32,6 +39,21 @@ describe('Acceptance Tests', async () => {
     findAllPickleSteps: (query: Query) => query.findAllPickleSteps().length,
     findAllStepDefinitions: (query: Query) => query.findAllStepDefinitions().length,
     findAllTestCaseStarted: (query: Query) => query.findAllTestCaseStarted().length,
+    findAllTestCaseStartedOrderBy: (query: Query) =>
+      query
+        .findAllTestCaseStartedOrderBy(
+          (q, testCaseStarted) => q.findPickleBy(testCaseStarted),
+          reversePickleComparator
+        )
+        .map((testCaseStarted) => testCaseStarted.id),
+    findAllTestCaseFinished: (query: Query) => query.findAllTestCaseFinished().length,
+    findAllTestCaseFinishedOrderBy: (query: Query) =>
+      query
+        .findAllTestCaseFinishedOrderBy(
+          (q, testCaseFinished) => q.findPickleBy(testCaseFinished),
+          reversePickleComparator
+        )
+        .map((testCaseFinished) => testCaseFinished.testCaseStartedId),
     findAllTestRunHookStarted: (query: Query) => query.findAllTestRunHookStarted().length,
     findAllTestRunHookFinished: (query: Query) => query.findAllTestRunHookFinished().length,
     findTestRunHookStartedBy: (query: Query) =>
@@ -281,7 +303,7 @@ describe('Acceptance Tests', async () => {
       it(suiteName + ' -> ' + methodName, async () => {
         const query = new Query()
 
-        await asyncPipeline(
+        await pipeline(
           fs.createReadStream(source, { encoding: 'utf-8' }),
           new NdjsonToMessageStream(),
           new Writable({