@backstage/test-utils 1.2.3-next.0 → 1.2.3-next.2

package/dist/index.d.ts

@@ -1,11 +1,86 @@
-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 { MatcherFunction } from '@testing-library/react';
+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 +88,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 +128,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 +165,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 +184,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 +266,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 +274,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 +304,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 +322,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 +419,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 +447,76 @@ 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:
+ * 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;
+    };
+};
+
+/**
+ * Returns a `@testing-library/react` valid MatcherFunction for supplied text
  *
- * ```tsx
- * renderInTestApp(
- *   <TestApiProvider apis={[[identityApiRef, mockIdentityApi]]}>
- *     {...}
- *   </TestApiProvider>
- * )
- * ```
+ * @param string - text Text to match by element's textContent
  *
- * 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 textContentMatcher: (text: string) => MatcherFunction;
+
+/**
+ * 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 { }