@itwin/reports-config-widget-react 0.0.8 → 0.2.0

package/src/test/AddMappingModal.test.tsx

@@ -0,0 +1,315 @@
+/*---------------------------------------------------------------------------------------------
+* 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,
+} from "@itwin/core-frontend";
+import { NoRenderApp } from "@itwin/core-frontend";
+import { ReportsConfigWidget } from "../ReportsConfigWidget";
+import {
+  render,
+  screen,
+  TestUtils,
+  waitFor,
+  within,
+} from "./test-utils";
+import * as moq from "typemoq";
+import type {
+  MappingSingle,
+  ReportMappingCollection,
+} from "@itwin/insights-client";
+import type { ReportMappingAndMapping } from "../widget/components/ReportMappings";
+import type { IModelOperations, OperationOptions } from "@itwin/imodels-client-management";
+import { IModelState } from "@itwin/imodels-client-management";
+import { AddMappingsModal } from "../widget/components/AddMappingsModal";
+import { EmptyLocalization } from "@itwin/core-common";
+
+const mockITwinId = faker.datatype.uuid();
+const mockIModelId1 = faker.datatype.uuid();
+const mockIModelId2 = faker.datatype.uuid();
+
+const mockReportId = faker.datatype.uuid();
+
+const mockIModelsResponse = [
+  {
+    iModel: {
+      id: mockIModelId1,
+      displayName: "rAnDoMdIsPlAynAmE1",
+      name: "rAnDomName1",
+      description: "rAnDoMDeScRiPtIoN1",
+      createdDateTime: "2021-10-04T22:13:50.397Z",
+      state: IModelState.Initialized,
+      projectId: mockITwinId,
+      extent: null,
+      _links: {
+        creator: {
+          href: "",
+        },
+        namedVersions: {
+          href: "",
+        },
+        changesets: {
+          href: "",
+        },
+      },
+    },
+  },
+  {
+    iModel: {
+      id: mockIModelId2,
+      displayName: "rAnDoMdIsPlAynAmE2",
+      name: "rAnDomName2",
+      description: "rAnDoMDeScRiPtIoN2",
+      createdDateTime: "2021-10-04T22:13:50.397Z",
+      state: IModelState.Initialized,
+      projectId: mockITwinId,
+      extent: null,
+      _links: {
+        creator: {
+          href: "",
+        },
+        namedVersions: {
+          href: "",
+        },
+        changesets: {
+          href: "",
+        },
+      },
+    },
+  },
+];
+
+const mockProjectIModels = {
+  iModels: mockIModelsResponse.map((iModel) => ({
+    id: iModel.iModel.id,
+    displayName: iModel.iModel.displayName,
+  })),
+  _links: {
+    self: {
+      href: "",
+    },
+    prev: null,
+    next: null,
+  },
+};
+
+const mockReportMappingsFactory = (): ReportMappingCollection => {
+  return {
+    mappings: [
+      {
+        reportId: mockReportId,
+        mappingId: faker.datatype.uuid(),
+        imodelId: mockIModelId1,
+        _links: {
+          report: {
+            href: "",
+          },
+          mapping: {
+            href: "",
+          },
+          imodel: {
+            href: "",
+          },
+        },
+      },
+      {
+        reportId: mockReportId,
+        mappingId: faker.datatype.uuid(),
+        imodelId: mockIModelId2,
+        _links: {
+          report: {
+            href: "",
+          },
+          mapping: {
+            href: "",
+          },
+          imodel: {
+            href: "",
+          },
+        },
+      },
+    ],
+    _links: {
+      next: undefined,
+      self: {
+        href: "",
+      },
+    },
+  };
+};
+
+const mockMappingsFactory = (
+  mockReportMappings: ReportMappingCollection
+): MappingSingle[] => {
+  const mockMappings: MappingSingle[] = mockReportMappings.mappings.map(
+    (mapping, index) => ({
+      mapping: {
+        id: mapping.mappingId,
+        mappingName: `mOcKMaPpIngNaMe${index}`,
+        description: `mOcKmApPInGDeScRiPtIoN${index}`,
+        extractionEnabled: false,
+        createdOn: "",
+        createdBy: "",
+        modifiedOn: "",
+        modifiedBy: "",
+        _links: {
+          imodel: {
+            // Tie the mapping to to the iModel Id
+            href: mapping.imodelId,
+          },
+        },
+      },
+    })
+  );
+
+  const extraMappingId = faker.datatype.uuid();
+  const extraMappingName = "mOcKNaMeExTrA";
+  const extraMappingDescription = "mOcKDeScRiPtIoNeXtRa";
+
+  mockMappings.push({
+    mapping: {
+      id: extraMappingId,
+      mappingName: extraMappingName,
+      description: extraMappingDescription,
+      extractionEnabled: false,
+      createdOn: "",
+      createdBy: "",
+      modifiedOn: "",
+      modifiedBy: "",
+      _links: {
+        imodel: {
+          href: "",
+        },
+      },
+    },
+  });
+
+  return mockMappings;
+};
+
+const mockReportMappingsAndMappingsFactory = (mockMappings: MappingSingle[], reportMappings: ReportMappingCollection): ReportMappingAndMapping[] => {
+  const reportMappingsAndMapping =
+    reportMappings.mappings.map((reportMapping) => {
+      const mapping = mockMappings.find((x) => x.mapping.id === reportMapping.mappingId)!.mapping;
+      const iModelName = mockProjectIModels.iModels.find((x) => x.id === reportMapping.imodelId)!.displayName;
+      const reportMappingAndMapping: ReportMappingAndMapping = {
+        ...reportMapping,
+        iModelName,
+        mappingName: mapping.mappingName,
+        mappingDescription: mapping.description ?? "",
+      };
+      return reportMappingAndMapping;
+    });
+  return reportMappingsAndMapping;
+};
+
+const connectionMock = moq.Mock.ofType<IModelConnection>();
+const mockIModelsClient = moq.Mock.ofType<IModelOperations<OperationOptions>>();
+
+jest.mock("@itwin/appui-react", () => ({
+  ...jest.requireActual("@itwin/appui-react"),
+  useActiveIModelConnection: () => connectionMock.object,
+}));
+
+jest.mock("@itwin/imodels-client-management", () => ({
+  ...jest.requireActual("@itwin/imodels-client-management"),
+  IModelsClient: jest.fn().mockImplementation(() => ({
+    iModels: mockIModelsClient.object,
+  })),
+  toArray: jest.fn().mockImplementation(async () => {
+    return mockProjectIModels.iModels;
+  }),
+}));
+
+const mockGetMappings = jest.fn();
+const mockCreateReportMapping = jest.fn();
+
+jest.mock("@itwin/insights-client", () => ({
+  ...jest.requireActual("@itwin/insights-client"),
+  MappingsClient: jest.fn().mockImplementation(() => ({
+    getMappings: mockGetMappings,
+  })),
+  ReportsClient: jest.fn().mockImplementation(() => ({
+    createReportMapping: mockCreateReportMapping,
+  })),
+}));
+
+beforeAll(async () => {
+  await NoRenderApp.startup({localization: new EmptyLocalization()});
+  connectionMock.setup((x) => x.iModelId).returns(() => mockIModelId1);
+  await ReportsConfigWidget.initialize();
+});
+
+afterAll(() => {
+  TestUtils.terminateUiFramework();
+});
+
+afterEach(() => {
+  mockGetMappings.mockReset();
+  mockIModelsClient.reset();
+});
+
+describe("Add Mapping Modal", () => {
+  it("Adding mapping sends create request", async () => {
+    const mockReportMappings = mockReportMappingsFactory();
+    const mockMappings = mockMappingsFactory(mockReportMappings);
+    const mockReportMappingsAndMappings = mockReportMappingsAndMappingsFactory(mockMappings, mockReportMappings);
+
+    mockGetMappings.mockReturnValueOnce(mockMappings.map((m: MappingSingle) => m.mapping));
+
+    const { user } = render(
+      <AddMappingsModal
+        show={true}
+        reportId={mockReportId}
+        existingMappings={mockReportMappingsAndMappings}
+        returnFn={jest.fn()}
+      />
+    );
+
+    expect(screen.getByRole("dialog")).toBeInTheDocument();
+    const modal = screen.getByRole("dialog");
+    const withinModal = within(modal);
+    expect(withinModal.getByText(/addmappings/i)).toBeInTheDocument();
+
+    const addButton = withinModal.getByRole("button", {
+      name: /add/i,
+    });
+    // Add button should be disabled
+    expect(addButton).toBeDisabled();
+
+    await waitFor(() => screen.getByRole("row"));
+
+    // Already mapped mappings are disabled
+    for (let i = 0; i < mockMappings.length - 1; i++) {
+      const row = screen.getByRole("row", {
+        name: new RegExp(
+          `${mockMappings[i].mapping.mappingName} ${mockMappings[i].mapping.description}`,
+          "i"
+        ),
+      });
+
+      const checkbox = within(row).getByRole("checkbox");
+      expect(checkbox).toBeDisabled();
+    }
+
+    // Click on checkbox on new mapping
+    const unmappedRow = screen.getByRole("row", {
+      name: new RegExp(
+        `${mockMappings[mockMappings.length - 1].mapping.mappingName
+        } ${mockMappings[mockMappings.length - 1].mapping.description}`,
+        "i"
+      ),
+    });
+
+    const enabledCheckbox = within(unmappedRow).getByRole("checkbox");
+
+    await user.click(enabledCheckbox);
+    await user.click(addButton);
+
+    expect(mockCreateReportMapping).toBeCalledTimes(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);
+  });
+});