@7365admin1/core 3.53.9 → 3.55.0

package/test/personal-emergency-chain.test.mjs

@@ -0,0 +1,261 @@
+/**
+ * The ordering rules of a person's own emergency chain, run as the shipped
+ * module -- not a description of it.
+ *
+ * Two things decide whether "ring my wife, then my son, then my doctor" works
+ * at all, and both are enforced here rather than in a screen:
+ *
+ *  1. no two contacts may claim the same position -- otherwise "who is second"
+ *     has two answers and the dialer picks one at random;
+ *  2. a chain that breaks rule 1 is refused BEFORE anything is written, which is
+ *     what makes a reorder atomic. There is no partial order to clean up,
+ *     because a rejected reorder never reaches the database at all.
+ *
+ * The E.164 rule is checked here too: a number that is not dialable from
+ * outside the country it was typed in is not an emergency contact.
+ *
+ * Nothing here opens a socket or a database.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { ObjectId } from "mongodb";
+
+import {
+  MAX_PERSONAL_EMERGENCY_CONTACTS,
+  DEFAULT_RING_SECONDS,
+  MPersonalEmergencyChain,
+  emptyPersonalEmergencyChain,
+  schemaUpdatePersonalEmergencyChain,
+} from "./.build/models/personal-emergency-chain.model.mjs";
+
+const USER = new ObjectId().toString();
+
+const contact = (over = {}) => ({
+  name: "Wife",
+  phone: "+6591234567",
+  relationship: "Spouse",
+  order: 1,
+  active: true,
+  ...over,
+});
+
+const validate = (body) =>
+  schemaUpdatePersonalEmergencyChain.validate(body, { convert: true });
+
+const chain = (contacts) => ({
+  user: USER,
+  contacts,
+  ringSeconds: DEFAULT_RING_SECONDS,
+  siteDirectoryFallback: true,
+});
+
+// ---------------------------------------------------------------- positions
+
+test("a chain with distinct positions is accepted -- the positive control", () => {
+  const { error, value } = validate({
+    contacts: [
+      contact({ name: "Wife", order: 1 }),
+      contact({ name: "Son", phone: "+6598765432", order: 2 }),
+      contact({ name: "Dr Tan", phone: "+6567001122", order: 3 }),
+    ],
+  });
+
+  assert.equal(error, undefined);
+  // A positive control that returned nothing would prove nothing.
+  assert.equal(value.contacts.length, 3);
+  assert.deepEqual(
+    value.contacts.map((c) => c.order),
+    [1, 2, 3],
+  );
+});
+
+test("two contacts cannot share a position", () => {
+  const { error } = validate({
+    contacts: [contact({ order: 2 }), contact({ name: "Son", order: 2 })],
+  });
+
+  assert.notEqual(error, undefined);
+  assert.match(error.message, /same position/i);
+});
+
+test("the model refuses a duplicate position even if validation is bypassed", () => {
+  // The repository calls the model, so this is the last gate before the write.
+  assert.throws(
+    () =>
+      MPersonalEmergencyChain(
+        chain([contact({ order: 1 }), contact({ name: "Son", order: 1 })]),
+      ),
+    /same position/i,
+  );
+});
+
+test("a stored chain comes back in dialling order, whatever order it was sent in", () => {
+  const doc = MPersonalEmergencyChain(
+    chain([
+      contact({ name: "Dr Tan", phone: "+6567001122", order: 3 }),
+      contact({ name: "Wife", order: 1 }),
+      contact({ name: "Son", phone: "+6598765432", order: 2 }),
+    ]),
+  );
+
+  assert.deepEqual(
+    doc.contacts.map((c) => c.name),
+    ["Wife", "Son", "Dr Tan"],
+  );
+  assert.deepEqual(
+    doc.contacts.map((c) => c.order),
+    [1, 2, 3],
+  );
+});
+
+test("a reorder is a whole new chain, and an invalid one changes nothing", () => {
+  const wife = contact({ name: "Wife", order: 1 });
+  const son = contact({ name: "Son", phone: "+6598765432", order: 2 });
+
+  const before = MPersonalEmergencyChain(chain([wife, son]));
+  assert.deepEqual(
+    before.contacts.map((c) => c.name),
+    ["Wife", "Son"],
+  );
+
+  // Swapping them is valid and lands complete.
+  const after = MPersonalEmergencyChain(
+    chain([
+      contact({ name: "Wife", order: 2 }),
+      contact({ name: "Son", phone: "+6598765432", order: 1 }),
+    ]),
+  );
+  assert.deepEqual(
+    after.contacts.map((c) => c.name),
+    ["Son", "Wife"],
+  );
+
+  // A half-typed reorder -- both at position 1 -- is refused outright, so the
+  // caller still holds the chain it had.
+  assert.throws(
+    () =>
+      MPersonalEmergencyChain(
+        chain([
+          contact({ name: "Wife", order: 1 }),
+          contact({ name: "Son", phone: "+6598765432", order: 1 }),
+        ]),
+      ),
+    /same position/i,
+  );
+  assert.deepEqual(
+    before.contacts.map((c) => c.name),
+    ["Wife", "Son"],
+  );
+});
+
+// -------------------------------------------------------------------- phone
+
+test("a phone number must be dialable from anywhere", () => {
+  for (const phone of [
+    "91234567",
+    "+0591234567",
+    "6591234567",
+    "+65 9123 4567",
+    "",
+    "+",
+  ]) {
+    const { error } = validate({ contacts: [contact({ phone })] });
+    assert.notEqual(error, undefined, JSON.stringify(phone) + " was accepted");
+  }
+
+  // Positive control across three countries, so the rule is not "Singapore only".
+  for (const phone of ["+6591234567", "+442071234567", "+14155550123"]) {
+    const { error } = validate({ contacts: [contact({ phone })] });
+    assert.equal(error, undefined, phone + " was refused");
+  }
+});
+
+// ----------------------------------------------------------------- settings
+
+test("chain settings have working defaults and real bounds", () => {
+  const { error, value } = validate({ contacts: [] });
+
+  assert.equal(error, undefined);
+  assert.equal(value.ringSeconds, DEFAULT_RING_SECONDS);
+  assert.equal(value.siteDirectoryFallback, true);
+
+  assert.notEqual(validate({ contacts: [], ringSeconds: 1 }).error, undefined);
+  assert.notEqual(validate({ contacts: [], ringSeconds: 600 }).error, undefined);
+  assert.equal(validate({ contacts: [], ringSeconds: 45 }).error, undefined);
+
+  assert.equal(
+    validate({ contacts: [], siteDirectoryFallback: false }).value
+      .siteDirectoryFallback,
+    false,
+  );
+});
+
+test("the chain is bounded, so a body cannot be padded into an expensive write", () => {
+  const many = Array.from(
+    { length: MAX_PERSONAL_EMERGENCY_CONTACTS + 1 },
+    (_, i) => contact({ order: i + 1 }),
+  );
+
+  assert.notEqual(validate({ contacts: many }).error, undefined);
+  assert.equal(
+    validate({ contacts: many.slice(0, MAX_PERSONAL_EMERGENCY_CONTACTS) }).error,
+    undefined,
+  );
+});
+
+test("a contact can be kept but taken out of the chain", () => {
+  const { error, value } = validate({
+    contacts: [contact({ order: 1, active: false })],
+  });
+
+  assert.equal(error, undefined);
+  assert.equal(value.contacts[0].active, false);
+});
+
+test("no user id is accepted from the body -- the URL and the gate decide that", () => {
+  const { error } = validate({ contacts: [], user: new ObjectId().toString() });
+
+  assert.notEqual(error, undefined, "a user id in the body was accepted");
+});
+
+// ------------------------------------------------------------------- absent
+
+test("somebody who has never saved a chain reads an empty one, not an error", () => {
+  const empty = emptyPersonalEmergencyChain(USER);
+
+  assert.deepEqual(empty.contacts, []);
+  assert.equal(empty.ringSeconds, DEFAULT_RING_SECONDS);
+  assert.equal(empty.siteDirectoryFallback, true);
+  assert.equal(empty.user, USER);
+});
+
+test("nothing in the model names a telephony vendor", () => {
+  // The chain has to outlive whatever places the call. If a provider name ever
+  // appears here, the data model has been tied to one dialer.
+  const text = readFileSync(
+    fileURLToPath(
+      new URL(
+        "../src/models/personal-emergency-chain.model.ts",
+        import.meta.url,
+      ),
+    ),
+    "utf8",
+  );
+
+  for (const vendor of [
+    "twilio",
+    "vonage",
+    "nexmo",
+    "asterisk",
+    "plivo",
+    "sinch",
+    "telnyx",
+  ]) {
+    assert.ok(
+      !new RegExp(vendor, "i").test(text),
+      vendor + " is named in the model",
+    );
+  }
+});