@backstage/frontend-test-utils 0.4.6-next.1 → 0.5.0-next.2

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # @backstage/frontend-test-utils
 
+## 0.5.0-next.2
+
+### Minor Changes
+
+- 09a6aad: **BREAKING**: Removed the `TestApiRegistry` class, use `TestApiProvider` directly instead, storing reused APIs in a variable, e.g. `const apis = [...] as const`.
+- d2ac2ec: Added `MockAlertApi` and `MockFeatureFlagsApi` implementations to the `mockApis` namespace. The mock implementations include useful testing methods like `clearAlerts()`, `waitForAlert()`, `getState()`, `setState()`, and `clearState()` for better test ergonomics.
+- 09a6aad: **BREAKING**: The `mockApis` namespace is no longer a re-export from `@backstage/test-utils`. It's now a standalone namespace with mock implementations of most core APIs. Mock API instances can be passed directly to `TestApiProvider`, `renderInTestApp`, and `renderTestApp` without needing `[apiRef, impl]` tuples. As part of this change, the `.factory()` method on some mocks has been removed, since it's now redundant.
+
+  ```tsx
+  // Before
+  import { mockApis } from '@backstage/frontend-test-utils';
+
+  renderInTestApp(<MyComponent />, {
+    apis: [[identityApiRef, mockApis.identity()]],
+  });
+
+  // After - mock APIs can be passed directly
+  renderInTestApp(<MyComponent />, {
+    apis: [mockApis.identity()],
+  });
+  ```
+
+  This change also adds `createApiMock`, a public utility for creating mock API factories, intended for plugin authors to create their own `.mock()` variants.
+
+### Patch Changes
+
+- 15ed3f9: Added `snapshot()` method to `ExtensionTester`, which returns a tree-shaped representation of the resolved extension hierarchy. Convenient to use with `toMatchInlineSnapshot()`.
+- 013ec22: Added `mountedRoutes` option to `renderTestApp` for binding route refs to paths, matching the existing option in `renderInTestApp`:
+
+  ```typescript
+  renderTestApp({
+    extensions: [...],
+    mountedRoutes: {
+      '/my-path': myRouteRef,
+    },
+  });
+  ```
+
+- a7e0d50: Prepare for React Router v7 migration by updating to v6.30.2 across all NFS packages and enabling v7 future flags. Convert routes from splat paths to parent/child structure with Outlet components.
+- Updated dependencies
+  - @backstage/core-app-api@1.19.5-next.1
+  - @backstage/frontend-plugin-api@0.14.0-next.2
+  - @backstage/frontend-app-api@0.15.0-next.2
+  - @backstage/core-plugin-api@1.12.3-next.1
+  - @backstage/plugin-permission-react@0.4.40-next.1
+  - @backstage/version-bridge@1.0.12-next.0
+  - @backstage/test-utils@1.7.15-next.2
+  - @backstage/plugin-app@0.4.0-next.2
+  - @backstage/plugin-app-react@0.1.1-next.0
+
 ## 0.4.6-next.1
 
 ### Patch Changes

package/dist/apis/AlertApi/MockAlertApi.esm.js

@@ -0,0 +1,64 @@
+import ObservableImpl from 'zen-observable';
+
+class MockAlertApi {
+  alerts = [];
+  observers = /* @__PURE__ */ new Set();
+  post(alert) {
+    this.alerts.push(alert);
+    this.observers.forEach((observer) => observer(alert));
+  }
+  alert$() {
+    return new ObservableImpl((subscriber) => {
+      const observer = (alert) => {
+        subscriber.next(alert);
+      };
+      this.observers.add(observer);
+      return () => {
+        this.observers.delete(observer);
+      };
+    });
+  }
+  /**
+   * Get all alerts that have been posted.
+   */
+  getAlerts() {
+    return this.alerts;
+  }
+  /**
+   * Clear all collected alerts.
+   */
+  clearAlerts() {
+    this.alerts.length = 0;
+  }
+  /**
+   * Wait for an alert matching the given predicate.
+   *
+   * @param predicate - Function to test each alert
+   * @param timeoutMs - Maximum time to wait in milliseconds
+   * @returns Promise that resolves with the matching alert
+   */
+  async waitForAlert(predicate, timeoutMs = 2e3) {
+    const existing = this.alerts.find(predicate);
+    if (existing) {
+      return existing;
+    }
+    const observers = this.observers;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        observers.delete(observer);
+        reject(new Error("Timed out waiting for alert"));
+      }, timeoutMs);
+      function observer(alert) {
+        if (predicate(alert)) {
+          clearTimeout(timeoutId);
+          observers.delete(observer);
+          resolve(alert);
+        }
+      }
+      observers.add(observer);
+    });
+  }
+}
+
+export { MockAlertApi };
+//# sourceMappingURL=MockAlertApi.esm.js.map

package/dist/apis/AlertApi/MockAlertApi.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockAlertApi.esm.js","sources":["../../../src/apis/AlertApi/MockAlertApi.ts"],"sourcesContent":["/*\n * Copyright 2025 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AlertMessage } from '@backstage/frontend-plugin-api';\nimport { AlertApi } from '@backstage/frontend-plugin-api';\nimport { Observable } from '@backstage/types';\nimport ObservableImpl from 'zen-observable';\n\n/**\n * Mock implementation of {@link @backstage/frontend-plugin-api#AlertApi} for testing alert behavior.\n *\n * @public\n * @example\n * ```ts\n * const alertApi = new MockAlertApi();\n * alertApi.post({ message: 'Test alert' });\n * expect(alertApi.getAlerts()).toHaveLength(1);\n * ```\n */\nexport class MockAlertApi implements AlertApi {\n  private readonly alerts: AlertMessage[] = [];\n  private readonly observers = new Set<(alert: AlertMessage) => void>();\n\n  post(alert: AlertMessage) {\n    this.alerts.push(alert);\n    this.observers.forEach(observer => observer(alert));\n  }\n\n  alert$(): Observable<AlertMessage> {\n    return new ObservableImpl(subscriber => {\n      const observer = (alert: AlertMessage) => {\n        subscriber.next(alert);\n      };\n      this.observers.add(observer);\n      return () => {\n        this.observers.delete(observer);\n      };\n    });\n  }\n\n  /**\n   * Get all alerts that have been posted.\n   */\n  getAlerts(): AlertMessage[] {\n    return this.alerts;\n  }\n\n  /**\n   * Clear all collected alerts.\n   */\n  clearAlerts(): void {\n    this.alerts.length = 0;\n  }\n\n  /**\n   * Wait for an alert matching the given predicate.\n   *\n   * @param predicate - Function to test each alert\n   * @param timeoutMs - Maximum time to wait in milliseconds\n   * @returns Promise that resolves with the matching alert\n   */\n  async waitForAlert(\n    predicate: (alert: AlertMessage) => boolean,\n    timeoutMs: number = 2000,\n  ): Promise<AlertMessage> {\n    const existing = this.alerts.find(predicate);\n    if (existing) {\n      return existing;\n    }\n    const observers = this.observers;\n\n    return new Promise<AlertMessage>((resolve, reject) => {\n      const timeoutId = setTimeout(() => {\n        observers.delete(observer);\n        reject(new Error('Timed out waiting for alert'));\n      }, timeoutMs);\n\n      function observer(alert: AlertMessage) {\n        if (predicate(alert)) {\n          clearTimeout(timeoutId);\n          observers.delete(observer);\n          resolve(alert);\n        }\n      }\n\n      observers.add(observer);\n    });\n  }\n}\n"],"names":[],"mappings":";;AAgCO,MAAM,YAAA,CAAiC;AAAA,EAC3B,SAAyB,EAAC;AAAA,EAC1B,SAAA,uBAAgB,GAAA,EAAmC;AAAA,EAEpE,KAAK,KAAA,EAAqB;AACxB,IAAA,IAAA,CAAK,MAAA,CAAO,KAAK,KAAK,CAAA;AACtB,IAAA,IAAA,CAAK,SAAA,CAAU,OAAA,CAAQ,CAAA,QAAA,KAAY,QAAA,CAAS,KAAK,CAAC,CAAA;AAAA,EACpD;AAAA,EAEA,MAAA,GAAmC;AACjC,IAAA,OAAO,IAAI,eAAe,CAAA,UAAA,KAAc;AACtC,MAAA,MAAM,QAAA,GAAW,CAAC,KAAA,KAAwB;AACxC,QAAA,UAAA,CAAW,KAAK,KAAK,CAAA;AAAA,MACvB,CAAA;AACA,MAAA,IAAA,CAAK,SAAA,CAAU,IAAI,QAAQ,CAAA;AAC3B,MAAA,OAAO,MAAM;AACX,QAAA,IAAA,CAAK,SAAA,CAAU,OAAO,QAAQ,CAAA;AAAA,MAChC,CAAA;AAAA,IACF,CAAC,CAAA;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKA,SAAA,GAA4B;AAC1B,IAAA,OAAO,IAAA,CAAK,MAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,WAAA,GAAoB;AAClB,IAAA,IAAA,CAAK,OAAO,MAAA,GAAS,CAAA;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,YAAA,CACJ,SAAA,EACA,SAAA,GAAoB,GAAA,EACG;AACvB,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,MAAA,CAAO,IAAA,CAAK,SAAS,CAAA;AAC3C,IAAA,IAAI,QAAA,EAAU;AACZ,MAAA,OAAO,QAAA;AAAA,IACT;AACA,IAAA,MAAM,YAAY,IAAA,CAAK,SAAA;AAEvB,IAAA,OAAO,IAAI,OAAA,CAAsB,CAAC,OAAA,EAAS,MAAA,KAAW;AACpD,MAAA,MAAM,SAAA,GAAY,WAAW,MAAM;AACjC,QAAA,SAAA,CAAU,OAAO,QAAQ,CAAA;AACzB,QAAA,MAAA,CAAO,IAAI,KAAA,CAAM,6BAA6B,CAAC,CAAA;AAAA,MACjD,GAAG,SAAS,CAAA;AAEZ,MAAA,SAAS,SAAS,KAAA,EAAqB;AACrC,QAAA,IAAI,SAAA,CAAU,KAAK,CAAA,EAAG;AACpB,UAAA,YAAA,CAAa,SAAS,CAAA;AACtB,UAAA,SAAA,CAAU,OAAO,QAAQ,CAAA;AACzB,UAAA,OAAA,CAAQ,KAAK,CAAA;AAAA,QACf;AAAA,MACF;AAEA,MAAA,SAAA,CAAU,IAAI,QAAQ,CAAA;AAAA,IACxB,CAAC,CAAA;AAAA,EACH;AACF;;;;"}

package/dist/apis/ConfigApi/MockConfigApi.esm.js

@@ -0,0 +1,76 @@
+import { ConfigReader } from '@backstage/config';
+
+class MockConfigApi {
+  config;
+  // NOTE: not extending in order to avoid inheriting the static `.fromConfigs`
+  constructor({ data }) {
+    this.config = new ConfigReader(data);
+  }
+  /** {@inheritdoc @backstage/config#Config.has} */
+  has(key) {
+    return this.config.has(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.keys} */
+  keys() {
+    return this.config.keys();
+  }
+  /** {@inheritdoc @backstage/config#Config.get} */
+  get(key) {
+    return this.config.get(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getOptional} */
+  getOptional(key) {
+    return this.config.getOptional(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getConfig} */
+  getConfig(key) {
+    return this.config.getConfig(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getOptionalConfig} */
+  getOptionalConfig(key) {
+    return this.config.getOptionalConfig(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getConfigArray} */
+  getConfigArray(key) {
+    return this.config.getConfigArray(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getOptionalConfigArray} */
+  getOptionalConfigArray(key) {
+    return this.config.getOptionalConfigArray(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getNumber} */
+  getNumber(key) {
+    return this.config.getNumber(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getOptionalNumber} */
+  getOptionalNumber(key) {
+    return this.config.getOptionalNumber(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getBoolean} */
+  getBoolean(key) {
+    return this.config.getBoolean(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getOptionalBoolean} */
+  getOptionalBoolean(key) {
+    return this.config.getOptionalBoolean(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getString} */
+  getString(key) {
+    return this.config.getString(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getOptionalString} */
+  getOptionalString(key) {
+    return this.config.getOptionalString(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getStringArray} */
+  getStringArray(key) {
+    return this.config.getStringArray(key);
+  }
+  /** {@inheritdoc @backstage/config#Config.getOptionalStringArray} */
+  getOptionalStringArray(key) {
+    return this.config.getOptionalStringArray(key);
+  }
+}
+
+export { MockConfigApi };
+//# sourceMappingURL=MockConfigApi.esm.js.map

package/dist/apis/ConfigApi/MockConfigApi.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockConfigApi.esm.js","sources":["../../../src/apis/ConfigApi/MockConfigApi.ts"],"sourcesContent":["/*\n * Copyright 2022 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Config, ConfigReader } from '@backstage/config';\nimport { JsonObject, JsonValue } from '@backstage/types';\nimport { ConfigApi } from '@backstage/core-plugin-api';\n\n/**\n * MockConfigApi is a thin wrapper around {@link @backstage/config#ConfigReader}\n * that can be used to mock configuration using a plain object.\n *\n * @public\n * @example\n * ```tsx\n * const mockConfig = new MockConfigApi({\n *   data: { app: { baseUrl: 'https://example.com' } },\n * });\n *\n * const rendered = await renderInTestApp(\n *   <TestApiProvider apis={[[configApiRef, mockConfig]]}>\n *     <MyTestedComponent />\n *   </TestApiProvider>,\n * );\n * ```\n */\nexport class MockConfigApi implements ConfigApi {\n  private readonly config: ConfigReader;\n\n  // NOTE: not extending in order to avoid inheriting the static `.fromConfigs`\n  constructor({ data }: { data: JsonObject }) {\n    this.config = new ConfigReader(data);\n  }\n\n  /** {@inheritdoc @backstage/config#Config.has} */\n  has(key: string): boolean {\n    return this.config.has(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.keys} */\n  keys(): string[] {\n    return this.config.keys();\n  }\n  /** {@inheritdoc @backstage/config#Config.get} */\n  get<T = JsonValue>(key?: string): T {\n    return this.config.get(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getOptional} */\n  getOptional<T = JsonValue>(key?: string): T | undefined {\n    return this.config.getOptional(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getConfig} */\n  getConfig(key: string): Config {\n    return this.config.getConfig(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getOptionalConfig} */\n  getOptionalConfig(key: string): Config | undefined {\n    return this.config.getOptionalConfig(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getConfigArray} */\n  getConfigArray(key: string): Config[] {\n    return this.config.getConfigArray(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getOptionalConfigArray} */\n  getOptionalConfigArray(key: string): Config[] | undefined {\n    return this.config.getOptionalConfigArray(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getNumber} */\n  getNumber(key: string): number {\n    return this.config.getNumber(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getOptionalNumber} */\n  getOptionalNumber(key: string): number | undefined {\n    return this.config.getOptionalNumber(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getBoolean} */\n  getBoolean(key: string): boolean {\n    return this.config.getBoolean(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getOptionalBoolean} */\n  getOptionalBoolean(key: string): boolean | undefined {\n    return this.config.getOptionalBoolean(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getString} */\n  getString(key: string): string {\n    return this.config.getString(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getOptionalString} */\n  getOptionalString(key: string): string | undefined {\n    return this.config.getOptionalString(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getStringArray} */\n  getStringArray(key: string): string[] {\n    return this.config.getStringArray(key);\n  }\n  /** {@inheritdoc @backstage/config#Config.getOptionalStringArray} */\n  getOptionalStringArray(key: string): string[] | undefined {\n    return this.config.getOptionalStringArray(key);\n  }\n}\n"],"names":[],"mappings":";;AAsCO,MAAM,aAAA,CAAmC;AAAA,EAC7B,MAAA;AAAA;AAAA,EAGjB,WAAA,CAAY,EAAE,IAAA,EAAK,EAAyB;AAC1C,IAAA,IAAA,CAAK,MAAA,GAAS,IAAI,YAAA,CAAa,IAAI,CAAA;AAAA,EACrC;AAAA;AAAA,EAGA,IAAI,GAAA,EAAsB;AACxB,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,GAAG,CAAA;AAAA,EAC5B;AAAA;AAAA,EAEA,IAAA,GAAiB;AACf,IAAA,OAAO,IAAA,CAAK,OAAO,IAAA,EAAK;AAAA,EAC1B;AAAA;AAAA,EAEA,IAAmB,GAAA,EAAiB;AAClC,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,GAAG,CAAA;AAAA,EAC5B;AAAA;AAAA,EAEA,YAA2B,GAAA,EAA6B;AACtD,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,WAAA,CAAY,GAAG,CAAA;AAAA,EACpC;AAAA;AAAA,EAEA,UAAU,GAAA,EAAqB;AAC7B,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,SAAA,CAAU,GAAG,CAAA;AAAA,EAClC;AAAA;AAAA,EAEA,kBAAkB,GAAA,EAAiC;AACjD,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,iBAAA,CAAkB,GAAG,CAAA;AAAA,EAC1C;AAAA;AAAA,EAEA,eAAe,GAAA,EAAuB;AACpC,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,cAAA,CAAe,GAAG,CAAA;AAAA,EACvC;AAAA;AAAA,EAEA,uBAAuB,GAAA,EAAmC;AACxD,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,sBAAA,CAAuB,GAAG,CAAA;AAAA,EAC/C;AAAA;AAAA,EAEA,UAAU,GAAA,EAAqB;AAC7B,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,SAAA,CAAU,GAAG,CAAA;AAAA,EAClC;AAAA;AAAA,EAEA,kBAAkB,GAAA,EAAiC;AACjD,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,iBAAA,CAAkB,GAAG,CAAA;AAAA,EAC1C;AAAA;AAAA,EAEA,WAAW,GAAA,EAAsB;AAC/B,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,UAAA,CAAW,GAAG,CAAA;AAAA,EACnC;AAAA;AAAA,EAEA,mBAAmB,GAAA,EAAkC;AACnD,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,kBAAA,CAAmB,GAAG,CAAA;AAAA,EAC3C;AAAA;AAAA,EAEA,UAAU,GAAA,EAAqB;AAC7B,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,SAAA,CAAU,GAAG,CAAA;AAAA,EAClC;AAAA;AAAA,EAEA,kBAAkB,GAAA,EAAiC;AACjD,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,iBAAA,CAAkB,GAAG,CAAA;AAAA,EAC1C;AAAA;AAAA,EAEA,eAAe,GAAA,EAAuB;AACpC,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,cAAA,CAAe,GAAG,CAAA;AAAA,EACvC;AAAA;AAAA,EAEA,uBAAuB,GAAA,EAAmC;AACxD,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,sBAAA,CAAuB,GAAG,CAAA;AAAA,EAC/C;AACF;;;;"}

package/dist/apis/ErrorApi/MockErrorApi.esm.js

@@ -0,0 +1,44 @@
+const nullObservable = {
+  subscribe: () => ({ unsubscribe: () => {
+  }, closed: true }),
+  [Symbol.observable]() {
+    return this;
+  }
+};
+class MockErrorApi {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  errors = new Array();
+  waiters = /* @__PURE__ */ new Set();
+  post(error, context) {
+    if (this.options.collect) {
+      this.errors.push({ error, context });
+      for (const waiter of this.waiters) {
+        if (waiter.pattern.test(error.message)) {
+          this.waiters.delete(waiter);
+          waiter.resolve({ error, context });
+        }
+      }
+      return;
+    }
+    throw new Error(`MockErrorApi received unexpected error, ${error}`);
+  }
+  error$() {
+    return nullObservable;
+  }
+  getErrors() {
+    return this.errors;
+  }
+  waitForError(pattern, timeoutMs = 2e3) {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject(new Error("Timed out waiting for error"));
+      }, timeoutMs);
+      this.waiters.add({ resolve, pattern });
+    });
+  }
+}
+
+export { MockErrorApi };
+//# sourceMappingURL=MockErrorApi.esm.js.map

package/dist/apis/ErrorApi/MockErrorApi.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockErrorApi.esm.js","sources":["../../../src/apis/ErrorApi/MockErrorApi.ts"],"sourcesContent":["/*\n * Copyright 2020 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ErrorApi,\n  ErrorApiError,\n  ErrorApiErrorContext,\n} from '@backstage/core-plugin-api';\nimport { Observable } from '@backstage/types';\n\n/**\n * Constructor arguments for {@link MockErrorApi}\n * @public\n */\nexport type MockErrorApiOptions = {\n  // Need to be true if getErrors is used in testing.\n  collect?: boolean;\n};\n\n/**\n * ErrorWithContext contains error and ErrorApiErrorContext\n * @public\n */\nexport type ErrorWithContext = {\n  error: ErrorApiError;\n  context?: ErrorApiErrorContext;\n};\n\ntype Waiter = {\n  pattern: RegExp;\n  resolve: (err: ErrorWithContext) => void;\n};\n\nconst nullObservable = {\n  subscribe: () => ({ unsubscribe: () => {}, closed: true }),\n\n  [Symbol.observable]() {\n    return this;\n  },\n};\n\n/**\n * Mock implementation of the {@link core-plugin-api#ErrorApi} to be used in tests.\n * Includes withForError and getErrors methods for error testing.\n * @public\n */\nexport class MockErrorApi implements ErrorApi {\n  private readonly errors = new Array<ErrorWithContext>();\n  private readonly waiters = new Set<Waiter>();\n\n  constructor(private readonly options: MockErrorApiOptions = {}) {}\n\n  post(error: ErrorApiError, context?: ErrorApiErrorContext) {\n    if (this.options.collect) {\n      this.errors.push({ error, context });\n\n      for (const waiter of this.waiters) {\n        if (waiter.pattern.test(error.message)) {\n          this.waiters.delete(waiter);\n          waiter.resolve({ error, context });\n        }\n      }\n\n      return;\n    }\n\n    throw new Error(`MockErrorApi received unexpected error, ${error}`);\n  }\n\n  error$(): Observable<{\n    error: ErrorApiError;\n    context?: ErrorApiErrorContext;\n  }> {\n    return nullObservable;\n  }\n\n  getErrors(): ErrorWithContext[] {\n    return this.errors;\n  }\n\n  waitForError(\n    pattern: RegExp,\n    timeoutMs: number = 2000,\n  ): Promise<ErrorWithContext> {\n    return new Promise<ErrorWithContext>((resolve, reject) => {\n      setTimeout(() => {\n        reject(new Error('Timed out waiting for error'));\n      }, timeoutMs);\n\n      this.waiters.add({ resolve, pattern });\n    });\n  }\n}\n"],"names":[],"mappings":"AA8CA,MAAM,cAAA,GAAiB;AAAA,EACrB,SAAA,EAAW,OAAO,EAAE,WAAA,EAAa,MAAM;AAAA,EAAC,CAAA,EAAG,QAAQ,IAAA,EAAK,CAAA;AAAA,EAExD,CAAC,MAAA,CAAO,UAAU,CAAA,GAAI;AACpB,IAAA,OAAO,IAAA;AAAA,EACT;AACF,CAAA;AAOO,MAAM,YAAA,CAAiC;AAAA,EAI5C,WAAA,CAA6B,OAAA,GAA+B,EAAC,EAAG;AAAnC,IAAA,IAAA,CAAA,OAAA,GAAA,OAAA;AAAA,EAAoC;AAAA,EAHhD,MAAA,GAAS,IAAI,KAAA,EAAwB;AAAA,EACrC,OAAA,uBAAc,GAAA,EAAY;AAAA,EAI3C,IAAA,CAAK,OAAsB,OAAA,EAAgC;AACzD,IAAA,IAAI,IAAA,CAAK,QAAQ,OAAA,EAAS;AACxB,MAAA,IAAA,CAAK,MAAA,CAAO,IAAA,CAAK,EAAE,KAAA,EAAO,SAAS,CAAA;AAEnC,MAAA,KAAA,MAAW,MAAA,IAAU,KAAK,OAAA,EAAS;AACjC,QAAA,IAAI,MAAA,CAAO,OAAA,CAAQ,IAAA,CAAK,KAAA,CAAM,OAAO,CAAA,EAAG;AACtC,UAAA,IAAA,CAAK,OAAA,CAAQ,OAAO,MAAM,CAAA;AAC1B,UAAA,MAAA,CAAO,OAAA,CAAQ,EAAE,KAAA,EAAO,OAAA,EAAS,CAAA;AAAA,QACnC;AAAA,MACF;AAEA,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,wCAAA,EAA2C,KAAK,CAAA,CAAE,CAAA;AAAA,EACpE;AAAA,EAEA,MAAA,GAGG;AACD,IAAA,OAAO,cAAA;AAAA,EACT;AAAA,EAEA,SAAA,GAAgC;AAC9B,IAAA,OAAO,IAAA,CAAK,MAAA;AAAA,EACd;AAAA,EAEA,YAAA,CACE,OAAA,EACA,SAAA,GAAoB,GAAA,EACO;AAC3B,IAAA,OAAO,IAAI,OAAA,CAA0B,CAAC,OAAA,EAAS,MAAA,KAAW;AACxD,MAAA,UAAA,CAAW,MAAM;AACf,QAAA,MAAA,CAAO,IAAI,KAAA,CAAM,6BAA6B,CAAC,CAAA;AAAA,MACjD,GAAG,SAAS,CAAA;AAEZ,MAAA,IAAA,CAAK,OAAA,CAAQ,GAAA,CAAI,EAAE,OAAA,EAAS,SAAS,CAAA;AAAA,IACvC,CAAC,CAAA;AAAA,EACH;AACF;;;;"}

package/dist/apis/FeatureFlagsApi/MockFeatureFlagsApi.esm.js

@@ -0,0 +1,55 @@
+import { FeatureFlagState } from '@backstage/frontend-plugin-api';
+
+class MockFeatureFlagsApi {
+  registeredFlags = [];
+  states;
+  constructor(options) {
+    this.states = new Map(Object.entries(options?.initialStates ?? {}));
+  }
+  registerFlag(flag) {
+    if (!this.registeredFlags.some((f) => f.name === flag.name)) {
+      this.registeredFlags.push(flag);
+    }
+  }
+  getRegisteredFlags() {
+    return this.registeredFlags;
+  }
+  isActive(name) {
+    return this.states.get(name) === FeatureFlagState.Active;
+  }
+  save(options) {
+    if (options.merge) {
+      for (const [name, state] of Object.entries(options.states)) {
+        this.states.set(name, state);
+      }
+    } else {
+      this.states.clear();
+      for (const [name, state] of Object.entries(options.states)) {
+        this.states.set(name, state);
+      }
+    }
+  }
+  /**
+   * Get the current state of all feature flags as a record.
+   */
+  getState() {
+    return Object.fromEntries(this.states);
+  }
+  /**
+   * Set the state of multiple feature flags.
+   */
+  setState(states) {
+    for (const [name, state] of Object.entries(states)) {
+      this.states.set(name, state);
+    }
+  }
+  /**
+   * Clear all feature flag states.
+   */
+  clearState() {
+    this.states.clear();
+  }
+}
+
+export { MockFeatureFlagsApi };
+//# sourceMappingURL=MockFeatureFlagsApi.esm.js.map

package/dist/apis/FeatureFlagsApi/MockFeatureFlagsApi.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockFeatureFlagsApi.esm.js","sources":["../../../src/apis/FeatureFlagsApi/MockFeatureFlagsApi.ts"],"sourcesContent":["/*\n * Copyright 2025 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FeatureFlag,\n  FeatureFlagsApi,\n  FeatureFlagsSaveOptions,\n  FeatureFlagState,\n} from '@backstage/frontend-plugin-api';\n\n/**\n * Options for configuring {@link MockFeatureFlagsApi}.\n *\n * @public\n */\nexport interface MockFeatureFlagsApiOptions {\n  /**\n   * Initial feature flag states.\n   */\n  initialStates?: Record<string, FeatureFlagState>;\n}\n\n/**\n * Mock implementation of {@link @backstage/frontend-plugin-api#FeatureFlagsApi} for testing feature flag behavior.\n *\n * @public\n * @example\n * ```ts\n * const api = new MockFeatureFlagsApi({\n *   initialStates: { 'my-feature': FeatureFlagState.Active }\n * });\n * expect(api.isActive('my-feature')).toBe(true);\n * ```\n */\nexport class MockFeatureFlagsApi implements FeatureFlagsApi {\n  private readonly registeredFlags: FeatureFlag[] = [];\n  private readonly states: Map<string, FeatureFlagState>;\n\n  constructor(options?: MockFeatureFlagsApiOptions) {\n    this.states = new Map(Object.entries(options?.initialStates ?? {}));\n  }\n\n  registerFlag(flag: FeatureFlag): void {\n    if (!this.registeredFlags.some(f => f.name === flag.name)) {\n      this.registeredFlags.push(flag);\n    }\n  }\n\n  getRegisteredFlags(): FeatureFlag[] {\n    return this.registeredFlags;\n  }\n\n  isActive(name: string): boolean {\n    return this.states.get(name) === FeatureFlagState.Active;\n  }\n\n  save(options: FeatureFlagsSaveOptions): void {\n    if (options.merge) {\n      for (const [name, state] of Object.entries(options.states)) {\n        this.states.set(name, state);\n      }\n    } else {\n      this.states.clear();\n      for (const [name, state] of Object.entries(options.states)) {\n        this.states.set(name, state);\n      }\n    }\n  }\n\n  /**\n   * Get the current state of all feature flags as a record.\n   */\n  getState(): Record<string, FeatureFlagState> {\n    return Object.fromEntries(this.states);\n  }\n\n  /**\n   * Set the state of multiple feature flags.\n   */\n  setState(states: Record<string, FeatureFlagState>): void {\n    for (const [name, state] of Object.entries(states)) {\n      this.states.set(name, state);\n    }\n  }\n\n  /**\n   * Clear all feature flag states.\n   */\n  clearState(): void {\n    this.states.clear();\n  }\n}\n"],"names":[],"mappings":";;AA+CO,MAAM,mBAAA,CAA+C;AAAA,EACzC,kBAAiC,EAAC;AAAA,EAClC,MAAA;AAAA,EAEjB,YAAY,OAAA,EAAsC;AAChD,IAAA,IAAA,CAAK,MAAA,GAAS,IAAI,GAAA,CAAI,MAAA,CAAO,QAAQ,OAAA,EAAS,aAAA,IAAiB,EAAE,CAAC,CAAA;AAAA,EACpE;AAAA,EAEA,aAAa,IAAA,EAAyB;AACpC,IAAA,IAAI,CAAC,KAAK,eAAA,CAAgB,IAAA,CAAK,OAAK,CAAA,CAAE,IAAA,KAAS,IAAA,CAAK,IAAI,CAAA,EAAG;AACzD,MAAA,IAAA,CAAK,eAAA,CAAgB,KAAK,IAAI,CAAA;AAAA,IAChC;AAAA,EACF;AAAA,EAEA,kBAAA,GAAoC;AAClC,IAAA,OAAO,IAAA,CAAK,eAAA;AAAA,EACd;AAAA,EAEA,SAAS,IAAA,EAAuB;AAC9B,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,IAAI,MAAM,gBAAA,CAAiB,MAAA;AAAA,EACpD;AAAA,EAEA,KAAK,OAAA,EAAwC;AAC3C,IAAA,IAAI,QAAQ,KAAA,EAAO;AACjB,MAAA,KAAA,MAAW,CAAC,MAAM,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,OAAA,CAAQ,MAAM,CAAA,EAAG;AAC1D,QAAA,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,IAAA,EAAM,KAAK,CAAA;AAAA,MAC7B;AAAA,IACF,CAAA,MAAO;AACL,MAAA,IAAA,CAAK,OAAO,KAAA,EAAM;AAClB,MAAA,KAAA,MAAW,CAAC,MAAM,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,OAAA,CAAQ,MAAM,CAAA,EAAG;AAC1D,QAAA,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,IAAA,EAAM,KAAK,CAAA;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,QAAA,GAA6C;AAC3C,IAAA,OAAO,MAAA,CAAO,WAAA,CAAY,IAAA,CAAK,MAAM,CAAA;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA,EAKA,SAAS,MAAA,EAAgD;AACvD,IAAA,KAAA,MAAW,CAAC,IAAA,EAAM,KAAK,KAAK,MAAA,CAAO,OAAA,CAAQ,MAAM,CAAA,EAAG;AAClD,MAAA,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,IAAA,EAAM,KAAK,CAAA;AAAA,IAC7B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,UAAA,GAAmB;AACjB,IAAA,IAAA,CAAK,OAAO,KAAA,EAAM;AAAA,EACpB;AACF;;;;"}

package/dist/apis/FetchApi/MockFetchApi.esm.js

@@ -0,0 +1,56 @@
+import { createFetchApi, FetchMiddlewares } from '@backstage/core-app-api';
+
+class MockFetchApi {
+  implementation;
+  /**
+   * Creates a mock {@link @backstage/core-plugin-api#FetchApi}.
+   */
+  constructor(options) {
+    this.implementation = build(options);
+  }
+  /** {@inheritdoc @backstage/core-plugin-api#FetchApi.fetch} */
+  get fetch() {
+    return this.implementation.fetch;
+  }
+}
+function build(options) {
+  return createFetchApi({
+    baseImplementation: baseImplementation(options),
+    middleware: [
+      resolvePluginProtocol(options),
+      injectIdentityAuth(options)
+    ].filter((x) => Boolean(x))
+  });
+}
+function baseImplementation(options) {
+  const implementation = options?.baseImplementation;
+  if (!implementation) {
+    return (input, init) => global.fetch(input, init);
+  } else if (implementation === "none") {
+    return () => Promise.resolve(new Response());
+  }
+  return implementation;
+}
+function resolvePluginProtocol(allOptions) {
+  const options = allOptions?.resolvePluginProtocol;
+  if (!options) {
+    return void 0;
+  }
+  return FetchMiddlewares.resolvePluginProtocol({
+    discoveryApi: options.discoveryApi
+  });
+}
+function injectIdentityAuth(allOptions) {
+  const options = allOptions?.injectIdentityAuth;
+  if (!options) {
+    return void 0;
+  }
+  const identityApi = "token" in options ? { getCredentials: async () => ({ token: options.token }) } : options.identityApi;
+  return FetchMiddlewares.injectIdentityAuth({
+    identityApi,
+    allowUrl: () => true
+  });
+}
+
+export { MockFetchApi };
+//# sourceMappingURL=MockFetchApi.esm.js.map

package/dist/apis/FetchApi/MockFetchApi.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockFetchApi.esm.js","sources":["../../../src/apis/FetchApi/MockFetchApi.ts"],"sourcesContent":["/*\n * Copyright 2022 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  createFetchApi,\n  FetchMiddleware,\n  FetchMiddlewares,\n} from '@backstage/core-app-api';\nimport {\n  DiscoveryApi,\n  FetchApi,\n  IdentityApi,\n} from '@backstage/core-plugin-api';\n/**\n * The options given when constructing a {@link MockFetchApi}.\n *\n * @public\n */\nexport interface MockFetchApiOptions {\n  /**\n   * Define the underlying base `fetch` implementation.\n   *\n   * @defaultValue undefined\n   * @remarks\n   *\n   * Leaving out this parameter or passing `undefined`, makes the API use the\n   * global `fetch` implementation to make real network requests.\n   *\n   * `'none'` swallows all calls and makes no requests at all.\n   *\n   * You can also pass in any `fetch` compatible callback, such as a\n   * `jest.fn()`, if you want to use a custom implementation or to just track\n   * and assert on calls.\n   */\n  baseImplementation?: undefined | 'none' | typeof fetch;\n\n  /**\n   * Add translation from `plugin://` URLs to concrete http(s) URLs, basically\n   * simulating what\n   * {@link @backstage/core-app-api#FetchMiddlewares.resolvePluginProtocol}\n   * does.\n   *\n   * @defaultValue undefined\n   * @remarks\n   *\n   * Leaving out this parameter or passing `undefined`, disables plugin protocol\n   * translation.\n   *\n   * To enable the feature, pass in a discovery API which is then used to\n   * resolve the URLs.\n   */\n  resolvePluginProtocol?:\n    | undefined\n    | { discoveryApi: Pick<DiscoveryApi, 'getBaseUrl'> };\n\n  /**\n   * Add token based Authorization headers to requests, basically simulating\n   * what {@link @backstage/core-app-api#FetchMiddlewares.injectIdentityAuth}\n   * does.\n   *\n   * @defaultValue undefined\n   * @remarks\n   *\n   * Leaving out this parameter or passing `undefined`, disables auth injection.\n   *\n   * To enable the feature, pass in either a static token or an identity API\n   * which is queried on each request for a token.\n   */\n  injectIdentityAuth?:\n    | undefined\n    | { token: string }\n    | { identityApi: Pick<IdentityApi, 'getCredentials'> };\n}\n\n/**\n * A test helper implementation of {@link @backstage/core-plugin-api#FetchApi}.\n *\n * @public\n */\nexport class MockFetchApi implements FetchApi {\n  private readonly implementation: FetchApi;\n\n  /**\n   * Creates a mock {@link @backstage/core-plugin-api#FetchApi}.\n   */\n  constructor(options?: MockFetchApiOptions) {\n    this.implementation = build(options);\n  }\n\n  /** {@inheritdoc @backstage/core-plugin-api#FetchApi.fetch} */\n  get fetch(): typeof fetch {\n    return this.implementation.fetch;\n  }\n}\n\n//\n// Helpers\n//\n\nfunction build(options?: MockFetchApiOptions): FetchApi {\n  return createFetchApi({\n    baseImplementation: baseImplementation(options),\n    middleware: [\n      resolvePluginProtocol(options),\n      injectIdentityAuth(options),\n    ].filter((x): x is FetchMiddleware => Boolean(x)),\n  });\n}\n\nfunction baseImplementation(\n  options: MockFetchApiOptions | undefined,\n): typeof fetch {\n  const implementation = options?.baseImplementation;\n  if (!implementation) {\n    // Return a wrapper that evaluates global.fetch at call time, not construction time.\n    // This allows MSW to patch global.fetch after MockFetchApi is constructed.\n    return (input, init) => global.fetch(input, init);\n  } else if (implementation === 'none') {\n    return () => Promise.resolve(new Response());\n  }\n  return implementation;\n}\n\nfunction resolvePluginProtocol(\n  allOptions: MockFetchApiOptions | undefined,\n): FetchMiddleware | undefined {\n  const options = allOptions?.resolvePluginProtocol;\n  if (!options) {\n    return undefined;\n  }\n\n  return FetchMiddlewares.resolvePluginProtocol({\n    discoveryApi: options.discoveryApi,\n  });\n}\n\nfunction injectIdentityAuth(\n  allOptions: MockFetchApiOptions | undefined,\n): FetchMiddleware | undefined {\n  const options = allOptions?.injectIdentityAuth;\n  if (!options) {\n    return undefined;\n  }\n\n  const identityApi: Pick<IdentityApi, 'getCredentials'> =\n    'token' in options\n      ? { getCredentials: async () => ({ token: options.token }) }\n      : options.identityApi;\n\n  return FetchMiddlewares.injectIdentityAuth({\n    identityApi: identityApi as IdentityApi,\n    allowUrl: () => true,\n  });\n}\n"],"names":[],"mappings":";;AA4FO,MAAM,YAAA,CAAiC;AAAA,EAC3B,cAAA;AAAA;AAAA;AAAA;AAAA,EAKjB,YAAY,OAAA,EAA+B;AACzC,IAAA,IAAA,CAAK,cAAA,GAAiB,MAAM,OAAO,CAAA;AAAA,EACrC;AAAA;AAAA,EAGA,IAAI,KAAA,GAAsB;AACxB,IAAA,OAAO,KAAK,cAAA,CAAe,KAAA;AAAA,EAC7B;AACF;AAMA,SAAS,MAAM,OAAA,EAAyC;AACtD,EAAA,OAAO,cAAA,CAAe;AAAA,IACpB,kBAAA,EAAoB,mBAAmB,OAAO,CAAA;AAAA,IAC9C,UAAA,EAAY;AAAA,MACV,sBAAsB,OAAO,CAAA;AAAA,MAC7B,mBAAmB,OAAO;AAAA,MAC1B,MAAA,CAAO,CAAC,CAAA,KAA4B,OAAA,CAAQ,CAAC,CAAC;AAAA,GACjD,CAAA;AACH;AAEA,SAAS,mBACP,OAAA,EACc;AACd,EAAA,MAAM,iBAAiB,OAAA,EAAS,kBAAA;AAChC,EAAA,IAAI,CAAC,cAAA,EAAgB;AAGnB,IAAA,OAAO,CAAC,KAAA,EAAO,IAAA,KAAS,MAAA,CAAO,KAAA,CAAM,OAAO,IAAI,CAAA;AAAA,EAClD,CAAA,MAAA,IAAW,mBAAmB,MAAA,EAAQ;AACpC,IAAA,OAAO,MAAM,OAAA,CAAQ,OAAA,CAAQ,IAAI,UAAU,CAAA;AAAA,EAC7C;AACA,EAAA,OAAO,cAAA;AACT;AAEA,SAAS,sBACP,UAAA,EAC6B;AAC7B,EAAA,MAAM,UAAU,UAAA,EAAY,qBAAA;AAC5B,EAAA,IAAI,CAAC,OAAA,EAAS;AACZ,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,OAAO,iBAAiB,qBAAA,CAAsB;AAAA,IAC5C,cAAc,OAAA,CAAQ;AAAA,GACvB,CAAA;AACH;AAEA,SAAS,mBACP,UAAA,EAC6B;AAC7B,EAAA,MAAM,UAAU,UAAA,EAAY,kBAAA;AAC5B,EAAA,IAAI,CAAC,OAAA,EAAS;AACZ,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,MAAM,WAAA,GACJ,OAAA,IAAW,OAAA,GACP,EAAE,cAAA,EAAgB,aAAa,EAAE,KAAA,EAAO,OAAA,CAAQ,KAAA,EAAM,CAAA,EAAG,GACzD,OAAA,CAAQ,WAAA;AAEd,EAAA,OAAO,iBAAiB,kBAAA,CAAmB;AAAA,IACzC,WAAA;AAAA,IACA,UAAU,MAAM;AAAA,GACjB,CAAA;AACH;;;;"}

package/dist/apis/MockWithApiFactory.esm.js

@@ -0,0 +1,28 @@
+const mockApiFactorySymbol = /* @__PURE__ */ Symbol.for("@backstage/mock-api");
+function mockWithApiFactory(apiRef, implementation) {
+  const marked = implementation;
+  marked[mockApiFactorySymbol] = {
+    api: apiRef,
+    deps: {},
+    factory: () => implementation
+  };
+  return marked;
+}
+function attachMockApiFactory(apiRef, implementation) {
+  const marked = implementation;
+  marked[mockApiFactorySymbol] = {
+    api: apiRef,
+    deps: {},
+    factory: () => implementation
+  };
+  return marked;
+}
+function getMockApiFactory(value) {
+  if (typeof value === "object" && value !== null && mockApiFactorySymbol in value && typeof value[mockApiFactorySymbol] === "object") {
+    return value[mockApiFactorySymbol];
+  }
+  return void 0;
+}
+
+export { attachMockApiFactory, getMockApiFactory, mockApiFactorySymbol, mockWithApiFactory };
+//# sourceMappingURL=MockWithApiFactory.esm.js.map

package/dist/apis/MockWithApiFactory.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockWithApiFactory.esm.js","sources":["../../src/apis/MockWithApiFactory.ts"],"sourcesContent":["/*\n * Copyright 2025 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ApiRef } from '@backstage/frontend-plugin-api';\nimport { ApiFactory } from '@backstage/frontend-plugin-api';\n\n/**\n * Symbol used to mark mock API instances with their corresponding API factory.\n *\n * @ignore\n */\nexport const mockApiFactorySymbol = Symbol.for('@backstage/mock-api');\n\n/**\n * Symbol used to mark mock API instances with their corresponding API factory.\n * This allows mock APIs to be passed directly to test utilities without\n * needing to explicitly provide the [apiRef, implementation] tuple.\n *\n * @public\n */\nexport type MockApiFactorySymbol = typeof mockApiFactorySymbol;\n\n/**\n * Type for an API instance that has been marked as a mock API.\n *\n * @public\n */\nexport type MockWithApiFactory<TApi> = TApi & {\n  [mockApiFactorySymbol]: ApiFactory<TApi, TApi, {}>;\n};\n\n/**\n * Helper to attach mock API metadata to an instance.\n *\n * @internal\n */\nexport function mockWithApiFactory<TApi, TImpl extends TApi = TApi>(\n  apiRef: ApiRef<TApi>,\n  implementation: TImpl,\n): TImpl & { [mockApiFactorySymbol]: ApiFactory<TApi, TApi, {}> } {\n  const marked = implementation as TImpl & {\n    [mockApiFactorySymbol]: ApiFactory<TApi, TApi, {}>;\n  };\n  (marked as any)[mockApiFactorySymbol] = {\n    api: apiRef,\n    deps: {},\n    factory: () => implementation,\n  };\n  return marked;\n}\n\n/**\n * Attaches mock API factory metadata to an API instance, allowing it to be\n * passed directly to test utilities without needing to explicitly provide\n * the [apiRef, implementation] tuple.\n *\n * @public\n * @example\n * ```ts\n * const catalogApi = attachMockApiFactory(\n *   catalogApiRef,\n *   new InMemoryCatalogClient()\n * );\n * // Can now be passed directly to TestApiProvider\n * <TestApiProvider apis={[catalogApi]}>\n * ```\n */\nexport function attachMockApiFactory<TApi, TImpl extends TApi = TApi>(\n  apiRef: ApiRef<TApi>,\n  implementation: TImpl,\n): TImpl & { [mockApiFactorySymbol]: ApiFactory<TApi, TApi, {}> } {\n  const marked = implementation as TImpl & {\n    [mockApiFactorySymbol]: ApiFactory<TApi, TApi, {}>;\n  };\n  (marked as any)[mockApiFactorySymbol] = {\n    api: apiRef,\n    deps: {},\n    factory: () => implementation,\n  };\n  return marked;\n}\n\n/**\n * Retrieves the API factory from a mock API instance.\n * Returns undefined if the value is not a mock API instance.\n *\n * @internal\n */\nexport function getMockApiFactory(\n  value: unknown,\n): ApiFactory<any, any, {}> | undefined {\n  if (\n    typeof value === 'object' &&\n    value !== null &&\n    mockApiFactorySymbol in value &&\n    typeof (value as any)[mockApiFactorySymbol] === 'object'\n  ) {\n    return (value as any)[mockApiFactorySymbol];\n  }\n  return undefined;\n}\n"],"names":[],"mappings":"AAwBO,MAAM,oBAAA,mBAAuB,MAAA,CAAO,GAAA,CAAI,qBAAqB;AAyB7D,SAAS,kBAAA,CACd,QACA,cAAA,EACgE;AAChE,EAAA,MAAM,MAAA,GAAS,cAAA;AAGf,EAAC,MAAA,CAAe,oBAAoB,CAAA,GAAI;AAAA,IACtC,GAAA,EAAK,MAAA;AAAA,IACL,MAAM,EAAC;AAAA,IACP,SAAS,MAAM;AAAA,GACjB;AACA,EAAA,OAAO,MAAA;AACT;AAkBO,SAAS,oBAAA,CACd,QACA,cAAA,EACgE;AAChE,EAAA,MAAM,MAAA,GAAS,cAAA;AAGf,EAAC,MAAA,CAAe,oBAAoB,CAAA,GAAI;AAAA,IACtC,GAAA,EAAK,MAAA;AAAA,IACL,MAAM,EAAC;AAAA,IACP,SAAS,MAAM;AAAA,GACjB;AACA,EAAA,OAAO,MAAA;AACT;AAQO,SAAS,kBACd,KAAA,EACsC;AACtC,EAAA,IACE,OAAO,KAAA,KAAU,QAAA,IACjB,KAAA,KAAU,IAAA,IACV,oBAAA,IAAwB,KAAA,IACxB,OAAQ,KAAA,CAAc,oBAAoB,CAAA,KAAM,QAAA,EAChD;AACA,IAAA,OAAQ,MAAc,oBAAoB,CAAA;AAAA,EAC5C;AACA,EAAA,OAAO,MAAA;AACT;;;;"}

package/dist/apis/PermissionApi/MockPermissionApi.esm.js

@@ -0,0 +1,13 @@
+import { AuthorizeResult } from '@backstage/plugin-permission-common';
+
+class MockPermissionApi {
+  constructor(requestHandler = () => AuthorizeResult.ALLOW) {
+    this.requestHandler = requestHandler;
+  }
+  async authorize(request) {
+    return { result: this.requestHandler(request) };
+  }
+}
+
+export { MockPermissionApi };
+//# sourceMappingURL=MockPermissionApi.esm.js.map

package/dist/apis/PermissionApi/MockPermissionApi.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockPermissionApi.esm.js","sources":["../../../src/apis/PermissionApi/MockPermissionApi.ts"],"sourcesContent":["/*\n * Copyright 2022 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { PermissionApi } from '@backstage/plugin-permission-react';\nimport {\n  EvaluatePermissionResponse,\n  EvaluatePermissionRequest,\n  AuthorizeResult,\n} from '@backstage/plugin-permission-common';\n\n/**\n * Mock implementation of\n * {@link @backstage/plugin-permission-react#PermissionApi}. Supply a\n * requestHandler function to override the mock result returned for a given\n * request.\n *\n * @public\n */\nexport class MockPermissionApi implements PermissionApi {\n  constructor(\n    private readonly requestHandler: (\n      request: EvaluatePermissionRequest,\n    ) => AuthorizeResult.ALLOW | AuthorizeResult.DENY = () =>\n      AuthorizeResult.ALLOW,\n  ) {}\n\n  async authorize(\n    request: EvaluatePermissionRequest,\n  ): Promise<EvaluatePermissionResponse> {\n    return { result: this.requestHandler(request) };\n  }\n}\n"],"names":[],"mappings":";;AA+BO,MAAM,iBAAA,CAA2C;AAAA,EACtD,WAAA,CACmB,cAAA,GAEmC,MAClD,eAAA,CAAgB,KAAA,EAClB;AAJiB,IAAA,IAAA,CAAA,cAAA,GAAA,cAAA;AAAA,EAIhB;AAAA,EAEH,MAAM,UACJ,OAAA,EACqC;AACrC,IAAA,OAAO,EAAE,MAAA,EAAQ,IAAA,CAAK,cAAA,CAAe,OAAO,CAAA,EAAE;AAAA,EAChD;AACF;;;;"}

package/dist/apis/StorageApi/MockStorageApi.esm.js

@@ -0,0 +1,98 @@
+import ObservableImpl from 'zen-observable';
+
+class MockStorageApi {
+  namespace;
+  data;
+  bucketStorageApis;
+  constructor(namespace, bucketStorageApis, data) {
+    this.namespace = namespace;
+    this.bucketStorageApis = bucketStorageApis;
+    this.data = { ...data };
+  }
+  static create(data) {
+    const keyValues = {};
+    function put(value, namespace) {
+      for (const [key, val] of Object.entries(value)) {
+        if (typeof val === "object" && val !== null) {
+          put(val, `${namespace}/${key}`);
+        } else {
+          const namespacedKey = `${namespace}/${key.replace(/^\//, "")}`;
+          keyValues[namespacedKey] = val;
+        }
+      }
+    }
+    put(data ?? {}, "");
+    return new MockStorageApi("", /* @__PURE__ */ new Map(), keyValues);
+  }
+  forBucket(name) {
+    if (!this.bucketStorageApis.has(name)) {
+      this.bucketStorageApis.set(
+        name,
+        new MockStorageApi(
+          `${this.namespace}/${name}`,
+          this.bucketStorageApis,
+          this.data
+        )
+      );
+    }
+    return this.bucketStorageApis.get(name);
+  }
+  snapshot(key) {
+    if (this.data.hasOwnProperty(this.getKeyName(key))) {
+      const data = this.data[this.getKeyName(key)];
+      return {
+        key,
+        presence: "present",
+        value: data
+      };
+    }
+    return {
+      key,
+      presence: "absent",
+      value: void 0
+    };
+  }
+  async set(key, data) {
+    const serialized = JSON.parse(JSON.stringify(data), (_key, value) => {
+      if (typeof value === "object" && value !== null) {
+        Object.freeze(value);
+      }
+      return value;
+    });
+    this.data[this.getKeyName(key)] = serialized;
+    this.notifyChanges({
+      key,
+      presence: "present",
+      value: serialized
+    });
+  }
+  async remove(key) {
+    delete this.data[this.getKeyName(key)];
+    this.notifyChanges({
+      key,
+      presence: "absent",
+      value: void 0
+    });
+  }
+  observe$(key) {
+    return this.observable.filter(({ key: messageKey }) => messageKey === key);
+  }
+  getKeyName(key) {
+    return `${this.namespace}/${encodeURIComponent(key)}`;
+  }
+  notifyChanges(message) {
+    for (const subscription of this.subscribers) {
+      subscription.next(message);
+    }
+  }
+  subscribers = /* @__PURE__ */ new Set();
+  observable = new ObservableImpl((subscriber) => {
+    this.subscribers.add(subscriber);
+    return () => {
+      this.subscribers.delete(subscriber);
+    };
+  });
+}
+
+export { MockStorageApi };
+//# sourceMappingURL=MockStorageApi.esm.js.map

package/dist/apis/StorageApi/MockStorageApi.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockStorageApi.esm.js","sources":["../../../src/apis/StorageApi/MockStorageApi.ts"],"sourcesContent":["/*\n * Copyright 2020 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { StorageApi, StorageValueSnapshot } from '@backstage/core-plugin-api';\nimport { JsonObject, JsonValue, Observable } from '@backstage/types';\nimport ObservableImpl from 'zen-observable';\n\n/**\n * Mock implementation of the {@link core-plugin-api#StorageApi} to be used in tests\n *\n * @public\n */\nexport class MockStorageApi implements StorageApi {\n  private readonly namespace: string;\n  private readonly data: JsonObject;\n  private readonly bucketStorageApis: Map<string, MockStorageApi>;\n\n  private constructor(\n    namespace: string,\n    bucketStorageApis: Map<string, MockStorageApi>,\n    data?: JsonObject,\n  ) {\n    this.namespace = namespace;\n    this.bucketStorageApis = bucketStorageApis;\n    this.data = { ...data };\n  }\n\n  static create(data?: JsonObject) {\n    // Translate a nested data object structure into a flat object with keys\n    // like `/a/b` with their corresponding leaf values\n    const keyValues: { [key: string]: any } = {};\n    function put(value: { [key: string]: any }, namespace: string) {\n      for (const [key, val] of Object.entries(value)) {\n        if (typeof val === 'object' && val !== null) {\n          put(val, `${namespace}/${key}`);\n        } else {\n          const namespacedKey = `${namespace}/${key.replace(/^\\//, '')}`;\n          keyValues[namespacedKey] = val;\n        }\n      }\n    }\n    put(data ?? {}, '');\n    return new MockStorageApi('', new Map(), keyValues);\n  }\n\n  forBucket(name: string): StorageApi {\n    if (!this.bucketStorageApis.has(name)) {\n      this.bucketStorageApis.set(\n        name,\n        new MockStorageApi(\n          `${this.namespace}/${name}`,\n          this.bucketStorageApis,\n          this.data,\n        ),\n      );\n    }\n    return this.bucketStorageApis.get(name)!;\n  }\n\n  snapshot<T extends JsonValue>(key: string): StorageValueSnapshot<T> {\n    if (this.data.hasOwnProperty(this.getKeyName(key))) {\n      const data = this.data[this.getKeyName(key)];\n      return {\n        key,\n        presence: 'present',\n        value: data as T,\n      };\n    }\n    return {\n      key,\n      presence: 'absent',\n      value: undefined,\n    };\n  }\n\n  async set<T>(key: string, data: T): Promise<void> {\n    const serialized = JSON.parse(JSON.stringify(data), (_key, value) => {\n      if (typeof value === 'object' && value !== null) {\n        Object.freeze(value);\n      }\n      return value;\n    });\n    this.data[this.getKeyName(key)] = serialized;\n    this.notifyChanges({\n      key,\n      presence: 'present',\n      value: serialized,\n    });\n  }\n\n  async remove(key: string): Promise<void> {\n    delete this.data[this.getKeyName(key)];\n    this.notifyChanges({\n      key,\n      presence: 'absent',\n      value: undefined,\n    });\n  }\n\n  observe$<T extends JsonValue>(\n    key: string,\n  ): Observable<StorageValueSnapshot<T>> {\n    return this.observable.filter(({ key: messageKey }) => messageKey === key);\n  }\n\n  private getKeyName(key: string) {\n    return `${this.namespace}/${encodeURIComponent(key)}`;\n  }\n\n  private notifyChanges<T extends JsonValue>(message: StorageValueSnapshot<T>) {\n    for (const subscription of this.subscribers) {\n      subscription.next(message);\n    }\n  }\n\n  private subscribers = new Set<\n    ZenObservable.SubscriptionObserver<StorageValueSnapshot<JsonValue>>\n  >();\n\n  private readonly observable = new ObservableImpl<\n    StorageValueSnapshot<JsonValue>\n  >(subscriber => {\n    this.subscribers.add(subscriber);\n    return () => {\n      this.subscribers.delete(subscriber);\n    };\n  });\n}\n"],"names":[],"mappings":"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"}

package/dist/apis/TestApiProvider.esm.js

@@ -0,0 +1,31 @@
+import { jsx } from 'react/jsx-runtime';
+import { ApiProvider } from '../core-app-api/src/apis/system/ApiProvider.esm.js';
+import { getMockApiFactory } from './MockWithApiFactory.esm.js';
+
+function resolveTestApiEntries(apis) {
+  const apiMap = /* @__PURE__ */ new Map();
+  for (const entry of apis) {
+    const mockFactory = getMockApiFactory(entry);
+    if (mockFactory) {
+      apiMap.set(mockFactory.api.id, mockFactory.factory({}));
+    } else {
+      const [apiRef, impl] = entry;
+      apiMap.set(apiRef.id, impl);
+    }
+  }
+  return {
+    get: (ref) => apiMap.get(ref.id)
+  };
+}
+function TestApiProvider(props) {
+  return /* @__PURE__ */ jsx(
+    ApiProvider,
+    {
+      apis: resolveTestApiEntries(props.apis),
+      children: props.children
+    }
+  );
+}
+
+export { TestApiProvider, resolveTestApiEntries };
+//# sourceMappingURL=TestApiProvider.esm.js.map

package/dist/apis/TestApiProvider.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestApiProvider.esm.js","sources":["../../src/apis/TestApiProvider.tsx"],"sourcesContent":["/*\n * Copyright 2020 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ReactNode } from 'react';\n// eslint-disable-next-line @backstage/no-relative-monorepo-imports\nimport { ApiProvider } from '../../../core-app-api/src/apis/system';\nimport { ApiHolder, ApiRef } from '@backstage/frontend-plugin-api';\nimport {\n  getMockApiFactory,\n  type MockWithApiFactory,\n} from './MockWithApiFactory';\n\n/**\n * Represents a single API implementation, either as a tuple of the reference and the implementation, or a mock with an embedded factory.\n * @public\n */\nexport type TestApiPair<TApi> =\n  | readonly [ApiRef<TApi>, TApi extends infer TImpl ? Partial<TImpl> : never]\n  | MockWithApiFactory<TApi>;\n\n/**\n * Represents an array of mock API implementation.\n * @public\n */\nexport type TestApiPairs<TApiPairs> = {\n  [TIndex in keyof TApiPairs]: TestApiPair<TApiPairs[TIndex]>;\n};\n\n/** @internal */\nexport function resolveTestApiEntries<const TApiPairs extends any[]>(\n  apis: readonly [...TestApiPairs<TApiPairs>],\n): ApiHolder {\n  const apiMap = new Map<string, unknown>();\n\n  for (const entry of apis) {\n    const mockFactory = getMockApiFactory(entry);\n    if (mockFactory) {\n      apiMap.set(mockFactory.api.id, mockFactory.factory({}));\n    } else {\n      const [apiRef, impl] = entry as readonly [ApiRef<any>, any];\n      apiMap.set(apiRef.id, impl);\n    }\n  }\n\n  return {\n    get: <T,>(ref: ApiRef<T>) => apiMap.get(ref.id) as T | undefined,\n  };\n}\n\n/**\n * Properties for the {@link TestApiProvider} component.\n *\n * @public\n */\nexport type TestApiProviderProps<TApiPairs extends any[]> = {\n  apis: readonly [...TestApiPairs<TApiPairs>];\n  children: ReactNode;\n};\n\n/**\n * The `TestApiProvider` is a Utility API context provider for standalone rendering\n * scenarios where you're not using `renderInTestApp` or other test utilities.\n *\n * It lets you provide any number of API implementations, without necessarily\n * having to fully implement each of the APIs.\n *\n * @remarks\n *\n * For most test scenarios, prefer using the `apis` option in `renderInTestApp` or\n * `createExtensionTester` instead of wrapping components with `TestApiProvider`.\n *\n * @example\n * ```tsx\n * import { render } from '\\@testing-library/react';\n * import { myCustomApiRef } from '../apis';\n * import { TestApiProvider, mockApis } from '\\@backstage/frontend-test-utils';\n *\n * // Mock custom APIs with tuple syntax\n * const myCustomApiMock = { myMethod: jest.fn() };\n * render(\n *   <TestApiProvider\n *     apis={[\n *       [myCustomApiRef, myCustomApiMock]\n *     ]}\n *   >\n *     <MyComponent />\n *   </TestApiProvider>\n * );\n *\n * // Use with built-in mock APIs (no tuples needed)\n * render(\n *   <TestApiProvider\n *     apis={[\n *       mockApis.identity({ userEntityRef: 'user:default/guest' }),\n *       mockApis.alert(),\n *     ]}\n *   >\n *     <MyComponent />\n *   </TestApiProvider>\n * );\n * ```\n *\n * @public\n */\nexport function TestApiProvider<const TApiPairs extends any[]>(\n  props: TestApiProviderProps<TApiPairs>,\n): JSX.Element {\n  return (\n    <ApiProvider\n      apis={resolveTestApiEntries(props.apis)}\n      children={props.children}\n    />\n  );\n}\n"],"names":[],"mappings":";;;;AA0CO,SAAS,sBACd,IAAA,EACW;AACX,EAAA,MAAM,MAAA,uBAAa,GAAA,EAAqB;AAExC,EAAA,KAAA,MAAW,SAAS,IAAA,EAAM;AACxB,IAAA,MAAM,WAAA,GAAc,kBAAkB,KAAK,CAAA;AAC3C,IAAA,IAAI,WAAA,EAAa;AACf,MAAA,MAAA,CAAO,GAAA,CAAI,YAAY,GAAA,CAAI,EAAA,EAAI,YAAY,OAAA,CAAQ,EAAE,CAAC,CAAA;AAAA,IACxD,CAAA,MAAO;AACL,MAAA,MAAM,CAAC,MAAA,EAAQ,IAAI,CAAA,GAAI,KAAA;AACvB,MAAA,MAAA,CAAO,GAAA,CAAI,MAAA,CAAO,EAAA,EAAI,IAAI,CAAA;AAAA,IAC5B;AAAA,EACF;AAEA,EAAA,OAAO;AAAA,IACL,KAAK,CAAK,GAAA,KAAmB,MAAA,CAAO,GAAA,CAAI,IAAI,EAAE;AAAA,GAChD;AACF;AAyDO,SAAS,gBACd,KAAA,EACa;AACb,EAAA,uBACE,GAAA;AAAA,IAAC,WAAA;AAAA,IAAA;AAAA,MACC,IAAA,EAAM,qBAAA,CAAsB,KAAA,CAAM,IAAI,CAAA;AAAA,MACtC,UAAU,KAAA,CAAM;AAAA;AAAA,GAClB;AAEJ;;;;"}