@cucumber/query 5.0.0 → 7.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cucumber/query",
-  "version": "5.0.0",
+  "version": "7.0.1",
   "description": "Cucumber Query - query messages",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -26,30 +26,32 @@
   },
   "homepage": "https://github.com/cucumber/cucumber#readme",
   "devDependencies": {
-    "@cucumber/fake-cucumber": "^6.0.0",
-    "@types/mocha": "^7.0.2",
-    "@types/node": "^13.9.8",
-    "@typescript-eslint/eslint-plugin": "^2.26.0",
-    "@typescript-eslint/parser": "^2.26.0",
-    "eslint": "^6.8.0",
-    "eslint-config-prettier": "^6.10.1",
+    "@cucumber/fake-cucumber": "^9.0.0",
+    "@cucumber/gherkin": "^16.0.0",
+    "@cucumber/gherkin-utils": "^2.1.1",
+    "@types/mocha": "^8.2.0",
+    "@types/node": "^14.14.14",
+    "@typescript-eslint/eslint-plugin": "^4.10.0",
+    "@typescript-eslint/parser": "^4.10.0",
+    "core-js": "^3.8.1",
+    "eslint": "^7.15.0",
+    "eslint-config-prettier": "^7.0.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^3.1.2",
-    "eslint-plugin-react": "^7.19.0",
-    "mocha": "^7.1.1",
-    "nyc": "^15.0.0",
-    "prettier": "^2.0.2",
-    "source-map-support": "^0.5.16",
-    "ts-loader": "^6.2.2",
-    "ts-node": "^8.8.1",
-    "typescript": "^3.8.3"
+    "eslint-plugin-prettier": "^3.3.0",
+    "eslint-plugin-react": "^7.21.5",
+    "mocha": "^8.2.1",
+    "nyc": "^15.1.0",
+    "prettier": "^2.2.1",
+    "source-map-support": "^0.5.19",
+    "ts-loader": "^8.0.12",
+    "ts-node": "^9.1.1",
+    "typescript": "^4.1.3"
   },
   "files": [
     "*"
   ],
   "dependencies": {
-    "@cucumber/gherkin": "^12.0.0",
-    "@cucumber/messages": "^11.1.1",
+    "@cucumber/messages": "^13.2.1",
     "@teppeis/multimaps": "^1.1.0"
   },
   "directories": {

package/src/Query.ts

@@ -4,17 +4,27 @@ import { ArrayMultimap } from '@teppeis/multimaps'
 export default class Query {
   private readonly testStepResultByPickleId = new ArrayMultimap<
     string,
-    messages.ITestStepResult
+    messages.TestStepFinished.ITestStepResult
   >()
   private readonly testStepResultsByPickleStepId = new ArrayMultimap<
     string,
-    messages.ITestStepResult
+    messages.TestStepFinished.ITestStepResult
   >()
   private readonly testStepById = new Map<string, messages.TestCase.ITestStep>()
+  private readonly testCaseByPickleId = new Map<string, messages.ITestCase>()
   private readonly pickleIdByTestStepId = new Map<string, string>()
   private readonly pickleStepIdByTestStepId = new Map<string, string>()
+  private readonly testStepResultsbyTestStepId = new ArrayMultimap<
+    string,
+    messages.TestStepFinished.ITestStepResult
+  >()
+  private readonly testStepIdsByPickleStepId = new ArrayMultimap<
+    string,
+    string
+  >()
+  private readonly hooksById = new Map<string, messages.IHook>()
 
-  private readonly attachmentsByPickleStepId = new ArrayMultimap<
+  private readonly attachmentsByTestStepId = new ArrayMultimap<
     string,
     messages.IAttachment
   >()
@@ -26,10 +36,12 @@ export default class Query {
 
   public update(envelope: messages.IEnvelope) {
     if (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(
           testStep.pickleStepId,
           testStep.stepMatchArgumentsLists
@@ -53,13 +65,21 @@ export default class Query {
         testStep.pickleStepId,
         envelope.testStepFinished.testStepResult
       )
+      this.testStepResultsbyTestStepId.put(
+        testStep.id,
+        envelope.testStepFinished.testStepResult
+      )
+    }
+
+    if (envelope.hook) {
+      this.hooksById.set(envelope.hook.id, envelope.hook)
     }
 
     if (envelope.attachment) {
-      const pickleStepId = this.pickleStepIdByTestStepId.get(
-        envelope.attachment.testStepId
+      this.attachmentsByTestStepId.put(
+        envelope.attachment.testStepId,
+        envelope.attachment
       )
-      this.attachmentsByPickleStepId.put(pickleStepId, envelope.attachment)
     }
   }
 
@@ -69,17 +89,20 @@ export default class Query {
    */
   public getPickleStepTestStepResults(
     pickleStepIds: ReadonlyArray<string>
-  ): ReadonlyArray<messages.ITestStepResult> {
+  ): ReadonlyArray<messages.TestStepFinished.ITestStepResult> {
     if (pickleStepIds.length === 0) {
       return [
-        new messages.TestStepResult({
-          status: messages.TestStepResult.Status.UNKNOWN,
+        new messages.TestStepFinished.TestStepResult({
+          status: messages.TestStepFinished.TestStepResult.Status.UNKNOWN,
           duration: TimeConversion.millisecondsToDuration(0),
         }),
       ]
     }
     return pickleStepIds.reduce(
-      (testStepResults: messages.ITestStepResult[], pickleId) => {
+      (
+        testStepResults: messages.TestStepFinished.ITestStepResult[],
+        pickleId
+      ) => {
         return testStepResults.concat(
           this.testStepResultsByPickleStepId.get(pickleId)
         )
@@ -94,17 +117,20 @@ export default class Query {
    */
   public getPickleTestStepResults(
     pickleIds: ReadonlyArray<string>
-  ): ReadonlyArray<messages.ITestStepResult> {
+  ): ReadonlyArray<messages.TestStepFinished.ITestStepResult> {
     if (pickleIds.length === 0) {
       return [
-        new messages.TestStepResult({
-          status: messages.TestStepResult.Status.UNKNOWN,
+        new messages.TestStepFinished.TestStepResult({
+          status: messages.TestStepFinished.TestStepResult.Status.UNKNOWN,
           duration: TimeConversion.millisecondsToDuration(0),
         }),
       ]
     }
     return pickleIds.reduce(
-      (testStepResults: messages.ITestStepResult[], pickleId) => {
+      (
+        testStepResults: messages.TestStepFinished.ITestStepResult[],
+        pickleId
+      ) => {
         return testStepResults.concat(
           this.testStepResultByPickleId.get(pickleId)
         )
@@ -118,12 +144,12 @@ export default class Query {
    * @param testStepResults
    */
   public getWorstTestStepResult(
-    testStepResults: ReadonlyArray<messages.ITestStepResult>
-  ): messages.ITestStepResult {
+    testStepResults: ReadonlyArray<messages.TestStepFinished.ITestStepResult>
+  ): messages.TestStepFinished.ITestStepResult {
     return (
       testStepResults.slice().sort((r1, r2) => r2.status - r1.status)[0] ||
-      new messages.TestStepResult({
-        status: messages.TestStepResult.Status.UNKNOWN,
+      new messages.TestStepFinished.TestStepResult({
+        status: messages.TestStepFinished.TestStepResult.Status.UNKNOWN,
         duration: TimeConversion.millisecondsToDuration(0),
       })
     )
@@ -136,11 +162,21 @@ export default class Query {
   public getPickleStepAttachments(
     pickleStepIds: ReadonlyArray<string>
   ): ReadonlyArray<messages.IAttachment> {
-    return pickleStepIds.reduce(
-      (attachments: messages.IAttachment[], pickleStepId) => {
-        return attachments.concat(
-          this.attachmentsByPickleStepId.get(pickleStepId)
+    return this.getTestStepsAttachments(
+      pickleStepIds.reduce((testStepIds: string[], pickleStepId: string) => {
+        return testStepIds.concat(
+          this.testStepIdsByPickleStepId.get(pickleStepId)
         )
+      }, [])
+    )
+  }
+
+  public getTestStepsAttachments(
+    testStepIds: ReadonlyArray<string>
+  ): ReadonlyArray<messages.IAttachment> {
+    return testStepIds.reduce(
+      (attachments: messages.IAttachment[], testStepId) => {
+        return attachments.concat(this.attachmentsByTestStepId.get(testStepId))
       },
       []
     )
@@ -157,4 +193,62 @@ export default class Query {
     | undefined {
     return this.stepMatchArgumentsListsByPickleStepId.get(pickleStepId)
   }
+
+  public getHook(hookId: string): messages.IHook {
+    return this.hooksById.get(hookId)
+  }
+
+  public getBeforeHookSteps(
+    pickleId: string
+  ): ReadonlyArray<messages.TestCase.ITestStep> {
+    const hookSteps: messages.TestCase.ITestStep[] = []
+
+    this.identifyHookSteps(
+      pickleId,
+      (hook) => hookSteps.push(hook),
+      () => null
+    )
+    return hookSteps
+  }
+
+  public getAfterHookSteps(
+    pickleId: string
+  ): ReadonlyArray<messages.TestCase.ITestStep> {
+    const hookSteps: messages.TestCase.ITestStep[] = []
+
+    this.identifyHookSteps(
+      pickleId,
+      () => null,
+      (hook) => hookSteps.push(hook)
+    )
+    return hookSteps
+  }
+
+  private identifyHookSteps(
+    pickleId: string,
+    onBeforeHookFound: (hook: messages.TestCase.ITestStep) => void,
+    onAfterHookFound: (hook: messages.TestCase.ITestStep) => void
+  ): void {
+    const testCase = this.testCaseByPickleId.get(pickleId)
+
+    if (!testCase) {
+      return
+    }
+
+    let pickleStepFound = false
+
+    for (const step of testCase.testSteps) {
+      if (step.hookId) {
+        pickleStepFound ? onAfterHookFound(step) : onBeforeHookFound(step)
+      } else {
+        pickleStepFound = true
+      }
+    }
+  }
+
+  public getTestStepResults(
+    testStepId: string
+  ): messages.TestStepFinished.ITestStepResult[] {
+    return this.testStepResultsbyTestStepId.get(testStepId)
+  }
 }