@itwin/reports-config-widget-react 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itwin/reports-config-widget-react",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "An iTwin.js 3D Viewer Widget that interfaces with the iTwin Reporting Platform.",
   "keywords": [
     "Bentley",
@@ -33,6 +33,7 @@
     "copy:public": "cpx \"./public/**/*\" ./lib/public",
     "cover": "npm test -- --coverage",
     "dual-build": "npm run -s build:cjs && npm run -s build:esm",
+    "extract-api": "betools extract-api --entry=reports-config-widget-react --apiReportFolder=./api --apiReportTempFolder=./api/temp --apiSummaryFolder=./api",
     "lint": "eslint -f visualstudio \"./src/**/*.{ts,tsx}\" 1>&2",
     "lint:fix": "npm run lint -- --fix",
     "pseudolocalize": "betools pseudolocalize --englishDir ./public/locales/en --out ./public/locales/en-PSEUDO",
@@ -44,7 +45,10 @@
     "plugins": [
       "@itwin"
     ],
-    "extends": "plugin:@itwin/ui",
+    "extends": [
+      "plugin:@itwin/ui",
+      "prettier"
+    ],
     "rules": {
       "no-duplicate-imports": "off",
       "@typescript-eslint/consistent-type-imports": "error",
@@ -58,7 +62,7 @@
     "@itwin/imodels-access-common": "^4.1.4",
     "@itwin/imodels-access-frontend": "^4.1.4",
     "@itwin/imodels-client-management": "^4.2.3",
-    "@itwin/insights-client": "^0.4.0",
+    "@itwin/insights-client": "^0.10.1",
     "@itwin/itwinui-icons-color-react": "^2.1.0",
     "@itwin/itwinui-icons-react": "^2.4.0",
     "@itwin/itwinui-react": "^2.11.0",
@@ -81,8 +85,8 @@
     "@itwin/core-quantity": "^4.0.0",
     "@itwin/core-react": "^4.0.0",
     "@itwin/core-telemetry": "^4.0.0",
-    "@itwin/eslint-plugin": "^3.7.8",
     "@itwin/ecschema-metadata": "^4.0.0",
+    "@itwin/eslint-plugin": "^3.7.8",
     "@itwin/imodel-components-react": "^4.0.0",
     "@itwin/presentation-common": "^4.0.0",
     "@itwin/presentation-frontend": "^4.0.0",
@@ -104,6 +108,7 @@
     "chai": "^4.2.0",
     "cpx2": "^3.0.0",
     "eslint": "^7.32.0",
+    "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-react": "^7.33.2",
     "eslint-plugin-react-hooks": "^4.2.0",

package/src/ReportsConfigWidget.ts

@@ -1,10 +1,14 @@
 /*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
 import type { Localization } from "@itwin/core-common";
 import { IModelApp } from "@itwin/core-frontend";
 
+/**
+ * ReportsConfigWidget localization
+ * @public
+ */
 export class ReportsConfigWidget {
   private static _localizationNamespace: string;
   private static _localization: Localization;
@@ -21,16 +25,12 @@ export class ReportsConfigWidget {
     ReportsConfigWidget._localization = localization ?? IModelApp.localization;
     // Setup localization
     const ReportsConfigWidgetNamespace = "ReportsConfigWidget";
-    await ReportsConfigWidget._localization.registerNamespace(
-      ReportsConfigWidgetNamespace
-    );
+    await ReportsConfigWidget._localization.registerNamespace(ReportsConfigWidgetNamespace);
 
     ReportsConfigWidget._localizationNamespace = ReportsConfigWidgetNamespace;
   }
 
   public static terminate() {
-    ReportsConfigWidget._localization.unregisterNamespace(
-      ReportsConfigWidget.localizationNamespace
-    );
+    ReportsConfigWidget._localization.unregisterNamespace(ReportsConfigWidget.localizationNamespace);
   }
 }

package/src/reports-config-widget-react.ts

@@ -1,7 +1,7 @@
 /*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
 /** UI Provider for iTwin Viewer Applications */
 export * from "./widget/ReportsConfigUiProvider";
 export * from "./ReportsConfigWidget";

package/src/test/AddMappingModal.test.tsx

@@ -1,29 +1,14 @@
 /*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
+ * 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 { ReportsConfigWidget } from "../ReportsConfigWidget";
-import {
-  mockIModelId1,
-  mockIModelId2,
-  mockIModelsResponse,
-  mockITwinId,
-  mockReportId,
-  render,
-  screen,
-  waitFor,
-  within,
-} from "./test-utils";
+import { mockIModelId1, mockIModelId2, mockIModelsResponse, mockITwinId, mockReportId, render, screen, waitFor, within } from "./test-utils";
 import * as moq from "typemoq";
-import type {
-  MappingsClient,
-  MappingSingle,
-  ReportMappingCollection,
-  ReportsClient,
-} from "@itwin/insights-client";
+import type { MappingContainer, MappingsClient, ReportMappingCollection, ReportsClient } from "@itwin/insights-client";
 import type { ReportMappingAndMapping } from "../widget/components/ReportMappings";
 import type { GetSingleIModelParams, IModelsClient } from "@itwin/imodels-client-management";
 import { AddMappingsModal } from "../widget/components/AddMappingsModal";
@@ -89,29 +74,25 @@ const mockReportMappingsFactory = (): ReportMappingCollection => {
   };
 };
 
-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 mockMappingsFactory = (mockReportMappings: ReportMappingCollection): MappingContainer[] => {
+  const mockMappings: MappingContainer[] = 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";
@@ -128,7 +109,7 @@ const mockMappingsFactory = (
       modifiedOn: "",
       modifiedBy: "",
       _links: {
-        imodel: {
+        iModel: {
           href: "",
         },
       },
@@ -138,19 +119,18 @@ const mockMappingsFactory = (
   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;
-    });
+const mockReportMappingsAndMappingsFactory = (mockMappings: MappingContainer[], 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;
 };
 
@@ -172,12 +152,13 @@ const mockMappingsClient = moq.Mock.ofType<MappingsClient>();
 beforeAll(async () => {
   const localization = new EmptyLocalization();
   await ReportsConfigWidget.initialize(localization);
-  mockIModelsClientOperations.setup(async (x) => x.getSingle(moq.It.isObjectWith<GetSingleIModelParams>({ iModelId: mockIModelId1 })))
+  mockIModelsClientOperations
+    .setup(async (x) => x.getSingle(moq.It.isObjectWith<GetSingleIModelParams>({ iModelId: mockIModelId1 })))
     .returns(async () => mockIModelsResponse[0].iModel);
-  mockIModelsClientOperations.setup(async (x) => x.getSingle(moq.It.isObjectWith<GetSingleIModelParams>({ iModelId: mockIModelId2 })))
+  mockIModelsClientOperations
+    .setup(async (x) => x.getSingle(moq.It.isObjectWith<GetSingleIModelParams>({ iModelId: mockIModelId2 })))
     .returns(async () => mockIModelsResponse[1].iModel);
-  mockIModelsClient.setup((x) => x.iModels)
-    .returns(() => mockIModelsClientOperations.object);
+  mockIModelsClient.setup((x) => x.iModels).returns(() => mockIModelsClientOperations.object);
   mockReportsClient.setup(async (x) => x.createReportMapping(moq.It.isAny(), moq.It.isAny(), moq.It.isAny())).returns(mockCreateReportMapping);
   mockMappingsClient.setup(async (x) => x.getMappings(moq.It.isAny(), moq.It.isAny())).returns(mockGetMappings);
 });
@@ -193,7 +174,7 @@ describe("Add Mapping Modal", () => {
     const mockMappings = mockMappingsFactory(mockReportMappings);
     const mockReportMappingsAndMappings = mockReportMappingsAndMappingsFactory(mockMappings, mockReportMappings);
 
-    mockGetMappings.mockReturnValueOnce(mockMappings.map((m: MappingSingle) => m.mapping));
+    mockGetMappings.mockReturnValueOnce({ mappings: mockMappings.map((m: MappingContainer) => m.mapping) });
 
     const { user } = render(
       <AddMappingsModal
@@ -202,7 +183,8 @@ describe("Add Mapping Modal", () => {
         existingMappings={mockReportMappingsAndMappings}
         onClose={jest.fn()}
         defaultIModelId={mockIModelId1}
-      />, { iTwinId: mockITwinId, reportsClient: mockReportsClient.object, mappingsClient: mockMappingsClient.object, iModelsClient: mockIModelsClient.object }
+      />,
+      { iTwinId: mockITwinId, reportsClient: mockReportsClient.object, mappingsClient: mockMappingsClient.object, iModelsClient: mockIModelsClient.object },
     );
 
     expect(screen.getByRole("dialog")).toBeInTheDocument();
@@ -219,10 +201,7 @@ describe("Add Mapping Modal", () => {
     // 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"
-        ),
+        name: new RegExp(`${mockMappings[i].mapping.mappingName} ${mockMappings[i].mapping.description}`, "i"),
       });
 
       const checkbox = within(row).getByRole("checkbox");
@@ -231,11 +210,7 @@ describe("Add Mapping Modal", () => {
 
     // 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"
-      ),
+      name: new RegExp(`${mockMappings[mockMappings.length - 1].mapping.mappingName} ${mockMappings[mockMappings.length - 1].mapping.description}`, "i"),
     });
 
     const enabledCheckbox = within(unmappedRow).getByRole("checkbox");

package/src/test/BulkExtractor.test.ts

@@ -1,13 +1,14 @@
 /*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
+ * 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 { ExtractionClient, ExtractorState, ReportsClient } from "@itwin/insights-client";
+import { ExtractionClient, ExtractionState, ReportsClient } from "@itwin/insights-client";
 import type { AccessToken } from "@itwin/core-bentley";
+import type { ExtractionRequestDetails } from "@itwin/insights-client";
 
 jest.mock("../widget/components/Constants.ts", () => ({
   STATUS_CHECK_INTERVAL: -1,
@@ -18,9 +19,9 @@ jest.mock("../widget/components/ExtractionToast.tsx", () => ({
   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 }[]>>();
+const mockRunExtraction = moq.Mock.ofType<(accessToken: AccessToken, extractionRequest: ExtractionRequestDetails) => Promise<{ id: string }>>();
+const mockGetStatus = moq.Mock.ofType<(accessToken: AccessToken, jobId: string) => Promise<{ state: ExtractionState }>>();
+const mockGetReportMappings = moq.Mock.ofType<(accessToken: AccessToken, reportId: string) => Promise<{ imodelId: string; mappingId: string }[]>>();
 
 jest.mock("@itwin/insights-client", () => ({
   ...jest.requireActual("@itwin/insights-client"),
@@ -47,9 +48,18 @@ const mockIModelId1 = "mockIModelId1";
 const mockReportId = "mockReportId";
 const mockRunId = "mockRunId";
 const mockRunId1 = "mockRunId1";
+const mockMappingId = "mockMappingId";
+const mockMappingId1 = "mockMappingId1";
+const mockExtractionRequest = {
+  mappings: [{ id: mockMappingId }],
+  iModelId: mockIModelId,
+};
+const mockExtractionRequest1 = {
+  mappings: [{ id: mockMappingId1 }],
+  iModelId: mockIModelId1,
+};
 
 describe("BulkExtractor", () => {
-
   it("should return status none for unknown iModel", async () => {
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
     const result = await sut.getIModelState(mockIModelId, "", "");
@@ -57,54 +67,38 @@ describe("BulkExtractor", () => {
   });
 
   it("should return running status for started extraction", async () => {
-    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
-      async () => ({ id: mockRunId })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest)).returns(async () => ({ id: mockRunId }));
 
-    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: ExtractionState.Running }));
 
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
-    await sut.runIModelExtraction(mockIModelId);
+    await sut.runIModelExtraction(mockExtractionRequest);
     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 })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest)).returns(async () => ({ id: mockRunId }));
 
-    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
-      async () => ({ state: ExtractorState.Failed })
-    );
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(async () => ({ state: ExtractionState.Failed }));
 
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
-    await sut.runIModelExtraction(mockIModelId);
+    await sut.runIModelExtraction(mockExtractionRequest);
     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 })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest)).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: ExtractionState.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: ExtractionState.Running }));
 
-    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
-      async () => ({ state: ExtractorState.Succeeded })
-    );
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(async () => ({ state: ExtractionState.Succeeded }));
 
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
-    await sut.runIModelExtraction(mockIModelId);
+    await sut.runIModelExtraction(mockExtractionRequest);
 
     let result = await sut.getIModelState(mockIModelId, "", "");
     assert.strictEqual(result, ExtractionStates.Queued);
@@ -117,27 +111,19 @@ describe("BulkExtractor", () => {
   });
 
   it("two started jobs should return status", async () => {
-    const mockIModelIds = [mockIModelId, mockIModelId1];
+    const mockExtractionRequests = [mockExtractionRequest, mockExtractionRequest1];
 
-    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
-      async () => ({ id: mockRunId })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest)).returns(async () => ({ id: mockRunId }));
 
-    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId1)).returns(
-      async () => ({ id: mockRunId1 })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest1)).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(), mockRunId)).returns(async () => ({ state: ExtractionState.Queued }));
 
-    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(
-      async () => ({ state: ExtractorState.Queued })
-    );
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(async () => ({ state: ExtractionState.Queued }));
 
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
 
-    await sut.runIModelExtractions(mockIModelIds);
+    await sut.runIModelExtractions(mockExtractionRequests);
 
     const result1 = await sut.getIModelState(mockIModelId, "", "");
     const result2 = await sut.getIModelState(mockIModelId1, "", "");
@@ -153,17 +139,11 @@ describe("BulkExtractor", () => {
   });
 
   it("should return status running for running report", async () => {
-    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
-      async () => ({ id: mockRunId })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest)).returns(async () => ({ id: mockRunId }));
 
-    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: ExtractionState.Running }));
 
-    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
-      async () => ([{ imodelId: mockIModelId }])
-    );
+    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(async () => [{ imodelId: mockIModelId, mappingId: mockMappingId }]);
 
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
 
@@ -174,25 +154,20 @@ describe("BulkExtractor", () => {
   });
 
   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(), mockExtractionRequest)).returns(async () => ({ id: mockRunId }));
 
-    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId1)).returns(
-      async () => ({ id: mockRunId1 })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest1)).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(), mockRunId)).returns(async () => ({ state: ExtractionState.Running }));
 
-    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(
-      async () => ({ state: ExtractorState.Running })
-    );
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(async () => ({ state: ExtractionState.Running }));
 
-    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
-      async () => ([{ imodelId: mockIModelId }, { imodelId: mockIModelId1 }])
-    );
+    mockGetReportMappings
+      .setup(async (x) => x(moq.It.isAny(), mockReportId))
+      .returns(async () => [
+        { imodelId: mockIModelId, mappingId: mockMappingId },
+        { imodelId: mockIModelId1, mappingId: mockMappingId1 },
+      ]);
 
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
 
@@ -206,25 +181,20 @@ describe("BulkExtractor", () => {
   });
 
   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(), mockExtractionRequest)).returns(async () => ({ id: mockRunId }));
 
-    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId1)).returns(
-      async () => ({ id: mockRunId1 })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest1)).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(), mockRunId)).returns(async () => ({ state: ExtractionState.Running }));
 
-    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(
-      async () => ({ state: ExtractorState.Queued })
-    );
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(async () => ({ state: ExtractionState.Queued }));
 
-    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
-      async () => ([{ imodelId: mockIModelId }, { imodelId: mockIModelId1 }])
-    );
+    mockGetReportMappings
+      .setup(async (x) => x(moq.It.isAny(), mockReportId))
+      .returns(async () => [
+        { imodelId: mockIModelId, mappingId: mockMappingId },
+        { imodelId: mockIModelId1, mappingId: mockMappingId1 },
+      ]);
 
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
 
@@ -235,25 +205,20 @@ describe("BulkExtractor", () => {
   });
 
   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(), mockExtractionRequest)).returns(async () => ({ id: mockRunId }));
 
-    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId1)).returns(
-      async () => ({ id: mockRunId1 })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest1)).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(), mockRunId)).returns(async () => ({ state: ExtractionState.Succeeded }));
 
-    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(
-      async () => ({ state: ExtractorState.Failed })
-    );
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId1)).returns(async () => ({ state: ExtractionState.Failed }));
 
-    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
-      async () => ([{ imodelId: mockIModelId1 }, { imodelId: mockIModelId1 }])
-    );
+    mockGetReportMappings
+      .setup(async (x) => x(moq.It.isAny(), mockReportId))
+      .returns(async () => [
+        { imodelId: mockIModelId, mappingId: mockMappingId },
+        { imodelId: mockIModelId1, mappingId: mockMappingId1 },
+      ]);
 
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
 
@@ -264,25 +229,15 @@ describe("BulkExtractor", () => {
   });
 
   it("full report extraction status check cycle", async () => {
-    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockIModelId)).returns(
-      async () => ({ id: mockRunId })
-    );
+    mockRunExtraction.setup(async (x) => x(moq.It.isAny(), mockExtractionRequest)).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: ExtractionState.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: ExtractionState.Running }));
 
-    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(
-      async () => ({ state: ExtractorState.Succeeded })
-    );
+    mockGetStatus.setup(async (x) => x(moq.It.isAny(), mockRunId)).returns(async () => ({ state: ExtractionState.Succeeded }));
 
-    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(
-      async () => ([{ imodelId: mockIModelId }])
-    );
+    mockGetReportMappings.setup(async (x) => x(moq.It.isAny(), mockReportId)).returns(async () => [{ imodelId: mockIModelId, mappingId: mockMappingId }]);
 
     const sut = new BulkExtractor(new ReportsClient(), new ExtractionClient(), mockGetAccessToken, mockToastCallback, mockToastCallback);
     await sut.runReportExtractions([mockReportId]);

package/src/test/DeleteModal.test.tsx

@@ -1,13 +1,10 @@
 /*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
+ * 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 "@testing-library/jest-dom";
-import {
-  render,
-  screen,
-} from "./test-utils";
+import { render, screen } from "./test-utils";
 import DeleteModal from "../widget/components/DeleteModal";
 import { ReportsConfigWidget } from "../ReportsConfigWidget";
 import { EmptyLocalization } from "@itwin/core-common";
@@ -19,27 +16,13 @@ beforeAll(async () => {
 
 describe("Delete modal", () => {
   it("should render", () => {
-    const { container } = render(
-      <DeleteModal
-        entityName="test"
-        onDelete={jest.fn()}
-        refresh={jest.fn()}
-        onClose={jest.fn()}
-      />
-    );
+    const { container } = render(<DeleteModal entityName="test" onDelete={jest.fn()} refresh={jest.fn()} onClose={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"
-        onDelete={onDelete}
-        refresh={jest.fn()}
-        onClose={jest.fn()}
-      />
-    );
+    const { user } = render(<DeleteModal entityName="test" onDelete={onDelete} refresh={jest.fn()} onClose={jest.fn()} />);
     const deleteButton = screen.getByRole("button", {
       name: /delete/i,
     });