droboticflow-new/tests/frontend/database-browser.test.mjs
2026-06-18 13:06:24 +08:00

126 lines
5.7 KiB
JavaScript

import test from "node:test";
import assert from "node:assert/strict";
import {
buildDatabaseBrowserPageOptions,
buildExternalWriteCollectionWhitelist,
parseDatabaseBrowserPageNumber,
parseDatabaseFilterText,
parseDatabaseIndexKeysText,
validateDatabaseCollectionName,
validateDatabaseDocumentPayload,
validateDatabaseIndexName,
validateDatabaseIndexKeys,
validateMongoConnectionURI,
} from "../../src/lib/database-browser.js";
test("database browser page parser keeps blank values as defaults", () => {
assert.deepEqual(parseDatabaseBrowserPageNumber("", { field: "Limit", defaultValue: 50, minValue: 1 }), {
value: 50,
error: "",
});
assert.deepEqual(parseDatabaseBrowserPageNumber(" ", { field: "Skip", defaultValue: 0, minValue: 0 }), {
value: 0,
error: "",
});
});
test("database browser page parser rejects lossy integer coercion", () => {
assert.match(
parseDatabaseBrowserPageNumber("1.5", { field: "Limit", defaultValue: 50, minValue: 1 }).error,
/must be an integer/,
);
assert.match(
parseDatabaseBrowserPageNumber("12abc", { field: "Limit", defaultValue: 50, minValue: 1 }).error,
/must be an integer/,
);
});
test("database browser page parser enforces field minimums", () => {
assert.match(
parseDatabaseBrowserPageNumber("0", { field: "Limit", defaultValue: 50, minValue: 1 }).error,
/greater than or equal to 1/,
);
assert.match(
parseDatabaseBrowserPageNumber("-1", { field: "Skip", defaultValue: 0, minValue: 0 }).error,
/greater than or equal to 0/,
);
});
test("database browser page options combine valid parsed limit and skip", () => {
assert.deepEqual(buildDatabaseBrowserPageOptions({ limitText: "25", skipText: "5" }), {
limit: 25,
skip: 5,
error: "",
});
});
test("database browser page options collect query errors before API calls", () => {
assert.equal(
buildDatabaseBrowserPageOptions({ limitText: "abc", skipText: "-1" }).error,
"Limit must be an integer; Skip must be greater than or equal to 0",
);
});
test("database browser collection name validator mirrors backend reserved names", () => {
assert.equal(validateDatabaseCollectionName("orders_2026"), "");
assert.match(validateDatabaseCollectionName("system.profile"), /reserved system prefix/);
assert.match(validateDatabaseCollectionName("orders/archive"), /path separators/);
assert.match(validateDatabaseCollectionName("orders$archive"), /cannot contain \$/);
});
test("external write collection whitelist rejects invalid collection names before saving tokens", () => {
assert.deepEqual(buildExternalWriteCollectionWhitelist("orders\ncustomers, orders"), {
collections: ["customers", "orders"],
error: "",
});
assert.deepEqual(buildExternalWriteCollectionWhitelist(""), {
collections: [],
error: "",
});
assert.match(buildExternalWriteCollectionWhitelist("orders\nsystem.profile").error, /reserved system prefix/);
assert.match(buildExternalWriteCollectionWhitelist("orders/archive").error, /path separators/);
assert.match(buildExternalWriteCollectionWhitelist("orders$archive").error, /cannot contain \$/);
});
test("mongo connection URI validator mirrors backend connection rules", () => {
assert.equal(validateMongoConnectionURI("mongodb://business.example:27017"), "");
assert.equal(validateMongoConnectionURI("mongodb+srv://cluster.example.mongodb.net/business"), "");
assert.match(validateMongoConnectionURI("", { required: true }), /required/);
assert.match(validateMongoConnectionURI("http://business.example:27017"), /mongodb:\/\/ or mongodb\+srv:\/\//);
assert.match(validateMongoConnectionURI("mongodb://<user>:<password>@business.example:27017"), /placeholder markers/);
assert.match(validateMongoConnectionURI("mongodb://business.example:27017/bad path"), /without whitespace/);
});
test("database browser index validators reject unsafe index definitions", () => {
assert.equal(validateDatabaseIndexName("orders_created_at"), "");
assert.match(validateDatabaseIndexName("_id_"), /reserved/);
assert.deepEqual(parseDatabaseIndexKeysText('{ "createdAt": -1, "status": 1 }'), {
createdAt: -1,
status: 1,
});
assert.equal(validateDatabaseIndexKeys({ name: "text", location: "2dsphere" }), "");
assert.match(validateDatabaseIndexKeys({ $where: 1 }), /operator keys/);
assert.match(validateDatabaseIndexKeys({ "metadata..name": 1 }), /empty path segments/);
assert.throws(() => parseDatabaseIndexKeysText('{ "createdAt": "ascending" }'), /index key direction/);
});
test("database browser filter parser rejects unsafe query operators before API calls", () => {
assert.deepEqual(parseDatabaseFilterText('{ "$or": [{ "status": "open" }, { "priority": { "$in": [1, 2] } }] }'), {
$or: [{ status: "open" }, { priority: { $in: [1, 2] } }],
});
assert.deepEqual(parseDatabaseFilterText(""), {});
assert.throws(() => parseDatabaseFilterText('{ "$where": "return true" }'), /cannot use the \$where operator/);
assert.throws(() => parseDatabaseFilterText('{ "metadata..name": "demo" }'), /empty path segments/);
assert.throws(() => parseDatabaseFilterText('{ "": "demo" }'), /empty field names/);
});
test("database browser document payload validator rejects unsafe document keys", () => {
assert.equal(validateDatabaseDocumentPayload({ name: "demo", nested: [{ count: 1 }] }), "");
assert.match(validateDatabaseDocumentPayload({}), /required/);
assert.match(validateDatabaseDocumentPayload({ $set: { name: "demo" } }), /operator keys/);
assert.match(validateDatabaseDocumentPayload({ nested: [{ $inc: { count: 1 } }] }), /operator keys/);
assert.match(validateDatabaseDocumentPayload({ "bad\u0000key": "demo" }), /NUL bytes/);
assert.match(validateDatabaseDocumentPayload({ nested: [{ "bad\u0000key": "demo" }] }), /NUL bytes/);
});