@7365admin1/core 3.86.0 → 3.88.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);
+});