@backstage/test-utils 1.2.2 → 1.2.3-next.1

package/dist/index.d.ts

@@ -1,11 +1,85 @@
-import { AnalyticsApi, AnalyticsEvent, ConfigApi, ErrorApiError, ErrorApiErrorContext, ErrorApi, DiscoveryApi, IdentityApi, FetchApi, StorageApi, StorageValueSnapshot, RouteRef, ExternalRouteRef, ApiHolder, ApiRef } from '@backstage/core-plugin-api';
+/**
+ * Utilities to test Backstage plugins and apps.
+ *
+ * @packageDocumentation
+ */
+
+import { AnalyticsApi } from '@backstage/core-plugin-api';
+import { AnalyticsEvent } from '@backstage/core-plugin-api';
+import { ApiHolder } from '@backstage/core-plugin-api';
+import { ApiRef } from '@backstage/core-plugin-api';
+import { AuthorizeResult } from '@backstage/plugin-permission-common';
+import { ComponentType } from 'react';
 import { Config } from '@backstage/config';
-import { JsonObject, JsonValue, Observable } from '@backstage/types';
+import { ConfigApi } from '@backstage/core-plugin-api';
 import crossFetch from 'cross-fetch';
+import { DiscoveryApi } from '@backstage/core-plugin-api';
+import { ErrorApi } from '@backstage/core-plugin-api';
+import { ErrorApiError } from '@backstage/core-plugin-api';
+import { ErrorApiErrorContext } from '@backstage/core-plugin-api';
+import { EvaluatePermissionRequest } from '@backstage/plugin-permission-common';
+import { EvaluatePermissionResponse } from '@backstage/plugin-permission-common';
+import { ExternalRouteRef } from '@backstage/core-plugin-api';
+import { FetchApi } from '@backstage/core-plugin-api';
+import { IdentityApi } from '@backstage/core-plugin-api';
+import { JsonObject } from '@backstage/types';
+import { JsonValue } from '@backstage/types';
+import { Observable } from '@backstage/types';
 import { PermissionApi } from '@backstage/plugin-permission-react';
-import { EvaluatePermissionRequest, AuthorizeResult, EvaluatePermissionResponse } from '@backstage/plugin-permission-common';
-import { ReactNode, ComponentType, ReactElement } from 'react';
-import { RenderResult, RenderOptions } from '@testing-library/react';
+import { PropsWithChildren } from 'react';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { RenderOptions } from '@testing-library/react';
+import { RenderResult } from '@testing-library/react';
+import { RouteRef } from '@backstage/core-plugin-api';
+import { StorageApi } from '@backstage/core-plugin-api';
+import { StorageValueSnapshot } from '@backstage/core-plugin-api';
+
+/**
+ * AsyncLogCollector type used in {@link (withLogCollector:1)} callback function.
+ * @public
+ */
+export declare type AsyncLogCollector = () => Promise<void>;
+
+/**
+ * Map of severity level and corresponding log lines.
+ * @public
+ */
+export declare type CollectedLogs<T extends LogFuncs> = {
+    [key in T]: string[];
+};
+
+/**
+ * Creates a Wrapper component that wraps a component inside a Backstage test app,
+ * providing a mocked theme and app context, along with mocked APIs.
+ *
+ * @param options - Additional options for the rendering.
+ * @public
+ */
+export declare function createTestAppWrapper(options?: TestAppOptions): (props: {
+    children: ReactNode;
+}) => JSX.Element;
+
+/**
+ * ErrorWithContext contains error and ErrorApiErrorContext
+ * @public
+ */
+export declare type ErrorWithContext = {
+    error: ErrorApiError;
+    context?: ErrorApiErrorContext;
+};
+
+/**
+ * Union type used in {@link (withLogCollector:3)} callback function.
+ * @public
+ */
+export declare type LogCollector = AsyncLogCollector | SyncLogCollector;
+
+/**
+ * Severity levels of {@link CollectedLogs}
+ * @public
+ */
+export declare type LogFuncs = 'log' | 'warn' | 'error';
 
 /**
  * Mock implementation of {@link core-plugin-api#AnalyticsApi} with helpers to ensure that events are sent correctly.
@@ -13,12 +87,28 @@ import { RenderResult, RenderOptions } from '@testing-library/react';
  *
  * @public
  */
-declare class MockAnalyticsApi implements AnalyticsApi {
+export declare class MockAnalyticsApi implements AnalyticsApi {
     private events;
     captureEvent(event: AnalyticsEvent): void;
     getEvents(): AnalyticsEvent[];
 }
 
+/**
+ *  This is a mocking method suggested in the Jest docs, as it is not implemented in JSDOM yet.
+ *  It can be used to mock values for the MUI `useMediaQuery` hook if it is used in a tested component.
+ *
+ *  For issues checkout the documentation:
+ *  https://jestjs.io/docs/manual-mocks#mocking-methods-which-are-not-implemented-in-jsdom
+ *
+ *  If there are any updates from MUI React on testing `useMediaQuery` this mock should be replaced
+ *  https://material-ui.com/components/use-media-query/#testing
+ *
+ * @public
+ */
+export declare function mockBreakpoint(options: {
+    matches: boolean;
+}): void;
+
 /**
  * MockConfigApi is a thin wrapper around {@link @backstage/config#ConfigReader}
  * that can be used to mock configuration using a plain object.
@@ -37,7 +127,7 @@ declare class MockAnalyticsApi implements AnalyticsApi {
  * );
  * ```
  */
-declare class MockConfigApi implements ConfigApi {
+export declare class MockConfigApi implements ConfigApi {
     private readonly config;
     constructor(data: JsonObject);
     /** {@inheritdoc @backstage/config#Config.has} */
@@ -74,27 +164,12 @@ declare class MockConfigApi implements ConfigApi {
     getOptionalStringArray(key: string): string[] | undefined;
 }
 
-/**
- * Constructor arguments for {@link MockErrorApi}
- * @public
- */
-declare type MockErrorApiOptions = {
-    collect?: boolean;
-};
-/**
- * ErrorWithContext contains error and ErrorApiErrorContext
- * @public
- */
-declare type ErrorWithContext = {
-    error: ErrorApiError;
-    context?: ErrorApiErrorContext;
-};
 /**
  * Mock implementation of the {@link core-plugin-api#ErrorApi} to be used in tests.
  * Includes withForError and getErrors methods for error testing.
  * @public
  */
-declare class MockErrorApi implements ErrorApi {
+export declare class MockErrorApi implements ErrorApi {
     private readonly options;
     private readonly errors;
     private readonly waiters;
@@ -108,12 +183,35 @@ declare class MockErrorApi implements ErrorApi {
     waitForError(pattern: RegExp, timeoutMs?: number): Promise<ErrorWithContext>;
 }
 
+/**
+ * Constructor arguments for {@link MockErrorApi}
+ * @public
+ */
+export declare type MockErrorApiOptions = {
+    collect?: boolean;
+};
+
+/**
+ * A test helper implementation of {@link @backstage/core-plugin-api#FetchApi}.
+ *
+ * @public
+ */
+export declare class MockFetchApi implements FetchApi {
+    private readonly implementation;
+    /**
+     * Creates a mock {@link @backstage/core-plugin-api#FetchApi}.
+     */
+    constructor(options?: MockFetchApiOptions);
+    /** {@inheritdoc @backstage/core-plugin-api#FetchApi.fetch} */
+    get fetch(): typeof crossFetch;
+}
+
 /**
  * The options given when constructing a {@link MockFetchApi}.
  *
  * @public
  */
-interface MockFetchApiOptions {
+export declare interface MockFetchApiOptions {
     /**
      * Define the underlying base `fetch` implementation.
      *
@@ -167,20 +265,6 @@ interface MockFetchApiOptions {
         identityApi: Pick<IdentityApi, 'getCredentials'>;
     };
 }
-/**
- * A test helper implementation of {@link @backstage/core-plugin-api#FetchApi}.
- *
- * @public
- */
-declare class MockFetchApi implements FetchApi {
-    private readonly implementation;
-    /**
-     * Creates a mock {@link @backstage/core-plugin-api#FetchApi}.
-     */
-    constructor(options?: MockFetchApiOptions);
-    /** {@inheritdoc @backstage/core-plugin-api#FetchApi.fetch} */
-    get fetch(): typeof crossFetch;
-}
 
 /**
  * Mock implementation of
@@ -189,24 +273,19 @@ declare class MockFetchApi implements FetchApi {
  * request.
  * @public
  */
-declare class MockPermissionApi implements PermissionApi {
+export declare class MockPermissionApi implements PermissionApi {
     private readonly requestHandler;
     constructor(requestHandler?: (request: EvaluatePermissionRequest) => AuthorizeResult.ALLOW | AuthorizeResult.DENY);
     authorize(request: EvaluatePermissionRequest): Promise<EvaluatePermissionResponse>;
 }
 
-/**
- * Type for map holding data in {@link MockStorageApi}
- * @public
- */
-declare type MockStorageBucket = {
-    [key: string]: any;
-};
+/* Excluded from this release type: MockPluginProvider */
+
 /**
  * Mock implementation of the {@link core-plugin-api#StorageApi} to be used in tests
  * @public
  */
-declare class MockStorageApi implements StorageApi {
+export declare class MockStorageApi implements StorageApi {
     private readonly namespace;
     private readonly data;
     private readonly bucketStorageApis;
@@ -224,67 +303,13 @@ declare class MockStorageApi implements StorageApi {
 }
 
 /**
- *  This is a mocking method suggested in the Jest docs, as it is not implemented in JSDOM yet.
- *  It can be used to mock values for the MUI `useMediaQuery` hook if it is used in a tested component.
- *
- *  For issues checkout the documentation:
- *  https://jestjs.io/docs/manual-mocks#mocking-methods-which-are-not-implemented-in-jsdom
- *
- *  If there are any updates from MUI React on testing `useMediaQuery` this mock should be replaced
- *  https://material-ui.com/components/use-media-query/#testing
- *
- * @public
- */
-declare function mockBreakpoint(options: {
-    matches: boolean;
-}): void;
-
-/**
- * Options to customize the behavior of the test app wrapper.
+ * Type for map holding data in {@link MockStorageApi}
  * @public
  */
-declare type TestAppOptions = {
-    /**
-     * Initial route entries to pass along as `initialEntries` to the router.
-     */
-    routeEntries?: string[];
-    /**
-     * An object of paths to mount route ref on, with the key being the path and the value
-     * being the RouteRef that the path will be bound to. This allows the route refs to be
-     * used by `useRouteRef` in the rendered elements.
-     *
-     * @example
-     * wrapInTestApp(<MyComponent />, \{
-     *   mountedRoutes: \{
-     *     '/my-path': myRouteRef,
-     *   \}
-     * \})
-     * // ...
-     * const link = useRouteRef(myRouteRef)
-     */
-    mountedRoutes?: {
-        [path: string]: RouteRef | ExternalRouteRef;
-    };
+export declare type MockStorageBucket = {
+    [key: string]: any;
 };
-/**
- * Creates a Wrapper component that wraps a component inside a Backstage test app,
- * providing a mocked theme and app context, along with mocked APIs.
- *
- * @param options - Additional options for the rendering.
- * @public
- */
-declare function createTestAppWrapper(options?: TestAppOptions): (props: {
-    children: ReactNode;
-}) => JSX.Element;
-/**
- * Wraps a component inside a Backstage test app, providing a mocked theme
- * and app context, along with mocked APIs.
- *
- * @param Component - A component or react node to render inside the test app.
- * @param options - Additional options for the rendering.
- * @public
- */
-declare function wrapInTestApp(Component: ComponentType | ReactNode, options?: TestAppOptions): ReactElement;
+
 /**
  * Renders a component inside a Backstage test app, providing a mocked theme
  * and app context, along with mocked APIs.
@@ -296,96 +321,96 @@ declare function wrapInTestApp(Component: ComponentType | ReactNode, options?: T
  * @param options - Additional options for the rendering.
  * @public
  */
-declare function renderInTestApp(Component: ComponentType | ReactNode, options?: TestAppOptions): Promise<RenderResult>;
+export declare function renderInTestApp(Component: ComponentType | ReactNode, options?: TestAppOptions): Promise<RenderResult>;
+
+/**
+ * @public
+ * Simplifies rendering of async components in by taking care of the wrapping inside act
+ *
+ * @remarks
+ *
+ * Components using useEffect to perform an asynchronous action (such as fetch) must be rendered within an async
+ * act call to properly get the final state, even with mocked responses. This utility method makes the signature a bit
+ * cleaner, since act doesn't return the result of the evaluated function.
+ * https://github.com/testing-library/react-testing-library/issues/281
+ * https://github.com/facebook/react/pull/14853
+ */
+export declare function renderWithEffects(nodes: ReactElement, options?: Pick<RenderOptions, 'wrapper'>): Promise<RenderResult>;
 
 /**
  * Sets up handlers for request mocking
  * @public
  * @param worker - service worker
  */
-declare function setupRequestMockHandlers(worker: {
+export declare function setupRequestMockHandlers(worker: {
     listen: (t: any) => void;
     close: () => void;
     resetHandlers: () => void;
 }): void;
 
-/**
- * Severity levels of {@link CollectedLogs}
- * @public
- */
-declare type LogFuncs = 'log' | 'warn' | 'error';
-/**
- * AsyncLogCollector type used in {@link (withLogCollector:1)} callback function.
- * @public
- */
-declare type AsyncLogCollector = () => Promise<void>;
 /**
  * SyncLogCollector type used in {@link (withLogCollector:2)} callback function.
  * @public
  */
-declare type SyncLogCollector = () => void;
-/**
- * Union type used in {@link (withLogCollector:3)} callback function.
- * @public
- */
-declare type LogCollector = AsyncLogCollector | SyncLogCollector;
-/**
- * Map of severity level and corresponding log lines.
- * @public
- */
-declare type CollectedLogs<T extends LogFuncs> = {
-    [key in T]: string[];
-};
-/**
- * Asynchronous log collector with that collects all categories
- * @public
- */
-declare function withLogCollector(callback: AsyncLogCollector): Promise<CollectedLogs<LogFuncs>>;
-/**
- * Synchronous log collector with that collects all categories
- * @public
- */
-declare function withLogCollector(callback: SyncLogCollector): CollectedLogs<LogFuncs>;
-/**
- * Asynchronous log collector with that only collects selected categories
- * @public
- */
-declare function withLogCollector<T extends LogFuncs>(logsToCollect: T[], callback: AsyncLogCollector): Promise<CollectedLogs<T>>;
-/**
- * Synchronous log collector with that only collects selected categories
- * @public
- */
-declare function withLogCollector<T extends LogFuncs>(logsToCollect: T[], callback: SyncLogCollector): CollectedLogs<T>;
+export declare type SyncLogCollector = () => void;
 
 /**
- * @public
- * Simplifies rendering of async components in by taking care of the wrapping inside act
+ * The `TestApiProvider` is a Utility API context provider that is particularly
+ * well suited for development and test environments such as unit tests, storybooks,
+ * and isolated plugin development setups.
  *
- * @remarks
+ * It lets you provide any number of API implementations, without necessarily
+ * having to fully implement each of the APIs.
  *
- * Components using useEffect to perform an asynchronous action (such as fetch) must be rendered within an async
- * act call to properly get the final state, even with mocked responses. This utility method makes the signature a bit
- * cleaner, since act doesn't return the result of the evaluated function.
- * https://github.com/testing-library/react-testing-library/issues/281
- * https://github.com/facebook/react/pull/14853
- */
-declare function renderWithEffects(nodes: ReactElement, options?: Pick<RenderOptions, 'wrapper'>): Promise<RenderResult>;
+ * A migration from `ApiRegistry` and `ApiProvider` might look like this, from:
+ *
+ * ```tsx
+ * renderInTestApp(
+ *   <ApiProvider
+ *     apis={ApiRegistry.from([
+ *       [identityApiRef, mockIdentityApi as unknown as IdentityApi]
+ *     ])}
+ *   >
+ *     {...}
+ *   </ApiProvider>
+ * )
+ * ```
+ *
+ * To the following:
+ *
+ * ```tsx
+ * renderInTestApp(
+ *   <TestApiProvider apis={[[identityApiRef, mockIdentityApi]]}>
+ *     {...}
+ *   </TestApiProvider>
+ * )
+ * ```
+ *
+ * Note that the cast to `IdentityApi` is no longer needed as long as the mock API
+ * implements a subset of the `IdentityApi`.
+ *
+ * @public
+ **/
+export declare const TestApiProvider: <T extends any[]>(props: TestApiProviderProps<T>) => JSX.Element;
 
-/** @ignore */
-declare type TestApiProviderPropsApiPair<TApi> = TApi extends infer TImpl ? readonly [ApiRef<TApi>, Partial<TImpl>] : never;
-/** @ignore */
-declare type TestApiProviderPropsApiPairs<TApiPairs> = {
-    [TIndex in keyof TApiPairs]: TestApiProviderPropsApiPair<TApiPairs[TIndex]>;
-};
 /**
  * Properties for the {@link TestApiProvider} component.
  *
  * @public
  */
-declare type TestApiProviderProps<TApiPairs extends any[]> = {
+export declare type TestApiProviderProps<TApiPairs extends any[]> = {
     apis: readonly [...TestApiProviderPropsApiPairs<TApiPairs>];
     children: ReactNode;
 };
+
+/** @ignore */
+declare type TestApiProviderPropsApiPair<TApi> = TApi extends infer TImpl ? readonly [ApiRef<TApi>, Partial<TImpl>] : never;
+
+/** @ignore */
+declare type TestApiProviderPropsApiPairs<TApiPairs> = {
+    [TIndex in keyof TApiPairs]: TestApiProviderPropsApiPair<TApiPairs[TIndex]>;
+};
+
 /**
  * The `TestApiRegistry` is an {@link @backstage/core-plugin-api#ApiHolder} implementation
  * that is particularly well suited for development and test environments such as
@@ -393,7 +418,7 @@ declare type TestApiProviderProps<TApiPairs extends any[]> = {
  *
  * @public
  */
-declare class TestApiRegistry implements ApiHolder {
+export declare class TestApiRegistry implements ApiHolder {
     private readonly apis;
     /**
      * Creates a new {@link TestApiRegistry} with a list of API implementation pairs.
@@ -421,43 +446,67 @@ declare class TestApiRegistry implements ApiHolder {
      */
     get<T>(api: ApiRef<T>): T | undefined;
 }
+
 /**
- * The `TestApiProvider` is a Utility API context provider that is particularly
- * well suited for development and test environments such as unit tests, storybooks,
- * and isolated plugin development setups.
- *
- * It lets you provide any number of API implementations, without necessarily
- * having to fully implement each of the APIs.
- *
- * A migration from `ApiRegistry` and `ApiProvider` might look like this, from:
- *
- * ```tsx
- * renderInTestApp(
- *   <ApiProvider
- *     apis={ApiRegistry.from([
- *       [identityApiRef, mockIdentityApi as unknown as IdentityApi]
- *     ])}
- *   >
- *     {...}
- *   </ApiProvider>
- * )
- * ```
- *
- * To the following:
- *
- * ```tsx
- * renderInTestApp(
- *   <TestApiProvider apis={[[identityApiRef, mockIdentityApi]]}>
- *     {...}
- *   </TestApiProvider>
- * )
- * ```
- *
- * Note that the cast to `IdentityApi` is no longer needed as long as the mock API
- * implements a subset of the `IdentityApi`.
+ * Options to customize the behavior of the test app wrapper.
+ * @public
+ */
+export declare type TestAppOptions = {
+    /**
+     * Initial route entries to pass along as `initialEntries` to the router.
+     */
+    routeEntries?: string[];
+    /**
+     * An object of paths to mount route ref on, with the key being the path and the value
+     * being the RouteRef that the path will be bound to. This allows the route refs to be
+     * used by `useRouteRef` in the rendered elements.
+     *
+     * @example
+     * wrapInTestApp(<MyComponent />, \{
+     *   mountedRoutes: \{
+     *     '/my-path': myRouteRef,
+     *   \}
+     * \})
+     * // ...
+     * const link = useRouteRef(myRouteRef)
+     */
+    mountedRoutes?: {
+        [path: string]: RouteRef | ExternalRouteRef;
+    };
+};
+
+/**
+ * Asynchronous log collector with that collects all categories
+ * @public
+ */
+export declare function withLogCollector(callback: AsyncLogCollector): Promise<CollectedLogs<LogFuncs>>;
+
+/**
+ * Synchronous log collector with that collects all categories
+ * @public
+ */
+export declare function withLogCollector(callback: SyncLogCollector): CollectedLogs<LogFuncs>;
+
+/**
+ * Asynchronous log collector with that only collects selected categories
+ * @public
+ */
+export declare function withLogCollector<T extends LogFuncs>(logsToCollect: T[], callback: AsyncLogCollector): Promise<CollectedLogs<T>>;
+
+/**
+ * Synchronous log collector with that only collects selected categories
+ * @public
+ */
+export declare function withLogCollector<T extends LogFuncs>(logsToCollect: T[], callback: SyncLogCollector): CollectedLogs<T>;
+
+/**
+ * Wraps a component inside a Backstage test app, providing a mocked theme
+ * and app context, along with mocked APIs.
  *
+ * @param Component - A component or react node to render inside the test app.
+ * @param options - Additional options for the rendering.
  * @public
- **/
-declare const TestApiProvider: <T extends any[]>(props: TestApiProviderProps<T>) => JSX.Element;
+ */
+export declare function wrapInTestApp(Component: ComponentType | ReactNode, options?: TestAppOptions): ReactElement;
 
-export { AsyncLogCollector, CollectedLogs, ErrorWithContext, LogCollector, LogFuncs, MockAnalyticsApi, MockConfigApi, MockErrorApi, MockErrorApiOptions, MockFetchApi, MockFetchApiOptions, MockPermissionApi, MockStorageApi, MockStorageBucket, SyncLogCollector, TestApiProvider, TestApiProviderProps, TestApiRegistry, TestAppOptions, createTestAppWrapper, mockBreakpoint, renderInTestApp, renderWithEffects, setupRequestMockHandlers, withLogCollector, wrapInTestApp };
+export { }

package/dist/index.esm.js

@@ -10,7 +10,7 @@ import { lightTheme } from '@backstage/theme';
 import { ThemeProvider } from '@material-ui/core/styles';
 import { CssBaseline } from '@material-ui/core';
 import MockIcon from '@material-ui/icons/AcUnit';
-import { createApiFactory, discoveryApiRef, configApiRef, alertApiRef, analyticsApiRef, errorApiRef, storageApiRef, oauthRequestApiRef, googleAuthApiRef, microsoftAuthApiRef, githubAuthApiRef, oktaAuthApiRef, gitlabAuthApiRef, oneloginAuthApiRef, bitbucketAuthApiRef, atlassianAuthApiRef, createRouteRef, attachComponentData } from '@backstage/core-plugin-api';
+import { createApiFactory, discoveryApiRef, configApiRef, alertApiRef, analyticsApiRef, errorApiRef, storageApiRef, oauthRequestApiRef, googleAuthApiRef, microsoftAuthApiRef, githubAuthApiRef, oktaAuthApiRef, gitlabAuthApiRef, oneloginAuthApiRef, bitbucketAuthApiRef, atlassianAuthApiRef, createRouteRef, attachComponentData, createPlugin, PluginProvider } from '@backstage/core-plugin-api';
 import { act, render } from '@testing-library/react';
 
 class MockAnalyticsApi {
@@ -462,9 +462,7 @@ const NotFoundErrorPage = () => {
 const BootErrorPage = ({ step, error }) => {
   throw new Error(`Reached BootError Page at step ${step} with error ${error}`);
 };
-const Progress = () => /* @__PURE__ */ React.createElement("div", {
-  "data-testid": "progress"
-});
+const Progress = () => /* @__PURE__ */ React.createElement("div", { "data-testid": "progress" });
 const NoRender = (_props) => null;
 function isExternalRouteRef(routeRef) {
   return String(routeRef).includes("{type=external,");
@@ -482,10 +480,7 @@ function createTestAppWrapper(options = {}) {
       BootErrorPage,
       NotFoundErrorPage,
       ErrorBoundaryFallback,
-      Router: ({ children }) => /* @__PURE__ */ React.createElement(MemoryRouter, {
-        initialEntries: routeEntries,
-        children
-      })
+      Router: ({ children }) => /* @__PURE__ */ React.createElement(MemoryRouter, { initialEntries: routeEntries, children })
     },
     icons: mockIcons,
     plugins: [],
@@ -494,9 +489,7 @@ function createTestAppWrapper(options = {}) {
         id: "light",
         title: "Test App Theme",
         variant: "light",
-        Provider: ({ children }) => /* @__PURE__ */ React.createElement(ThemeProvider, {
-          theme: lightTheme
-        }, /* @__PURE__ */ React.createElement(CssBaseline, null, children))
+        Provider: ({ children }) => /* @__PURE__ */ React.createElement(ThemeProvider, { theme: lightTheme }, /* @__PURE__ */ React.createElement(CssBaseline, null, children))
       }
     ],
     bindRoutes: ({ bind }) => {
@@ -520,11 +513,7 @@ function createTestAppWrapper(options = {}) {
       } else {
         attachComponentData(Page, "core.mountPoint", routeRef);
       }
-      return /* @__PURE__ */ React.createElement(Route, {
-        key: path,
-        path,
-        element: /* @__PURE__ */ React.createElement(Page, null)
-      });
+      return /* @__PURE__ */ React.createElement(Route, { key: path, path, element: /* @__PURE__ */ React.createElement(Page, null) });
     }
   );
   const AppProvider = app.getProvider();
@@ -615,6 +604,16 @@ function withLogCollector(logsToCollect, callback) {
   }
 }
 
+const MockPluginProvider = ({ children }) => {
+  const plugin = createPlugin({
+    id: "my-plugin",
+    __experimentalConfigure(_) {
+      return {};
+    }
+  });
+  return /* @__PURE__ */ React.createElement(PluginProvider, { plugin }, children);
+};
+
 class TestApiRegistry {
   constructor(apis) {
     this.apis = apis;
@@ -629,11 +628,14 @@ class TestApiRegistry {
   }
 }
 const TestApiProvider = (props) => {
-  return /* @__PURE__ */ React.createElement(ApiProvider, {
-    apis: TestApiRegistry.from(...props.apis),
-    children: props.children
-  });
+  return /* @__PURE__ */ React.createElement(
+    ApiProvider,
+    {
+      apis: TestApiRegistry.from(...props.apis),
+      children: props.children
+    }
+  );
 };
 
-export { MockAnalyticsApi, MockConfigApi, MockErrorApi, MockFetchApi, MockPermissionApi, MockStorageApi, TestApiProvider, TestApiRegistry, createTestAppWrapper, mockBreakpoint, renderInTestApp, renderWithEffects, setupRequestMockHandlers, withLogCollector, wrapInTestApp };
+export { MockAnalyticsApi, MockConfigApi, MockErrorApi, MockFetchApi, MockPermissionApi, MockPluginProvider, MockStorageApi, TestApiProvider, TestApiRegistry, createTestAppWrapper, mockBreakpoint, renderInTestApp, renderWithEffects, setupRequestMockHandlers, withLogCollector, wrapInTestApp };
 //# sourceMappingURL=index.esm.js.map