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

src/datasources/work-items/README.md

@@ -1,5 +1,5 @@
-# SystemLink Work Items data source
+# SystemLink Work Items Data Source
 
-This is a plugin for Work Items from the Work item service. It allows you to:
+This is a plugin for Work Items from the Work Items service. It allows you to:
 
-- Visualize work items metadata and count on a dashboard
+- Visualize work item metadata and its count on a dashboard

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

@@ -1,25 +1,94 @@
 import { WorkItemsDataSource } from './WorkItemsDataSource';
 import { setupDataSource } from 'test/fixtures';
+import { OrderByOptions, OutputType, WorkItemPropertiesOptions, WorkItemTypeOptions } from './types';
+import { TAKE_LIMIT } from './constants/QueryEditor.constants';
 
 describe('WorkItemsDataSource', () => {
-  it('returns an empty placeholder frame', async () => {
-    const [datasource] = setupDataSource(WorkItemsDataSource);
+  it('applies expected default query values', () => {
+    const [ds] = setupDataSource(WorkItemsDataSource);
 
-    const result = await datasource.runQuery({ refId: 'A' }, { scopedVars: {} } as any);
+    const query = ds.prepareQuery({ refId: 'A' });
+
+    expect(query.outputType).toBe(OutputType.Properties);
+    expect(query.types).toEqual([WorkItemTypeOptions.All]);
+    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('normalizes invalid types and defaults out-of-range take values', () => {
+    const [ds] = setupDataSource(WorkItemsDataSource);
+
+    const invalidTakeQuery = ds.prepareQuery({
+      refId: 'A',
+      types: [],
+      take: 12000,
+    });
+
+    const maxTakeQuery = ds.prepareQuery({
+      refId: 'A',
+      take: TAKE_LIMIT,
+    });
+
+    expect(invalidTakeQuery.types).toEqual([WorkItemTypeOptions.All]);
+    expect(invalidTakeQuery.take).toBe(1000);
+    expect(maxTakeQuery.take).toBe(TAKE_LIMIT);
+  });
+
+  it('preserves an explicit empty properties selection instead of resetting to defaults', () => {
+    const [ds] = setupDataSource(WorkItemsDataSource);
+
+    const emptyPropertiesQuery = ds.prepareQuery({ refId: 'A', properties: [] });
+    const customPropertiesQuery = ds.prepareQuery({
+      refId: 'A',
+      properties: [WorkItemPropertiesOptions.ASSET_NAME],
+    });
+    const undefinedPropertiesQuery = ds.prepareQuery({ refId: 'A' });
+
+    expect(emptyPropertiesQuery.properties).toEqual([]);
+    expect(ds.isPropertiesValid(emptyPropertiesQuery.properties)).toBe(false);
+    expect(customPropertiesQuery.properties).toEqual([WorkItemPropertiesOptions.ASSET_NAME]);
+    expect(undefinedPropertiesQuery.properties).toEqual(ds.defaultQuery.properties);
+  });
+
+  it('defaults take when it is negative or not finite', () => {
+    const [ds] = setupDataSource(WorkItemsDataSource);
+
+    const negativeTakeQuery = ds.prepareQuery({ refId: 'A', take: -1 });
+    const nanTakeQuery = ds.prepareQuery({ refId: 'A', take: Number.NaN });
+
+    expect(negativeTakeQuery.take).toBe(1000);
+    expect(nanTakeQuery.take).toBe(1000);
+  });
+
+  it('returns a placeholder frame', async () => {
+    const [ds] = setupDataSource(WorkItemsDataSource);
+
+    const result = await ds.runQuery({ refId: 'A' }, { scopedVars: {} } as any);
     expect(result).toEqual({ refId: 'A', name: 'A', fields: [] });
   });
 
   it('tests datasource connection against the work-items service endpoint', async () => {
-    const [datasource] = setupDataSource(WorkItemsDataSource);
-    const postSpy = jest.spyOn(datasource, 'post').mockResolvedValue({} as any);
+    const [ds] = setupDataSource(WorkItemsDataSource);
+    const postSpy = jest.spyOn(ds, 'post').mockResolvedValue({} as any);
 
-    const result = await datasource.testDatasource();
+    const result = await ds.testDatasource();
 
-    expect(postSpy).toHaveBeenCalledWith(
-      '/niworkitem/v1/query-workitems',
-      { take: 1 },
-      { showErrorAlert: false }
-    );
+    expect(postSpy).toHaveBeenCalledWith('/niworkitem/v1/query-workitems', { take: 1 });
     expect(result.status).toBe('success');
   });
+
+  it('bubbles up exception when datasource connectivity check fails', async () => {
+    const [ds] = setupDataSource(WorkItemsDataSource);
+    jest.spyOn(ds, 'post').mockRejectedValue(new Error('Failed'));
+
+    await expect(ds.testDatasource()).rejects.toThrow('Failed');
+  });
 });

src/datasources/work-items/WorkItemsDataSource.ts

@@ -6,7 +6,14 @@ import {
 } from '@grafana/data';
 import { BackendSrv, TemplateSrv, getBackendSrv, getTemplateSrv } from '@grafana/runtime';
 import { DataSourceBase } from 'core/DataSourceBase';
-import { WorkItemsQuery } from './types';
+import {
+  OrderByOptions,
+  OutputType,
+  WorkItemPropertiesOptions,
+  WorkItemsQuery,
+  WorkItemTypeOptions,
+} from './types';
+import { TAKE_LIMIT } from './constants/QueryEditor.constants';
 
 export class WorkItemsDataSource extends DataSourceBase<WorkItemsQuery> {
   constructor(
@@ -20,7 +27,56 @@ export class WorkItemsDataSource extends DataSourceBase<WorkItemsQuery> {
   baseUrl = `${this.instanceSettings.url}/niworkitem/v1`;
   queryWorkItemsUrl = `${this.baseUrl}/query-workitems`;
 
-  defaultQuery = {};
+  defaultQuery = {
+    outputType: OutputType.Properties,
+    types: [WorkItemTypeOptions.All],
+    properties: [
+      WorkItemPropertiesOptions.ID,
+      WorkItemPropertiesOptions.NAME,
+      WorkItemPropertiesOptions.TYPE,
+      WorkItemPropertiesOptions.STATE,
+      WorkItemPropertiesOptions.WORKSPACE,
+    ],
+    orderBy: OrderByOptions.UPDATED_AT,
+    descending: true,
+    take: 1000,
+  };
+
+  public prepareQuery(query: WorkItemsQuery): WorkItemsQuery {
+    const prepared = super.prepareQuery(query);
+
+    return {
+      ...prepared,
+      outputType: prepared.outputType ?? this.defaultQuery.outputType,
+      orderBy: prepared.orderBy ?? this.defaultQuery.orderBy,
+      descending: prepared.descending ?? this.defaultQuery.descending,
+      types: this.normalizeTypes(prepared.types),
+      properties: this.normalizeProperties(prepared.properties),
+      take: this.normalizeTake(prepared.take),
+    };
+  }
+
+  isTypesValid(types?: WorkItemTypeOptions[]): boolean {
+    return Boolean(types && types.length > 0);
+  }
+
+  normalizeTypes(types?: WorkItemTypeOptions[]): WorkItemTypeOptions[] {
+    return this.isTypesValid(types) ? [...types!] : [...this.defaultQuery.types];
+  }
+
+  isPropertiesValid(properties?: WorkItemPropertiesOptions[]): boolean {
+    return Boolean(properties && properties.length > 0);
+  }
+
+  normalizeProperties(properties?: WorkItemPropertiesOptions[]): WorkItemPropertiesOptions[] {
+    return properties ?? [...this.defaultQuery.properties];
+  }
+
+  normalizeTake(take?: number): number {
+    return Number.isFinite(take) && (take as number) >= 0 && (take as number) <= TAKE_LIMIT
+      ? (take as number)
+      : this.defaultQuery.take;
+  }
 
   async runQuery(query: WorkItemsQuery, _options: DataQueryRequest<WorkItemsQuery>): Promise<DataFrameDTO> {
     return {
@@ -35,7 +91,7 @@ export class WorkItemsDataSource extends DataSourceBase<WorkItemsQuery> {
   }
 
   async testDatasource(): Promise<TestDataSourceResponse> {
-    await this.post(this.queryWorkItemsUrl, { take: 1 }, { showErrorAlert: false });
+    await this.post(this.queryWorkItemsUrl, { take: 1 });
     return { status: 'success', message: 'Data source connected and authentication successful!' };
   }
 }

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

@@ -1,14 +1,84 @@
-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 } from '../constants/QueryEditor.constants';
 import { WorkItemsDataSource } from '../WorkItemsDataSource';
+import { OutputType, WorkItemPropertiesOptions } 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();
+  });
+
+  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();
   });
 });