@cucumber/query 10.0.0 → 12.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cucumber/query",
-  "version": "10.0.0",
+  "version": "12.0.0",
   "description": "Cucumber Query - query messages",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -22,18 +22,18 @@
   },
   "homepage": "https://github.com/cucumber/cucumber#readme",
   "devDependencies": {
-    "@cucumber/fake-cucumber": "^12.0.0",
-    "@cucumber/gherkin": "^19.0.1",
-    "@cucumber/gherkin-streams": "^2.0.1",
-    "@cucumber/gherkin-utils": "^5.0.1",
-    "@types/mocha": "8.2.2",
-    "@types/node": "15.3.0",
-    "mocha": "8.4.0",
-    "ts-node": "9.1.1",
-    "typescript": "4.2.4"
+    "@cucumber/fake-cucumber": "^16.0.0",
+    "@cucumber/gherkin": "^24.0.0",
+    "@cucumber/gherkin-streams": "^5.0.1",
+    "@cucumber/gherkin-utils": "^8.0.0",
+    "@types/mocha": "9.1.1",
+    "@types/node": "16.11.38",
+    "mocha": "10.0.0",
+    "ts-node": "10.8.0",
+    "typescript": "4.7.2"
   },
   "dependencies": {
-    "@cucumber/messages": "^16.0.0",
+    "@cucumber/messages": "^19.0.0",
     "@teppeis/multimaps": "2.0.0"
   },
   "directories": {

package/src/Query.ts

@@ -1,4 +1,5 @@
 import * as messages from '@cucumber/messages'
+import { getWorstTestStepResult } from '@cucumber/messages'
 import { ArrayMultimap } from '@teppeis/multimaps'
 
 export default class Query {
@@ -9,6 +10,7 @@ export default class Query {
   >()
   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<
@@ -27,6 +29,7 @@ export default class Query {
 
   public update(envelope: messages.Envelope) {
     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)
@@ -40,6 +43,21 @@ export default class Query {
       }
     }
 
+    /*
+    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
+     */
+    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)
+      }
+    }
+
     if (envelope.testStepFinished) {
       const pickleId = this.pickleIdByTestStepId.get(envelope.testStepFinished.testStepId)
       this.testStepResultByPickleId.put(pickleId, envelope.testStepFinished.testStepResult)
@@ -73,7 +91,6 @@ export default class Query {
         {
           status: messages.TestStepResultStatus.UNKNOWN,
           duration: messages.TimeConversion.millisecondsToDuration(0),
-          willBeRetried: false,
         },
       ]
     }
@@ -94,7 +111,6 @@ export default class Query {
         {
           status: messages.TestStepResultStatus.UNKNOWN,
           duration: messages.TimeConversion.millisecondsToDuration(0),
-          willBeRetried: false,
         },
       ]
     }
@@ -184,4 +200,16 @@ export default class Query {
   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
+  }
 }

package/test/QueryTest.ts

@@ -10,6 +10,7 @@ import {
   makeTestCase,
   IncrementClock,
   IncrementStopwatch,
+  RunOptions,
 } from '@cucumber/fake-cucumber'
 
 import { promisify } from 'util'
@@ -381,6 +382,24 @@ describe('Query', () => {
         assert.deepStrictEqual(results.length, 1)
         assert.deepStrictEqual(results[0].status, 'PASSED')
       })
+
+      it('returns the result from the last attempt only where retry has been used', async () => {
+        const emittedMessages: Array<messages.Envelope> = []
+        await execute(
+          `Feature: hello
+Scenario: hi
+  Given a step that passes the second time
+`,
+          (message) => emittedMessages.push(message),
+          { allowedRetries: 1 }
+        )
+        const testCase = emittedMessages.find((child) => child.testCase).testCase
+        const testStep = testCase.testSteps[0]
+        const results = cucumberQuery.getTestStepResults(testStep.id)
+
+        assert.deepStrictEqual(results.length, 1)
+        assert.deepStrictEqual(results[0].status, 'PASSED')
+      })
     })
 
     describe('#getHook(HookId)', () => {
@@ -423,14 +442,84 @@ describe('Query', () => {
 
         assert.strictEqual(attachments[0].body, 'Hello')
       })
+
+      it('returns attachments from the last attempt only where retry has been used', async () => {
+        const testCases: messages.TestCase[] = []
+        await execute(
+          `Feature: hello
+    Scenario: ok
+      Given a passed step with attachment
+      And a step that passes the second time
+  `,
+          (envelope) => {
+            if (envelope.testCase) {
+              testCases.push(envelope.testCase)
+            }
+          },
+          { allowedRetries: 1 }
+        )
+
+        const attachments = cucumberQuery.getTestStepsAttachments([testCases[0].testSteps[0].id])
+        assert.strictEqual(attachments.length, 1)
+
+        assert.strictEqual(attachments[0].body, 'Hello')
+      })
+    })
+
+    describe('#getStatusCounts', () => {
+      it('returns the number of pickles for each status', async () => {
+        await execute(
+          `Feature: hello
+    Scenario: ok
+      Given a passed step
+  `,
+          () => undefined
+        )
+
+        await execute(
+          `Feature: hello
+    Scenario: ok
+      Given a passed step
+  `,
+          () => undefined
+        )
+
+        await execute(
+          `Feature: hello
+    Scenario: ok
+      Given a failed step
+  `,
+          () => undefined
+        )
+
+        await execute(
+          `Feature: hello
+    Scenario: ok
+      Given an undefined step
+  `,
+          () => undefined
+        )
+
+        const statuses = cucumberQuery.getStatusCounts(
+          gherkinQuery.getPickles().map((pickle) => pickle.id)
+        )
+
+        const expectedStatuses: Partial<Record<messages.TestStepResultStatus, number>> = {
+          PASSED: 2,
+          FAILED: 1,
+          UNDEFINED: 1,
+        }
+        assert.deepStrictEqual(statuses, expectedStatuses)
+      })
     })
   })
 
   async function execute(
     gherkinSource: string,
-    messagesHandler: (envelope: messages.Envelope) => void = () => null
+    messagesHandler: (envelope: messages.Envelope) => void = () => null,
+    runOptions: RunOptions = { allowedRetries: 0 }
   ): Promise<void> {
-    const newId = messages.IdGenerator.incrementing()
+    const newId = messages.IdGenerator.uuid()
     const clock = new IncrementClock()
     const stopwatch = new IncrementStopwatch()
     const makeErrorMessage = withFullStackTrace()
@@ -453,6 +542,13 @@ describe('Query', () => {
     supportCode.defineStepDefinition(null, 'I have {int} cukes in my {word}', (cukes: number) => {
       assert.ok(cukes)
     })
+    let passesSecondTime = 0
+    supportCode.defineStepDefinition(null, 'a step that passes the second time', () => {
+      passesSecondTime++
+      if (passesSecondTime < 2) {
+        throw new Error(`This step failed.`)
+      }
+    })
 
     const queryUpdateStream = new Writable({
       objectMode: true,
@@ -473,7 +569,7 @@ describe('Query', () => {
     })
     await pipelinePromise(gherkinMessages(gherkinSource, 'test.feature', newId), queryUpdateStream)
 
-    const testPlan = makeTestPlan(gherkinQuery, supportCode, makeTestCase)
+    const testPlan = makeTestPlan(gherkinQuery, supportCode, runOptions, makeTestCase)
     await testPlan.execute((envelope: messages.Envelope) => {
       messagesHandler(envelope)
       cucumberQuery.update(envelope)