use lineage for test case names

Author: davidjgoss

javascript/src/ExtendedQuery.ts

@@ -2,7 +2,6 @@ import * as assert from 'node:assert'
 
 import {
   Envelope,
-  Examples,
   Feature,
   getWorstTestStepResult,
   GherkinDocument,
@@ -11,7 +10,6 @@ import {
   Rule,
   Scenario,
   Step,
-  TableRow,
   TestCase,
   TestCaseFinished,
   TestCaseStarted,
@@ -24,16 +22,7 @@ import {
 } from '@cucumber/messages'
 import { ArrayMultimap } from '@teppeis/multimaps'
 
-export interface Lineage {
-  gherkinDocument?: GherkinDocument
-  feature?: Feature
-  rule?: Rule
-  scenario?: Scenario
-  examples?: Examples
-  examplesIndex?: number
-  example?: TableRow
-  exampleIndex?: number
-}
+import { Lineage, NamingStrategy } from './Lineage.js'
 
 export class ExtendedQuery {
   private testRunStarted: TestRunStarted
@@ -188,6 +177,11 @@ export class ExtendedQuery {
     return this.lineageById.get(deepestAstNodeId)
   }
 
+  findNameOf(pickle: Pickle, namingStrategy: NamingStrategy) {
+    const lineage = this.findLineageBy(pickle)
+    return lineage ? namingStrategy.reduce(lineage, pickle) : pickle.name
+  }
+
   findStepBy(pickleStep: PickleStep) {
     const [astNodeId] = pickleStep.astNodeIds
     assert.ok('Expected PickleStep to have an astNodeId')

javascript/src/Lineage.ts

@@ -0,0 +1,110 @@
+import {
+  Examples,
+  Feature,
+  GherkinDocument,
+  Pickle,
+  Rule,
+  Scenario,
+  TableRow,
+} from '@cucumber/messages'
+
+export interface Lineage {
+  gherkinDocument?: GherkinDocument
+  feature?: Feature
+  rule?: Rule
+  scenario?: Scenario
+  examples?: Examples
+  examplesIndex?: number
+  example?: TableRow
+  exampleIndex?: number
+}
+
+export interface LineageReducer<T> {
+  reduce: (lineage: Lineage, pickle: Pickle) => T
+}
+
+export type NamingStrategy = LineageReducer<string>
+
+export enum NamingStrategyLength {
+  LONG = 'LONG',
+  SHORT = 'SHORT',
+}
+
+export enum NamingStrategyFeatureName {
+  INCLUDE = 'INCLUDE',
+  EXCLUDE = 'EXCLUDE',
+}
+
+export enum NamingStrategyExampleName {
+  NUMBER = 'NUMBER',
+  PICKLE = 'PICKLE',
+  NUMBER_AND_PICKLE_IF_PARAMETERIZED = 'NUMBER_AND_PICKLE_IF_PARAMETERIZED',
+}
+
+class BuiltinNamingStrategy implements NamingStrategy {
+  constructor(
+    private readonly length: NamingStrategyLength,
+    private readonly featureName: NamingStrategyFeatureName,
+    private readonly exampleName: NamingStrategyExampleName
+  ) {}
+
+  reduce(lineage: Lineage, pickle: Pickle): string {
+    const parts: string[] = []
+
+    if (lineage.feature?.name && this.featureName === NamingStrategyFeatureName.INCLUDE) {
+      parts.push(lineage.feature.name)
+    }
+
+    if (lineage.rule?.name) {
+      parts.push(lineage.rule.name)
+    }
+
+    if (lineage.scenario?.name) {
+      parts.push(lineage.scenario.name)
+    } else {
+      parts.push(pickle.name)
+    }
+
+    if (lineage.examples?.name) {
+      parts.push(lineage.examples.name)
+    }
+
+    if (lineage.example) {
+      const exampleNumber = [
+        '#',
+        (lineage.examplesIndex ?? 0) + 1,
+        '.',
+        (lineage.exampleIndex ?? 0) + 1,
+      ].join('')
+
+      switch (this.exampleName) {
+        case NamingStrategyExampleName.NUMBER:
+          parts.push(exampleNumber)
+          break
+        case NamingStrategyExampleName.NUMBER_AND_PICKLE_IF_PARAMETERIZED:
+          if (lineage.scenario?.name !== pickle.name) {
+            parts.push(exampleNumber + ': ' + pickle.name)
+          } else {
+            parts.push(exampleNumber)
+          }
+          break
+        case NamingStrategyExampleName.PICKLE:
+          parts.push(pickle.name)
+          break
+      }
+    }
+
+    if (this.length === NamingStrategyLength.SHORT) {
+      return parts.at(-1) as string
+    }
+    return parts.filter((part) => !!part).join(' - ')
+  }
+}
+
+export function namingStrategy(
+  length: NamingStrategyLength,
+  featureName: NamingStrategyFeatureName,
+  exampleName: NamingStrategyExampleName
+): NamingStrategy {
+  return new BuiltinNamingStrategy(length, featureName, exampleName)
+}

javascript/src/index.ts

@@ -6,6 +6,18 @@ import xmlbuilder from 'xmlbuilder'
 
 import { ExtendedQuery } from './ExtendedQuery.js'
 import { countStatuses, durationToSeconds, formatStep } from './helpers.js'
+import {
+  namingStrategy,
+  NamingStrategyExampleName,
+  NamingStrategyFeatureName,
+  NamingStrategyLength,
+} from './Lineage.js'
+
+const NAMING_STRATEGY = namingStrategy(
+  NamingStrategyLength.LONG,
+  NamingStrategyFeatureName.EXCLUDE,
+  NamingStrategyExampleName.NUMBER_AND_PICKLE_IF_PARAMETERIZED
+)
 
 export default {
   type: 'formatter',
@@ -93,9 +105,10 @@ function makeTestCases(query: ExtendedQuery): ReadonlyArray<ReportTestCase> {
     const pickle = query.findPickleBy(testCaseStarted)
     assert.ok(pickle, 'Expected to find Pickle by TestCaseStarted')
     const lineage = query.findLineageBy(pickle)
+
     return {
       classname: lineage?.feature?.name ?? pickle.uri,
-      name: pickle.name,
+      name: query.findNameOf(pickle, NAMING_STRATEGY),
       time: durationToSeconds(query.findTestCaseDurationBy(testCaseStarted)),
       failure: makeFailure(query, testCaseStarted),
       output: query