tabletcommand-location 2.4.2 → 2.4.3

package/.claude/worktrees/sc-36275/src/test/location.ts

@@ -0,0 +1,485 @@
+import { assert } from "chai";
+import { describe, it, describe as context, before, after, beforeEach, afterEach } from "node:test";
+import * as modelsModule from "tabletcommand-backend-models";
+import storeModule, { StoreModule } from "../store";
+import mockModule from "./mock";
+import locationModule, { LocationModule } from "../location";
+import { LocationPayload } from "../types";
+import { AccountIndustry, BackendModels } from "tabletcommand-backend-models";
+
+let location: LocationModule;
+let store: StoreModule;
+
+const mock = mockModule(modelsModule);
+const mockDepartment = mock.department;
+let models: BackendModels;
+
+describe("location", () => {
+  before(async () => {
+    await mock.before();
+  });
+
+  beforeEach(async () => {
+    await mock.beforeEach();
+    models = mock.getModels();
+    store = storeModule(
+      models.Department,
+      models.Location,
+      models.CADVehicle,
+      models.DeviceMapping
+    );
+    location = locationModule(store);
+  });
+
+  afterEach(async () => {
+    await mock.afterEach();
+  });
+
+  after(async () => {
+    await mock.after();
+  });
+
+  context("Process Locations Items", () => {
+    it("Will save locations (long lat strings) and add CAD Vehicle records: ", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      /* cSpell:disable */
+      const items = [
+        {
+          Interface: "Fake Interface",
+          vehicleId: "BEEDOO1",
+          radioName: "BEEDOO1",
+          statusCode: "RED",
+          latitude: "34.35264",
+          longitude: "-119.0669",
+          heading: "",
+          speed: 5,
+          locationCurrent: "1st\\MAIN",
+          locationDestination: "Gru's House",
+          avlTime: "1602563494"
+        },
+        {
+          Interface: "Fake Interface",
+          vehicleId: "BEEDOO2",
+          radioName: "BEEDOO2",
+          statusCode: "BLUE",
+          latitude: "34.35264",
+          longitude: "-119.0669",
+          heading: "",
+          speed: 10,
+          locationCurrent: "2nd\\MAIN",
+          locationDestination: "Gru's House2",
+          avlTime: "1602563495"
+        }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const locationRecords = await models.Location.find({});
+      assert.equal(locationRecords[0].userId, "BEEDOO1-BEEDOO1");
+      assert.equal(locationRecords[0].departmentId, "5195426cc4e016a988000969");
+      assert.equal(locationRecords[0].username, "BEEDOO1");
+      assert.equal(locationRecords[0].locationGeoJSON.coordinates[0], -119.0669);
+      assert.equal(locationRecords[0].locationGeoJSON.coordinates[1], 34.35264);
+      assert.equal(locationRecords[0].speed, 5);
+      assert.equal(locationRecords[0].personnelUUID, "");
+      assert.equal(locationRecords.length, 2);
+      const vehicles = await models.CADVehicle.find({});
+      assert.equal(vehicles[0].vehicleId, "BEEDOO1");
+      assert.equal(vehicles[0].radioName, "BEEDOO1");
+      assert.equal(vehicles[0].mapHidden, false);
+      assert.equal(vehicles.length, 2);
+    });
+    it("Will save locations (long lat numbers) and add CAD Vehicle records: ", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      const items = [{
+        Interface: "Fake Interface",
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        statusCode: "RED",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        heading: "",
+        locationCurrent: "1st\\MAIN",
+        locationDestination: "Gru's House",
+        avlTime: "1602563494"
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const locationRecord = await models.Location.find({});
+      assert.equal(locationRecord[0]?.userId, "BEEDOO1-BEEDOO1");
+      assert.equal(locationRecord[0]?.departmentId, "5195426cc4e016a988000969");
+      assert.equal(locationRecord[0]?.username, "BEEDOO1");
+      assert.equal(locationRecord[0]?.locationGeoJSON.coordinates[0], -119.0669);
+      assert.equal(locationRecord[0]?.locationGeoJSON.coordinates[1], 34.35264);
+      assert.equal(locationRecord[0]?.speed, -1);
+      assert.equal(locationRecord[0]?.personnelUUID, "");
+      assert.equal(locationRecord[0]?.visibility.includes("visible"), true);
+      assert.equal(locationRecord[0]?.visibility.includes("shared"), true);
+      const vehicle = await models.CADVehicle.find({});
+      assert.equal(vehicle[0]?.vehicleId, "BEEDOO1");
+      assert.equal(vehicle[0]?.radioName, "BEEDOO1");
+      assert.equal(vehicle[0]?.mapHidden, false);
+    });
+    it("Will save geotab locations (long lat numbers) and add use device mappping data on record save: ", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      const items = [{
+        Interface: "Fake Interface",
+        vehicleId: "BEEDOO3",
+        radioName: "BEEDOO3",
+        statusCode: "RED",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        heading: "",
+        locationCurrent: "1st\\MAIN",
+        locationDestination: "Gru's House",
+        source: "Geotab",
+        avlTime: "1602563494"
+      }] as unknown as LocationPayload[];
+      await location.processItemsDeviceMappingGeotab(department, items, atDate);
+      const locationRecord = await models.Location.find({});
+      assert.equal(locationRecord[0]?.userId, "BOOPBEEP99-BEEDOO3");
+      assert.equal(locationRecord[0]?.departmentId, "5195426cc4e016a988000969");
+      assert.equal(locationRecord[0]?.username, "BOOPBEEP99");
+      assert.equal(locationRecord[0]?.locationGeoJSON.coordinates[0], -119.0669);
+      assert.equal(locationRecord[0]?.locationGeoJSON.coordinates[1], 34.35264);
+      assert.equal(locationRecord[0]?.speed, -1);
+      assert.equal(locationRecord[0]?.personnelUUID, "");
+      assert.equal(locationRecord[0]?.sendToCAD, true);
+      assert.equal(locationRecord[0]?.shared, true);
+      assert.equal(locationRecord[0]?.visibility.includes("cad"), true);
+      assert.equal(locationRecord[0]?.visibility.includes("visible"), true);
+      assert.equal(locationRecord[0]?.visibility.includes("shared"), true);
+      /* cSpell:enable */
+    });
+    it("applies person invariants on the geotab path, ignoring device mapping", async () => {
+      const department = mockDepartment;
+      // BEEDOO3 has a device mapping with mapId BOOPBEEP99 and locationToCAD:
+      // true; a person payload must not pick either of those up.
+      const items = [{
+        vehicleId: "BEEDOO3",
+        radioName: "Smokey Bear",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        transponderUUID: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        userId: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        session: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        username: "Smokey Bear",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItemsDeviceMappingGeotab(department, items, new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.username, "Smokey Bear");
+      assert.equal(recs[0]?.session, "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.transponderUUID, "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.active, true);
+      assert.equal(recs[0]?.shared, false);
+      assert.equal(recs[0]?.sendToCAD, false);
+      assert.deepEqual(recs[0]?.visibility, ["visible"]);
+    });
+    it("skips geotab person locations with neither personnelUUID nor transponderUUID", async () => {
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "BEEDOO3",
+        radioName: "Smokey Bear",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItemsDeviceMappingGeotab(department, items, new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 0);
+    });
+    it("saves person locations keyed by session with person invariants, no CAD vehicle", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "12345",
+        radioName: "SmokeyBear",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        kind: "",
+        type: "",
+        source: "TXRX",
+        personnelUUID: "11111111-2222-3333-4444-555555555555",
+        userId: "TXRX-12345",
+        session: "TXRX-12345",
+        username: "SmokeyBear",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.kindType, "person");
+      assert.equal(recs[0]?.locationType, "person");
+      assert.equal(recs[0]?.personnelUUID, "11111111-2222-3333-4444-555555555555");
+      assert.equal(recs[0]?.transponderUUID, "");
+      assert.equal(recs[0]?.username, "SmokeyBear");
+      assert.equal(recs[0]?.userId, "TXRX-12345");
+      assert.equal(recs[0]?.session, "TXRX-12345");
+      assert.equal(recs[0]?.active, true);
+      assert.equal(recs[0]?.shared, false);
+      assert.equal(recs[0]?.sendToCAD, false);
+      assert.deepEqual(recs[0]?.visibility, ["visible"]);
+      // Person records must not create phantom CAD vehicles
+      const vehicles = await models.CADVehicle.find({});
+      assert.equal(vehicles.length, 0);
+    });
+    it("stamps kindType on person locations classified by locationType alone", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "12345",
+        radioName: "SmokeyBear",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        locationType: "person",
+        source: "TXRX",
+        personnelUUID: "11111111-2222-3333-4444-555555555555",
+        userId: "TXRX-12345",
+        session: "TXRX-12345",
+        username: "SmokeyBear",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      // The person feed queries kindType: "person", so the record must not
+      // rely on the payload having set it
+      assert.equal(recs[0]?.kindType, "person");
+      assert.equal(recs[0]?.locationType, "person");
+      assert.equal(recs[0]?.personnelUUID, "11111111-2222-3333-4444-555555555555");
+      const vehicles = await models.CADVehicle.find({});
+      assert.equal(vehicles.length, 0);
+    });
+    it("accepts transponder person locations on transponderUUID alone", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "FB:9D:2C:3E:C9:E4",
+        radioName: "Fire Hose 1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        transponderUUID: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        userId: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        session: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        username: "Fire Hose 1",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.transponderUUID, "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.personnelUUID, "");
+      assert.equal(recs[0]?.session, "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.active, true);
+      assert.equal(recs[0]?.shared, false);
+      assert.equal(recs[0]?.sendToCAD, false);
+      assert.deepEqual(recs[0]?.visibility, ["visible"]);
+      // Person records must not create phantom CAD vehicles
+      const vehicles = await models.CADVehicle.find({});
+      assert.equal(vehicles.length, 0);
+    });
+    it("updates person locations in place on rename, preserving person fields", async () => {
+      const department = mockDepartment;
+      const base = {
+        vehicleId: "FB:9D:2C:3E:C9:E4",
+        radioName: "William Jones",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        transponderUUID: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        userId: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        session: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        username: "William Jones",
+        visibility: [],
+      };
+      await location.processItems(department, [base] as unknown as LocationPayload[], new Date());
+      const renamed = {
+        ...base,
+        radioName: "Bill Jones",
+        username: "Bill Jones",
+        latitude: 34.4,
+      };
+      await location.processItems(department, [renamed] as unknown as LocationPayload[], new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.username, "Bill Jones");
+      assert.equal(recs[0]?.session, "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.locationGeoJSON.coordinates[1], 34.4);
+      // Update path must preserve the person fields
+      assert.equal(recs[0]?.kindType, "person");
+      assert.equal(recs[0]?.locationType, "person");
+      assert.equal(recs[0]?.transponderUUID, "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.deepEqual(recs[0]?.visibility, ["visible"]);
+    });
+    it("does not wipe transponderUUID when an update omits it", async () => {
+      const department = mockDepartment;
+      const base = {
+        vehicleId: "FB:9D:2C:3E:C9:E4",
+        radioName: "Fire Hose 1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        transponderUUID: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        userId: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        session: "TXRX-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        username: "Fire Hose 1",
+        visibility: [],
+      };
+      await location.processItems(department, [base] as unknown as LocationPayload[], new Date());
+      // Same session, but this update carries only a personnelUUID
+      const update = {
+        ...base,
+        transponderUUID: "",
+        personnelUUID: "11111111-2222-3333-4444-555555555555",
+        latitude: 34.4,
+      };
+      await location.processItems(department, [update] as unknown as LocationPayload[], new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.transponderUUID, "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+      assert.equal(recs[0]?.personnelUUID, "11111111-2222-3333-4444-555555555555");
+      assert.equal(recs[0]?.locationGeoJSON.coordinates[1], 34.4);
+    });
+    it("skips person locations with neither personnelUUID nor transponderUUID", async () => {
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "12345",
+        radioName: "William Jones",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "2026-07-10T15:43:36.816Z",
+        kindType: "person",
+        locationType: "person",
+        source: "TXRX",
+        session: "TXRX-12345",
+        visibility: [],
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 0);
+      const vehicles = await models.CADVehicle.find({});
+      assert.equal(vehicles.length, 0);
+    });
+    it("continues processing the batch after an invalid item", async () => {
+      const department = mockDepartment;
+      const items = [{
+        vehicleId: "",
+        radioName: "",
+        latitude: 0,
+        longitude: 0,
+        avlTime: "1602563494",
+      }, {
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.username, "BEEDOO1");
+    });
+    it("carries kind/type/locationType/kindColor onto the saved Location", async () => {
+      const atDate = new Date();
+      const department = mockDepartment;
+      const items = [{
+        Interface: "Fake Interface",
+        vehicleId: "N777TC",
+        radioName: "COPTER-1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        heading: "",
+        avlTime: "1602563494",
+        kindType: "helicopter",
+        locationType: "helicopter",
+        kind: "helicopter",
+        type: "1",
+        kindColor: { background: "#0000FF", text: "#FFFFFF" },
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const recs = await models.Location.find({});
+      assert.equal(recs[0]?.kind, "helicopter");
+      assert.equal(recs[0]?.type, "1");
+      assert.equal(recs[0]?.locationType, "helicopter");
+      assert.equal(recs[0]?.kindColor?.background, "#0000FF");
+      assert.equal(recs[0]?.kindColor?.text, "#FFFFFF");
+      assert.instanceOf(recs[0]?.kindColorChangedAt, Date);
+    });
+    it("stamps the department's industry on the saved location", async () => {
+      const atDate = new Date();
+      const session = "item-with-industry-utility";
+      const items = [{
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+        session,
+      }] as unknown as LocationPayload[];
+      await location.processItems(mockDepartment, items, atDate);
+      const sut = await models.Location.findOne({ session });
+      assert.equal(sut?.industry, AccountIndustry.Utility);
+    });
+    it("falls back to fire industry when the department has none set", async () => {
+      const atDate = new Date();
+      const session = "item-with-industry-fallback";
+      const department = { ...mockDepartment, industry: undefined };
+      const items = [{
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+        session,
+      }] as unknown as LocationPayload[];
+      await location.processItems(department, items, atDate);
+      const sut = await models.Location.findOne({ session });
+      assert.equal(sut?.industry, AccountIndustry.Fire);
+    });
+    it("updates industry in place and stamps propsChangedAt when it changes", async () => {
+      const base = {
+        vehicleId: "BEEDOO1",
+        radioName: "BEEDOO1",
+        latitude: 34.35264,
+        longitude: -119.0669,
+        avlTime: "1602563494",
+      } as unknown as LocationPayload;
+      await location.processItems(mockDepartment, [base], new Date());
+      const initial = await models.Location.find({});
+      assert.equal(initial[0]?.industry, AccountIndustry.Utility);
+      const initialPropsChangedAt = initial[0]?.propsChangedAt;
+      assert.instanceOf(initialPropsChangedAt, Date);
+
+      const lawDepartment = { ...mockDepartment, industry: AccountIndustry.Law };
+      await location.processItems(lawDepartment, [base], new Date());
+      const recs = await models.Location.find({});
+      assert.equal(recs.length, 1);
+      assert.equal(recs[0]?.industry, AccountIndustry.Law);
+      assert.isAbove(recs[0]!.propsChangedAt.valueOf(), initialPropsChangedAt!.valueOf());
+    });
+  });
+});

package/.claude/worktrees/sc-36275/src/test/mock.ts

@@ -0,0 +1,186 @@
+import * as mongoose from "mongoose";
+import {
+  BackendModels,
+  AccountIndustry,
+  Agency,
+  Department,
+  convertToObjectId as ObjectId
+} from "tabletcommand-backend-models";
+
+export default function(modelsModule: typeof import("tabletcommand-backend-models")) {
+  const departmentId = "5195426cc4e016a988000969";
+  const agencyId = "5f07b93bfb41951409d58493";
+  const apiKey = "secretApiKey1990";
+
+  const d: Partial<Department> = {
+    _id: ObjectId(departmentId),
+    department: "Test Department",
+    accountType: "production",
+    industry: AccountIndustry.Utility,
+    shareAVL: {
+      enabled: true,
+      opAreaName: "Test Area",
+      opAreaCode: "TEST",
+      fadeZoomLevel: 45000,
+      area: {
+        type: "Polygon",
+        coordinates: [],
+      },
+    },
+    signupDomains: [],
+    signupKey: "abcd",
+    incidentTypes: [],
+    rtsChannelPrefix: "rtsChannelPrefix123",
+    cadGetLocationEnabled: true,
+    rtsEnabled: true,
+    pushEnabled: true,
+    cadBidirectionalEnabled: false,
+    cadOneWayVehiclesEnabled: true,
+    cadEmailUsername: "",
+    apikey: apiKey,
+    active: true,
+    modified_unix_date: 1492743603.514,
+    state: "CO",
+    city: "Denver",
+    fdid: "06905",
+    uuid: "e4c5873c-1684-47a9-ad2d-81ded6e7ac15",
+    modified_date: "2017-04-21T03:00:03.514",
+    addressDetails: {
+      address: "123 Delta Way",
+      city: "Delta Junction",
+      state: "CA",
+      country: "US",
+      zipCode: "99999"
+    }
+  };
+  // cSpell:disable
+  const mappedDevice = {
+    departmentId,
+    remoteFamily: "IPv4",
+    uuid: "c01c192f-b71d-4bd6-b5a4-bab6e350a491",
+    remoteAddress: "166.140.104.203",
+    active: true,
+    modified_unix_date: 0,
+    deviceId: "BEEDOO3",
+    mapId: "BOOPBEEP99",
+    deviceType: "geotab",
+    userId: "",
+    locationToCAD: true,
+    mapHidden: false,
+  };
+  // cSpell:denable
+  const agency: Partial<Agency> = {
+    _id: ObjectId(agencyId),
+    active: true,
+    code: "OTHER",
+    departmentId: ObjectId(departmentId),
+    name: "Other",
+    personnelApiKey: "123",
+    crossStaffing: [
+      {
+        alwaysCrossStaff: true,
+        crossStaffedUnits: ["Z1"],
+        radioName: "D22"
+      },
+      {
+        alwaysCrossStaff: false,
+        crossStaffedUnits: ["M1"],
+        radioName: "K12"
+      },
+      {
+        alwaysCrossStaff: true,
+        crossStaffedUnits: ["A1", "A2"],
+        radioName: "Z12"
+      },
+      {
+        alwaysCrossStaff: false,
+        crossStaffedUnits: ["A1", "A2", "D22"],
+        radioName: "Z99"
+      }
+    ]
+  };
+
+  async function clearTestData(mods: BackendModels) {
+    const query = {};
+    await mods.Agency.deleteMany(query);
+    await mods.Department.deleteMany(query);
+    await mods.Location.deleteMany(query);
+    await mods.CADVehicle.deleteMany(query);
+    await mods.DeviceMapping.deleteMany(query);
+  }
+
+  async function prepareTestData(mods: BackendModels) {
+    const testDepartment = new mods.Department(d);
+    await testDepartment.save();
+    const testItem = new models.Agency(agency);
+    await testItem.save();
+    const deviceMapped = new models.DeviceMapping(mappedDevice);
+    await deviceMapped.save();
+  }
+
+  let models: BackendModels;
+  let connection: typeof mongoose;
+
+  async function afterEach() {
+    if (!shouldRun()) {
+      process.exit(1);
+    }
+  }
+
+  async function after() {
+    await getConnection().connection.close();
+  }
+
+  async function before() {
+    if (!shouldRun()) {
+      process.exit(1);
+    }
+
+    const {
+      models: lModels,
+      connection: lConnection
+    } = await modelsModule.connect(process.env.NODE_MONGO_URL || "");
+    models = lModels;
+    connection = lConnection;
+    return models;
+  }
+
+  async function beforeEach() {
+    if (!shouldRun()) {
+      process.exit(1);
+    }
+
+    await clearTestData(models);
+    await prepareTestData(models);
+  }
+
+  function shouldRun() {
+    const mongoUrl = process.env.NODE_MONGO_URL || "";
+    if (!/massive-test/i.exec(mongoUrl)) {
+      console.log(`Not a test database: ${mongoUrl}? Expecting database: massive-test.`);
+      return false;
+    }
+    return true;
+  }
+
+  function getModels(): BackendModels {
+    return models;
+  }
+
+  function getConnection(): typeof mongoose {
+    return connection;
+  }
+
+  return {
+    department: d,
+    agency,
+    clearTestData,
+    prepareTestData,
+    before,
+    beforeEach,
+    after,
+    afterEach,
+    getModels,
+    getConnection,
+  };
+}