Unit test for QueryUtils, application, plugin (#96) (#125)

* Unit test for QueryUtils, application, plugin



* Changes



* Changes



* Updated QueryUtils.test.ts



* Updated Application.test.tsx



* Updated plugin.test.tsx



* used coremock in application.test.tsx and plugin.test.tsx



* added edge cases - the response structure is different



* added edge cases - the response structure is different



---------




(cherry picked from commit b2502f0)

Signed-off-by: Kishore Kumaar Natarajan <[email protected]>
Signed-off-by: [email protected] <[email protected]>
Signed-off-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Kishore Kumaar Natarajan <[email protected]>

Author: 3 people

common/utils/QueryUtils.test.ts

@@ -0,0 +1,98 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { retrieveQueryById } from './QueryUtils';
+import { mockQueries } from '../../test/mocks/mockQueries';
+import { testQueryParams } from '../../test/mocks/testConstants';
+
+jest.unmock('../../common/utils/QueryUtils');
+
+describe('retrieveQueryById - Fetch Query Record by ID from API', () => {
+  const mockCore = {
+    http: {
+      get: jest.fn(),
+      post: jest.fn(),
+    },
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const testStart = testQueryParams?.start;
+  const testEnd = testQueryParams?.end;
+  const testId = testQueryParams?.id;
+  const mockQuery = mockQueries[0];
+
+  const mockResponse = {
+    response: {
+      top_queries: [mockQuery],
+    },
+  };
+
+  it('should make three GET requests to fetch different query records', async () => {
+    mockCore.http.get.mockResolvedValue(mockResponse);
+
+    await retrieveQueryById(mockCore, undefined, testStart, testEnd, testId);
+
+    expect(mockCore.http.get).toHaveBeenCalledTimes(3);
+    expect(mockCore.http.get).toHaveBeenCalledWith('/api/top_queries/latency', {
+      query: { from: testStart, to: testEnd, id: testId, dataSourceId: undefined },
+    });
+    expect(mockCore.http.get).toHaveBeenCalledWith('/api/top_queries/cpu', {
+      query: { from: testStart, to: testEnd, id: testId, dataSourceId: undefined },
+    });
+    expect(mockCore.http.get).toHaveBeenCalledWith('/api/top_queries/memory', {
+      query: { from: testStart, to: testEnd, id: testId, dataSourceId: undefined },
+    });
+  });
+
+  it('should return the valid query result', async () => {
+    mockCore.http.get.mockResolvedValue(mockResponse);
+
+    const result = await retrieveQueryById(mockCore, undefined, testStart, testEnd, testId);
+
+    expect(result).toEqual(mockResponse.response.top_queries[0]);
+  });
+
+  it('should return null if no queries are found', async () => {
+    mockCore.http.get.mockResolvedValue({ response: { top_queries: [] } });
+
+    const result = await retrieveQueryById(mockCore, undefined, testStart, testEnd, testId);
+
+    expect(result).toBeNull();
+  });
+  it('should return null if API response is missing the response field', async () => {
+    mockCore.http.get.mockResolvedValue({});
+
+    const result = await retrieveQueryById(mockCore, undefined, testStart, testEnd, testId);
+
+    expect(result).toBeNull();
+  });
+
+  it('should return null if API response contains an unexpected structure', async () => {
+    mockCore.http.get.mockResolvedValue({ unexpectedKey: {} });
+
+    const result = await retrieveQueryById(mockCore, undefined, testStart, testEnd, testId);
+
+    expect(result).toBeNull();
+  });
+
+  it('should return null if API request fails', async () => {
+    mockCore.http.get.mockRejectedValue(new Error('API error'));
+
+    const result = await retrieveQueryById(mockCore, undefined, testStart, testEnd, testId);
+
+    expect(result).toBeNull();
+  });
+
+  it('should handle cases where API returns an empty object instead of expected response structure', async () => {
+    mockCore.http.get.mockResolvedValue({});
+
+    const result = await retrieveQueryById(mockCore, undefined, testStart, testEnd, testId);
+
+    expect(result).toBeNull();
+  });
+});

public/application.test.tsx

@@ -0,0 +1,35 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as ReactDOM from 'react-dom';
+import { renderApp } from './application';
+import { coreMock } from '../../../src/core/public/mocks';
+
+jest.mock('react-dom', () => {
+  const actualReactDOM = jest.requireActual('react-dom');
+  return {
+    ...actualReactDOM,
+    render: jest.fn(),
+    unmountComponentAtNode: jest.fn(),
+  };
+});
+
+describe('renderApp', () => {
+  const coreMockStart = coreMock.createStart();
+  const depsStartMock = {};
+  const paramsMock = { element: document.createElement('div') };
+  const dataSourceManagementMock = {};
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should unmount the component when the returned function is called', () => {
+    const unmount = renderApp(coreMockStart, depsStartMock, paramsMock, dataSourceManagementMock);
+    unmount();
+
+    expect(ReactDOM.unmountComponentAtNode).toHaveBeenCalledWith(paramsMock.element);
+  });
+});

public/plugin.test.tsx

@@ -0,0 +1,78 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CoreSetup, CoreStart } from '../../../src/core/public';
+import { QueryInsightsDashboardsPlugin } from './plugin';
+import { PLUGIN_NAME } from '../common';
+import { renderApp } from './application';
+import { coreMock } from '../../../src/core/public/mocks';
+
+jest.mock('./application', () => ({
+  renderApp: jest.fn(),
+}));
+
+describe('QueryInsightsDashboardsPlugin', () => {
+  let plugin: QueryInsightsDashboardsPlugin;
+  let coreSetupMock: jest.Mocked<CoreSetup>;
+  let coreStartMock: jest.Mocked<CoreStart>;
+  let registerMock: jest.Mock;
+
+  beforeEach(() => {
+    coreSetupMock = coreMock.createSetup();
+    coreStartMock = coreMock.createStart();
+
+    plugin = new QueryInsightsDashboardsPlugin();
+    registerMock = coreSetupMock.application.register;
+  });
+
+  it('should register the application in setup', () => {
+    plugin.setup(coreSetupMock, {} as any);
+
+    expect(registerMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: PLUGIN_NAME,
+        title: 'Query Insights',
+        category: expect.objectContaining({
+          id: expect.any(String),
+          label: expect.any(String),
+          order: expect.any(Number),
+        }),
+        mount: expect.any(Function),
+        order: expect.any(Number),
+        description: expect.any(String),
+      })
+    );
+  });
+
+  it('should mount the application correctly', async () => {
+    plugin.setup(coreSetupMock, {} as any);
+
+    const appRegistration = registerMock.mock.calls[0][0];
+    expect(appRegistration).toBeDefined();
+
+    const paramsMock = { element: document.createElement('div') };
+    const mountFunction = appRegistration.mount;
+
+    await mountFunction(paramsMock);
+
+    const depsMock = { dataSourceManagement: undefined };
+    coreSetupMock.getStartServices.mockResolvedValue([coreStartMock, depsMock]);
+
+    await mountFunction(paramsMock);
+
+    expect(renderApp).toHaveBeenCalledWith(
+      coreStartMock,
+      depsMock,
+      expect.objectContaining({ element: expect.any(HTMLElement) }),
+      depsMock.dataSourceManagement
+    );
+  });
+
+  it('should return empty start and stop methods', () => {
+    // Ensures `start` and `stop` do not introduce unwanted behavior
+    expect(plugin.start(coreStartMock)).toEqual({});
+    expect(plugin.stop()).toBeUndefined();
+  });
+});

test/mocks/testConstants.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const testQueryParams = {
+  start: '2025-01-01T00:00:00Z',
+  end: '2025-01-31T23:59:59Z',
+  id: '8c1e50c035663459d567fa11d8eb494d',
+};