@elisra-devops/docgen-data-provider 1.109.0 → 1.110.0

package/bin/tests/modules/ticketsDataProvider.test.js

@@ -52,11 +52,145 @@ describe('TicketsDataProvider', () => {
             expect(structureSpy.mock.calls[0][3]).toEqual(['epic', 'feature', 'requirement', 'task']);
         });
     });
+    describe('fetchFlatUpstreamQueries', () => {
+        it('should allow only Requirement flat queries and exclude oneHop/tree query types', async () => {
+            const structureSpy = jest
+                .spyOn(ticketsDataProvider, 'structureFetchedQueries')
+                .mockResolvedValue({ tree1: { id: 't1' }, tree2: null });
+            await ticketsDataProvider.fetchFlatUpstreamQueries({ hasChildren: false }, []);
+            expect(structureSpy.mock.calls[0][3]).toEqual(['requirement']);
+            expect(structureSpy.mock.calls[0][7]).toBe(false);
+            expect(structureSpy.mock.calls[0][9]).toBe(true);
+            expect(structureSpy.mock.calls[0][10]).toBe(false);
+        });
+        it('should allow Requirement flat queries for fallback discovery', async () => {
+            const structureSpy = jest
+                .spyOn(ticketsDataProvider, 'structureFetchedQueries')
+                .mockResolvedValue({ tree1: { id: 't1' }, tree2: null });
+            await ticketsDataProvider.fetchFlatUpstreamQueries({ hasChildren: false }, ['system to subsystem', 'system-to-subsystem', 'system subsystem'], ['requirement']);
+            expect(structureSpy.mock.calls[0][3]).toEqual(['requirement']);
+            expect(structureSpy.mock.calls[0][8]).toEqual([
+                'system to subsystem',
+                'system-to-subsystem',
+                'system subsystem',
+            ]);
+            expect(structureSpy.mock.calls[0][9]).toBe(true);
+            expect(structureSpy.mock.calls[0][10]).toBe(false);
+        });
+        it('should let structureFetchedQueries exclude oneHop leaves only for flat-only callers', async () => {
+            const result = await ticketsDataProvider.structureFetchedQueries({
+                id: 'one-hop',
+                hasChildren: false,
+                isFolder: false,
+                queryType: 'oneHop',
+                wiql: "[Source].[System.WorkItemType] = 'Requirement'",
+            }, false, null, ['requirement'], [], undefined, undefined, false, [], true, false);
+            expect(result).toEqual({ tree1: null, tree2: null });
+        });
+    });
+    describe('fetchCustomerRequirementQueries', () => {
+        it('should return flat, tree, and oneHop query nodes without WIQL type filtering', async () => {
+            const root = {
+                id: 'root',
+                name: 'SYSRS',
+                isFolder: true,
+                hasChildren: true,
+                children: [
+                    {
+                        id: 'flat-query',
+                        name: 'Flat Customer Pull',
+                        isFolder: false,
+                        hasChildren: false,
+                        queryType: 'flat',
+                        wiql: "SELECT * FROM WorkItems WHERE [System.WorkItemType] = 'Task'",
+                        columns: [],
+                        _links: { wiql: { href: 'flat-url' } },
+                    },
+                    {
+                        id: 'tree-query',
+                        name: 'Tree Customer Pull',
+                        isFolder: false,
+                        hasChildren: false,
+                        queryType: 'tree',
+                        wiql: "SELECT * FROM WorkItemLinks WHERE [System.Links.LinkType] = 'System.LinkTypes.Hierarchy-Forward'",
+                        columns: [],
+                        _links: { wiql: { href: 'tree-url' } },
+                    },
+                    {
+                        id: 'onehop-query',
+                        name: 'OneHop Customer Pull',
+                        isFolder: false,
+                        hasChildren: false,
+                        queryType: 'oneHop',
+                        wiql: "SELECT * FROM WorkItemLinks WHERE [System.Links.LinkType] = 'System.LinkTypes.Related'",
+                        columns: [],
+                        _links: { wiql: { href: 'onehop-url' } },
+                    },
+                    {
+                        id: 'unsupported-query',
+                        name: 'Unsupported',
+                        isFolder: false,
+                        hasChildren: false,
+                        queryType: 'invalid',
+                        _links: { wiql: { href: 'unsupported-url' } },
+                    },
+                ],
+            };
+            const result = await ticketsDataProvider.fetchCustomerRequirementQueries(root, []);
+            expect(result.systemRequirementsQueryTree.children.map((child) => child.queryType)).toEqual([
+                'flat',
+                'tree',
+                'oneHop',
+            ]);
+            expect(result.systemRequirementsQueryTree.children.map((child) => child.wiql.href)).toEqual([
+                'flat-url',
+                'tree-url',
+                'onehop-url',
+            ]);
+        });
+        it('should include system-to-subsystem queries because customer discovery has no folder exclusions', async () => {
+            const root = {
+                id: 'root',
+                name: 'SYSRS',
+                isFolder: true,
+                hasChildren: true,
+                children: [
+                    {
+                        id: 'excluded-folder',
+                        name: 'System To Subsystem',
+                        isFolder: true,
+                        hasChildren: true,
+                        children: [
+                            {
+                                id: 'system-to-subsystem-query',
+                                name: 'System To Subsystem Query',
+                                isFolder: false,
+                                hasChildren: false,
+                                queryType: 'tree',
+                                _links: { wiql: { href: 'system-to-subsystem-url' } },
+                            },
+                        ],
+                    },
+                    {
+                        id: 'included-query',
+                        name: 'Included Query',
+                        isFolder: false,
+                        hasChildren: false,
+                        queryType: 'oneHop',
+                        _links: { wiql: { href: 'included-url' } },
+                    },
+                ],
+            };
+            const result = await ticketsDataProvider.fetchCustomerRequirementQueries(root);
+            expect(result.systemRequirementsQueryTree.children).toHaveLength(2);
+            expect(result.systemRequirementsQueryTree.children[0].children[0]).toEqual(expect.objectContaining({ id: 'system-to-subsystem-query', queryType: 'tree' }));
+            expect(result.systemRequirementsQueryTree.children[1]).toEqual(expect.objectContaining({ id: 'included-query', queryType: 'oneHop' }));
+        });
+    });
     describe('fetchSysRsQueries', () => {
-        it('should use sysrs root, exclude trace folders from system requirements and resolve both trace directions', async () => {
+        it('should scan the dedicated sysrs folder for customer queries regardless of query type', async () => {
             const rootQueries = { id: 'root' };
             const sysRsRoot = { id: 'sysrs-root', name: 'SYSRS' };
-            const subsystemToSystemFolder = { id: 'fwd-folder', name: 'System To Customer' };
             const systemToSubsystemFolder = { id: 'rev-folder', name: 'System To Subsystem' };
             const getDocTypeRootSpy = jest
                 .spyOn(ticketsDataProvider, 'getDocTypeRoot')
@@ -64,31 +198,39 @@ describe('TicketsDataProvider', () => {
             const fetchSystemRequirementQueriesSpy = jest
                 .spyOn(ticketsDataProvider, 'fetchSystemRequirementQueries')
                 .mockResolvedValue({ systemRequirementsQueryTree: { id: 'system-tree' } });
+            const fetchCustomerRequirementQueriesSpy = jest
+                .spyOn(ticketsDataProvider, 'fetchCustomerRequirementQueries')
+                .mockResolvedValue({ systemRequirementsQueryTree: { id: 'customer-tree' } });
             const findChildFolderByPossibleNamesSpy = jest
                 .spyOn(ticketsDataProvider, 'findChildFolderByPossibleNames')
-                .mockResolvedValueOnce(subsystemToSystemFolder)
                 .mockResolvedValueOnce(systemToSubsystemFolder);
             const fetchRequirementsTraceQueriesForFolderSpy = jest
                 .spyOn(ticketsDataProvider, 'fetchRequirementsTraceQueriesForFolder')
-                .mockResolvedValueOnce({ id: 'fwd-trace-tree' })
                 .mockResolvedValueOnce({ id: 'rev-trace-tree' });
             const result = await ticketsDataProvider.fetchSysRsQueries(rootQueries);
             expect(getDocTypeRootSpy).toHaveBeenCalledWith(rootQueries, 'sysrs');
+            // fetchSystemRequirementQueries only excludes the sub-system trace folder;
+            // the legacy System-to-Customer exclusion list is gone.
             expect(fetchSystemRequirementQueriesSpy).toHaveBeenCalledWith(sysRsRoot, [
-                'System To Customer',
-                'System To Subsystem',
+                'system to subsystem',
+                'system-to-subsystem',
+                'system subsystem',
             ]);
-            expect(findChildFolderByPossibleNamesSpy).toHaveBeenNthCalledWith(1, sysRsRoot, expect.arrayContaining(['system to customer', 'subsystem to system', 'customer to system']));
-            expect(findChildFolderByPossibleNamesSpy).toHaveBeenNthCalledWith(2, sysRsRoot, expect.arrayContaining(['system to subsystem', 'system-to-subsystem']));
-            expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenNthCalledWith(1, subsystemToSystemFolder);
-            expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenNthCalledWith(2, systemToSubsystemFolder);
+            // Only one folder lookup remains (sub-system trace); no System-to-Customer lookup.
+            expect(findChildFolderByPossibleNamesSpy).toHaveBeenCalledTimes(1);
+            expect(findChildFolderByPossibleNamesSpy).toHaveBeenCalledWith(sysRsRoot, expect.arrayContaining(['system to subsystem', 'system-to-subsystem']));
+            expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenCalledTimes(1);
+            expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenCalledWith(systemToSubsystemFolder);
+            // Customer picker scans the whole sysRsRoot with no query/folder exclusions.
+            expect(fetchCustomerRequirementQueriesSpy).toHaveBeenCalledWith(sysRsRoot);
             expect(result).toEqual({
                 systemRequirementsQueries: { systemRequirementsQueryTree: { id: 'system-tree' } },
-                subsystemToSystemRequirementsQueries: { id: 'fwd-trace-tree' },
+                customerRequirementsQueries: { systemRequirementsQueryTree: { id: 'customer-tree' } },
+                subsystemToSystemRequirementsQueries: null,
                 systemToSubsystemRequirementsQueries: { id: 'rev-trace-tree' },
             });
         });
-        it('should fall back to root queries and return null trace trees when trace folders are missing', async () => {
+        it('should return null customer/trace trees when the dedicated sysrs folder is missing (no fallback scan)', async () => {
             const rootQueries = { id: 'root' };
             jest
                 .spyOn(ticketsDataProvider, 'getDocTypeRoot')
@@ -96,23 +238,27 @@ describe('TicketsDataProvider', () => {
             const fetchSystemRequirementQueriesSpy = jest
                 .spyOn(ticketsDataProvider, 'fetchSystemRequirementQueries')
                 .mockResolvedValue({ systemRequirementsQueryTree: { id: 'system-tree' } });
-            jest
-                .spyOn(ticketsDataProvider, 'findChildFolderByPossibleNames')
-                .mockResolvedValueOnce(null)
-                .mockResolvedValueOnce(null);
+            const fetchCustomerRequirementQueriesSpy = jest
+                .spyOn(ticketsDataProvider, 'fetchCustomerRequirementQueries')
+                .mockResolvedValue({ systemRequirementsQueryTree: { id: 'should-not-be-used' } });
+            jest.spyOn(ticketsDataProvider, 'findChildFolderByPossibleNames').mockResolvedValueOnce(null);
             const fetchRequirementsTraceQueriesForFolderSpy = jest
                 .spyOn(ticketsDataProvider, 'fetchRequirementsTraceQueriesForFolder')
-                .mockResolvedValueOnce(null)
                 .mockResolvedValueOnce(null);
             const result = await ticketsDataProvider.fetchSysRsQueries(rootQueries);
             expect(fetchSystemRequirementQueriesSpy).toHaveBeenCalledWith(rootQueries, [
-                'System To Customer',
-                'System To Subsystem',
+                'system to subsystem',
+                'system-to-subsystem',
+                'system subsystem',
             ]);
-            expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenNthCalledWith(1, null);
-            expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenNthCalledWith(2, null);
+            expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenCalledTimes(1);
+            expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenCalledWith(null);
+            // No fallback scan when the dedicated sysrs folder is absent — otherwise
+            // unrelated flat queries from the Shared Queries root would leak in.
+            expect(fetchCustomerRequirementQueriesSpy).not.toHaveBeenCalled();
             expect(result).toEqual({
                 systemRequirementsQueries: { systemRequirementsQueryTree: { id: 'system-tree' } },
+                customerRequirementsQueries: null,
                 subsystemToSystemRequirementsQueries: null,
                 systemToSubsystemRequirementsQueries: null,
             });
@@ -1028,6 +1174,35 @@ describe('TicketsDataProvider', () => {
             // Assert
             expect(result).toBeDefined();
         });
+        // Regression: WI_DEFAULT_FIELDS must include System.WorkItemType so that
+        // downstream Requirement-type filters (e.g. the customer-coverage table)
+        // do not drop every row because workItemType resolves to empty string.
+        it('should request System.WorkItemType in default fields for flat queries and expose workItemType on parsed items', async () => {
+            const mockWiqlHref = 'https://example.com/wiql';
+            const mockQueryResult = {
+                queryType: 'flat',
+                workItems: [{ id: 42, url: 'https://example.com/wi/42' }],
+            };
+            const mockWiResponse = {
+                fields: {
+                    'System.Title': 'Customer Requirement',
+                    'System.WorkItemType': 'Requirement',
+                    'System.Description': 'Desc',
+                },
+                _links: { html: { href: 'https://example.com/wi/42' } },
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockQueryResult)
+                .mockResolvedValueOnce(mockWiResponse);
+            const result = await ticketsDataProvider.GetQueryResultsFromWiql(mockWiqlHref, false, new Map());
+            // The per-item fetch URL must request System.WorkItemType.
+            const perItemCall = tfs_1.TFSServices.getItemContent.mock.calls.find((call) => typeof call[0] === 'string' && call[0].startsWith('https://example.com/wi/42'));
+            expect(perItemCall).toBeDefined();
+            expect(perItemCall[0]).toContain('System.WorkItemType');
+            // The parsed item must expose workItemType so downstream filters work.
+            expect(Array.isArray(result)).toBe(true);
+            expect(result[0]).toMatchObject({ id: 42, workItemType: 'Requirement' });
+        });
         it('should return undefined when queryType is not supported', async () => {
             tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({ queryType: 'Unknown' });
             const res = await ticketsDataProvider.GetQueryResultsFromWiql('https://example.com/wiql', false, new Map());