feat(work-items): add query editor for SystemLink Work Items data source

src/datasources/work-items/WorkItemsDataSource.test.ts

@@ -1,12 +1,40 @@
 import { WorkItemsDataSource } from './WorkItemsDataSource';
 import { setupDataSource } from 'test/fixtures';
+import { OrderByOptions, OutputType, WorkItemPropertiesOptions, WorkItemTypeOptions } from './types';
 
 describe('WorkItemsDataSource', () => {
-  it('returns an empty placeholder frame', async () => {
+  it('applies expected default query values', () => {
     const [datasource] = setupDataSource(WorkItemsDataSource);
 
-    const result = await datasource.runQuery({ refId: 'A' }, { scopedVars: {} } as any);
-    expect(result).toEqual({ refId: 'A', name: 'A', fields: [] });
+    const query = datasource.prepareQuery({ refId: 'A' });
+
+    expect(query.outputType).toBe(OutputType.Properties);
+    expect(query.types).toEqual(Object.values(WorkItemTypeOptions));
+    expect(query.properties).toEqual([
+      WorkItemPropertiesOptions.ID,
+      WorkItemPropertiesOptions.NAME,
+      WorkItemPropertiesOptions.TYPE,
+      WorkItemPropertiesOptions.STATE,
+      WorkItemPropertiesOptions.WORKSPACE,
+    ]);
+    expect(query.orderBy).toBe(OrderByOptions.UPDATED_AT);
+    expect(query.descending).toBe(true);
+    expect(query.take).toBe(1000);
+  });
+
+  it('preserves explicit selections instead of resetting them to defaults', () => {
+    const [datasource] = setupDataSource(WorkItemsDataSource);
+
+    const clearedQuery = datasource.prepareQuery({
+      refId: 'A',
+      types: [],
+      properties: [],
+      take: 12000,
+    });
+
+    expect(clearedQuery.types).toEqual([]);
+    expect(clearedQuery.properties).toEqual([]);
+    expect(clearedQuery.take).toBe(12000);
   });
 
   it('tests datasource connection against the work-items service endpoint', async () => {
@@ -15,11 +43,14 @@ describe('WorkItemsDataSource', () => {
 
     const result = await datasource.testDatasource();
 
-    expect(postSpy).toHaveBeenCalledWith(
-      '/niworkitem/v1/query-workitems',
-      { take: 1 },
-      { showErrorAlert: false }
-    );
+    expect(postSpy).toHaveBeenCalledWith('/niworkitem/v1/query-workitems', { take: 1 }, { showErrorAlert: false });
     expect(result.status).toBe('success');
   });
+
+  it('bubbles up exception when datasource connectivity check fails', async () => {
+    const [datasource] = setupDataSource(WorkItemsDataSource);
+    jest.spyOn(datasource, 'post').mockRejectedValue(new Error('Failed'));
+
+    await expect(datasource.testDatasource()).rejects.toThrow('Failed');
+  });
 });

src/datasources/work-items/WorkItemsDataSource.ts

@@ -6,7 +6,15 @@ import {
 } from '@grafana/data';
 import { BackendSrv, TemplateSrv, getBackendSrv, getTemplateSrv } from '@grafana/runtime';
 import { DataSourceBase } from 'core/DataSourceBase';
-import { WorkItemsQuery } from './types';
+import { QueryBuilderOption } from 'core/types';
+import {
+  OrderByOptions,
+  OutputType,
+  WorkItemPropertiesOptions,
+  WorkItemsQuery,
+  WorkItemTypeOptions,
+} from './types';
+import { DEFAULT_TAKE } from './constants';
 
 export class WorkItemsDataSource extends DataSourceBase<WorkItemsQuery> {
   constructor(
@@ -20,8 +28,25 @@ export class WorkItemsDataSource extends DataSourceBase<WorkItemsQuery> {
   baseUrl = `${this.instanceSettings.url}/niworkitem/v1`;
   queryWorkItemsUrl = `${this.baseUrl}/query-workitems`;
 
-  defaultQuery = {};
+  defaultQuery = {
+    outputType: OutputType.Properties,
+    types: Object.values(WorkItemTypeOptions),
+    properties: [
+      WorkItemPropertiesOptions.ID,
+      WorkItemPropertiesOptions.NAME,
+      WorkItemPropertiesOptions.TYPE,
+      WorkItemPropertiesOptions.STATE,
+      WorkItemPropertiesOptions.WORKSPACE,
+    ],
+    orderBy: OrderByOptions.UPDATED_AT,
+    descending: true,
+    take: DEFAULT_TAKE,
+  };
+
+  // TODO: AB#3923375 - Dummy Query By scaffolding for the query editor PR
+  globalVariableOptions = (): QueryBuilderOption[] => this.getVariableOptions();
 
+  // TODO: AB#3923375 - Query work items and return the requested properties instead of an empty frame.
   async runQuery(query: WorkItemsQuery, _options: DataQueryRequest<WorkItemsQuery>): Promise<DataFrameDTO> {
     return {
       refId: query.refId,

src/datasources/work-items/components/WorkItemsQueryEditor.test.tsx

@@ -1,14 +1,102 @@
-import { screen } from '@testing-library/react';
+import { fireEvent, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
 import { setupRenderer } from 'test/fixtures';
+import { labels, propertiesErrorMessages, takeErrorMessages, typesErrorMessages } from '../constants/QueryEditor.constants';
 import { WorkItemsDataSource } from '../WorkItemsDataSource';
+import { OutputType, WorkItemPropertiesOptions, WorkItemTypeOptions } from '../types';
 import { WorkItemsQueryEditor } from './WorkItemsQueryEditor';
 
 describe('WorkItemsQueryEditor', () => {
-  it('shows placeholder message', () => {
+  it('renders controls', () => {
     const render = setupRenderer(WorkItemsQueryEditor, WorkItemsDataSource);
 
     render({});
 
-    expect(screen.getByText('Work Items datasource query controls will be added in follow-up stories.')).toBeInTheDocument();
+    expect(screen.getByRole('radio', { name: OutputType.Properties })).toBeTruthy();
+    expect(screen.getByRole('radio', { name: OutputType.TotalCount })).toBeTruthy();
+    expect(screen.getByText(labels.types)).toBeTruthy();
+    expect(screen.getAllByText(labels.properties)[1]).toBeTruthy();
+    expect(screen.getByText(labels.orderBy)).toBeTruthy();
+    expect(screen.getByText(labels.descending)).toBeTruthy();
+    expect(screen.getByText(labels.take)).toBeTruthy();
+  });
+
+  it('hides properties-only controls for total count output', async () => {
+    const render = setupRenderer(WorkItemsQueryEditor, WorkItemsDataSource);
+
+    render({});
+    await userEvent.click(screen.getByRole('radio', { name: OutputType.TotalCount }));
+
+    expect(screen.getAllByText(labels.properties)).toHaveLength(1);
+    expect(screen.queryByText(labels.orderBy)).toBeNull();
+    expect(screen.queryByText(labels.descending)).toBeNull();
+    expect(screen.queryByText(labels.take)).toBeNull();
+  });
+
+  it('renders default selected properties for properties output', () => {
+    const render = setupRenderer(WorkItemsQueryEditor, WorkItemsDataSource);
+
+    render({});
+
+    expect(screen.getByText('Work item ID')).toBeTruthy();
+    expect(screen.getAllByText(labels.properties)[1]).toBeTruthy();
+  });
+
+  describe('validation', () => {
+    it('shows types validation error when all types are removed instead of restoring the default selection', async () => {
+      const offsetHeightSpy = jest.spyOn(HTMLElement.prototype, 'offsetHeight', 'get').mockReturnValue(30);
+
+      try {
+        const render = setupRenderer(WorkItemsQueryEditor, WorkItemsDataSource);
+        const [onChange] = render({ types: [WorkItemTypeOptions.WorkOrders] });
+
+        await userEvent.click(screen.getByRole('button', { name: 'Remove Work orders' }));
+
+        expect(screen.getByText(typesErrorMessages.atLeastOneRequired)).toBeTruthy();
+        expect(onChange).toHaveBeenLastCalledWith(expect.objectContaining({ types: [] }));
+      } finally {
+        offsetHeightSpy.mockRestore();
+      }
+    });
+
+    it('shows properties validation error when all properties are removed, and clears it (without restoring defaults) when a property is re-added', async () => {
+      const offsetHeightSpy = jest.spyOn(HTMLElement.prototype, 'offsetHeight', 'get').mockReturnValue(30);
+
+      try {
+        const render = setupRenderer(WorkItemsQueryEditor, WorkItemsDataSource);
+        const [onChange] = render({ properties: [WorkItemPropertiesOptions.ID] });
+
+        await userEvent.click(screen.getByRole('button', { name: 'Remove Work item ID' }));
+
+        expect(screen.getByText(propertiesErrorMessages.atLeastOneRequired)).toBeTruthy();
+        expect(onChange).toHaveBeenLastCalledWith(expect.objectContaining({ properties: [] }));
+
+        const propertiesCombobox = screen.getAllByRole('combobox')[1];
+        await userEvent.click(propertiesCombobox);
+        await userEvent.type(propertiesCombobox, 'Work item name');
+        await userEvent.click(await screen.findByRole('option', { name: 'Work item name' }));
+
+        expect(screen.queryByText(propertiesErrorMessages.atLeastOneRequired)).toBeNull();
+        expect(onChange).toHaveBeenLastCalledWith(
+          expect.objectContaining({ properties: [WorkItemPropertiesOptions.NAME] })
+        );
+      } finally {
+        offsetHeightSpy.mockRestore();
+      }
+    });
+
+    it('shows take validation error and suppresses query execution for invalid take input', () => {
+      const render = setupRenderer(WorkItemsQueryEditor, WorkItemsDataSource);
+
+      const [onChange, onRunQuery] = render({});
+      const takeInput = screen.getByRole('spinbutton');
+
+      fireEvent.change(takeInput, { target: { value: '-5' } });
+      fireEvent.blur(takeInput);
+
+      expect(screen.getByText(takeErrorMessages.greaterOrEqualToZero)).toBeTruthy();
+      expect(onChange).not.toHaveBeenCalled();
+      expect(onRunQuery).not.toHaveBeenCalled();
+    });
   });
 });