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

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,
     });

package/src/test/ReportAction.test.tsx

@@ -1,16 +1,12 @@
 /*---------------------------------------------------------------------------------------------
-* 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 {
-  render,
-  screen,
-  waitForElementToBeRemoved,
-} from "./test-utils";
+import { render, screen, waitForElementToBeRemoved } from "./test-utils";
 import { ReportAction } from "../widget/components/ReportAction";
 import userEvent from "@testing-library/user-event";
 import { EmptyLocalization } from "@itwin/core-common";
@@ -55,12 +51,16 @@ describe("Reports Action", () => {
 
     const reportsClient = new ReportsClient();
 
-    jest.spyOn(reportsClient, "createReport").mockImplementation(async () =>
-      new Promise((resolve) => setTimeout(() => { resolve(mockReport); }, 100))
+    jest.spyOn(reportsClient, "createReport").mockImplementation(
+      async () =>
+        new Promise((resolve) =>
+          setTimeout(() => {
+            resolve(mockReport);
+          }, 100),
+        ),
     );
 
-    const { user } = render(
-      <ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />, { reportsClient });
+    const { user } = render(<ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />, { reportsClient });
 
     const addButton = screen.getByRole("button", {
       name: /add/i,
@@ -86,9 +86,7 @@ describe("Reports Action", () => {
     expect(cancelButton).toBeDisabled();
     expect(nameInput).toBeDisabled();
 
-    await waitForElementToBeRemoved(() =>
-      screen.getByTestId(/loading\-spinner/i)
-    );
+    await waitForElementToBeRemoved(() => screen.getByTestId(/loading\-spinner/i));
 
     expect(mockReturnFn).toHaveBeenCalledTimes(1);
   });
@@ -96,9 +94,7 @@ describe("Reports Action", () => {
   it("No duplicate underscores in the beginning of name", async () => {
     const mockReturnFn = jest.fn();
 
-    const { user } = render(
-      <ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />
-    );
+    const { user } = render(<ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />);
 
     const addButton = screen.getByRole("button", {
       name: /add/i,
@@ -110,17 +106,13 @@ describe("Reports Action", () => {
 
     await userEvent.type(nameInput, "__testName");
     await user.click(addButton);
-    expect(
-      screen.getByText(/validators\.noduplicateunderscore/i)
-    ).toBeInTheDocument();
+    expect(screen.getByText(/validators\.noduplicateunderscore/i)).toBeInTheDocument();
   });
 
   it("Only begin with letters or underscores of name", async () => {
     const mockReturnFn = jest.fn();
 
-    const { user } = render(
-      <ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />
-    );
+    const { user } = render(<ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />);
 
     const addButton = screen.getByRole("button", {
       name: /add/i,
@@ -132,17 +124,13 @@ describe("Reports Action", () => {
 
     await userEvent.type(nameInput, "$testName");
     await user.click(addButton);
-    expect(
-      screen.getByText(/validators\.onlybeginswithletterorunderscore/i)
-    ).toBeInTheDocument();
+    expect(screen.getByText(/validators\.onlybeginswithletterorunderscore/i)).toBeInTheDocument();
   });
 
   it("Only letters underscores and digits of name", async () => {
     const mockReturnFn = jest.fn();
 
-    const { user } = render(
-      <ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />
-    );
+    const { user } = render(<ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />);
 
     const addButton = screen.getByRole("button", {
       name: /add/i,
@@ -154,19 +142,13 @@ describe("Reports Action", () => {
 
     await userEvent.type(nameInput, "_# ");
     await user.click(addButton);
-    expect(
-      screen.getByText(
-        /validators\.FollowedByLettersUnderscoresSpacesAndDigits/i
-      )
-    ).toBeInTheDocument();
+    expect(screen.getByText(/validators\.FollowedByLettersUnderscoresSpacesAndDigits/i)).toBeInTheDocument();
   });
 
   it("check for character limits of name", async () => {
     const mockReturnFn = jest.fn();
 
-    const { user } = render(
-      <ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />
-    );
+    const { user } = render(<ReportAction onClickCancel={jest.fn()} onSaveSuccess={mockReturnFn} />);
 
     const addButton = screen.getByRole("button", {
       name: /add/i,