@elisra-devops/docgen-data-provider 1.92.0 → 1.94.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elisra-devops/docgen-data-provider",
-  "version": "1.92.0",
+  "version": "1.94.0",
   "description": "A document generator data provider, aimed to retrive data from azure devops",
   "repository": {
     "type": "git",

package/src/modules/ResultDataProvider.ts

@@ -52,6 +52,11 @@ const pLimit = require('p-limit');
  * Instantiate the class with the organization URL and token, and use the provided methods to fetch and process test data.
  */
 export default class ResultDataProvider {
+  private static readonly MEWP_INTERNAL_VALIDATION_TRACE_TAG = '[MEWP][InternalValidation][Trace]';
+  private static readonly MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG =
+    '[MEWP][InternalValidation][Diagnostics]';
+  private static readonly MEWP_INTERNAL_VALIDATION_SUMMARY_TAG = '[MEWP][InternalValidation][Summary]';
+
   private static readonly MEWP_L2_COVERAGE_COLUMNS = [
     'L2 REQ ID',
     'L2 REQ Title',
@@ -732,7 +737,10 @@ export default class ResultDataProvider {
     testPlanId: string,
     projectName: string,
     selectedSuiteIds: number[] | undefined,
-    linkedQueryRequest?: any
+    linkedQueryRequest?: any,
+    options?: {
+      debugMode?: boolean;
+    }
   ): Promise<MewpInternalValidationFlatPayload> {
     const defaultPayload: MewpInternalValidationFlatPayload = {
       sheetName: `MEWP Internal Validation - Plan ${testPlanId}`,
@@ -832,9 +840,19 @@ export default class ResultDataProvider {
         testCasesWithoutMentionedCustomerIds: 0,
         failingRows: 0,
       };
+      const traceInternalValidation = options?.debugMode === true;
+      if (traceInternalValidation) {
+        logger.info(
+          this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+            mode: 'enabled',
+            source: 'ui-debug-mode',
+          })
+        );
+      }
 
       for (const testCaseId of [...allTestCaseIds].sort((a, b) => a - b)) {
         diagnostics.totalTestCases += 1;
+        const traceCurrentTestCase = traceInternalValidation;
         const stepsXml = stepsXmlByTestCase.get(testCaseId) || '';
         const parsedSteps =
           stepsXml && String(stepsXml).trim() !== ''
@@ -884,6 +902,23 @@ export default class ResultDataProvider {
           if (!mentionedCodesByBase.has(baseKey)) mentionedCodesByBase.set(baseKey, new Set<string>());
           mentionedCodesByBase.get(baseKey)!.add(code);
         }
+        if (traceCurrentTestCase) {
+          logger.debug(
+            this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+              event: 'test-case-start',
+              tc: testCaseId,
+              parsedSteps: executableSteps.length,
+              stepsWithMentions: mentionEntries.length,
+              mentionedCodes:
+                [...mentionedL2Only].sort((a, b) => this.compareMewpRequirementCodes(a, b)).join('; ') ||
+                '<none>',
+              linkedCodesInTestCase:
+                [...linkedFullCodes]
+                  .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                  .join('; ') || '<none>',
+            })
+          );
+        }
 
         // Direction A logic:
         // 1) Base mention ("SR0054") is parent-level and considered covered only when
@@ -901,43 +936,110 @@ export default class ResultDataProvider {
 
           if (familyCodes?.size) {
             const familyLinkedCodes = linkedFamilyCodesAcrossTestCases.get(baseKey) || new Set<string>();
+            const normalizedFamilyMembers = [...familyCodes]
+              .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
+              .filter((code) => !!code);
+            const specificFamilyMembers = normalizedFamilyMembers.filter((code) => /-\d+$/.test(code));
+            const requiredFamilyMembers =
+              specificFamilyMembers.length > 0 ? specificFamilyMembers : normalizedFamilyMembers;
 
             // Base mention ("SR0054") requires full family coverage across selected test cases.
             if (hasBaseMention) {
-              const normalizedFamilyMembers = [...familyCodes]
-                .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
-                .filter((code) => !!code);
-              const specificFamilyMembers = normalizedFamilyMembers.filter((code) => /-\d+$/.test(code));
-              const requiredFamilyMembers =
-                specificFamilyMembers.length > 0 ? specificFamilyMembers : normalizedFamilyMembers;
+              const missingRequiredFamilyMembers = requiredFamilyMembers.filter(
+                (memberCode) => !familyLinkedCodes.has(memberCode)
+              );
               const isWholeFamilyCovered = requiredFamilyMembers.every((memberCode) =>
                 familyLinkedCodes.has(memberCode)
               );
               if (!isWholeFamilyCovered) {
                 missingBaseWhenFamilyUncovered.add(baseKey);
               }
+              if (traceCurrentTestCase) {
+                logger.debug(
+                  this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+                    event: 'base-family-coverage',
+                    tc: testCaseId,
+                    base: baseKey,
+                    baseMention: true,
+                    requiredFamily:
+                      requiredFamilyMembers
+                        .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                        .join('; ') || '<none>',
+                    linkedAcrossScope:
+                      [...familyLinkedCodes]
+                        .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                        .join('; ') || '<none>',
+                    missingRequired:
+                      missingRequiredFamilyMembers
+                        .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                        .join('; ') || '<none>',
+                    covered: isWholeFamilyCovered,
+                  })
+                );
+              }
             }
 
             // Specific mention ("SR0054-1") validates as exact-match only across scoped test cases.
-            for (const code of mentionedSpecificMembers) {
-              if (!familyLinkedCodes.has(code)) {
-                missingSpecificMentionedNoFamily.add(code);
-              }
+            const missingSpecificMembers = mentionedSpecificMembers.filter(
+              (code) => !familyLinkedCodes.has(code)
+            );
+            for (const code of missingSpecificMembers) {
+              missingSpecificMentionedNoFamily.add(code);
+            }
+            if (traceCurrentTestCase && mentionedSpecificMembers.length > 0) {
+              logger.debug(
+                this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+                  event: 'specific-members-check',
+                  tc: testCaseId,
+                  base: baseKey,
+                  specificMentioned:
+                    mentionedSpecificMembers
+                      .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                      .join('; ') || '<none>',
+                  specificMissing:
+                    missingSpecificMembers
+                      .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                      .join('; ') || '<none>',
+                })
+              );
             }
             continue;
           }
 
           // Fallback path when family data is unavailable for this base key.
+          const fallbackMissingSpecific: string[] = [];
+          let fallbackMissingBase = false;
           for (const code of mentionedCodes) {
             const hasSpecificSuffix = /-\d+$/.test(code);
             if (hasSpecificSuffix) {
               if (!linkedFullCodesAcrossTestCases.has(code)) {
                 missingSpecificMentionedNoFamily.add(code);
+                fallbackMissingSpecific.push(code);
               }
             } else if (!linkedBaseKeysAcrossTestCases.has(baseKey)) {
               missingBaseWhenFamilyUncovered.add(baseKey);
+              fallbackMissingBase = true;
             }
           }
+          if (traceCurrentTestCase) {
+            logger.debug(
+              this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+                event: 'fallback-path',
+                tc: testCaseId,
+                base: baseKey,
+                fallbackUsed: true,
+                mentioned:
+                  mentionedCodesList
+                    .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                    .join('; ') || '<none>',
+                missingSpecific:
+                  fallbackMissingSpecific
+                    .sort((a, b) => this.compareMewpRequirementCodes(a, b))
+                    .join('; ') || '<none>',
+                missingBase: fallbackMissingBase,
+              })
+            );
+          }
         }
 
         // Direction B is family-based: if any member of a family is mentioned in Expected Result,
@@ -983,6 +1085,16 @@ export default class ResultDataProvider {
           const stepRef = mentionedBaseFirstStep.get(baseKey) || 'Step ?';
           appendMentionedButNotLinked(baseKey, stepRef);
         }
+        if (traceCurrentTestCase) {
+          logger.debug(
+            this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
+              event: 'direction-a-summary',
+              tc: testCaseId,
+              missingSpecific: sortedMissingSpecificMentionedNoFamily.join('; ') || '<none>',
+              missingBase: sortedMissingBaseWhenFamilyUncovered.join('; ') || '<none>',
+            })
+          );
+        }
 
         const sortedExtraLinked = [...new Set(extraLinked)]
           .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
@@ -1022,15 +1134,19 @@ export default class ResultDataProvider {
           mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
         if (validationStatus === 'Fail') diagnostics.failingRows += 1;
         logger.debug(
-          `MEWP internal validation parse diagnostics: ` +
-            `testCaseId=${testCaseId} parsedSteps=${executableSteps.length} ` +
-            `stepsWithMentions=${mentionEntries.length} customerIdsFound=${mentionedL2Only.size} ` +
-            `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${
+          this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG, {
+            testCaseId,
+            parsedSteps: executableSteps.length,
+            stepsWithMentions: mentionEntries.length,
+            customerIdsFound: mentionedL2Only.size,
+            linkedRequirements: linkedFullCodes.size,
+            mentionedButNotLinked:
               sortedMissingSpecificMentionedNoFamily.length +
-              sortedMissingBaseWhenFamilyUncovered.length
-            } ` +
-            `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
-            `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`
+              sortedMissingBaseWhenFamilyUncovered.length,
+            linkedButNotMentioned: sortedExtraLinked.length,
+            status: validationStatus,
+            customerIdSample: [...mentionedL2Only].slice(0, 5).join(', '),
+          })
         );
 
         rows.push({
@@ -1042,11 +1158,14 @@ export default class ResultDataProvider {
         });
       }
       logger.info(
-        `MEWP internal validation summary: testCases=${diagnostics.totalTestCases} ` +
-          `parsedSteps=${diagnostics.totalParsedSteps} stepsWithMentions=${diagnostics.totalStepsWithMentions} ` +
-          `totalCustomerIdsFound=${diagnostics.totalMentionedCustomerIds} ` +
-          `testCasesWithoutCustomerIds=${diagnostics.testCasesWithoutMentionedCustomerIds} ` +
-          `failingRows=${diagnostics.failingRows}`
+        this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_SUMMARY_TAG, {
+          testCases: diagnostics.totalTestCases,
+          parsedSteps: diagnostics.totalParsedSteps,
+          stepsWithMentions: diagnostics.totalStepsWithMentions,
+          totalCustomerIdsFound: diagnostics.totalMentionedCustomerIds,
+          testCasesWithoutCustomerIds: diagnostics.testCasesWithoutMentionedCustomerIds,
+          failingRows: diagnostics.failingRows,
+        })
       );
 
       return {
@@ -1163,6 +1282,17 @@ export default class ResultDataProvider {
     return `MEWP Internal Validation - ${suffix}`;
   }
 
+  private formatLogValue(value: any): string {
+    if (value === null || value === undefined) return '<none>';
+    const asText = String(value).trim();
+    return asText !== '' ? asText : '<none>';
+  }
+
+  private buildTaggedLogMessage(tag: string, fields: Record<string, any>): string {
+    const sections = Object.entries(fields).map(([key, value]) => `${key}=${this.formatLogValue(value)}`);
+    return `${tag} ${sections.join(' | ')}`;
+  }
+
   private createMewpCoverageRow(
     requirement: Pick<
       MewpL2RequirementFamily,
@@ -2698,7 +2828,7 @@ export default class ResultDataProvider {
         // Direction B display is family-level when multiple members exist.
         return baseKey;
       })
-      .join('\n');
+      .join('; ');
   }
 
   private toMewpComparableText(value: any): string {
@@ -2919,7 +3049,7 @@ export default class ResultDataProvider {
       // Fetch detailed information for each test point and map to required format
       const detailedPoints = await Promise.all(
         latestPoints.map(async (point: any) => {
-          const url = `${point.url}?witFields=Microsoft.VSTS.TCM.Steps&includePointDetails=true`;
+          const url = `${point.url}?witFields=Microsoft.VSTS.TCM.Steps,System.Rev&includePointDetails=true`;
           const detailedPoint = await TFSServices.getItemContent(url, this.token);
           return this.mapTestPointForCrossPlans(detailedPoint, projectName);
           // return this.mapTestPointForCrossPlans(detailedPoint, projectName);
@@ -3012,7 +3142,7 @@ export default class ResultDataProvider {
     testPlanId: string,
     suiteId: string
   ): Promise<any[]> {
-    const url = `${this.orgUrl}${projectName}/_apis/testplan/Plans/${testPlanId}/Suites/${suiteId}/TestCase?witFields=Microsoft.VSTS.TCM.Steps`;
+    const url = `${this.orgUrl}${projectName}/_apis/testplan/Plans/${testPlanId}/Suites/${suiteId}/TestCase?witFields=Microsoft.VSTS.TCM.Steps,System.Rev`;
 
     const { value: testCases } = await TFSServices.getItemContent(url, this.token);
 
@@ -3056,8 +3186,28 @@ export default class ResultDataProvider {
     return fields;
   }
 
+  private getFieldValueByName(fields: Record<string, any>, fieldName: string): any {
+    if (!fields || typeof fields !== 'object') return undefined;
+    if (Object.prototype.hasOwnProperty.call(fields, fieldName)) {
+      return fields[fieldName];
+    }
+
+    const lookupName = String(fieldName || '').toLowerCase().trim();
+    if (!lookupName) return undefined;
+    const matchedKey = Object.keys(fields).find(
+      (key) => String(key || '').toLowerCase().trim() === lookupName
+    );
+    return matchedKey ? fields[matchedKey] : undefined;
+  }
+
   private resolveSuiteTestCaseRevision(testCaseItem: any): number {
+    const fieldsFromList = this.extractWorkItemFieldsMap(testCaseItem?.workItem?.workItemFields);
+    const fieldsFromMap = testCaseItem?.workItem?.fields || {};
+    const systemRevFromList = this.getFieldValueByName(fieldsFromList, 'System.Rev');
+    const systemRevFromMap = this.getFieldValueByName(fieldsFromMap, 'System.Rev');
     const revisionCandidates = [
+      systemRevFromList,
+      systemRevFromMap,
       testCaseItem?.workItem?.rev,
       testCaseItem?.workItem?.revision,
       testCaseItem?.workItem?.version,

package/src/tests/modules/ResultDataProvider.test.ts

@@ -679,6 +679,34 @@ describe('ResultDataProvider', () => {
 
       // Assert
       expect(result).toEqual(mockTestCases.value);
+      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
+        expect.stringContaining(
+          `/_apis/testplan/Plans/${mockTestPlanId}/Suites/${mockSuiteId}/TestCase?witFields=Microsoft.VSTS.TCM.Steps,System.Rev`
+        ),
+        mockToken
+      );
+    });
+  });
+
+  describe('resolveSuiteTestCaseRevision', () => {
+    it('should resolve System.Rev from workItemFields', () => {
+      const revision = (resultDataProvider as any).resolveSuiteTestCaseRevision({
+        workItem: {
+          workItemFields: [{ key: 'System.Rev', value: '12' }],
+        },
+      });
+
+      expect(revision).toBe(12);
+    });
+
+    it('should resolve System.Rev case-insensitively from workItem fields map', () => {
+      const revision = (resultDataProvider as any).resolveSuiteTestCaseRevision({
+        workItem: {
+          fields: { 'system.rev': 14 },
+        },
+      });
+
+      expect(revision).toBe(14);
     });
   });
 
@@ -837,7 +865,7 @@ describe('ResultDataProvider', () => {
       const result = await (resultDataProvider as any).fetchCrossTestPoints(mockProjectName, [1, 2]);
 
       expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        'https://example.com/points/2?witFields=Microsoft.VSTS.TCM.Steps&includePointDetails=true',
+        'https://example.com/points/2?witFields=Microsoft.VSTS.TCM.Steps,System.Rev&includePointDetails=true',
         mockToken
       );
       expect(result).toHaveLength(2);
@@ -2993,7 +3021,7 @@ describe('ResultDataProvider', () => {
           'Test Case ID': 42,
           'Test Case Title': 'TC-0042',
           'Mentioned but Not Linked': 'Step 3: SR0027',
-          'Linked but Not Mentioned': 'SR0817\nSR0818\nSR0859',
+          'Linked but Not Mentioned': 'SR0817; SR0818; SR0859',
           'Validation Status': 'Fail',
         })
       );
@@ -3874,6 +3902,53 @@ describe('ResultDataProvider', () => {
       expect(res).toEqual(expect.objectContaining({ testCaseRevision: 9 }));
     });
 
+    it('should resolve no-run revision from System.Rev in suite test-case fields', async () => {
+      const point = {
+        testCaseId: '321',
+        testCaseName: 'TC 321',
+        outcome: 'Not Run',
+        suiteTestCase: {
+          workItem: {
+            id: 321,
+            workItemFields: [
+              { key: 'System.Rev', value: '13' },
+              { key: 'Microsoft.VSTS.TCM.Steps', value: '<steps></steps>' },
+            ],
+          },
+        },
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({
+        id: 321,
+        rev: 13,
+        fields: {
+          'System.State': 'Design',
+          'System.CreatedDate': '2024-05-01T00:00:00',
+          'Microsoft.VSTS.TCM.Priority': 1,
+          'System.Title': 'Title 321',
+          'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+        },
+        relations: [],
+      });
+
+      const res = await (resultDataProvider as any).fetchResultDataBasedOnWiBase(
+        mockProjectName,
+        '0',
+        '0',
+        true,
+        [],
+        false,
+        point
+      );
+
+      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
+        expect.stringContaining('/_apis/wit/workItems/321/revisions/13?$expand=all'),
+        mockToken
+      );
+      expect(res).toEqual(expect.objectContaining({ testCaseRevision: 13 }));
+    });
+
     it('should append linked relations and filter testCaseWorkItemField when isTestReporter=true and isQueryMode=false', async () => {
       (TFSServices.getItemContent as jest.Mock).mockReset();
 
@@ -5045,6 +5120,35 @@ describe('ResultDataProvider', () => {
       expect(fetchStrategy).not.toHaveBeenCalled();
       expect(result).toEqual([]);
     });
+
+    it('should keep points without run/result IDs when test reporter mode is enabled', async () => {
+      const testData = [
+        {
+          testSuiteId: 1,
+          testPointsItems: [{ testCaseId: 10, lastRunId: 101, lastResultId: 201 }, { testCaseId: 11 }],
+        },
+      ];
+      const fetchStrategy = jest
+        .fn()
+        .mockResolvedValueOnce({ testCaseId: 10 })
+        .mockResolvedValueOnce({ testCaseId: 11 });
+
+      const result = await (resultDataProvider as any).fetchAllResultDataBase(
+        testData,
+        mockProjectName,
+        true,
+        fetchStrategy
+      );
+
+      expect(fetchStrategy).toHaveBeenCalledTimes(2);
+      expect(fetchStrategy).toHaveBeenNthCalledWith(
+        2,
+        mockProjectName,
+        1,
+        expect.objectContaining({ testCaseId: 11 })
+      );
+      expect(result).toEqual([{ testCaseId: 10 }, { testCaseId: 11 }]);
+    });
   });
 
   describe('fetchResultDataBase', () => {
@@ -5071,6 +5175,26 @@ describe('ResultDataProvider', () => {
       expect(fetchResultMethod).toHaveBeenCalled();
       expect(result).toBeDefined();
     });
+
+    it('should call fetch method with runId/resultId as 0 when point has no run history', async () => {
+      const point = { testCaseId: 15, lastRunId: undefined, lastResultId: undefined };
+      const fetchResultMethod = jest.fn().mockResolvedValue({
+        testCase: { id: 15, name: 'TC 15' },
+        testSuite: { name: 'S' },
+        iterationDetails: [],
+      });
+      const createResponseObject = jest.fn().mockReturnValue({ id: 15 });
+
+      await (resultDataProvider as any).fetchResultDataBase(
+        mockProjectName,
+        'suite-no-runs',
+        point,
+        fetchResultMethod,
+        createResponseObject
+      );
+
+      expect(fetchResultMethod).toHaveBeenCalledWith(mockProjectName, '0', '0');
+    });
   });
 
   describe('getCombinedResultsSummary', () => {
@@ -5460,6 +5584,86 @@ describe('ResultDataProvider', () => {
         })
       );
     });
+
+    it('should return test-level row with empty step fields when suite has no run history', async () => {
+      jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan 12');
+      jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([
+        {
+          testSuiteId: 300,
+          suiteId: 300,
+          suiteName: 'suite no runs',
+          parentSuiteId: 100,
+          parentSuiteName: 'Rel3',
+          suitePath: 'Root/Rel3/suite no runs',
+          testGroupName: 'suite no runs',
+        },
+      ]);
+
+      jest.spyOn(resultDataProvider as any, 'fetchTestData').mockResolvedValueOnce([
+        {
+          testSuiteId: 300,
+          suiteId: 300,
+          suiteName: 'suite no runs',
+          parentSuiteId: 100,
+          parentSuiteName: 'Rel3',
+          suitePath: 'Root/Rel3/suite no runs',
+          testGroupName: 'suite no runs',
+          testPointsItems: [
+            {
+              testCaseId: 55,
+              testCaseName: 'TC 55',
+              outcome: 'Not Run',
+              testPointId: 9001,
+              lastRunId: undefined,
+              lastResultId: undefined,
+              lastResultDetails: undefined,
+            },
+          ],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 55,
+                workItemFields: [{ key: 'System.Rev', value: 4 }],
+              },
+            },
+          ],
+        },
+      ]);
+
+      jest.spyOn(resultDataProvider as any, 'fetchAllResultDataTestReporter').mockResolvedValueOnce([
+        {
+          testCaseId: 55,
+          testCase: { id: 55, name: 'TC 55' },
+          testSuite: { name: 'suite no runs' },
+          executionDate: '',
+          testCaseResult: { resultMessage: 'Not Run', url: '' },
+          customFields: {},
+          runBy: '',
+          iteration: undefined,
+          lastRunId: undefined,
+          lastResultId: undefined,
+        },
+      ]);
+
+      const result = await resultDataProvider.getTestReporterFlatResults(
+        mockTestPlanId,
+        mockProjectName,
+        undefined,
+        [],
+        false
+      );
+
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0]).toEqual(
+        expect.objectContaining({
+          testCaseId: 55,
+          testRunId: undefined,
+          testPointId: 9001,
+          stepOutcome: undefined,
+          stepStepIdentifier: '',
+        })
+      );
+    });
   });
 
   describe('getCombinedResultsSummary - appendix branches', () => {