apostrophe 4.30.1-beta.1 → 4.31.0

package/test-lib/util.js

@@ -1,5 +1,27 @@
 const { createId } = require('@paralleldrive/cuid2');
-const mongodbConnect = require('../lib/mongodb-connect');
+
+const testDbProtocol = process.env.APOS_TEST_DB_PROTOCOL || 'mongodb';
+
+// Build a test database URI for postgres based on the shortName.
+// Returns undefined for mongodb, letting the default logic handle it.
+function getTestDbUri(shortName) {
+  if (testDbProtocol === 'postgres') {
+    // PostgreSQL database names cannot contain hyphens
+    const dbName = shortName.replace(/-/g, '_');
+    return `postgres://localhost:5432/${dbName}`;
+  }
+  if (testDbProtocol === 'multipostgres') {
+    // Multi-schema mode: shared real database, per-test schema
+    const schemaName = shortName.replace(/-/g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+    return `multipostgres://localhost:5432/apos_test-${schemaName}`;
+  }
+  if (testDbProtocol === 'sqlite') {
+    const os = require('os');
+    const path = require('path');
+    const dbName = shortName.replace(/-/g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+    return `sqlite://${path.join(os.tmpdir(), `apos_test_${dbName}.db`)}`;
+  }
+}
 
 // Properly clean up an apostrophe instance and drop its
 // database collections to create a sane environment for the next test.
@@ -10,23 +32,23 @@ const mongodbConnect = require('../lib/mongodb-connect');
 // If `apos` is null, no work is done.
 
 async function destroy(apos) {
-  if (!apos) {
+  if (!apos || apos._destroyed) {
     return;
   }
+  apos._destroyed = true;
+  const dbModule = apos.modules['@apostrophecms/db'];
+  const { uri } = dbModule;
+  const dbName = apos.db && (apos.db.databaseName || apos.db._name);
   await apos.destroy();
-  const { uri } = apos.modules['@apostrophecms/db'];
-  const dbName = apos.db && apos.db.databaseName;
-  // TODO at some point accommodate nonsense like testing remote databases
-  // that won't let us use dropDatabase, no shell available etc., but the
-  // important principle here is that we should not have to have an apos
-  // object to clean up the database, otherwise we have to get hold of one
-  // when initialization failed and that's really not apostrophe's concern
-  if (dbName && uri) {
-    const client = await mongodbConnect(`${uri}${dbName}`);
-    const db = client.db(dbName);
-    await db.dropDatabase();
-    await client.close();
+  if (!uri || !dbName) {
+    return;
   }
+  // Make a fresh connection (the original was closed by destroy)
+  // and use it to drop the test database
+  const client = await dbModule.connectToAdapter(uri);
+  const db = client.db(dbName);
+  await db.dropDatabase();
+  await client.close();
 };
 
 async function create(options = {}) {
@@ -55,6 +77,18 @@ async function create(options = {}) {
     express.options.session.secret = express.options.session.secret || 'test';
     config.modules['@apostrophecms/express'] = express;
   }
+  // When APOS_TEST_DB_PROTOCOL=postgres, automatically configure the db
+  // module to use a postgres URI unless already explicitly configured
+  const testUri = getTestDbUri(config.shortName);
+  if (testUri) {
+    config.modules = config.modules || {};
+    const dbModule = config.modules['@apostrophecms/db'] || {};
+    dbModule.options = dbModule.options || {};
+    if (!dbModule.options.uri && !dbModule.options.client) {
+      dbModule.options.uri = testUri;
+    }
+    config.modules['@apostrophecms/db'] = dbModule;
+  }
   return require('../index.js')(config);
 }
 
@@ -151,5 +185,7 @@ module.exports = {
   loginAs,
   logout,
   getUserJar,
+  getTestDbUri,
+  testDbProtocol,
   timeout: (process.env.TEST_TIMEOUT && parseInt(process.env.TEST_TIMEOUT)) || 20000
 };

package/lib/mongodb-connect.js

@@ -1,62 +0,0 @@
-const mongo = require('@apostrophecms/emulate-mongo-3-driver');
-const dns = require('dns');
-
-// Connect to MongoDB, using the modern topology and parser, and
-// a tolerant policy to successfully connect to "localhost" even if
-// the first record returned by the resolver doesn't reach mongodb's
-// bind address because localhost resolves first to ::1 (ipv6) and
-// mongodb lists only on 127.0.0.1 (ipv4) by default. For broadest
-// compatibility we don't assume we know this will happen, we try all the
-// addresses that localhost actually resolves to and succeed with the
-// first one that works.
-
-module.exports = async (uri, options) => {
-  const connectOptions = {
-    useUnifiedTopology: true,
-    useNewUrlParser: true,
-    ...options
-  };
-  let parsed;
-  try {
-    parsed = new URL(uri);
-  } catch (e) {
-    // Parse failed, e.g. old school replica set URI
-    // with commas, just let the mongo driver handle it
-    return mongo.MongoClient.connect(uri, connectOptions);
-  }
-  if (!parsed || (parsed.protocol !== 'mongodb:') || (parsed.hostname !== 'localhost')) {
-    return mongo.MongoClient.connect(parsed.toString(), connectOptions);
-  }
-  const records = await dns.promises.lookup('localhost', { all: true });
-  if (!records.length) {
-    // The computer that reaches this point has bigger problems 😅
-    throw new Error('Unable to resolve localhost to an IP address.');
-  }
-  return new Promise((resolve, reject) => {
-    let failed = 0;
-    let succeeded = false;
-    records.forEach(attempt);
-    async function attempt(record) {
-      try {
-        const parsed = new URL(uri);
-        parsed.hostname = record.address;
-        const result = await mongo.MongoClient.connect(parsed.toString(), connectOptions);
-        if (!succeeded) {
-          succeeded = true;
-          resolve(result);
-        } else {
-          // We succeeded in reaching localhost at both ip4 and ip6,
-          // but we only need one of them to succeed
-          await result.close();
-        }
-      } catch (e) {
-        failed++;
-        if (failed === records.length) {
-          // None succeeded, so reject with the last error
-          // (which one we reject with doesn't really matter)
-          reject(e);
-        }
-      }
-    }
-  });
-};