@elisra-devops/docgen-data-provider 1.138.0 → 1.139.0

package/bin/modules/TicketsDataProvider.d.ts

@@ -202,6 +202,25 @@ export default class TicketsDataProvider {
     }>;
     private normalizeHistoricalAsOf;
     private normalizeHistoricalCompareValue;
+    /**
+     * Stores rich-text fields (Description, Steps) with only whitespace trimmed, preserving markup
+     * so the report renderer can clean/render it faithfully. Equality between two snapshots must go
+     * through canonicalizeHistoricalRichTextForCompare instead of comparing this value directly.
+     */
+    private rawHistoricalRichText;
+    /**
+     * Canonicalizes a rich-text field for equality comparison only. Intentionally identical to the
+     * whitespace collapse previously applied at storage time, so Changed/No-changes verdicts and
+     * summary counts are unaffected by storing the raw value for rendering.
+     */
+    private canonicalizeHistoricalRichTextForCompare;
+    /**
+     * Parses baseline/compareTo Steps XML into per-step Action/Expected arrays for a changed test
+     * case, so the report can render readable steps instead of raw Steps XML. Best-effort: a parse
+     * failure (malformed XML, shared-step lookup error) must not fail the whole comparison, so it
+     * logs and falls back to leaving the caller with only the raw XML strings.
+     */
+    private parseHistoricalStepsForDiff;
     private normalizeTestPhaseValue;
     private isTestCaseType;
     private toHistoricalRevision;

package/bin/modules/TicketsDataProvider.js

@@ -8,6 +8,7 @@ const tfs_data_3 = require("../models/tfs-data");
 const tfs_data_4 = require("../models/tfs-data");
 const tfs_data_5 = require("../models/tfs-data");
 const tfs_data_6 = require("../models/tfs-data");
+const testStepParserHelper_1 = require("../utils/testStepParserHelper");
 const logger_1 = require("../utils/logger");
 const pLimit = require('p-limit');
 const HISTORICAL_WIT_API_VERSIONS = ['7.1', '5.1', null];
@@ -1409,6 +1410,52 @@ class TicketsDataProvider {
         }
         return String(value).trim();
     }
+    /**
+     * Stores rich-text fields (Description, Steps) with only whitespace trimmed, preserving markup
+     * so the report renderer can clean/render it faithfully. Equality between two snapshots must go
+     * through canonicalizeHistoricalRichTextForCompare instead of comparing this value directly.
+     */
+    rawHistoricalRichText(value) {
+        if (value == null) {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value.trim();
+        }
+        return this.normalizeHistoricalCompareValue(value);
+    }
+    /**
+     * Canonicalizes a rich-text field for equality comparison only. Intentionally identical to the
+     * whitespace collapse previously applied at storage time, so Changed/No-changes verdicts and
+     * summary counts are unaffected by storing the raw value for rendering.
+     */
+    canonicalizeHistoricalRichTextForCompare(value) {
+        return this.normalizeHistoricalCompareValue(value);
+    }
+    /**
+     * Parses baseline/compareTo Steps XML into per-step Action/Expected arrays for a changed test
+     * case, so the report can render readable steps instead of raw Steps XML. Best-effort: a parse
+     * failure (malformed XML, shared-step lookup error) must not fail the whole comparison, so it
+     * logs and falls back to leaving the caller with only the raw XML strings.
+     */
+    async parseHistoricalStepsForDiff(testStepParserHelper, baselineStepsXml, compareToStepsXml) {
+        try {
+            const emptyRevisionMap = new Map();
+            const [baselineSteps, compareToSteps] = await Promise.all([
+                baselineStepsXml
+                    ? testStepParserHelper.parseTestSteps(baselineStepsXml, emptyRevisionMap)
+                    : Promise.resolve([]),
+                compareToStepsXml
+                    ? testStepParserHelper.parseTestSteps(compareToStepsXml, emptyRevisionMap)
+                    : Promise.resolve([]),
+            ]);
+            return { baselineSteps, compareToSteps };
+        }
+        catch (err) {
+            logger_1.default.warn(`Failed to parse historical Steps XML for diff rendering: ${(err === null || err === void 0 ? void 0 : err.message) || err}`);
+            return null;
+        }
+    }
     normalizeTestPhaseValue(value) {
         const rendered = this.normalizeHistoricalCompareValue(value);
         if (!rendered) {
@@ -1780,8 +1827,8 @@ class TicketsDataProvider {
             iterationPath: this.normalizeHistoricalCompareValue(fields['System.IterationPath']),
             versionId: this.toHistoricalRevision((_d = workItem === null || workItem === void 0 ? void 0 : workItem.rev) !== null && _d !== void 0 ? _d : fields['System.Rev']),
             versionTimestamp: this.normalizeHistoricalCompareValue(fields['System.ChangedDate']),
-            description: this.normalizeHistoricalCompareValue(fields['System.Description']),
-            steps: this.normalizeHistoricalCompareValue(fields['Microsoft.VSTS.TCM.Steps']),
+            description: this.rawHistoricalRichText(fields['System.Description']),
+            steps: this.rawHistoricalRichText(fields['Microsoft.VSTS.TCM.Steps']),
             testPhase: this.normalizeTestPhaseValue(testPhaseRaw),
             relatedLinkCount,
             workItemUrl: `${this.orgUrl}${project}/_workitems/edit/${id}`,
@@ -1917,7 +1964,8 @@ class TicketsDataProvider {
             ...Array.from(compareTo.snapshotMap.keys()),
         ]);
         const sortedIds = Array.from(allIds.values()).sort((a, b) => a - b);
-        const rows = sortedIds.map((id) => {
+        const testStepParserHelper = new testStepParserHelper_1.default(this.orgUrl, this.token);
+        const rows = await Promise.all(sortedIds.map(async (id) => {
             const baselineRow = baseline.snapshotMap.get(id) || null;
             const compareToRow = compareTo.snapshotMap.get(id) || null;
             const workItemType = (compareToRow === null || compareToRow === void 0 ? void 0 : compareToRow.workItemType) || (baselineRow === null || baselineRow === void 0 ? void 0 : baselineRow.workItemType) || '';
@@ -1951,7 +1999,12 @@ class TicketsDataProvider {
             const safeBaseline = baselineRow;
             const safeCompareTo = compareToRow;
             const changedFields = [];
-            if (safeBaseline.description !== safeCompareTo.description) {
+            const descriptionChanged = this.canonicalizeHistoricalRichTextForCompare(safeBaseline.description) !==
+                this.canonicalizeHistoricalRichTextForCompare(safeCompareTo.description);
+            const stepsChanged = isTestCase &&
+                this.canonicalizeHistoricalRichTextForCompare(safeBaseline.steps) !==
+                    this.canonicalizeHistoricalRichTextForCompare(safeCompareTo.steps);
+            if (descriptionChanged) {
                 changedFields.push('Description');
             }
             if (safeBaseline.title !== safeCompareTo.title) {
@@ -1960,7 +2013,7 @@ class TicketsDataProvider {
             if (safeBaseline.state !== safeCompareTo.state) {
                 changedFields.push('State');
             }
-            if (isTestCase && safeBaseline.steps !== safeCompareTo.steps) {
+            if (stepsChanged) {
                 changedFields.push('Steps');
             }
             if (safeBaseline.testPhase !== safeCompareTo.testPhase) {
@@ -1969,7 +2022,7 @@ class TicketsDataProvider {
             if (isTestCase && safeBaseline.relatedLinkCount !== safeCompareTo.relatedLinkCount) {
                 changedFields.push('Related Link Count');
             }
-            const differences = changedFields.map((field) => {
+            const differences = await Promise.all(changedFields.map(async (field) => {
                 switch (field) {
                     case 'Description':
                         return { field, baseline: safeBaseline.description, compareTo: safeCompareTo.description };
@@ -1977,8 +2030,10 @@ class TicketsDataProvider {
                         return { field, baseline: safeBaseline.title, compareTo: safeCompareTo.title };
                     case 'State':
                         return { field, baseline: safeBaseline.state, compareTo: safeCompareTo.state };
-                    case 'Steps':
-                        return { field, baseline: safeBaseline.steps, compareTo: safeCompareTo.steps };
+                    case 'Steps': {
+                        const parsed = await this.parseHistoricalStepsForDiff(testStepParserHelper, safeBaseline.steps, safeCompareTo.steps);
+                        return Object.assign({ field, baseline: safeBaseline.steps, compareTo: safeCompareTo.steps }, (parsed || {}));
+                    }
                     case 'Test Phase':
                         return { field, baseline: safeBaseline.testPhase, compareTo: safeCompareTo.testPhase };
                     case 'Related Link Count':
@@ -1990,7 +2045,7 @@ class TicketsDataProvider {
                     default:
                         return { field, baseline: '', compareTo: '' };
                 }
-            });
+            }));
             return {
                 id,
                 workItemType,
@@ -2002,7 +2057,7 @@ class TicketsDataProvider {
                 differences,
                 workItemUrl: safeCompareTo.workItemUrl || safeBaseline.workItemUrl,
             };
-        });
+        }));
         const summary = rows.reduce((acc, row) => {
             if (row.compareStatus === 'Added')
                 acc.addedCount += 1;