@backstage/backend-test-utils 0.2.2 → 0.2.3-next.2

package/dist/index.cjs.js

@@ -10,6 +10,7 @@ var uuid = require('uuid');
 var backendAppApi = require('@backstage/backend-app-api');
 var backendPluginApi = require('@backstage/backend-plugin-api');
 var express = require('express');
+var errors = require('@backstage/errors');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -391,26 +392,26 @@ class MockIdentityService {
   }
 }
 
-var __accessCheck = (obj, member, msg) => {
+var __accessCheck$3 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd = (obj, member, value) => {
+var __privateAdd$3 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
+var __privateMethod$2 = (obj, member, method) => {
+  __accessCheck$3(obj, member, "access private method");
   return method;
 };
 var _level, _meta, _log, log_fn;
@@ -423,11 +424,11 @@ const levels = {
 };
 const _MockRootLoggerService = class _MockRootLoggerService {
   constructor(level, meta) {
-    __privateAdd(this, _log);
-    __privateAdd(this, _level, void 0);
-    __privateAdd(this, _meta, void 0);
-    __privateSet(this, _level, level);
-    __privateSet(this, _meta, meta);
+    __privateAdd$3(this, _log);
+    __privateAdd$3(this, _level, void 0);
+    __privateAdd$3(this, _meta, void 0);
+    __privateSet$3(this, _level, level);
+    __privateSet$3(this, _meta, meta);
   }
   static create(options) {
     var _a;
@@ -438,19 +439,19 @@ const _MockRootLoggerService = class _MockRootLoggerService {
     return new _MockRootLoggerService(levels[level], {});
   }
   error(message, meta) {
-    __privateMethod(this, _log, log_fn).call(this, "error", message, meta);
+    __privateMethod$2(this, _log, log_fn).call(this, "error", message, meta);
   }
   warn(message, meta) {
-    __privateMethod(this, _log, log_fn).call(this, "warn", message, meta);
+    __privateMethod$2(this, _log, log_fn).call(this, "warn", message, meta);
   }
   info(message, meta) {
-    __privateMethod(this, _log, log_fn).call(this, "info", message, meta);
+    __privateMethod$2(this, _log, log_fn).call(this, "info", message, meta);
   }
   debug(message, meta) {
-    __privateMethod(this, _log, log_fn).call(this, "debug", message, meta);
+    __privateMethod$2(this, _log, log_fn).call(this, "debug", message, meta);
   }
   child(meta) {
-    return new _MockRootLoggerService(__privateGet(this, _level), { ...__privateGet(this, _meta), ...meta });
+    return new _MockRootLoggerService(__privateGet$3(this, _level), { ...__privateGet$3(this, _meta), ...meta });
   }
 };
 _level = new WeakMap();
@@ -459,8 +460,8 @@ _log = new WeakSet();
 log_fn = function(level, message, meta) {
   var _a;
   const levelValue = (_a = levels[level]) != null ? _a : 0;
-  if (levelValue <= __privateGet(this, _level)) {
-    const labels = Object.entries(__privateGet(this, _meta)).map(([key, value]) => `${key}=${value}`).join(",");
+  if (levelValue <= __privateGet$3(this, _level)) {
+    const labels = Object.entries(__privateGet$3(this, _meta)).map(([key, value]) => `${key}=${value}`).join(",");
     console[level](`${labels} ${message}`, meta);
   }
 };
@@ -475,6 +476,27 @@ function simpleFactory(ref, factory) {
     }
   }));
 }
+function simpleMock(ref, mockFactory) {
+  return (partialImpl) => {
+    const mock = mockFactory();
+    if (partialImpl) {
+      for (const [key, impl] of Object.entries(partialImpl)) {
+        if (typeof impl === "function") {
+          mock[key].mockImplementation(impl);
+        } else {
+          mock[key] = impl;
+        }
+      }
+    }
+    return Object.assign(mock, {
+      factory: backendPluginApi.createServiceFactory({
+        service: ref,
+        deps: {},
+        factory: () => mock
+      })()
+    });
+  };
+}
 exports.mockServices = void 0;
 ((mockServices2) => {
   function rootConfig(options) {
@@ -490,6 +512,13 @@ exports.mockServices = void 0;
   mockServices2.rootLogger = rootLogger;
   ((rootLogger2) => {
     rootLogger2.factory = simpleFactory(backendPluginApi.coreServices.rootLogger, rootLogger2);
+    rootLogger2.mock = simpleMock(backendPluginApi.coreServices.rootLogger, () => ({
+      child: jest.fn(),
+      debug: jest.fn(),
+      error: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn()
+    }));
   })(rootLogger = mockServices2.rootLogger || (mockServices2.rootLogger = {}));
   function tokenManager() {
     return {
@@ -509,6 +538,10 @@ exports.mockServices = void 0;
       backendPluginApi.coreServices.tokenManager,
       tokenManager2
     );
+    tokenManager2.mock = simpleMock(backendPluginApi.coreServices.tokenManager, () => ({
+      authenticate: jest.fn(),
+      getToken: jest.fn()
+    }));
   })(tokenManager = mockServices2.tokenManager || (mockServices2.tokenManager = {}));
   function identity() {
     return new MockIdentityService();
@@ -516,33 +549,84 @@ exports.mockServices = void 0;
   mockServices2.identity = identity;
   ((identity2) => {
     identity2.factory = simpleFactory(backendPluginApi.coreServices.identity, identity2);
+    identity2.mock = simpleMock(backendPluginApi.coreServices.identity, () => ({
+      getIdentity: jest.fn()
+    }));
   })(identity = mockServices2.identity || (mockServices2.identity = {}));
   ((cache2) => {
     cache2.factory = backendAppApi.cacheServiceFactory;
+    cache2.mock = simpleMock(backendPluginApi.coreServices.cache, () => ({
+      delete: jest.fn(),
+      get: jest.fn(),
+      set: jest.fn(),
+      withOptions: jest.fn()
+    }));
   })(mockServices2.cache || (mockServices2.cache = {}));
   ((database2) => {
     database2.factory = backendAppApi.databaseServiceFactory;
+    database2.mock = simpleMock(backendPluginApi.coreServices.database, () => ({
+      getClient: jest.fn()
+    }));
   })(mockServices2.database || (mockServices2.database = {}));
   ((httpRouter2) => {
     httpRouter2.factory = backendAppApi.httpRouterServiceFactory;
+    httpRouter2.mock = simpleMock(backendPluginApi.coreServices.httpRouter, () => ({
+      use: jest.fn()
+    }));
   })(mockServices2.httpRouter || (mockServices2.httpRouter = {}));
+  ((rootHttpRouter2) => {
+    rootHttpRouter2.factory = backendAppApi.rootHttpRouterServiceFactory;
+    rootHttpRouter2.mock = simpleMock(backendPluginApi.coreServices.rootHttpRouter, () => ({
+      use: jest.fn()
+    }));
+  })(mockServices2.rootHttpRouter || (mockServices2.rootHttpRouter = {}));
   ((lifecycle2) => {
     lifecycle2.factory = backendAppApi.lifecycleServiceFactory;
+    lifecycle2.mock = simpleMock(backendPluginApi.coreServices.lifecycle, () => ({
+      addShutdownHook: jest.fn(),
+      addStartupHook: jest.fn()
+    }));
   })(mockServices2.lifecycle || (mockServices2.lifecycle = {}));
   ((logger2) => {
     logger2.factory = backendAppApi.loggerServiceFactory;
+    logger2.mock = simpleMock(backendPluginApi.coreServices.logger, () => ({
+      child: jest.fn(),
+      debug: jest.fn(),
+      error: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn()
+    }));
   })(mockServices2.logger || (mockServices2.logger = {}));
   ((permissions2) => {
     permissions2.factory = backendAppApi.permissionsServiceFactory;
+    permissions2.mock = simpleMock(backendPluginApi.coreServices.permissions, () => ({
+      authorize: jest.fn(),
+      authorizeConditional: jest.fn()
+    }));
   })(mockServices2.permissions || (mockServices2.permissions = {}));
   ((rootLifecycle2) => {
     rootLifecycle2.factory = backendAppApi.rootLifecycleServiceFactory;
+    rootLifecycle2.mock = simpleMock(backendPluginApi.coreServices.rootLifecycle, () => ({
+      addShutdownHook: jest.fn(),
+      addStartupHook: jest.fn()
+    }));
   })(mockServices2.rootLifecycle || (mockServices2.rootLifecycle = {}));
   ((scheduler2) => {
     scheduler2.factory = backendAppApi.schedulerServiceFactory;
+    scheduler2.mock = simpleMock(backendPluginApi.coreServices.scheduler, () => ({
+      createScheduledTaskRunner: jest.fn(),
+      getScheduledTasks: jest.fn(),
+      scheduleTask: jest.fn(),
+      triggerTask: jest.fn()
+    }));
   })(mockServices2.scheduler || (mockServices2.scheduler = {}));
   ((urlReader2) => {
     urlReader2.factory = backendAppApi.urlReaderServiceFactory;
+    urlReader2.mock = simpleMock(backendPluginApi.coreServices.urlReader, () => ({
+      readTree: jest.fn(),
+      readUrl: jest.fn(),
+      search: jest.fn()
+    }));
   })(mockServices2.urlReader || (mockServices2.urlReader = {}));
 })(exports.mockServices || (exports.mockServices = {}));
 
@@ -729,6 +813,504 @@ function isInternalBackendFeature(feature) {
   return typeof feature.getRegistrations === "function";
 }
 
+var __accessCheck$2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$2(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$2 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod$1 = (obj, member, method) => {
+  __accessCheck$2(obj, member, "access private method");
+  return method;
+};
+var _nodeIds, _cycleKeys, _getCycleKey, getCycleKey_fn, _nodes, _allProvided;
+class Node {
+  constructor(value, consumes, provides) {
+    this.value = value;
+    this.consumes = consumes;
+    this.provides = provides;
+  }
+  static from(input) {
+    return new Node(
+      input.value,
+      input.consumes ? new Set(input.consumes) : /* @__PURE__ */ new Set(),
+      input.provides ? new Set(input.provides) : /* @__PURE__ */ new Set()
+    );
+  }
+}
+const _CycleKeySet = class _CycleKeySet {
+  constructor(nodes) {
+    __privateAdd$2(this, _getCycleKey);
+    __privateAdd$2(this, _nodeIds, void 0);
+    __privateAdd$2(this, _cycleKeys, void 0);
+    __privateSet$2(this, _nodeIds, new Map(nodes.map((n, i) => [n.value, i])));
+    __privateSet$2(this, _cycleKeys, /* @__PURE__ */ new Set());
+  }
+  static from(nodes) {
+    return new _CycleKeySet(nodes);
+  }
+  tryAdd(path) {
+    const cycleKey = __privateMethod$1(this, _getCycleKey, getCycleKey_fn).call(this, path);
+    if (__privateGet$2(this, _cycleKeys).has(cycleKey)) {
+      return false;
+    }
+    __privateGet$2(this, _cycleKeys).add(cycleKey);
+    return true;
+  }
+};
+_nodeIds = new WeakMap();
+_cycleKeys = new WeakMap();
+_getCycleKey = new WeakSet();
+getCycleKey_fn = function(path) {
+  return path.map((n) => __privateGet$2(this, _nodeIds).get(n)).sort().join(",");
+};
+let CycleKeySet = _CycleKeySet;
+const _DependencyGraph = class _DependencyGraph {
+  constructor(nodes) {
+    __privateAdd$2(this, _nodes, void 0);
+    __privateAdd$2(this, _allProvided, void 0);
+    __privateSet$2(this, _nodes, nodes);
+    __privateSet$2(this, _allProvided, /* @__PURE__ */ new Set());
+    for (const node of __privateGet$2(this, _nodes).values()) {
+      for (const produced of node.provides) {
+        __privateGet$2(this, _allProvided).add(produced);
+      }
+    }
+  }
+  static fromMap(nodes) {
+    return this.fromIterable(
+      Object.entries(nodes).map(([key, node]) => ({
+        value: String(key),
+        ...node
+      }))
+    );
+  }
+  static fromIterable(nodeInputs) {
+    const nodes = new Array();
+    for (const nodeInput of nodeInputs) {
+      nodes.push(Node.from(nodeInput));
+    }
+    return new _DependencyGraph(nodes);
+  }
+  /**
+   * Find all nodes that consume dependencies that are not provided by any other node.
+   */
+  findUnsatisfiedDeps() {
+    const unsatisfiedDependencies = [];
+    for (const node of __privateGet$2(this, _nodes).values()) {
+      const unsatisfied = Array.from(node.consumes).filter(
+        (id) => !__privateGet$2(this, _allProvided).has(id)
+      );
+      if (unsatisfied.length > 0) {
+        unsatisfiedDependencies.push({ value: node.value, unsatisfied });
+      }
+    }
+    return unsatisfiedDependencies;
+  }
+  /**
+   * Detect the first circular dependency within the graph, returning the path of nodes that
+   * form a cycle, with the same node as the first and last element of the array.
+   */
+  detectCircularDependency() {
+    return this.detectCircularDependencies().next().value;
+  }
+  /**
+   * Detect circular dependencies within the graph, returning the path of nodes that
+   * form a cycle, with the same node as the first and last element of the array.
+   */
+  *detectCircularDependencies() {
+    const cycleKeys = CycleKeySet.from(__privateGet$2(this, _nodes));
+    for (const startNode of __privateGet$2(this, _nodes)) {
+      const visited = /* @__PURE__ */ new Set();
+      const stack = new Array([
+        startNode,
+        [startNode.value]
+      ]);
+      while (stack.length > 0) {
+        const [node, path] = stack.pop();
+        if (visited.has(node)) {
+          continue;
+        }
+        visited.add(node);
+        for (const consumed of node.consumes) {
+          const providerNodes = __privateGet$2(this, _nodes).filter(
+            (other) => other.provides.has(consumed)
+          );
+          for (const provider of providerNodes) {
+            if (provider === startNode) {
+              if (cycleKeys.tryAdd(path)) {
+                yield [...path, startNode.value];
+              }
+              break;
+            }
+            if (!visited.has(provider)) {
+              stack.push([provider, [...path, provider.value]]);
+            }
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Traverses the dependency graph in topological order, calling the provided
+   * function for each node and waiting for it to resolve.
+   *
+   * The nodes are traversed in parallel, but in such a way that no node is
+   * visited before all of its dependencies.
+   *
+   * Dependencies of nodes that are not produced by any other nodes will be ignored.
+   */
+  async parallelTopologicalTraversal(fn) {
+    const allProvided = __privateGet$2(this, _allProvided);
+    const producedSoFar = /* @__PURE__ */ new Set();
+    const waiting = new Set(__privateGet$2(this, _nodes).values());
+    const visited = /* @__PURE__ */ new Set();
+    const results = new Array();
+    let inFlight = 0;
+    async function processMoreNodes() {
+      if (waiting.size === 0) {
+        return;
+      }
+      const nodesToProcess = [];
+      for (const node of waiting) {
+        let ready = true;
+        for (const consumed of node.consumes) {
+          if (allProvided.has(consumed) && !producedSoFar.has(consumed)) {
+            ready = false;
+            continue;
+          }
+        }
+        if (ready) {
+          nodesToProcess.push(node);
+        }
+      }
+      for (const node of nodesToProcess) {
+        waiting.delete(node);
+      }
+      if (nodesToProcess.length === 0 && inFlight === 0) {
+        throw new Error("Circular dependency detected");
+      }
+      await Promise.all(nodesToProcess.map(processNode));
+    }
+    async function processNode(node) {
+      visited.add(node);
+      inFlight += 1;
+      const result = await fn(node.value);
+      results.push(result);
+      node.provides.forEach((produced) => producedSoFar.add(produced));
+      inFlight -= 1;
+      await processMoreNodes();
+    }
+    await processMoreNodes();
+    return results;
+  }
+};
+_nodes = new WeakMap();
+_allProvided = new WeakMap();
+let DependencyGraph = _DependencyGraph;
+
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$1(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$1 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$1 = (obj, member, value, setter) => {
+  __accessCheck$1(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck$1(obj, member, "access private method");
+  return method;
+};
+var _providedFactories, _loadedDefaultFactories, _implementations, _rootServiceImplementations, _resolveFactory, resolveFactory_fn, _checkForMissingDeps, checkForMissingDeps_fn, _checkForCircularDeps, checkForCircularDeps_fn;
+function toInternalServiceFactory(factory) {
+  const f = factory;
+  if (f.$$type !== "@backstage/BackendFeature") {
+    throw new Error(`Invalid service factory, bad type '${f.$$type}'`);
+  }
+  if (f.version !== "v1") {
+    throw new Error(`Invalid service factory, bad version '${f.version}'`);
+  }
+  return f;
+}
+const pluginMetadataServiceFactory = backendPluginApi.createServiceFactory(
+  (options) => ({
+    service: backendPluginApi.coreServices.pluginMetadata,
+    deps: {},
+    factory: async () => ({ getId: () => options == null ? void 0 : options.pluginId })
+  })
+);
+const _ServiceRegistry = class _ServiceRegistry {
+  constructor(factories) {
+    __privateAdd$1(this, _resolveFactory);
+    __privateAdd$1(this, _checkForMissingDeps);
+    __privateAdd$1(this, _checkForCircularDeps);
+    __privateAdd$1(this, _providedFactories, void 0);
+    __privateAdd$1(this, _loadedDefaultFactories, void 0);
+    __privateAdd$1(this, _implementations, void 0);
+    __privateAdd$1(this, _rootServiceImplementations, /* @__PURE__ */ new Map());
+    __privateSet$1(this, _providedFactories, new Map(
+      factories.map((sf) => [sf.service.id, toInternalServiceFactory(sf)])
+    ));
+    __privateSet$1(this, _loadedDefaultFactories, /* @__PURE__ */ new Map());
+    __privateSet$1(this, _implementations, /* @__PURE__ */ new Map());
+  }
+  static create(factories) {
+    var _a;
+    const registry = new _ServiceRegistry(factories);
+    __privateMethod(_a = registry, _checkForCircularDeps, checkForCircularDeps_fn).call(_a);
+    return registry;
+  }
+  getServiceRefs() {
+    return Array.from(__privateGet$1(this, _providedFactories).values()).map((f) => f.service);
+  }
+  get(ref, pluginId) {
+    var _a;
+    return (_a = __privateMethod(this, _resolveFactory, resolveFactory_fn).call(this, ref, pluginId)) == null ? void 0 : _a.then((factory) => {
+      if (factory.service.scope === "root") {
+        let existing = __privateGet$1(this, _rootServiceImplementations).get(factory);
+        if (!existing) {
+          __privateMethod(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
+          const rootDeps = new Array();
+          for (const [name, serviceRef] of Object.entries(factory.deps)) {
+            if (serviceRef.scope !== "root") {
+              throw new Error(
+                `Failed to instantiate 'root' scoped service '${ref.id}' because it depends on '${serviceRef.scope}' scoped service '${serviceRef.id}'.`
+              );
+            }
+            const target = this.get(serviceRef, pluginId);
+            rootDeps.push(target.then((impl) => [name, impl]));
+          }
+          existing = Promise.all(rootDeps).then(
+            (entries) => factory.factory(Object.fromEntries(entries), void 0)
+          );
+          __privateGet$1(this, _rootServiceImplementations).set(factory, existing);
+        }
+        return existing;
+      }
+      let implementation = __privateGet$1(this, _implementations).get(factory);
+      if (!implementation) {
+        __privateMethod(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
+        const rootDeps = new Array();
+        for (const [name, serviceRef] of Object.entries(factory.deps)) {
+          if (serviceRef.scope === "root") {
+            const target = this.get(serviceRef, pluginId);
+            rootDeps.push(target.then((impl) => [name, impl]));
+          }
+        }
+        implementation = {
+          context: Promise.all(rootDeps).then(
+            (entries) => {
+              var _a2;
+              return (_a2 = factory.createRootContext) == null ? void 0 : _a2.call(factory, Object.fromEntries(entries));
+            }
+          ).catch((error) => {
+            const cause = errors.stringifyError(error);
+            throw new Error(
+              `Failed to instantiate service '${ref.id}' because createRootContext threw an error, ${cause}`
+            );
+          }),
+          byPlugin: /* @__PURE__ */ new Map()
+        };
+        __privateGet$1(this, _implementations).set(factory, implementation);
+      }
+      let result = implementation.byPlugin.get(pluginId);
+      if (!result) {
+        const allDeps = new Array();
+        for (const [name, serviceRef] of Object.entries(factory.deps)) {
+          const target = this.get(serviceRef, pluginId);
+          allDeps.push(target.then((impl) => [name, impl]));
+        }
+        result = implementation.context.then(
+          (context) => Promise.all(allDeps).then(
+            (entries) => factory.factory(Object.fromEntries(entries), context)
+          )
+        ).catch((error) => {
+          const cause = errors.stringifyError(error);
+          throw new Error(
+            `Failed to instantiate service '${ref.id}' for '${pluginId}' because the factory function threw an error, ${cause}`
+          );
+        });
+        implementation.byPlugin.set(pluginId, result);
+      }
+      return result;
+    });
+  }
+};
+_providedFactories = new WeakMap();
+_loadedDefaultFactories = new WeakMap();
+_implementations = new WeakMap();
+_rootServiceImplementations = new WeakMap();
+_resolveFactory = new WeakSet();
+resolveFactory_fn = function(ref, pluginId) {
+  if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
+    return Promise.resolve(
+      toInternalServiceFactory(pluginMetadataServiceFactory({ pluginId }))
+    );
+  }
+  let resolvedFactory = __privateGet$1(this, _providedFactories).get(ref.id);
+  const { __defaultFactory: defaultFactory } = ref;
+  if (!resolvedFactory && !defaultFactory) {
+    return void 0;
+  }
+  if (!resolvedFactory) {
+    let loadedFactory = __privateGet$1(this, _loadedDefaultFactories).get(defaultFactory);
+    if (!loadedFactory) {
+      loadedFactory = Promise.resolve().then(() => defaultFactory(ref)).then(
+        (f) => toInternalServiceFactory(typeof f === "function" ? f() : f)
+      );
+      __privateGet$1(this, _loadedDefaultFactories).set(defaultFactory, loadedFactory);
+    }
+    resolvedFactory = loadedFactory.catch((error) => {
+      throw new Error(
+        `Failed to instantiate service '${ref.id}' because the default factory loader threw an error, ${errors.stringifyError(
+          error
+        )}`
+      );
+    });
+  }
+  return Promise.resolve(resolvedFactory);
+};
+_checkForMissingDeps = new WeakSet();
+checkForMissingDeps_fn = function(factory, pluginId) {
+  const missingDeps = Object.values(factory.deps).filter((ref) => {
+    if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
+      return false;
+    }
+    if (__privateGet$1(this, _providedFactories).get(ref.id)) {
+      return false;
+    }
+    return !ref.__defaultFactory;
+  });
+  if (missingDeps.length) {
+    const missing = missingDeps.map((r) => `'${r.id}'`).join(", ");
+    throw new Error(
+      `Failed to instantiate service '${factory.service.id}' for '${pluginId}' because the following dependent services are missing: ${missing}`
+    );
+  }
+};
+_checkForCircularDeps = new WeakSet();
+checkForCircularDeps_fn = function() {
+  const graph = DependencyGraph.fromIterable(
+    Array.from(__privateGet$1(this, _providedFactories)).map(
+      ([serviceId, serviceFactory]) => ({
+        value: serviceId,
+        provides: [serviceId],
+        consumes: Object.values(serviceFactory.deps).map((d) => d.id)
+      })
+    )
+  );
+  const circularDependencies = Array.from(graph.detectCircularDependencies());
+  if (circularDependencies.length) {
+    const cycles = circularDependencies.map((c) => c.map((id) => `'${id}'`).join(" -> ")).join("\n  ");
+    throw new errors.ConflictError(`Circular dependencies detected:
+  ${cycles}`);
+  }
+};
+let ServiceRegistry = _ServiceRegistry;
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _subject, _registry;
+const _ServiceFactoryTester = class _ServiceFactoryTester {
+  constructor(subject, registry) {
+    __privateAdd(this, _subject, void 0);
+    __privateAdd(this, _registry, void 0);
+    __privateSet(this, _subject, subject);
+    __privateSet(this, _registry, registry);
+  }
+  /**
+   * Creates a new {@link ServiceFactoryTester} used to test the provided subject.
+   *
+   * @param subject - The service factory to test.
+   * @param options - Additional options
+   * @returns A new tester instance for the provided subject.
+   */
+  static from(subject, options) {
+    var _a, _b;
+    const subjectFactory = typeof subject === "function" ? subject() : subject;
+    const registry = ServiceRegistry.create([
+      ...defaultServiceFactories,
+      ...(_b = (_a = options == null ? void 0 : options.dependencies) == null ? void 0 : _a.map(
+        (f) => typeof f === "function" ? f() : f
+      )) != null ? _b : [],
+      subjectFactory
+    ]);
+    return new _ServiceFactoryTester(subjectFactory.service, registry);
+  }
+  /**
+   * Returns the service instance for the subject.
+   *
+   * @remarks
+   *
+   * If the subject is a plugin scoped service factory a plugin ID
+   * can be provided to instantiate the service for a specific plugin.
+   *
+   * By default the plugin ID 'test' is used.
+   */
+  async get(...args) {
+    const [pluginId] = args;
+    return __privateGet(this, _registry).get(__privateGet(this, _subject), pluginId != null ? pluginId : "test");
+  }
+  /**
+   * Return the service instance for any of the provided dependencies or built-in services.
+   *
+   * @remarks
+   *
+   * A plugin ID can optionally be provided for plugin scoped services, otherwise the plugin ID 'test' is used.
+   */
+  async getService(service, ...args) {
+    const [pluginId] = args;
+    const instance = await __privateGet(this, _registry).get(service, pluginId != null ? pluginId : "test");
+    if (instance === void 0) {
+      throw new Error(`Service '${service.id}' not found`);
+    }
+    return instance;
+  }
+};
+_subject = new WeakMap();
+_registry = new WeakMap();
+let ServiceFactoryTester = _ServiceFactoryTester;
+
+exports.ServiceFactoryTester = ServiceFactoryTester;
 exports.TestDatabases = TestDatabases;
 exports.isDockerDisabledForTests = isDockerDisabledForTests;
 exports.setupRequestMockHandlers = setupRequestMockHandlers;