@7365admin1/core 3.87.0 → 3.89.0

package/test/robot-map-lift.test.mjs

@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  LIFT_DOOR,
+  LIFT_MODE,
+  LIFT_SIM_BOARD_MS,
+  LIFT_SIM_DOOR_DWELL_MS,
+  LIFT_SIM_MS_PER_FLOOR,
+  liftQueueKey,
+  simulatedLiftState,
+} from "./.build/utils/lift-contract.util.mjs";
+import {
+  buildingMapCreateSchema,
+  buildingMapUpdateSchema,
+  liftRequestSchema,
+} from "./.build/models/robot-building-map.model.mjs";
+
+/* The lift broker's car is REPLAYED from the session, so every API instance
+ * must reach the same answer for the same inputs. These pin the phases. */
+
+const FLOORS = ["1", "2", "3", "4"];
+const session = (over = {}) => ({ id: "s1", fromFloor: "1", toFloor: "3", activeAt: 0, ...over });
+const at = (ms, s = session()) => simulatedLiftState({ name: "Lift A", floors: FLOORS, session: s, now: ms });
+
+test("no holder: the car is idle, in human mode, held by nobody", async () => {
+  const { state, phase } = await simulatedLiftState({ name: "Lift A", floors: FLOORS, session: null, now: 5000 });
+  assert.equal(phase, "idle");
+  assert.equal(state.sessionId, "");
+  assert.equal(state.currentMode, LIFT_MODE.HUMAN);
+});
+
+test("a session whose floors the lift does not serve is treated as no session", async () => {
+  const { phase } = await at(1000, session({ toFloor: "9" }));
+  assert.equal(phase, "idle");
+});
+
+test("pickup at the car's own floor boards at once, doors open, AGV mode", async () => {
+  const { state, phase } = await at(0);
+  assert.equal(phase, "boarding");
+  assert.equal(state.doorState, LIFT_DOOR.OPEN);
+  assert.equal(state.currentMode, LIFT_MODE.AGV);
+  assert.equal(state.sessionId, "s1");
+});
+
+test("boarding holds the doors longer than the dwell, then the car leaves", async () => {
+  const mid = await at(LIFT_SIM_BOARD_MS - 500);
+  assert.equal(mid.phase, "boarding");
+  assert.equal(mid.state.doorState, LIFT_DOOR.OPEN);
+
+  const moving = await at(LIFT_SIM_BOARD_MS + 1000);
+  assert.equal(moving.phase, "to-destination");
+  assert.equal(moving.state.doorState, LIFT_DOOR.CLOSED);
+});
+
+test("arrives at the destination and keeps the doors open while held", async () => {
+  const travel = 2 * LIFT_SIM_MS_PER_FLOOR;
+  const arrived = await at(LIFT_SIM_BOARD_MS + travel + 1000);
+  assert.equal(arrived.phase, "arrived");
+  assert.equal(arrived.state.currentFloor, "3");
+  assert.equal(arrived.state.doorState, LIFT_DOOR.OPEN);
+
+  // Long after the door dwell: the hold is still refreshed, so no door closes on the robot.
+  const later = await at(LIFT_SIM_BOARD_MS + travel + LIFT_SIM_DOOR_DWELL_MS * 5);
+  assert.equal(later.state.doorState, LIFT_DOOR.OPEN);
+});
+
+test("a pickup above the car travels there first", async () => {
+  const s = session({ fromFloor: "3", toFloor: "1" });
+  const start = await at(500, s);
+  assert.equal(start.phase, "to-pickup");
+  assert.equal(start.state.doorState, LIFT_DOOR.CLOSED);
+  const there = await at(2 * LIFT_SIM_MS_PER_FLOOR + 500, s);
+  assert.equal(there.phase, "boarding");
+  assert.equal(there.state.currentFloor, "3");
+});
+
+test("replay is deterministic - same inputs, same answer", async () => {
+  const a = await at(12_345);
+  const b = await at(12_345);
+  assert.deepEqual(a, b);
+});
+
+test("queue key separates same-named lifts in different buildings", () => {
+  assert.notEqual(liftQueueKey("a", "Lift A"), liftQueueKey("b", "Lift A"));
+});
+
+/* ---------------------------------------------------------------- schemas */
+
+const robotId = "a".repeat(24);
+const good = {
+  robotId,
+  name: "Tower 1",
+  levels: [{ floorNo: 1, elevationM: 0 }, { floorNo: 2, elevationM: 4.5 }],
+  doors: [{ name: "Lobby door", floorNo: 1, start: { x: 0, y: 0 }, end: { x: 1, y: 0 } }],
+  lifts: [{ name: "Lift A", x: 3, y: 4, floors: [1, 2] }],
+};
+
+test("a sensible map validates and gets defaults", () => {
+  const { error, value } = buildingMapCreateSchema.validate(good);
+  assert.equal(error, undefined);
+  assert.equal(value.doors[0].type, "hinged");
+  assert.equal(value.lifts[0].widthM, 2);
+});
+
+test("two lifts may not share a name - it is the queue's key", () => {
+  const { error } = buildingMapCreateSchema.validate({
+    ...good,
+    lifts: [good.lifts[0], { ...good.lifts[0], x: 9 }],
+  });
+  assert.ok(error);
+});
+
+test("a lift must span at least two floors, and a level may not repeat", () => {
+  assert.ok(buildingMapCreateSchema.validate({ ...good, lifts: [{ ...good.lifts[0], floors: [1] }] }).error);
+  assert.ok(buildingMapCreateSchema.validate({ ...good, levels: [{ floorNo: 1 }, { floorNo: 1 }] }).error);
+});
+
+test("pixel-sized coordinates are refused - the map is in metres", () => {
+  const { error } = buildingMapCreateSchema.validate({
+    ...good,
+    doors: [{ ...good.doors[0], end: { x: 5000, y: 0 } }],
+  });
+  assert.ok(error);
+});
+
+test("the estate cannot be sent - siteId/orgId are not accepted fields", () => {
+  assert.ok(buildingMapCreateSchema.validate({ ...good, siteId: robotId }).error);
+  assert.ok(buildingMapCreateSchema.validate({ ...good, orgId: robotId }).error);
+});
+
+test("a save must say which version it edited", () => {
+  const { robotId: _r, ...body } = good;
+  assert.ok(buildingMapUpdateSchema.validate(body).error);
+  assert.equal(buildingMapUpdateSchema.validate({ ...body, version: 3 }).error, undefined);
+});
+
+test("a lift request needs two different floors", () => {
+  assert.ok(liftRequestSchema.validate({ robotId, fromFloor: 2, toFloor: 2 }).error);
+  assert.equal(liftRequestSchema.validate({ robotId, fromFloor: 1, toFloor: 2 }).error, undefined);
+});

package/test/robot-network.test.mjs

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  NETWORK_PROJECTION,
+  escapeRegex,
+  networkListPipeline,
+  networkMatch,
+  networkSummaryPipeline,
+  shapeNetworkSummary,
+} from "./.build/utils/robot-network.util.mjs";
+
+/* --------------------------------------------------------------------------
+ * The Seven365 console's all-robots list (owner, 2026-09-23). The pipeline is
+ * where it can go wrong quietly: a removed robot listed, a credential
+ * projected, a filter on the default class that loses every row written before
+ * the field existed, or a search string treated as a pattern.
+ * ------------------------------------------------------------------------ */
+
+const ORG = "64b7f0c2a1b2c3d4e5f60718";
+const SITE = "64b7f0c2a1b2c3d4e5f60719";
+
+test("a removed robot never lists: the soft-delete test is always first", () => {
+  const [first] = networkListPipeline({});
+  assert.deepEqual(first.$match.deletedAt, { $in: ["", null] });
+  const [summaryFirst] = networkSummaryPipeline();
+  assert.deepEqual(summaryFirst.$match.deletedAt, { $in: ["", null] });
+});
+
+test("the credentials can never leave: the projection is an allow-list without them", () => {
+  assert.equal("appKey" in NETWORK_PROJECTION, false);
+  assert.equal("appToken" in NETWORK_PROJECTION, false);
+  const facet = networkListPipeline({}).at(-1).$facet.items;
+  assert.deepEqual(facet.at(-1).$project, NETWORK_PROJECTION);
+});
+
+test("client and site filters are ObjectIds on the indexed metadata fields", () => {
+  const m = networkMatch({ org: ORG, site: SITE });
+  assert.equal(String(m["metadata.orgId"]), ORG);
+  assert.equal(String(m["metadata.siteId"]), SITE);
+  assert.equal(typeof m["metadata.orgId"], "object");
+});
+
+test("filtering on the DEFAULT class/brand still finds rows written before the field existed", () => {
+  assert.deepEqual(networkMatch({ type: "cleaning" }).type, { $in: ["cleaning", null, ""] });
+  assert.deepEqual(networkMatch({ brand: "ounitech" }).brand, { $in: ["ounitech", null, ""] });
+  // A non-default value is matched exactly.
+  assert.equal(networkMatch({ type: "security" }).type, "security");
+  assert.equal(networkMatch({ brand: "demo" }).brand, "demo");
+});
+
+test("a search string is data, not a pattern", () => {
+  assert.equal(escapeRegex("a.b*(c)"), String.raw`a\.b\*\(c\)`);
+  const search = networkListPipeline({ search: "Tower (1)" }).find((s) => s.$match?.$or);
+  assert.equal(search.$match.$or[0].name.$regex, String.raw`Tower \(1\)`);
+  // and the escaped pattern matches the literal text only
+  assert.ok(new RegExp(escapeRegex("a.b*(c)")).test("xa.b*(c)y"));
+  assert.equal(new RegExp(escapeRegex("a.b")).test("axb"), false);
+  // searches the joined client and site names too
+  const fields = search.$match.$or.map((c) => Object.keys(c)[0]);
+  assert.deepEqual(fields, ["name", "robotSn", "client.name", "site.name"]);
+});
+
+test("paging is bounded and the default order groups by client then site", () => {
+  const p = networkListPipeline({ page: 3, limit: 500 });
+  const facet = p.at(-1).$facet.items;
+  assert.equal(facet[1].$limit, 100, "limit capped at 100");
+  assert.equal(facet[0].$skip, 200);
+  const sort = p.find((s) => s.$sort).$sort;
+  assert.deepEqual(Object.keys(sort), ["client.name", "site.name", "name", "_id"]);
+  const bySite = networkListPipeline({ sort: "site", order: "desc" }).find((s) => s.$sort).$sort;
+  assert.deepEqual(bySite, { "site.name": -1, _id: 1 });
+});
+
+test("the summary never claims a fault count it did not measure", () => {
+  const s = shapeNetworkSummary({
+    total: [{ n: 5 }],
+    sites: [{ n: 2 }],
+    byType: [{ _id: "cleaning", count: 4 }, { _id: "security", count: 1 }],
+    byBrand: [{ _id: "demo", count: 3 }, { _id: "ounitech", count: 2 }],
+    byClient: [{ _id: ORG, name: "Client A", count: 5, sites: 2 }],
+  });
+  assert.equal(s.total, 5);
+  assert.equal(s.sites, 2);
+  assert.deepEqual(s.byType, [{ key: "cleaning", count: 4 }, { key: "security", count: 1 }]);
+  assert.equal(s.demo, 3);
+  assert.equal(s.byClient[0].name, "Client A");
+  assert.deepEqual(s.faults, { live: false, count: null });
+  // empty collection: zeros, not a crash
+  const empty = shapeNetworkSummary(undefined);
+  assert.equal(empty.total, 0);
+  assert.deepEqual(empty.byType.map((t) => t.count), [0, 0]);
+});