@itwin/reports-config-widget-react 0.1.0 → 0.2.1

package/src/test/BulkExtractor.test.ts

@@ -0,0 +1,301 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import BulkExtractor from "../widget/components/BulkExtractor";
+import { ExtractionStates } from "../widget/components/ExtractionStatus";
+import { assert } from "chai";
+import * as moq from "typemoq";
+import { ExtractorState } from "@itwin/insights-client";
+import type { AccessToken } from "@itwin/core-bentley";
+
+jest.mock("../widget/components/Constants.ts", () => ({
+  STATUS_CHECK_INTERVAL: -1,
+}));
+
+jest.mock("../widget/components/ExtractionToast.tsx", () => ({
+  FailedExtractionToast: jest.fn(),
+  SuccessfulExtractionToast: jest.fn(),
+}));
+
+const mockRunExtraction = moq.Mock.ofType<(accessToken: AccessToken, iModelId: string) => Promise<{ id: string }>>();
+const mockGetStatus = moq.Mock.ofType<(accessToken: AccessToken, jobId: string) => Promise<{ state: ExtractorState }>>();
+const mockGetReportMappings = moq.Mock.ofType<(accessToken: AccessToken, reportId: string) => Promise<{ imodelId: string }[]>>();
+
+jest.mock("@itwin/insights-client", () => ({
+  ...jest.requireActual("@itwin/insights-client"),
+  ReportsClient: jest.fn().mockImplementation(() => ({
+    getReportMappings: mockGetReportMappings.object,
+  })),
+  ExtractionClient: jest.fn().mockImplementation(() => ({
+    runExtraction: mockRunExtraction.object,
+    getExtractionStatus: mockGetStatus.object,
+  })),
+}));
+
+afterEach(() => {
+  mockRunExtraction.reset();
+  mockGetStatus.reset();
+});
+
+const mockToastCallback = jest.fn();
+
+const mockIModelId = "mockIModelId";
+const mockIModelId1 = "mockIModelId1";
+const mockReportId = "mockReportId";
+const mockRunId = "mockRunId";
+const mockRunId1 = "mockRunId1";
+
+describe("BulkExtractor", () => {
+  const mockApiConfig = {
+    getAccessToken: async () => "mockAccessToken",
+    baseUrl: "",
+  };
+
+  it("should return status none for unknown iModel", async () => {
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+    const result = await sut.getIModelState(mockIModelId, "", "");
+    assert.strictEqual(result, ExtractionStates.None);
+  });
+
+  it("should return running status for started extraction", async () => {
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
+      async () => ({ id: mockRunId })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Running })
+    );
+
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+    await sut.runIModelExtraction(mockIModelId);
+    const result = await sut.getIModelState(mockIModelId, "", "");
+    assert.strictEqual(result, ExtractionStates.Running);
+  });
+
+  it("should return failed status for failed extraction", async () => {
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
+      async () => ({ id: mockRunId })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Failed })
+    );
+
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+    await sut.runIModelExtraction(mockIModelId);
+    const result = await sut.getIModelState(mockIModelId, "", "");
+    assert.strictEqual(result, ExtractionStates.Failed);
+  });
+
+  it("full status check cycle", async () => {
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
+      async () => ({ id: mockRunId })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Queued })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Running })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Succeeded })
+    );
+
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+    await sut.runIModelExtraction(mockIModelId);
+
+    let result = await sut.getIModelState(mockIModelId, "", "");
+    assert.strictEqual(result, ExtractionStates.Queued);
+
+    result = await sut.getIModelState(mockIModelId, "", "");
+    assert.strictEqual(result, ExtractionStates.Running);
+
+    result = await sut.getIModelState(mockIModelId, "", "");
+    assert.strictEqual(result, ExtractionStates.Succeeded);
+  });
+
+  it("two started jobs should return status", async () => {
+    const mockIModelIds = [mockIModelId, mockIModelId1];
+
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
+      async () => ({ id: mockRunId })
+    );
+
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId1)).returns(
+      async () => ({ id: mockRunId1 })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Queued })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(
+      async () => ({ state: ExtractorState.Queued })
+    );
+
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+
+    await sut.runIModelExtractions(mockIModelIds);
+
+    const result1 = await sut.getIModelState(mockIModelId, "", "");
+    const result2 = await sut.getIModelState(mockIModelId1, "", "");
+
+    assert.strictEqual(result1, ExtractionStates.Queued);
+    assert.strictEqual(result2, ExtractionStates.Queued);
+  });
+
+  it("should return status none for unknown report", async () => {
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+    const result = await sut.getReportState(mockReportId);
+    assert.strictEqual(result, ExtractionStates.None);
+  });
+
+  it("should return status running for running report", async () => {
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
+      async () => ({ id: mockRunId })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Running })
+    );
+
+    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
+      async () => ([{ imodelId: mockIModelId }])
+    );
+
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+
+    await sut.runReportExtractions([mockReportId]);
+
+    const result = await sut.getReportState(mockReportId);
+    assert.strictEqual(result, ExtractionStates.Running);
+  });
+
+  it("should return status running for both iModels in report", async () => {
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
+      async () => ({ id: mockRunId })
+    );
+
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId1)).returns(
+      async () => ({ id: mockRunId1 })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Running })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(
+      async () => ({ state: ExtractorState.Running })
+    );
+
+    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
+      async () => ([{ imodelId: mockIModelId }, { imodelId: mockIModelId1 }])
+    );
+
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+
+    await sut.runReportExtractions([mockReportId]);
+
+    const result1 = await sut.getIModelState(mockIModelId, "", "");
+    const result2 = await sut.getIModelState(mockIModelId1, "", "");
+
+    assert.strictEqual(result1, ExtractionStates.Running);
+    assert.strictEqual(result2, ExtractionStates.Running);
+  });
+
+  it("should return lowest progress status for extractions in report", async () => {
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
+      async () => ({ id: mockRunId })
+    );
+
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId1)).returns(
+      async () => ({ id: mockRunId1 })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Running })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(
+      async () => ({ state: ExtractorState.Queued })
+    );
+
+    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
+      async () => ([{ imodelId: mockIModelId }, { imodelId: mockIModelId1 }])
+    );
+
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+
+    await sut.runReportExtractions([mockReportId]);
+
+    const result = await sut.getReportState(mockReportId);
+    assert.strictEqual(result, ExtractionStates.Queued);
+  });
+
+  it("should return status failed if one of the extractions in report failed", async () => {
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
+      async () => ({ id: mockRunId })
+    );
+
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId1)).returns(
+      async () => ({ id: mockRunId1 })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Succeeded })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(
+      async () => ({ state: ExtractorState.Failed })
+    );
+
+    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
+      async () => ([{ imodelId: mockIModelId1 }, { imodelId: mockIModelId1 }])
+    );
+
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+
+    await sut.runReportExtractions([mockReportId]);
+
+    const result = await sut.getReportState(mockReportId);
+    assert.strictEqual(result, ExtractionStates.Failed);
+  });
+
+  it("full report extraction status check cycle", async () => {
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
+      async () => ({ id: mockRunId })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Queued })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Running })
+    );
+
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
+      async () => ({ state: ExtractorState.Succeeded })
+    );
+
+    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
+      async () => ([{ imodelId: mockIModelId }])
+    );
+
+    const sut = new BulkExtractor(mockApiConfig, mockToastCallback, mockToastCallback);
+    await sut.runReportExtractions([mockReportId]);
+
+    let result = await sut.getReportState(mockReportId);
+    assert.strictEqual(result, ExtractionStates.Queued);
+
+    result = await sut.getReportState(mockReportId);
+    assert.strictEqual(result, ExtractionStates.Running);
+
+    result = await sut.getReportState(mockReportId);
+    assert.strictEqual(result, ExtractionStates.Succeeded);
+  });
+});

package/src/test/DeleteModal.test.tsx

@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import React from "react";
+import faker from "@faker-js/faker";
+import "@testing-library/jest-dom";
+import type {
+  IModelConnection,
+  SelectionSet,
+  SelectionSetEvent,
+} from "@itwin/core-frontend";
+import { NoRenderApp } from "@itwin/core-frontend";
+import {
+  render,
+  screen,
+  TestUtils,
+} from "./test-utils";
+import * as moq from "typemoq";
+import type {
+  SelectionManager,
+  SelectionScopesManager,
+} from "@itwin/presentation-frontend";
+import {
+  Presentation,
+  SelectionChangeEvent,
+} from "@itwin/presentation-frontend";
+import type { BeEvent } from "@itwin/core-bentley";
+import DeleteModal from "../widget/components/DeleteModal";
+import { ReportsConfigWidget } from "../ReportsConfigWidget";
+import { EmptyLocalization } from "@itwin/core-common";
+
+const mockITwinId = faker.datatype.uuid();
+const mockIModelId1 = faker.datatype.uuid();
+
+const connectionMock = moq.Mock.ofType<IModelConnection>();
+const selectionManagerMock = moq.Mock.ofType<SelectionManager>();
+const selectionScopesManagerMock = moq.Mock.ofType<SelectionScopesManager>();
+
+beforeAll(async () => {
+  await NoRenderApp.startup({localization: new EmptyLocalization()});
+  await Presentation.initialize();
+  const selectionSet = moq.Mock.ofType<SelectionSet>();
+  const onChanged = moq.Mock.ofType<BeEvent<(ev: SelectionSetEvent) => void>>();
+  selectionSet.setup((x) => x.elements).returns(() => new Set([]));
+  selectionSet.setup((x) => x.onChanged).returns(() => onChanged.object);
+  connectionMock
+    .setup((x) => x.selectionSet)
+    .returns(() => selectionSet.object);
+  connectionMock.setup((x) => x.iModelId).returns(() => mockIModelId1);
+  connectionMock.setup((x) => x.iTwinId).returns(() => mockITwinId);
+
+  selectionManagerMock
+    .setup((x) => x.selectionChange)
+    .returns(() => new SelectionChangeEvent());
+
+  selectionScopesManagerMock
+    .setup(async (x) => x.getSelectionScopes(connectionMock.object))
+    .returns(async () => []);
+  selectionManagerMock
+    .setup((x) => x.scopes)
+    .returns(() => selectionScopesManagerMock.object);
+
+  Presentation.setSelectionManager(selectionManagerMock.object);
+  await TestUtils.initializeUiFramework(connectionMock.object);
+  await ReportsConfigWidget.initialize();
+});
+
+describe("Delete modal", () => {
+  it("should render", () => {
+    const { container } = render(
+      <DeleteModal
+        entityName="test"
+        show={true}
+        setShow={jest.fn()}
+        onDelete={jest.fn()}
+        refresh={jest.fn()}
+      />
+    );
+    expect(container).toBeTruthy();
+  });
+
+  it("should call onDelete when delete button is clicked", async () => {
+    const onDelete = jest.fn();
+    const { user } = render(
+      <DeleteModal
+        entityName="test"
+        show={true}
+        setShow={jest.fn()}
+        onDelete={onDelete}
+        refresh={jest.fn()}
+      />
+    );
+    const deleteButton = screen.getByRole("button", {
+      name: /delete/i,
+    });
+    await user.click(deleteButton);
+    expect(onDelete).toHaveBeenCalled();
+  });
+
+  it("should call setShow when cancel button is clicked", async () => {
+    const setShow = jest.fn();
+    const { user } = render(
+      <DeleteModal
+        entityName="test"
+        show={true}
+        setShow={setShow}
+        onDelete={jest.fn()}
+        refresh={jest.fn()}
+      />
+    );
+    const cancelButton = screen.getByRole("button", {
+      name: /cancel/i,
+    });
+    await user.click(cancelButton);
+    expect(setShow).toHaveBeenCalled();
+  });
+});

package/src/test/ReportAction.test.tsx

@@ -34,6 +34,7 @@ import {
   SelectionChangeEvent,
 } from "@itwin/presentation-frontend";
 import type { BeEvent } from "@itwin/core-bentley";
+import { EmptyLocalization } from "@itwin/core-common";
 
 const mockITwinId = faker.datatype.uuid();
 const mockIModelId = faker.datatype.uuid();
@@ -54,10 +55,7 @@ jest.mock("@itwin/appui-react", () => ({
 const server = setupServer();
 
 beforeAll(async () => {
-  // This is required by the i18n module within iTwin.js
-  (global as any).XMLHttpRequest = require("xmlhttprequest").XMLHttpRequest; // eslint-disable-line @typescript-eslint/no-var-requires
-
-  await NoRenderApp.startup();
+  await NoRenderApp.startup({localization: new EmptyLocalization()});
   await Presentation.initialize();
   const selectionSet = moq.Mock.ofType<SelectionSet>();
   const onChanged = moq.Mock.ofType<BeEvent<(ev: SelectionSetEvent) => void>>();