jskos-server 2.4.0

package/test/test-utils.js

@@ -0,0 +1,182 @@
+import assert from "node:assert"
+import mongoose from "mongoose"
+import { MongoMemoryServer, MongoMemoryReplSet } from "mongodb-memory-server"
+import { createServices } from "../index.js"
+
+import config from "../config/config.test.json" with { type: "json" }
+const services = createServices(config)
+
+let mongod
+
+/**
+ * Starts an in-memory MongoDB server (standalone or replica set).
+ */
+export async function setupInMemoryMongo(opts = { replSet: false }) {
+  if (opts.replSet) {
+    mongod = new MongoMemoryReplSet({ replSet: { count: 1 } })
+  } else {
+    mongod = new MongoMemoryServer()
+  }
+  await mongod.start()
+  const uri = mongod.getUri()
+
+  await mongoose.disconnect().catch(() => {})
+  await mongoose.connect(uri, {
+    serverSelectionTimeoutMS: 30000,
+  })
+
+  return uri
+}
+
+
+/**
+ * Stops Mongoose and in-memory server.
+ */
+export async function teardownInMemoryMongo() {
+  if (mongoose.connection.readyState !== 0) {
+    await mongoose.disconnect()
+  }
+  if (mongod) {
+    await mongod.stop()
+  }
+}
+
+
+/**
+ * Drop the database.
+ */
+export async function dropDatabase() {
+  const conn = mongoose.connection
+  // If not connected at all, skip drop
+  if (conn.readyState === 0) {
+    console.log("    ⚠ No connection, skipping drop")
+    return
+  }
+  // If connecting, wait until connected or timeout
+  if (conn.readyState !== 1) {
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("Timeout waiting for DB connection")), 5000)
+      conn.once("connected", () => {
+        clearTimeout(timeout); resolve()
+      })
+      conn.once("error", (err) => {
+        clearTimeout(timeout); reject(err)
+      })
+    })
+  }
+  try {
+    await conn.db.dropDatabase()
+    console.log("    ✓ Dropped in-memory database")
+  } catch (err) {
+    console.error("    x Error: Dropping database failed.", err)
+    throw err
+  }
+}
+
+
+/* process.on("SIGINT", () => {
+  dropDatabase(() => process.exit(1))
+}) */
+
+/**
+ * Mocha hooks: drop DB before and after each suite.
+ */
+export function dropDatabaseBeforeAndAfter() {
+  before(async () => {
+    await dropDatabase()
+  })
+  after(async ()  => {
+    await dropDatabase()
+  })
+}
+
+/**
+ * Asserts that Mongoose is connected.
+ */
+export function assertMongoDB() {
+  describe("MongoDB Connection", () => {
+    it("should connect successfully", (done) => {
+      const conn = mongoose.connection
+      if (conn.readyState === 1) {
+        return done()
+      }
+      conn.once("connected", () => done())
+      conn.once("error", (err) => done(err))
+    })
+  })
+}
+
+
+/**
+ * Ensure that all JSKOS collections exist and have their indexes.
+ * This replaces running `import.js --indexes`.
+ */
+export async function createCollectionsAndIndexes() {
+  const collNames = ["terminologies","concepts","concordances","mappings","annotations","registries"]
+  // 1. Create an empty collection if it doesn't exist
+  for (const name of collNames) {
+    const exists = await mongoose.connection.db
+      .listCollections({ name })
+      .hasNext()
+    if (!exists) {
+      await mongoose.connection.db.createCollection(name)
+    }
+  }
+  // 2. Call each service's createIndexes() method
+  for (const type of Object.keys(services)) {
+    // services[type].createIndexes() should invoke e.g. Model.createIndexes()
+    await services[type].createIndexes()
+  }
+}
+
+
+/**
+ * Verifies that indexes exist on all relevant collections.
+ */
+export async function assertIndexes() {
+  it("should have at least default indexes", async () => {
+    const collections = ["terminologies", "concepts", "concordances", "mappings", "annotations", "registries"]
+    for (const name of collections) {
+      // ensure collection exists
+      const exists = await mongoose.connection.db.listCollections({ name }).hasNext()
+      if (!exists) {
+        await mongoose.connection.db.createCollection(name)
+      }
+      const info = await mongoose.connection.db.collection(name).indexInformation()
+      // Expect at least the _id index
+      assert.ok(info._id_, `Missing _id index on ${name}`)
+      // Optionally check other indexes here
+    }
+  })
+}
+
+
+import { exec as cpexec } from "node:child_process"
+/**
+ * A wrapper around child_process' exec function for async/await.
+ *
+ * @param {*} command
+ * @param {*} options
+ */
+export async function exec(command, options) {
+  return new Promise((resolve, reject) => {
+    cpexec(command, options || {}, (error, stdout, stderr) => {
+      if (error) {
+        error.stdout = stdout
+        error.stderr = stderr
+        return reject(error)
+      }
+      resolve(stdout)
+    })
+  })
+}
+
+import Stream from "node:stream"
+import * as anystream from "json-anystream"
+
+export async function arrayToStream(array) {
+  const readable = new Stream.Readable({ objectMode: true })
+  array.forEach(item => readable.push(JSON.stringify(item) + "\n"))
+  readable.push(null)
+  return anystream.make(readable, "ndjson")
+}

package/test/utils.js

@@ -0,0 +1,425 @@
+// Tests for utilities
+
+import assert from "node:assert"
+import { getCreator, handleCreatorForObject } from "../utils/middleware.js"
+import { cleanJSON } from "../utils/utils.js"
+import config from "../config/index.js"
+
+describe("utils", () => {
+
+  describe("getCreator", () => {
+    const tests = [
+      {
+        req: {},
+        creator: null,
+      },
+      {
+        req: {
+          user: {
+            uri: "test",
+          },
+        },
+        creator: {
+          uri: "test",
+        },
+      },
+      {
+        req: {
+          user: {
+            uri: "test",
+          },
+          query: {
+            identity: "test2",
+          },
+        },
+        creator: {
+          uri: "test",
+        },
+      },
+      {
+        req: {
+          user: {
+            uri: "test",
+            identities: {
+              test2: { uri: "test2" },
+            },
+          },
+          query: {
+            identity: "test2",
+          },
+        },
+        creator: {
+          uri: "test2",
+        },
+      },
+      {
+        req: {
+          user: {
+            uri: "test",
+            identities: {
+              test2: {
+                uri: "test2",
+                name: "name2",
+              },
+            },
+          },
+          query: {
+            identity: "test2",
+          },
+        },
+        creator: {
+          uri: "test2",
+          prefLabel: { en: "name2" },
+        },
+      },
+      {
+        req: {
+          type: "annotations",
+          user: {
+            uri: "test",
+            identities: {
+              test2: {
+                uri: "test2",
+                name: "name2",
+              },
+            },
+          },
+          query: {
+            identity: "test2",
+          },
+        },
+        creator: {
+          id: "test2",
+          name: "name2",
+        },
+      },
+      {
+        req: {
+          user: {
+            uri: "test",
+            identities: {
+              test2: {
+                uri: "test2",
+                name: "name2",
+              },
+            },
+          },
+          query: {
+            identity: "test2",
+            identityName: "",
+          },
+        },
+        creator: {
+          uri: "test2",
+        },
+      },
+      {
+        req: {
+          query: {
+            identityName: "name",
+          },
+        },
+        creator: {
+          prefLabel: { en: "name" },
+        },
+      },
+      {
+        req: {
+          user: {
+            uri: "",
+          },
+        },
+        creator: null,
+      },
+    ]
+    let index = 0
+    for (let { req, creator: expected } of tests) {
+      it(`should pass test[${index}]`, async () => {
+        const actual = getCreator(Object.assign({ query: {} }, req))
+        // For non-annotations, creator should be an array if defined
+        assert.deepStrictEqual(actual, expected)
+      })
+      index += 1
+    }
+
+    it("should fail if req is undefined", async () => {
+      assert.throws(() => {
+        getCreator()
+      })
+    })
+
+    it("should fail if req.query is undefined", async () => {
+      assert.throws(() => {
+        getCreator({})
+      })
+    })
+
+  })
+
+  describe("handleCreatorForObject", () => {
+    const req = {
+      anonymous: false,
+      auth: true,
+    }
+    const reqWithMethod = (method) => Object.assign({ method }, req)
+    const tests = [
+      // Everything undefined
+      {
+        req,
+      },
+      // For null-ish values, keep the valye
+      {
+        object: null,
+        expected: null,
+        req,
+      },
+      // Everything empty
+      {
+        object: {},
+        expected: {},
+        req,
+      },
+      // No modifications without method/type
+      {
+        object: {
+          creator: "value doesn't matter",
+        },
+        expected: {
+          creator: "value doesn't matter",
+        },
+        req,
+      },
+      // Always remove contributor for annotations
+      {
+        object: {
+          contributor: "value doesn't matter",
+        },
+        expected: {},
+        req: Object.assign({
+          type: "annotations",
+        }, req),
+      },
+      // Set creator for POST
+      {
+        object: {},
+        creator: { uri: "test" },
+        req: reqWithMethod("POST"),
+        expected: {
+          creator: [{ uri: "test" }],
+        },
+      },
+      // Set creator for annotation
+      {
+        object: { creator: {} },
+        creator: { uri: "test" },
+        req: Object.assign({
+          type: "annotations",
+        }, reqWithMethod("PUT")),
+        expected: {
+          creator: { uri: "test" },
+        },
+      },
+      // Keep existing creator for PUT
+      {
+        object: {
+          creator: "some creator",
+        },
+        req: reqWithMethod("PUT"),
+        existing: {
+          creator: "creator",
+          contributor: "contributor",
+        },
+        expected: {
+          creator: "creator",
+        },
+      },
+      // Remove creator for PATCH
+      {
+        object: {
+          creator: "some creator",
+        },
+        req: reqWithMethod("PATCH"),
+        existing: {
+          creator: "creator",
+        },
+        expected: {},
+      },
+      // Add to contributor for PUT/PATCH
+      {
+        object: {},
+        req: reqWithMethod("PATCH"),
+        creator: {
+          uri: "test",
+        },
+        existing: {},
+        expected: {
+          contributor: [{ uri: "test" }],
+        },
+      },
+      {
+        object: {},
+        req: reqWithMethod("PUT"),
+        creator: {
+          uri: "test",
+        },
+        existing: {
+          creator: [{ uri: "other" }],
+        },
+        expected: {
+          creator: [{ uri: "other" }],
+          contributor: [{ uri: "test" }],
+        },
+      },
+      // Adjust existing creator entry
+      {
+        object: {},
+        req: Object.assign({
+          user: {
+            uri: "test",
+            identities: {
+              test: {
+                uri: "testAlternative",
+              },
+            },
+          },
+        }, reqWithMethod("PUT")),
+        creator: {
+          uri: "test",
+          prefLabel: { en: "name" },
+        },
+        existing: {
+          creator: [{ uri: "testAlternative" }],
+        },
+        expected: {
+          creator: [{
+            uri: "test",
+            prefLabel: { en: "name" },
+          }],
+        },
+      },
+      // Adjust existing contributor entry, push to end
+      {
+        object: {},
+        req: Object.assign({
+          user: {
+            uri: "test",
+            identities: {
+              test: {
+                uri: "testAlternative",
+              },
+            },
+          },
+        }, reqWithMethod("PUT")),
+        creator: { uri: "test" },
+        existing: {
+          creator: [{}],
+          contributor: [{ uri: "testAlternative" }, {}],
+        },
+        expected: {
+          creator: [{}],
+          contributor: [{}, { uri: "test" }],
+        },
+      },
+      // Allow any kind of values if auth is false
+      {
+        object: { creator: [{ uri: "abc " }], contributor: [] },
+        expected: { creator: [{ uri: "abc " }], contributor: [] },
+        req: Object.assign(reqWithMethod("POST"), { auth: false }),
+        // Should be ignored
+        creator: { uri: "test" },
+      },
+      // Always remove creator/contributor from payload when anonymous is true, but don't change existing values
+      {
+        object: { creator: [{ uri: "abc " }], contributor: [] },
+        existing: { creator: [{ uri: "def" }], contributor: [{ uri: "ghj" }] },
+        expected: { creator: [{ uri: "def" }], contributor: [{ uri: "ghj" }] },
+        req: Object.assign(reqWithMethod("PUT"), { anonymous: true }),
+      },
+    ]
+    let index = 0
+    for (let { expected, ...options } of tests) {
+      it(`should pass test[${index}]`, async () => {
+        const actual = handleCreatorForObject(Object.assign({ req: {} }, options))
+        // Should return object reference
+        assert.strictEqual(actual, options.object)
+        // Check if content is correct as well
+        assert.deepStrictEqual(actual, expected)
+      })
+      index += 1
+    }
+  })
+
+  describe("cleanJSON", () => {
+    const prevClosedWorldAssumption = config.closedWorldAssumption
+
+    const tests = [
+      {
+        closedWorldAssumption: false,
+        input: {
+          _a: 1,
+          b: {},
+          c: [],
+          d: 2,
+        },
+        output: {
+          d: 2,
+        },
+      },
+      {
+        closedWorldAssumption: true,
+        input: {
+          b: {},
+          c: [],
+        },
+        output: {
+          b: {},
+          c: [],
+        },
+      },
+      {
+        closedWorldAssumption: false,
+        input: [
+          {
+            _a: 1,
+            b: {},
+            c: [],
+            d: null,
+          },
+        ],
+        output: [
+          {
+            d: null,
+          },
+        ],
+      },
+      // Currently, only top-level properties are affected by closedWorldAssumption = false.
+      // See: https://github.com/gbv/jskos-server/commit/123dc9da09f1e41f2263ee8a0f7faeefe67fa9ed#r67204606
+      {
+        closedWorldAssumption: false,
+        input: {
+          a: {
+            b: {},
+            _b: 1,
+          },
+        },
+        output: {
+          a: {
+            b: {},
+          },
+        },
+      },
+    ]
+
+    let index = 0
+    for (let { closedWorldAssumption, input, output } of tests) {
+      it(`should pass test[${index}]`, async () => {
+        cleanJSON(input, 0, closedWorldAssumption)
+        assert.deepEqual(input, output)
+      })
+      index += 1
+    }
+
+    config.closedWorldAssumption = prevClosedWorldAssumption
+  })
+
+})