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

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @backstage/backend-test-utils
 
+## 0.4.0-next.2
+
+### Patch Changes
+
+- 0634fdc: Refactored `TestDatabases` to no longer depend on `backend-common`
+- Updated dependencies
+  - @backstage/backend-plugin-api@0.6.19-next.2
+  - @backstage/backend-app-api@0.7.6-next.2
+  - @backstage/plugin-auth-node@0.4.14-next.2
+  - @backstage/plugin-events-node@0.3.5-next.1
+  - @backstage/config@1.2.0
+  - @backstage/errors@1.2.4
+  - @backstage/types@1.1.1
+
 ## 0.4.0-next.1
 
 ### Minor Changes

package/dist/index.cjs.js

@@ -4,17 +4,18 @@ var Keyv = require('keyv');
 var KeyvMemcache = require('@keyv/memcache');
 var uuid = require('uuid');
 var KeyvRedis = require('@keyv/redis');
-var backendCommon = require('@backstage/backend-common');
-var config = require('@backstage/config');
+var errors = require('@backstage/errors');
 var crypto = require('crypto');
-var createConnection = require('knex');
+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');
@@ -24,7 +25,8 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 var Keyv__default = /*#__PURE__*/_interopDefaultCompat(Keyv);
 var KeyvMemcache__default = /*#__PURE__*/_interopDefaultCompat(KeyvMemcache);
 var KeyvRedis__default = /*#__PURE__*/_interopDefaultCompat(KeyvRedis);
-var createConnection__default = /*#__PURE__*/_interopDefaultCompat(createConnection);
+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);
@@ -298,80 +300,6 @@ class TestCaches {
   }
 }
 
-async function waitForMysqlReady(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}`
-          );
-        }
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  } finally {
-    db.destroy();
-  }
-}
-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 stop = async () => {
-    await container.stop({ timeout: 1e4 });
-  };
-  await waitForMysqlReady({ host, port, user, password });
-  return { host, port, user, password, stop };
-}
-
-async function waitForPostgresReady(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}`
-          );
-        }
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  } finally {
-    db.destroy();
-  }
-}
-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 stop = async () => {
-    await container.stop({ timeout: 1e4 });
-  };
-  await waitForPostgresReady({ host, port, user, password });
-  return { host, port, user, password, stop };
-}
-
 const allDatabases = Object.freeze({
   POSTGRES_16: {
     name: "Postgres 16.x",
@@ -426,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;
   /**
@@ -487,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) {
@@ -517,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
-          });
-        }
-      }
-      try {
-        await dropDatabases?.();
-      } catch (error) {
-        console.warn(`TestDatabases: Failed to drop databases`, {
-          error
-        });
-      }
+    const engines = [...this.engineByTestDatabaseId.values()];
+    this.engineByTestDatabaseId.clear();
+    for (const engine of engines) {
       try {
-        await stopContainer?.();
+        await engine.shutdown();
       } catch (error) {
-        console.warn(`TestDatabases: Failed to stop container`, {
-          databaseManager,
+        console.warn(`TestDatabases: Failed to shutdown engine`, {
+          engine,
           error
         });
       }