@cucumber/query 13.2.0 → 13.4.0

package/src/Query.ts

@@ -6,6 +6,7 @@ import {
   getWorstTestStepResult,
   GherkinDocument,
   Hook,
+  Location,
   Meta,
   Pickle,
   PickleStep,
@@ -21,11 +22,14 @@ import {
   TestStepFinished,
   TestStepResult,
   TestStepResultStatus,
+  TestStepStarted,
   TimeConversion,
 } from '@cucumber/messages'
-import {ArrayMultimap} from '@teppeis/multimaps'
-import {Lineage, NamingStrategy} from "./Lineage";
-import { comparatorBy, comparatorById, comparatorByStatus, assert } from './helpers'
+import { ArrayMultimap } from '@teppeis/multimaps'
+import sortBy from 'lodash.sortby'
+
+import { assert, statusOrdinal } from './helpers'
+import { Lineage, NamingStrategy } from './Lineage'
 
 export default class Query {
   private readonly testStepResultByPickleId = new ArrayMultimap<string, messages.TestStepResult>()
@@ -51,7 +55,7 @@ export default class Query {
   private meta: Meta
   private testRunStarted: TestRunStarted
   private testRunFinished: TestRunFinished
-  private readonly testCaseStarted: Array<TestCaseStarted> = []
+  private readonly testCaseStartedById: Map<string, TestCaseStarted> = new Map()
   private readonly lineageById: Map<string, Lineage> = new Map()
   private readonly stepById: Map<string, Step> = new Map()
   private readonly pickleById: Map<string, Pickle> = new Map()
@@ -59,10 +63,12 @@ export default class Query {
   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 testStepStartedByTestCaseStartedId: ArrayMultimap<string, TestStepStarted> =
+    new ArrayMultimap()
   private readonly testStepFinishedByTestCaseStartedId: ArrayMultimap<string, TestStepFinished> =
-      new ArrayMultimap()
+    new ArrayMultimap()
   private readonly attachmentsByTestCaseStartedId: ArrayMultimap<string, Attachment> =
-      new ArrayMultimap()
+    new ArrayMultimap()
 
   public update(envelope: messages.Envelope) {
     if (envelope.meta) {
@@ -86,6 +92,9 @@ export default class Query {
     if (envelope.testCaseStarted) {
       this.updateTestCaseStarted(envelope.testCaseStarted)
     }
+    if (envelope.testStepStarted) {
+      this.updateTestStepStarted(envelope.testStepStarted)
+    }
     if (envelope.attachment) {
       this.updateAttachment(envelope.attachment)
     }
@@ -187,14 +196,14 @@ export default class Query {
       this.pickleStepIdByTestStepId.set(testStep.id, testStep.pickleStepId)
       this.testStepIdsByPickleStepId.put(testStep.pickleStepId, testStep.id)
       this.stepMatchArgumentsListsByPickleStepId.set(
-          testStep.pickleStepId,
-          testStep.stepMatchArgumentsLists
+        testStep.pickleStepId,
+        testStep.stepMatchArgumentsLists
       )
     })
   }
 
   private updateTestCaseStarted(testCaseStarted: TestCaseStarted) {
-    this.testCaseStarted.push(testCaseStarted)
+    this.testCaseStartedById.set(testCaseStarted.id, testCaseStarted)
 
     /*
     when a test case attempt starts besides the first one, clear all existing results
@@ -202,14 +211,20 @@ export default class Query {
     (applies to legacy pickle-oriented query methods only)
      */
     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 (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) {
+    this.testStepStartedByTestCaseStartedId.put(testStepStarted.testCaseStartedId, testStepStarted)
+  }
+
   private updateAttachment(attachment: Attachment) {
     if (attachment.testStepId) {
       this.attachmentsByTestStepId.put(attachment.testStepId, attachment)
@@ -221,24 +236,21 @@ export default class Query {
 
   private updateTestStepFinished(testStepFinished: TestStepFinished) {
     this.testStepFinishedByTestCaseStartedId.put(
-        testStepFinished.testCaseStartedId,
-        testStepFinished
+      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.testStepResultsByPickleStepId.put(testStep.pickleStepId, testStepFinished.testStepResult)
     this.testStepResultsbyTestStepId.put(testStep.id, testStepFinished.testStepResult)
   }
 
   private updateTestCaseFinished(testCaseFinished: TestCaseFinished) {
     this.testCaseFinishedByTestCaseStartedId.set(
-        testCaseFinished.testCaseStartedId,
-        testCaseFinished
+      testCaseFinished.testCaseStartedId,
+      testCaseFinished
     )
   }
 
@@ -353,7 +365,11 @@ export default class Query {
 
     for (const step of testCase.testSteps) {
       if (step.hookId) {
-        pickleStepFound ? onAfterHookFound(step) : onBeforeHookFound(step)
+        if (pickleStepFound) {
+          onAfterHookFound(step)
+        } else {
+          onBeforeHookFound(step)
+        }
       } else {
         pickleStepFound = true
       }
@@ -389,10 +405,12 @@ export default class Query {
       [TestStepResultStatus.UNKNOWN]: 0,
     }
     for (const testCaseStarted of this.findAllTestCaseStarted()) {
-      const mostSevereResult = this.findTestStepFinishedAndTestStepBy(testCaseStarted)
-        .map(([testStepFinished]) => testStepFinished.testStepResult)
-        .sort(comparatorByStatus)
-        .at(-1)
+      const mostSevereResult = sortBy(
+        this.findTestStepFinishedAndTestStepBy(testCaseStarted).map(
+          ([testStepFinished]) => testStepFinished.testStepResult
+        ),
+        [(testStepResult) => statusOrdinal(testStepResult.status)]
+      ).at(-1)
       if (mostSevereResult) {
         result[mostSevereResult.status]++
       }
@@ -406,41 +424,54 @@ export default class Query {
 
   public findAllPickles(): ReadonlyArray<Pickle> {
     const pickles = [...this.pickleById.values()]
-    return pickles.sort(comparatorById)
+    return sortBy(pickles, ['id'])
   }
 
   public findAllPickleSteps(): ReadonlyArray<PickleStep> {
     const pickleSteps = [...this.pickleStepById.values()]
-    return pickleSteps.sort(comparatorById)
+    return sortBy(pickleSteps, ['id'])
   }
 
   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
-    })
+    return sortBy(
+      [...this.testCaseStartedById.values()].filter((testCaseStarted) => {
+        const testCaseFinished = this.testCaseFinishedByTestCaseStartedId.get(testCaseStarted.id)
+        // only include if not yet finished OR won't be retried
+        return !testCaseFinished?.willBeRetried
+      }),
+      [
+        (testCaseStarted) =>
+          TimeConversion.timestampToMillisecondsSinceEpoch(testCaseStarted.timestamp),
+        'id',
+      ]
+    )
   }
 
-  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])
-        })
+  public findAllTestCaseStartedGroupedByFeature(): Map<
+    Feature | undefined,
+    ReadonlyArray<TestCaseStarted>
+  > {
+    const results = new Map()
+    sortBy(
+      this.findAllTestCaseStarted().map(
+        (testCaseStarted) => [this.findLineageBy(testCaseStarted), testCaseStarted] as const
+      ),
+      [([lineage]) => lineage.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)
+    return sortBy(testSteps, ['id'])
   }
 
   public findAttachmentsBy(testStepFinished: TestStepFinished): ReadonlyArray<Attachment> {
-    return this.attachmentsByTestCaseStartedId.get(testStepFinished.testCaseStartedId)
-        .filter(attachment => attachment.testStepId === testStepFinished.testStepId)
+    return this.attachmentsByTestCaseStartedId
+      .get(testStepFinished.testCaseStartedId)
+      .filter((attachment) => attachment.testStepId === testStepFinished.testStepId)
   }
 
   public findFeatureBy(testCaseStarted: TestCaseStarted): Feature | undefined {
@@ -448,21 +479,25 @@ export default class Query {
   }
 
   public findHookBy(testStep: TestStep): Hook | undefined {
-    if (!testStep.hookId){
+    if (!testStep.hookId) {
       return undefined
     }
     return this.hooksById.get(testStep.hookId)
   }
 
   public findMeta(): Meta | undefined {
-    return this.meta;
+    return this.meta
   }
 
-  public findMostSevereTestStepResultBy(testCaseStarted: TestCaseStarted): TestStepResult | undefined {
-    return this.findTestStepFinishedAndTestStepBy(testCaseStarted)
-      .map(([testStepFinished]) => testStepFinished.testStepResult)
-      .sort(comparatorByStatus)
-      .at(-1)
+  public findMostSevereTestStepResultBy(
+    testCaseStarted: TestCaseStarted
+  ): TestStepResult | undefined {
+    return sortBy(
+      this.findTestStepFinishedAndTestStepBy(testCaseStarted).map(
+        ([testStepFinished]) => testStepFinished.testStepResult
+      ),
+      [(testStepResult) => statusOrdinal(testStepResult.status)]
+    ).at(-1)
   }
 
   public findNameOf(pickle: Pickle, namingStrategy: NamingStrategy): string {
@@ -470,14 +505,22 @@ export default class Query {
     return lineage ? namingStrategy.reduce(lineage, pickle) : pickle.name
   }
 
-  public findPickleBy(testCaseStarted: TestCaseStarted): Pickle | undefined {
-    const testCase = this.findTestCaseBy(testCaseStarted)
+  public findLocationOf(pickle: Pickle): Location | undefined {
+    const lineage = this.findLineageBy(pickle)
+    if (lineage?.example) {
+      return lineage.example.location
+    }
+    return lineage?.scenario?.location
+  }
+
+  public findPickleBy(element: TestCaseStarted | TestStepStarted): Pickle | undefined {
+    const testCase = this.findTestCaseBy(element)
     assert.ok(testCase, 'Expected to find TestCase from TestCaseStarted')
     return this.pickleById.get(testCase.pickleId)
   }
 
   public findPickleStepBy(testStep: TestStep): PickleStep | undefined {
-    if (!testStep.pickleStepId){
+    if (!testStep.pickleStepId) {
       return undefined
     }
     return this.pickleStepById.get(testStep.pickleStepId)
@@ -489,7 +532,10 @@ export default class Query {
     return this.stepById.get(astNodeId)
   }
 
-  public findTestCaseBy(testCaseStarted: TestCaseStarted): TestCase | undefined {
+  public findTestCaseBy(element: TestCaseStarted | TestStepStarted): TestCase | undefined {
+    const testCaseStarted =
+      'testCaseStartedId' in element ? this.findTestCaseStartedBy(element) : element
+    assert.ok(testCaseStarted, 'Expected to find TestCaseStarted by TestStepStarted')
     return this.testCaseById.get(testCaseStarted.testCaseId)
   }
 
@@ -499,11 +545,15 @@ export default class Query {
       return undefined
     }
     return TimeConversion.millisecondsToDuration(
-        TimeConversion.timestampToMillisecondsSinceEpoch(testCaseFinished.timestamp) -
+      TimeConversion.timestampToMillisecondsSinceEpoch(testCaseFinished.timestamp) -
         TimeConversion.timestampToMillisecondsSinceEpoch(testCaseStarted.timestamp)
     )
   }
 
+  public findTestCaseStartedBy(testStepStarted: TestStepStarted): TestCaseStarted | undefined {
+    return this.testCaseStartedById.get(testStepStarted.testCaseStartedId)
+  }
+
   public findTestCaseFinishedBy(testCaseStarted: TestCaseStarted): TestCaseFinished | undefined {
     return this.testCaseFinishedByTestCaseStartedId.get(testCaseStarted.id)
   }
@@ -513,7 +563,7 @@ export default class Query {
       return undefined
     }
     return TimeConversion.millisecondsToDuration(
-        TimeConversion.timestampToMillisecondsSinceEpoch(this.testRunFinished.timestamp) -
+      TimeConversion.timestampToMillisecondsSinceEpoch(this.testRunFinished.timestamp) -
         TimeConversion.timestampToMillisecondsSinceEpoch(this.testRunStarted.timestamp)
     )
   }
@@ -526,29 +576,36 @@ export default class Query {
     return this.testRunStarted
   }
 
-  public findTestStepBy(testStepFinished: TestStepFinished): TestStep | undefined {
-    return this.testStepById.get(testStepFinished.testStepId)
+  public findTestStepBy(element: TestStepStarted | TestStepFinished): TestStep | undefined {
+    return this.testStepById.get(element.testStepId)
+  }
+
+  public findTestStepsStartedBy(testCaseStarted: TestCaseStarted): ReadonlyArray<TestStepStarted> {
+    // multimaps `get` implements `getOrDefault([])` behaviour internally
+    return [...this.testStepStartedByTestCaseStartedId.get(testCaseStarted.id)]
   }
 
-  public findTestStepsFinishedBy(testCaseStarted: TestCaseStarted): ReadonlyArray<TestStepFinished> {
+  public findTestStepsFinishedBy(
+    testCaseStarted: TestCaseStarted
+  ): ReadonlyArray<TestStepFinished> {
     // multimaps `get` implements `getOrDefault([])` behaviour internally
     return [...this.testStepFinishedByTestCaseStartedId.get(testCaseStarted.id)]
   }
 
   public findTestStepFinishedAndTestStepBy(
-      testCaseStarted: TestCaseStarted
+    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]
-        })
+      .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
+  public findLineageBy(element: Pickle | TestCaseStarted): Lineage | undefined {
+    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)