@backstage/backend-test-utils 0.3.9-next.0 → 0.4.0-next.2

package/dist/index.cjs.js

@@ -1,24 +1,32 @@
 'use strict';
 
-var backendCommon = require('@backstage/backend-common');
-var config = require('@backstage/config');
-var crypto = require('crypto');
-var createConnection = require('knex');
+var Keyv = require('keyv');
+var KeyvMemcache = require('@keyv/memcache');
 var uuid = require('uuid');
+var KeyvRedis = require('@keyv/redis');
+var errors = require('@backstage/errors');
+var crypto = require('crypto');
+var knexFactory = require('knex');
+var yn = require('yn');
+var pgConnectionString = require('pg-connection-string');
 var os = require('os');
 var backendPluginApi = require('@backstage/backend-plugin-api');
 var fs = require('fs-extra');
 var textextensions = require('textextensions');
 var path = require('path');
 var backendAppApi = require('@backstage/backend-app-api');
-var errors = require('@backstage/errors');
+var config = require('@backstage/config');
 var cookie = require('cookie');
 var pluginEventsNode = require('@backstage/plugin-events-node');
 var express = require('express');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
-var createConnection__default = /*#__PURE__*/_interopDefaultCompat(createConnection);
+var Keyv__default = /*#__PURE__*/_interopDefaultCompat(Keyv);
+var KeyvMemcache__default = /*#__PURE__*/_interopDefaultCompat(KeyvMemcache);
+var KeyvRedis__default = /*#__PURE__*/_interopDefaultCompat(KeyvRedis);
+var knexFactory__default = /*#__PURE__*/_interopDefaultCompat(knexFactory);
+var yn__default = /*#__PURE__*/_interopDefaultCompat(yn);
 var os__default = /*#__PURE__*/_interopDefaultCompat(os);
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 var textextensions__default = /*#__PURE__*/_interopDefaultCompat(textextensions);
@@ -28,84 +36,270 @@ function isDockerDisabledForTests() {
   return Boolean(process.env.BACKSTAGE_TEST_DISABLE_DOCKER) || !Boolean(process.env.CI);
 }
 
-async function waitForMysqlReady(connection) {
+async function attemptMemcachedConnection(connection) {
   const startTime = Date.now();
-  const db = createConnection__default.default({ client: "mysql2", connection });
-  try {
-    for (; ; ) {
-      try {
-        const result = await db.select(db.raw("version() AS version"));
-        if (result[0]?.version) {
-          return;
-        }
-      } catch (e) {
-        if (Date.now() - startTime > 3e4) {
-          throw new Error(
-            `Timed out waiting for the database to be ready for connections, ${e}`
-          );
-        }
+  for (; ; ) {
+    try {
+      const store = new KeyvMemcache__default.default(connection);
+      const keyv = new Keyv__default.default({ store });
+      const value = uuid.v4();
+      await keyv.set("test", value);
+      if (await keyv.get("test") === value) {
+        return keyv;
+      }
+    } catch (e) {
+      if (Date.now() - startTime > 3e4) {
+        throw new Error(
+          `Timed out waiting for memcached to be ready for connections, ${e}`
+        );
       }
-      await new Promise((resolve) => setTimeout(resolve, 100));
     }
-  } finally {
-    db.destroy();
+    await new Promise((resolve) => setTimeout(resolve, 100));
   }
 }
-async function startMysqlContainer(image) {
-  const user = "root";
-  const password = uuid.v4();
+async function connectToExternalMemcache(connection) {
+  const keyv = await attemptMemcachedConnection(connection);
+  return {
+    store: "memcache",
+    connection,
+    keyv,
+    stop: async () => await keyv.disconnect()
+  };
+}
+async function startMemcachedContainer(image) {
   const { GenericContainer } = await import('testcontainers');
-  const container = await new GenericContainer(image).withExposedPorts(3306).withEnvironment({ MYSQL_ROOT_PASSWORD: password }).withTmpFs({ "/var/lib/mysql": "rw" }).start();
+  const container = await new GenericContainer(image).withExposedPorts(11211).start();
   const host = container.getHost();
-  const port = container.getMappedPort(3306);
-  const stop = async () => {
-    await container.stop({ timeout: 1e4 });
+  const port = container.getMappedPort(11211);
+  const connection = `${host}:${port}`;
+  const keyv = await attemptMemcachedConnection(connection);
+  return {
+    store: "memcache",
+    connection,
+    keyv,
+    stop: async () => {
+      await keyv.disconnect();
+      await container.stop({ timeout: 1e4 });
+    }
   };
-  await waitForMysqlReady({ host, port, user, password });
-  return { host, port, user, password, stop };
 }
 
-async function waitForPostgresReady(connection) {
+async function attemptRedisConnection(connection) {
   const startTime = Date.now();
-  const db = createConnection__default.default({ client: "pg", connection });
-  try {
-    for (; ; ) {
-      try {
-        const result = await db.select(db.raw("version()"));
-        if (Array.isArray(result) && result[0]?.version) {
-          return;
-        }
-      } catch (e) {
-        if (Date.now() - startTime > 3e4) {
-          throw new Error(
-            `Timed out waiting for the database to be ready for connections, ${e}`
-          );
-        }
+  for (; ; ) {
+    try {
+      const store = new KeyvRedis__default.default(connection);
+      const keyv = new Keyv__default.default({ store });
+      const value = uuid.v4();
+      await keyv.set("test", value);
+      if (await keyv.get("test") === value) {
+        return keyv;
+      }
+    } catch (e) {
+      if (Date.now() - startTime > 3e4) {
+        throw new Error(
+          `Timed out waiting for redis to be ready for connections, ${e}`
+        );
       }
-      await new Promise((resolve) => setTimeout(resolve, 100));
     }
-  } finally {
-    db.destroy();
+    await new Promise((resolve) => setTimeout(resolve, 100));
   }
 }
-async function startPostgresContainer(image) {
-  const user = "postgres";
-  const password = uuid.v4();
+async function connectToExternalRedis(connection) {
+  const keyv = await attemptRedisConnection(connection);
+  return {
+    store: "redis",
+    connection,
+    keyv,
+    stop: async () => await keyv.disconnect()
+  };
+}
+async function startRedisContainer(image) {
   const { GenericContainer } = await import('testcontainers');
-  const container = await new GenericContainer(image).withExposedPorts(5432).withEnvironment({ POSTGRES_PASSWORD: password }).withTmpFs({ "/var/lib/postgresql/data": "rw" }).start();
+  const container = await new GenericContainer(image).withExposedPorts(6379).start();
   const host = container.getHost();
-  const port = container.getMappedPort(5432);
-  const stop = async () => {
-    await container.stop({ timeout: 1e4 });
+  const port = container.getMappedPort(6379);
+  const connection = `redis://${host}:${port}`;
+  const keyv = await attemptRedisConnection(connection);
+  return {
+    store: "redis",
+    connection,
+    keyv,
+    stop: async () => {
+      await keyv.disconnect();
+      await container.stop({ timeout: 1e4 });
+    }
   };
-  await waitForPostgresReady({ host, port, user, password });
-  return { host, port, user, password, stop };
 }
 
 const getDockerImageForName = (name) => {
   return process.env.BACKSTAGE_TEST_DOCKER_REGISTRY ? `${process.env.BACKSTAGE_TEST_DOCKER_REGISTRY}/${name}` : name;
 };
 
+const allCaches = Object.freeze({
+  REDIS_7: {
+    name: "Redis 7.x",
+    store: "redis",
+    dockerImageName: getDockerImageForName("redis:7"),
+    connectionStringEnvironmentVariableName: "BACKSTAGE_TEST_CACHE_REDIS7_CONNECTION_STRING"
+  },
+  MEMCACHED_1: {
+    name: "Memcached 1.x",
+    store: "memcache",
+    dockerImageName: getDockerImageForName("memcached:1"),
+    connectionStringEnvironmentVariableName: "BACKSTAGE_TEST_CACHE_MEMCACHED1_CONNECTION_STRING"
+  },
+  MEMORY: {
+    name: "In-memory",
+    store: "memory"
+  }
+});
+
+class TestCaches {
+  instanceById;
+  supportedIds;
+  static defaultIds;
+  /**
+   * Creates an empty `TestCaches` instance, and sets up Jest to clean up all of
+   * its acquired resources after all tests finish.
+   *
+   * You typically want to create just a single instance like this at the top of
+   * your test file or `describe` block, and then call `init` many times on that
+   * instance inside the individual tests. Spinning up a "physical" cache
+   * instance takes a considerable amount of time, slowing down tests. But
+   * wiping the contents of an instance using `init` is very fast.
+   */
+  static create(options) {
+    const ids = options?.ids;
+    const disableDocker = options?.disableDocker ?? isDockerDisabledForTests();
+    let testCacheIds;
+    if (ids) {
+      testCacheIds = ids;
+    } else if (TestCaches.defaultIds) {
+      testCacheIds = TestCaches.defaultIds;
+    } else {
+      testCacheIds = Object.keys(allCaches);
+    }
+    const supportedIds = testCacheIds.filter((id) => {
+      const properties = allCaches[id];
+      if (!properties) {
+        return false;
+      }
+      if (properties.connectionStringEnvironmentVariableName && process.env[properties.connectionStringEnvironmentVariableName]) {
+        return true;
+      }
+      if (!properties.dockerImageName) {
+        return true;
+      }
+      if (disableDocker) {
+        return false;
+      }
+      return true;
+    });
+    const caches = new TestCaches(supportedIds);
+    if (supportedIds.length > 0) {
+      afterAll(async () => {
+        await caches.shutdown();
+      });
+    }
+    return caches;
+  }
+  static setDefaults(options) {
+    TestCaches.defaultIds = options.ids;
+  }
+  constructor(supportedIds) {
+    this.instanceById = /* @__PURE__ */ new Map();
+    this.supportedIds = supportedIds;
+  }
+  supports(id) {
+    return this.supportedIds.includes(id);
+  }
+  eachSupportedId() {
+    return this.supportedIds.map((id) => [id]);
+  }
+  /**
+   * Returns a fresh, empty cache for the given driver.
+   *
+   * @param id - The ID of the cache to use, e.g. 'REDIS_7'
+   * @returns Cache connection properties
+   */
+  async init(id) {
+    const properties = allCaches[id];
+    if (!properties) {
+      const candidates = Object.keys(allCaches).join(", ");
+      throw new Error(
+        `Unknown test cache ${id}, possible values are ${candidates}`
+      );
+    }
+    if (!this.supportedIds.includes(id)) {
+      const candidates = this.supportedIds.join(", ");
+      throw new Error(
+        `Unsupported test cache ${id} for this environment, possible values are ${candidates}`
+      );
+    }
+    let instance = this.instanceById.get(id);
+    if (!instance) {
+      instance = await this.initAny(properties);
+      this.instanceById.set(id, instance);
+    }
+    await instance.keyv.clear();
+    return {
+      store: instance.store,
+      connection: instance.connection,
+      keyv: instance.keyv
+    };
+  }
+  async initAny(properties) {
+    switch (properties.store) {
+      case "memcache":
+        return this.initMemcached(properties);
+      case "redis":
+        return this.initRedis(properties);
+      case "memory":
+        return {
+          store: "memory",
+          connection: "memory",
+          keyv: new Keyv__default.default(),
+          stop: async () => {
+          }
+        };
+      default:
+        throw new Error(`Unknown cache store '${properties.store}'`);
+    }
+  }
+  async initMemcached(properties) {
+    const envVarName = properties.connectionStringEnvironmentVariableName;
+    if (envVarName) {
+      const connectionString = process.env[envVarName];
+      if (connectionString) {
+        return connectToExternalMemcache(connectionString);
+      }
+    }
+    return await startMemcachedContainer(properties.dockerImageName);
+  }
+  async initRedis(properties) {
+    const envVarName = properties.connectionStringEnvironmentVariableName;
+    if (envVarName) {
+      const connectionString = process.env[envVarName];
+      if (connectionString) {
+        return connectToExternalRedis(connectionString);
+      }
+    }
+    return await startRedisContainer(properties.dockerImageName);
+  }
+  async shutdown() {
+    const instances = [...this.instanceById.values()];
+    this.instanceById.clear();
+    await Promise.all(
+      instances.map(
+        ({ stop }) => stop().catch((error) => {
+          console.warn(`TestCaches: Failed to stop container`, { error });
+        })
+      )
+    );
+  }
+}
+
 const allDatabases = Object.freeze({
   POSTGRES_16: {
     name: "Postgres 16.x",
@@ -160,15 +354,345 @@ const allDatabases = Object.freeze({
     driver: "better-sqlite3"
   }
 });
-
 const LARGER_POOL_CONFIG = {
   pool: {
     min: 0,
     max: 50
   }
 };
+
+async function waitForMysqlReady(connection) {
+  const startTime = Date.now();
+  let lastError;
+  let attempts = 0;
+  for (; ; ) {
+    attempts += 1;
+    let knex;
+    try {
+      knex = knexFactory__default.default({
+        client: "mysql2",
+        connection: {
+          // make a copy because the driver mutates this
+          ...connection
+        }
+      });
+      const result = await knex.select(knex.raw("version() AS version"));
+      if (Array.isArray(result) && result[0]?.version) {
+        return;
+      }
+    } catch (e) {
+      lastError = e;
+    } finally {
+      await knex?.destroy();
+    }
+    if (Date.now() - startTime > 3e4) {
+      throw new Error(
+        `Timed out waiting for the database to be ready for connections, ${attempts} attempts, ${lastError ? `last error was ${errors.stringifyError(lastError)}` : "(no errors thrown)"}`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+async function startMysqlContainer(image) {
+  const user = "root";
+  const password = uuid.v4();
+  const { GenericContainer } = await import('testcontainers');
+  const container = await new GenericContainer(image).withExposedPorts(3306).withEnvironment({ MYSQL_ROOT_PASSWORD: password }).withTmpFs({ "/var/lib/mysql": "rw" }).start();
+  const host = container.getHost();
+  const port = container.getMappedPort(3306);
+  const connection = { host, port, user, password };
+  const stopContainer = async () => {
+    await container.stop({ timeout: 1e4 });
+  };
+  await waitForMysqlReady(connection);
+  return { connection, stopContainer };
+}
+function parseMysqlConnectionString(connectionString) {
+  try {
+    const {
+      protocol,
+      username,
+      password,
+      port,
+      hostname,
+      pathname,
+      searchParams
+    } = new URL(connectionString);
+    if (protocol !== "mysql:") {
+      throw new Error(`Unknown protocol ${protocol}`);
+    } else if (!username || !password) {
+      throw new Error(`Missing username/password`);
+    } else if (!pathname.match(/^\/[^/]+$/)) {
+      throw new Error(`Expected single path segment`);
+    }
+    const result = {
+      user: username,
+      password,
+      host: hostname,
+      port: Number(port || 3306),
+      database: decodeURIComponent(pathname.substring(1))
+    };
+    const ssl = searchParams.get("ssl");
+    if (ssl) {
+      result.ssl = ssl;
+    }
+    const debug = searchParams.get("debug");
+    if (debug) {
+      result.debug = yn__default.default(debug);
+    }
+    return result;
+  } catch (e) {
+    throw new Error(`Error while parsing MySQL connection string, ${e}`, e);
+  }
+}
+class MysqlEngine {
+  static async create(properties) {
+    const { connectionStringEnvironmentVariableName, dockerImageName } = properties;
+    if (connectionStringEnvironmentVariableName) {
+      const connectionString = process.env[connectionStringEnvironmentVariableName];
+      if (connectionString) {
+        const connection = parseMysqlConnectionString(connectionString);
+        return new MysqlEngine(
+          properties,
+          connection
+        );
+      }
+    }
+    if (dockerImageName) {
+      const { connection, stopContainer } = await startMysqlContainer(
+        dockerImageName
+      );
+      return new MysqlEngine(properties, connection, stopContainer);
+    }
+    throw new Error(`Test databasee for ${properties.name} not configured`);
+  }
+  #properties;
+  #connection;
+  #knexInstances;
+  #databaseNames;
+  #stopContainer;
+  constructor(properties, connection, stopContainer) {
+    this.#properties = properties;
+    this.#connection = connection;
+    this.#knexInstances = [];
+    this.#databaseNames = [];
+    this.#stopContainer = stopContainer;
+  }
+  async createDatabaseInstance() {
+    const adminConnection = this.#connectAdmin();
+    try {
+      const databaseName = `db${crypto.randomBytes(16).toString("hex")}`;
+      await adminConnection.raw("CREATE DATABASE ??", [databaseName]);
+      this.#databaseNames.push(databaseName);
+      const knexInstance = knexFactory__default.default({
+        client: this.#properties.driver,
+        connection: {
+          ...this.#connection,
+          database: databaseName
+        },
+        ...LARGER_POOL_CONFIG
+      });
+      this.#knexInstances.push(knexInstance);
+      return knexInstance;
+    } finally {
+      await adminConnection.destroy();
+    }
+  }
+  async shutdown() {
+    for (const instance of this.#knexInstances) {
+      await instance.destroy();
+    }
+    const adminConnection = this.#connectAdmin();
+    try {
+      for (const databaseName of this.#databaseNames) {
+        await adminConnection.raw("DROP DATABASE ??", [databaseName]);
+      }
+    } finally {
+      await adminConnection.destroy();
+    }
+    await this.#stopContainer?.();
+  }
+  #connectAdmin() {
+    const connection = {
+      ...this.#connection,
+      database: null
+    };
+    return knexFactory__default.default({
+      client: this.#properties.driver,
+      connection,
+      pool: {
+        acquireTimeoutMillis: 1e4
+      }
+    });
+  }
+}
+
+async function waitForPostgresReady(connection) {
+  const startTime = Date.now();
+  let lastError;
+  let attempts = 0;
+  for (; ; ) {
+    attempts += 1;
+    let knex;
+    try {
+      knex = knexFactory__default.default({
+        client: "pg",
+        connection: {
+          // make a copy because the driver mutates this
+          ...connection
+        }
+      });
+      const result = await knex.select(knex.raw("version()"));
+      if (Array.isArray(result) && result[0]?.version) {
+        return;
+      }
+    } catch (e) {
+      lastError = e;
+    } finally {
+      await knex?.destroy();
+    }
+    if (Date.now() - startTime > 3e4) {
+      throw new Error(
+        `Timed out waiting for the database to be ready for connections, ${attempts} attempts, ${lastError ? `last error was ${errors.stringifyError(lastError)}` : "(no errors thrown)"}`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+async function startPostgresContainer(image) {
+  const user = "postgres";
+  const password = uuid.v4();
+  const { GenericContainer } = await import('testcontainers');
+  const container = await new GenericContainer(image).withExposedPorts(5432).withEnvironment({ POSTGRES_PASSWORD: password }).withTmpFs({ "/var/lib/postgresql/data": "rw" }).start();
+  const host = container.getHost();
+  const port = container.getMappedPort(5432);
+  const connection = { host, port, user, password };
+  const stopContainer = async () => {
+    await container.stop({ timeout: 1e4 });
+  };
+  await waitForPostgresReady(connection);
+  return { connection, stopContainer };
+}
+class PostgresEngine {
+  static async create(properties) {
+    const { connectionStringEnvironmentVariableName, dockerImageName } = properties;
+    if (connectionStringEnvironmentVariableName) {
+      const connectionString = process.env[connectionStringEnvironmentVariableName];
+      if (connectionString) {
+        const connection = pgConnectionString.parse(connectionString);
+        return new PostgresEngine(
+          properties,
+          connection
+        );
+      }
+    }
+    if (dockerImageName) {
+      const { connection, stopContainer } = await startPostgresContainer(
+        dockerImageName
+      );
+      return new PostgresEngine(properties, connection, stopContainer);
+    }
+    throw new Error(`Test databasee for ${properties.name} not configured`);
+  }
+  #properties;
+  #connection;
+  #knexInstances;
+  #databaseNames;
+  #stopContainer;
+  constructor(properties, connection, stopContainer) {
+    this.#properties = properties;
+    this.#connection = connection;
+    this.#knexInstances = [];
+    this.#databaseNames = [];
+    this.#stopContainer = stopContainer;
+  }
+  async createDatabaseInstance() {
+    const adminConnection = this.#connectAdmin();
+    try {
+      const databaseName = `db${crypto.randomBytes(16).toString("hex")}`;
+      await adminConnection.raw("CREATE DATABASE ??", [databaseName]);
+      this.#databaseNames.push(databaseName);
+      const knexInstance = knexFactory__default.default({
+        client: this.#properties.driver,
+        connection: {
+          ...this.#connection,
+          database: databaseName
+        },
+        ...LARGER_POOL_CONFIG
+      });
+      this.#knexInstances.push(knexInstance);
+      return knexInstance;
+    } finally {
+      await adminConnection.destroy();
+    }
+  }
+  async shutdown() {
+    for (const instance of this.#knexInstances) {
+      await instance.destroy();
+    }
+    const adminConnection = this.#connectAdmin();
+    try {
+      for (const databaseName of this.#databaseNames) {
+        await adminConnection.raw("DROP DATABASE ??", [databaseName]);
+      }
+    } finally {
+      await adminConnection.destroy();
+    }
+    await this.#stopContainer?.();
+  }
+  #connectAdmin() {
+    return knexFactory__default.default({
+      client: this.#properties.driver,
+      connection: {
+        ...this.#connection,
+        database: "postgres"
+      },
+      pool: {
+        acquireTimeoutMillis: 1e4
+      }
+    });
+  }
+}
+
+class SqliteEngine {
+  static async create(properties) {
+    return new SqliteEngine(properties);
+  }
+  #properties;
+  #instances;
+  constructor(properties) {
+    this.#properties = properties;
+    this.#instances = [];
+  }
+  async createDatabaseInstance() {
+    const instance = knexFactory__default.default({
+      client: this.#properties.driver,
+      connection: ":memory:",
+      useNullAsDefault: true
+    });
+    instance.client.pool.on("createSuccess", (_eventId, resource) => {
+      resource.run("PRAGMA foreign_keys = ON", () => {
+      });
+    });
+    this.#instances.push(instance);
+    return instance;
+  }
+  async shutdown() {
+    for (const instance of this.#instances) {
+      await instance.destroy();
+    }
+  }
+}
+
 class TestDatabases {
-  instanceById;
+  engineFactoryByDriver = {
+    pg: PostgresEngine.create,
+    mysql: MysqlEngine.create,
+    mysql2: MysqlEngine.create,
+    "better-sqlite3": SqliteEngine.create,
+    sqlite3: SqliteEngine.create
+  };
+  engineByTestDatabaseId;
   supportedIds;
   static defaultIds;
   /**
@@ -221,7 +745,7 @@ class TestDatabases {
     TestDatabases.defaultIds = options.ids;
   }
   constructor(supportedIds) {
-    this.instanceById = /* @__PURE__ */ new Map();
+    this.engineByTestDatabaseId = /* @__PURE__ */ new Map();
     this.supportedIds = supportedIds;
   }
   supports(id) {
@@ -251,154 +775,26 @@ class TestDatabases {
         `Unsupported test database ${id} for this environment, possible values are ${candidates}`
       );
     }
-    let instance = this.instanceById.get(id);
-    if (!instance) {
-      instance = await this.initAny(properties);
-      this.instanceById.set(id, instance);
-    }
-    const databaseName = `db${crypto.randomBytes(16).toString("hex")}`;
-    const connection = await instance.databaseManager.forPlugin(databaseName).getClient();
-    instance.connections.push(connection);
-    instance.databaseNames.push(databaseName);
-    return connection;
-  }
-  async initAny(properties) {
-    if (properties.driver === "pg" || properties.driver === "mysql2") {
-      const envVarName = properties.connectionStringEnvironmentVariableName;
-      if (envVarName) {
-        const connectionString = process.env[envVarName];
-        if (connectionString) {
-          const config$1 = new config.ConfigReader({
-            backend: {
-              database: {
-                knexConfig: properties.driver.includes("sqlite") ? {} : LARGER_POOL_CONFIG,
-                client: properties.driver,
-                connection: connectionString
-              }
-            }
-          });
-          const databaseManager = backendCommon.DatabaseManager.fromConfig(config$1);
-          const databaseNames = [];
-          return {
-            dropDatabases: async () => {
-              await backendCommon.dropDatabase(
-                config$1.getConfig("backend.database"),
-                ...databaseNames.map(
-                  (databaseName) => `backstage_plugin_${databaseName}`
-                )
-              );
-            },
-            databaseManager,
-            databaseNames,
-            connections: []
-          };
-        }
-      }
-    }
-    switch (properties.driver) {
-      case "pg":
-        return this.initPostgres(properties);
-      case "mysql2":
-        return this.initMysql(properties);
-      case "better-sqlite3":
-      case "sqlite3":
-        return this.initSqlite(properties);
-      default:
+    let engine = this.engineByTestDatabaseId.get(id);
+    if (!engine) {
+      const factory = this.engineFactoryByDriver[properties.driver];
+      if (!factory) {
         throw new Error(`Unknown database driver ${properties.driver}`);
+      }
+      engine = await factory(properties);
+      this.engineByTestDatabaseId.set(id, engine);
     }
-  }
-  async initPostgres(properties) {
-    const { host, port, user, password, stop } = await startPostgresContainer(
-      properties.dockerImageName
-    );
-    const databaseManager = backendCommon.DatabaseManager.fromConfig(
-      new config.ConfigReader({
-        backend: {
-          database: {
-            knexConfig: LARGER_POOL_CONFIG,
-            client: "pg",
-            connection: { host, port, user, password }
-          }
-        }
-      })
-    );
-    return {
-      stopContainer: stop,
-      databaseManager,
-      databaseNames: [],
-      connections: []
-    };
-  }
-  async initMysql(properties) {
-    const { host, port, user, password, stop } = await startMysqlContainer(
-      properties.dockerImageName
-    );
-    const databaseManager = backendCommon.DatabaseManager.fromConfig(
-      new config.ConfigReader({
-        backend: {
-          database: {
-            knexConfig: LARGER_POOL_CONFIG,
-            client: "mysql2",
-            connection: { host, port, user, password }
-          }
-        }
-      })
-    );
-    return {
-      stopContainer: stop,
-      databaseManager,
-      databaseNames: [],
-      connections: []
-    };
-  }
-  async initSqlite(properties) {
-    const databaseManager = backendCommon.DatabaseManager.fromConfig(
-      new config.ConfigReader({
-        backend: {
-          database: {
-            client: properties.driver,
-            connection: ":memory:"
-          }
-        }
-      })
-    );
-    return {
-      databaseManager,
-      databaseNames: [],
-      connections: []
-    };
+    return await engine.createDatabaseInstance();
   }
   async shutdown() {
-    const instances = [...this.instanceById.values()];
-    this.instanceById.clear();
-    for (const {
-      stopContainer,
-      dropDatabases,
-      connections,
-      databaseManager
-    } of instances) {
-      for (const connection of connections) {
-        try {
-          await connection.destroy();
-        } catch (error) {
-          console.warn(`TestDatabases: Failed to destroy connection`, {
-            connection,
-            error
-          });
-        }
-      }
+    const engines = [...this.engineByTestDatabaseId.values()];
+    this.engineByTestDatabaseId.clear();
+    for (const engine of engines) {
       try {
-        await dropDatabases?.();
+        await engine.shutdown();
       } catch (error) {
-        console.warn(`TestDatabases: Failed to drop databases`, {
-          error
-        });
-      }
-      try {
-        await stopContainer?.();
-      } catch (error) {
-        console.warn(`TestDatabases: Failed to stop container`, {
-          databaseManager,
+        console.warn(`TestDatabases: Failed to shutdown engine`, {
+          engine,
           error
         });
       }
@@ -697,10 +1093,14 @@ exports.mockCredentials = void 0;
     }
     limitedUser2.invalidCookie = invalidCookie;
   })(limitedUser = mockCredentials2.limitedUser || (mockCredentials2.limitedUser = {}));
-  function service(subject = DEFAULT_MOCK_SERVICE_SUBJECT) {
+  function service(subject = DEFAULT_MOCK_SERVICE_SUBJECT, accessRestrictions) {
     return {
       $$type: "@backstage/BackstageCredentials",
-      principal: { type: "service", subject }
+      principal: {
+        type: "service",
+        subject,
+        ...accessRestrictions ? { accessRestrictions } : {}
+      }
     };
   }
   mockCredentials2.service = service;
@@ -1876,6 +2276,7 @@ class ServiceFactoryTester {
 }
 
 exports.ServiceFactoryTester = ServiceFactoryTester;
+exports.TestCaches = TestCaches;
 exports.TestDatabases = TestDatabases;
 exports.createMockDirectory = createMockDirectory;
 exports.isDockerDisabledForTests = isDockerDisabledForTests;