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

package/src/tests/modules/ticketsDataProvider.historical.test.ts

@@ -946,6 +946,173 @@ describe('TicketsDataProvider historical queries', () => {
     expect(diff).toEqual({ field: 'Related Link Count', baseline: '1', compareTo: '2' });
   });
 
+  it('CompareHistoricalQueryResults preserves raw markup for rendering while comparing on canonicalized whitespace', async () => {
+    const baselineIso = '2026-02-01T00:00:00.000Z';
+    const compareIso = '2026-02-05T00:00:00.000Z';
+
+    (TFSServices.getItemContent as jest.Mock).mockImplementation(
+      async (url: string, _pat: string, method?: string, data?: any) => {
+        if (url.includes('/_apis/wit/queries/q-raw-html') && url.includes('api-version=7.1')) {
+          return { name: 'Raw Html Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
+        }
+        if (url.includes('/_apis/wit/wiql?') && method === 'post') {
+          return { workItems: [{ id: 601 }, { id: 602 }] };
+        }
+        if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
+          const isBaseline = data.asOf === baselineIso;
+          return {
+            value: [
+              {
+                id: 601,
+                rev: isBaseline ? 1 : 2,
+                fields: {
+                  'System.WorkItemType': 'Requirement',
+                  'System.Title': 'Whitespace-only edit',
+                  'System.State': 'Active',
+                  // Same content, differing only by internal whitespace: must compare as
+                  // unchanged (identical to the pre-existing collapse-then-compare behavior)
+                  // while the raw stored value keeps the original spacing for rendering.
+                  'System.Description': isBaseline
+                    ? '<p>Hello   world</p>'
+                    : '<p>Hello\nworld</p>',
+                  'System.ChangedDate': isBaseline ? baselineIso : compareIso,
+                },
+              },
+              {
+                id: 602,
+                rev: isBaseline ? 1 : 2,
+                fields: {
+                  'System.WorkItemType': 'Requirement',
+                  'System.Title': 'Real edit',
+                  'System.State': 'Active',
+                  'System.Description': isBaseline ? '<p>Hello world</p>' : '<p>Hello <b>world</b></p>',
+                  'System.ChangedDate': isBaseline ? baselineIso : compareIso,
+                },
+              },
+            ],
+          };
+        }
+        throw new Error(`unexpected URL: ${url}`);
+      },
+    );
+
+    const result = await provider.CompareHistoricalQueryResults('q-raw-html', project, baselineIso, compareIso);
+    const byId = new Map<number, any>(result.rows.map((row: any) => [row.id, row]));
+
+    expect(byId.get(601)?.compareStatus).toBe('No changes');
+    expect(byId.get(602)?.compareStatus).toBe('Changed');
+    const diff = byId.get(602)?.differences.find((d: any) => d.field === 'Description');
+    // Raw markup is preserved on the difference payload, not collapsed to plain text.
+    expect(diff.baseline).toBe('<p>Hello world</p>');
+    expect(diff.compareTo).toBe('<p>Hello <b>world</b></p>');
+  });
+
+  it('CompareHistoricalQueryResults attaches parsed Action/Expected steps for a changed test case', async () => {
+    const baselineIso = '2026-02-10T00:00:00.000Z';
+    const compareIso = '2026-02-15T00:00:00.000Z';
+
+    const buildStepsXml = (expected: string) =>
+      `<steps id="0" last="1"><step id="1" type="ActionStep">` +
+      `<parameterizedString isformatted="true">Open the app</parameterizedString>` +
+      `<parameterizedString isformatted="true">${expected}</parameterizedString>` +
+      `</step></steps>`;
+
+    (TFSServices.getItemContent as jest.Mock).mockImplementation(
+      async (url: string, _pat: string, method?: string, data?: any) => {
+        if (url.includes('/_apis/wit/queries/q-parsed-steps') && url.includes('api-version=7.1')) {
+          return { name: 'Parsed Steps Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
+        }
+        if (url.includes('/_apis/wit/wiql?') && method === 'post') {
+          return { workItems: [{ id: 701 }] };
+        }
+        if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
+          const isBaseline = data.asOf === baselineIso;
+          return {
+            value: [
+              {
+                id: 701,
+                rev: isBaseline ? 1 : 2,
+                fields: {
+                  'System.WorkItemType': 'Test Case',
+                  'System.Title': 'Login test',
+                  'System.State': 'Active',
+                  'Microsoft.VSTS.TCM.Steps': buildStepsXml(isBaseline ? 'Login page shown' : 'Dashboard shown'),
+                  'System.ChangedDate': isBaseline ? baselineIso : compareIso,
+                },
+              },
+            ],
+          };
+        }
+        throw new Error(`unexpected URL: ${url}`);
+      },
+    );
+
+    const result = await provider.CompareHistoricalQueryResults(
+      'q-parsed-steps',
+      project,
+      baselineIso,
+      compareIso,
+    );
+    const row = result.rows.find((r: any) => r.id === 701);
+    expect(row?.compareStatus).toBe('Changed');
+    expect(row?.changedFields).toContain('Steps');
+    const diff = row?.differences.find((d: any) => d.field === 'Steps');
+    expect(diff.baselineSteps).toEqual([
+      expect.objectContaining({ action: 'Open the app', expected: 'Login page shown' }),
+    ]);
+    expect(diff.compareToSteps).toEqual([
+      expect.objectContaining({ action: 'Open the app', expected: 'Dashboard shown' }),
+    ]);
+  });
+
+  it('CompareHistoricalQueryResults falls back gracefully when Steps XML cannot be parsed', async () => {
+    const baselineIso = '2026-02-20T00:00:00.000Z';
+    const compareIso = '2026-02-25T00:00:00.000Z';
+
+    (TFSServices.getItemContent as jest.Mock).mockImplementation(
+      async (url: string, _pat: string, method?: string, data?: any) => {
+        if (url.includes('/_apis/wit/queries/q-bad-steps') && url.includes('api-version=7.1')) {
+          return { name: 'Bad Steps Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
+        }
+        if (url.includes('/_apis/wit/wiql?') && method === 'post') {
+          return { workItems: [{ id: 801 }] };
+        }
+        if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
+          const isBaseline = data.asOf === baselineIso;
+          return {
+            value: [
+              {
+                id: 801,
+                rev: isBaseline ? 1 : 2,
+                fields: {
+                  'System.WorkItemType': 'Test Case',
+                  'System.Title': 'Malformed steps case',
+                  'System.State': 'Active',
+                  'Microsoft.VSTS.TCM.Steps': isBaseline ? '<steps><unclosed>' : '<steps><unclosed2>',
+                  'System.ChangedDate': isBaseline ? baselineIso : compareIso,
+                },
+              },
+            ],
+          };
+        }
+        throw new Error(`unexpected URL: ${url}`);
+      },
+    );
+
+    const result = await provider.CompareHistoricalQueryResults('q-bad-steps', project, baselineIso, compareIso);
+    const row = result.rows.find((r: any) => r.id === 801);
+    expect(row?.compareStatus).toBe('Changed');
+    expect(row?.changedFields).toContain('Steps');
+    const diff = row?.differences.find((d: any) => d.field === 'Steps');
+    expect(diff.baseline).toBe('<steps><unclosed>');
+    expect(diff.compareTo).toBe('<steps><unclosed2>');
+    // TestStepParserHelper.parseTestSteps already swallows its own parse errors and resolves to
+    // an empty list, so the diff carries empty parsed-steps arrays rather than raw XML garbage;
+    // the content-control adapter treats an empty array the same as "no parsed steps".
+    expect(diff.baselineSteps).toEqual([]);
+    expect(diff.compareToSteps).toEqual([]);
+  });
+
   it('GetHistoricalQueryResults treats a workitemsbatch errorPolicy Omit as skipped without a per-item fallback', async () => {
     const asOfIso = '2026-01-15T00:00:00.000Z';
 
@@ -995,73 +1162,158 @@ describe('TicketsDataProvider historical queries', () => {
     ).toBe(true);
   });
 
-  it('GetHistoricalQueryResults drops only the specific field ADO names in TF51535, keeping Custom.TestPhase when only Elisra.TestPhase is undefined for this project', async () => {
+  it('GetHistoricalQueryResults resolves the real Test Phase reference name from the project\'s own field list instead of guessing', async () => {
     const asOfIso = '2026-02-01T00:00:00.000Z';
-    // 205 ids -> 2 chunks (200 + 5), both dispatched with the full field list
-    // near-simultaneously — this proves the retry is decided per-call, not
-    // from the shared override flag, since both chunks fail before either
-    // one sets it.
-    const allIds = Array.from({ length: 205 }, (_, idx) => idx + 1);
 
     (TFSServices.getItemContent as jest.Mock).mockImplementation(
       async (url: string, _pat: string, method?: string, data?: any) => {
-        if (url.includes('/_apis/wit/queries/q-unknown-field') && url.includes('api-version=7.1')) {
-          return { name: 'Unknown Field Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
+        if (url.includes('/_apis/wit/queries/q-resolve-field') && url.includes('api-version=7.1')) {
+          return { name: 'Resolve Field Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
         }
         if (url.includes('/_apis/wit/wiql?') && method === 'post') {
-          return { workItems: allIds.map((id) => ({ id })) };
+          return { workItems: [{ id: 501 }] };
+        }
+        if (url.endsWith('/_apis/wit/fields?api-version=7.1')) {
+          // Neither Elisra.TestPhase nor Custom.TestPhase — a third,
+          // project-specific reference name, discovered only by friendly
+          // name ("Test Phase").
+          return {
+            value: [
+              { name: 'Title', referenceName: 'System.Title' },
+              { name: 'Test Phase', referenceName: 'MyCompany.QaPhase' },
+            ],
+          };
         }
         if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
           if (data?.$expand === 'Relations') {
-            return {
-              value: (Array.isArray(data?.ids) ? data.ids : []).map((id: number) => ({ id, relations: [] })),
-            };
+            return { value: [{ id: 501, relations: [] }] };
           }
-          if (Array.isArray(data?.fields) && data.fields.includes('Elisra.TestPhase')) {
-            throw {
-              response: {
-                status: 400,
-                data: { message: "TF51535: Cannot find field 'Elisra.TestPhase'." },
+          expect(data.fields).toEqual(expect.arrayContaining(['MyCompany.QaPhase']));
+          expect(data.fields).not.toEqual(
+            expect.arrayContaining(['Elisra.TestPhase', 'Custom.TestPhase']),
+          );
+          return {
+            value: [
+              {
+                id: 501,
+                rev: 1,
+                fields: {
+                  'System.WorkItemType': 'Test Case',
+                  'System.Title': 'Resolved',
+                  'System.State': 'Active',
+                  'System.ChangedDate': asOfIso,
+                  'MyCompany.QaPhase': 'FAT',
+                },
               },
-            };
+            ],
+          };
+        }
+        throw new Error(`unexpected URL: ${url}`);
+      },
+    );
+
+    const result = await provider.GetHistoricalQueryResults('q-resolve-field', project, asOfIso);
+
+    expect(result.total).toBe(1);
+    const fieldsListCalls = (TFSServices.getItemContent as jest.Mock).mock.calls.filter((call) =>
+      String(call[0]).endsWith('/_apis/wit/fields?api-version=7.1'),
+    );
+    expect(fieldsListCalls).toHaveLength(1);
+  });
+
+  it('GetHistoricalQueryResults reuses the resolved field across baseline and compareTo without re-querying fields', async () => {
+    const baselineIso = '2026-02-20T00:00:00.000Z';
+    const compareIso = '2026-02-25T00:00:00.000Z';
+    let fieldsListCallCount = 0;
+
+    (TFSServices.getItemContent as jest.Mock).mockImplementation(
+      async (url: string, _pat: string, method?: string, data?: any) => {
+        if (url.includes('/_apis/wit/queries/q-cache-field') && url.includes('api-version=7.1')) {
+          return { name: 'Cache Field Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
+        }
+        if (url.includes('/_apis/wit/wiql?') && method === 'post') {
+          return { workItems: [{ id: 601 }] };
+        }
+        if (url.endsWith('/_apis/wit/fields?api-version=7.1')) {
+          fieldsListCallCount += 1;
+          return { value: [{ name: 'Test Phase', referenceName: 'Custom.TestPhase' }] };
+        }
+        if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
+          if (data?.$expand === 'Relations') {
+            return { value: [{ id: 601, relations: [] }] };
           }
-          // Custom.TestPhase is the real field on this project and must
-          // still be requested — only the unrecognized alias should be
-          // dropped, not every optional field.
-          expect(data.fields).toEqual(expect.arrayContaining(['Custom.TestPhase']));
-          expect(data.fields).not.toEqual(expect.arrayContaining(['Elisra.TestPhase']));
           return {
-            value: (Array.isArray(data?.ids) ? data.ids : []).map((id: number) => ({
-              id,
-              rev: 1,
-              fields: {
-                'System.WorkItemType': 'Test Case',
-                'System.Title': `Test ${id}`,
-                'System.State': 'Active',
-                'System.ChangedDate': asOfIso,
-                'Custom.TestPhase': 'FAT',
+            value: [
+              {
+                id: 601,
+                rev: 1,
+                fields: {
+                  'System.WorkItemType': 'Test Case',
+                  'System.Title': 'Cached',
+                  'System.State': 'Active',
+                  'System.ChangedDate': data.asOf,
+                },
               },
-            })),
+            ],
           };
         }
         throw new Error(`unexpected URL: ${url}`);
       },
     );
 
-    const result = await provider.GetHistoricalQueryResults('q-unknown-field', project, asOfIso);
+    await provider.CompareHistoricalQueryResults('q-cache-field', project, baselineIso, compareIso);
 
-    // Every id came back — nothing fell to the 2xN per-item fallback, which
-    // would have thrown on any call not covered by the handler above.
-    expect(result.total).toBe(205);
-    const fieldsCallsWithElisraAlias = (TFSServices.getItemContent as jest.Mock).mock.calls.filter(
-      (call) => Array.isArray(call[3]?.fields) && call[3].fields.includes('Elisra.TestPhase'),
+    // Baseline and compareTo run concurrently against the same provider
+    // instance — the field list is fetched once, not once per snapshot.
+    expect(fieldsListCallCount).toBe(1);
+  });
+
+  it('GetHistoricalQueryResults omits Test Phase entirely when the project defines neither known name, without failing the batch', async () => {
+    const asOfIso = '2026-03-01T00:00:00.000Z';
+
+    (TFSServices.getItemContent as jest.Mock).mockImplementation(
+      async (url: string, _pat: string, method?: string, data?: any) => {
+        if (url.includes('/_apis/wit/queries/q-no-field') && url.includes('api-version=7.1')) {
+          return { name: 'No Field Q', wiql: 'SELECT [System.Id] FROM WorkItems' };
+        }
+        if (url.includes('/_apis/wit/wiql?') && method === 'post') {
+          return { workItems: [{ id: 701 }] };
+        }
+        if (url.endsWith('/_apis/wit/fields?api-version=7.1')) {
+          return { value: [{ name: 'Title', referenceName: 'System.Title' }] };
+        }
+        if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
+          if (data?.$expand === 'Relations') {
+            return { value: [{ id: 701, relations: [] }] };
+          }
+          expect(data.fields).not.toEqual(
+            expect.arrayContaining(['Elisra.TestPhase', 'Custom.TestPhase']),
+          );
+          return {
+            value: [
+              {
+                id: 701,
+                rev: 1,
+                fields: {
+                  'System.WorkItemType': 'Bug',
+                  'System.Title': 'No test phase field',
+                  'System.State': 'Active',
+                  'System.ChangedDate': asOfIso,
+                },
+              },
+            ],
+          };
+        }
+        throw new Error(`unexpected URL: ${url}`);
+      },
     );
-    // Both chunks start with the full field list before the override is set,
-    // so both legitimately fail once and both must retry — not just one.
-    expect(fieldsCallsWithElisraAlias).toHaveLength(2);
+
+    const result = await provider.GetHistoricalQueryResults('q-no-field', project, asOfIso);
+
+    expect(result.total).toBe(1);
     expect(
       (logger.warn as jest.Mock).mock.calls.some((call) =>
-        String(call[0]).includes("field 'Elisra.TestPhase' not defined for this project"),
+        String(call[0]).includes("no Test Phase field defined for project"),
       ),
     ).toBe(true);
   });