tabletcommand-backend-models 7.0.13 → 7.0.15

package/src/test/0index.ts

@@ -0,0 +1,71 @@
+import "mocha";
+// Check for a mocha config file where we can import those
+import { assert } from "chai";
+import * as m from "../index";
+import * as config from "./config";
+
+describe(" Models", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("are wired", function() {
+    // These should match index.js
+    assert.isFunction(models.ActionLog, "Missing ActionLog");
+    assert.isFunction(models.Agency, "Missing Agency");
+    assert.isFunction(models.ArcGISGroup, "Missing ArcGISGroup");
+    assert.isFunction(models.Assignment, "Missing Assignment");
+    assert.isFunction(models.Battalion, "Missing Battalion");
+    assert.isFunction(models.BeaconLog, "Missing BeaconLog");
+    assert.isFunction(models.CADIncident, "Missing CADIncident");
+    assert.isFunction(models.CADIncidentBlock, "Missing CADIncidentBlock");
+    assert.isFunction(models.CADIncidentStream, "Missing CADIncidentStream");
+    assert.isFunction(models.CADSimulation, "Missing CADSimulation");
+    assert.isFunction(models.CADStatus, "Missing CADStatus");
+    assert.isFunction(models.CADStatusMap, "Missing CADStatusMap");
+    assert.isFunction(models.CADVehicle, "Missing CADVehicle");
+    assert.isFunction(models.CADVehicleStatus, "Missing CADVehicleStatus");
+    assert.isFunction(models.CADVehicleStatusHistory, "Missing CADVehicleStatusHistory");
+    assert.isFunction(models.ChartDeviceStats, "Missing ChartDeviceStats");
+    assert.isFunction(models.ChartIncident, "Missing ChartIncident");
+    assert.isFunction(models.ChartManagedIncident, "Missing ChartManagedIncident");
+    assert.isFunction(models.ChartUser, "Missing ChartUser");
+    assert.isFunction(models.Checklist, "Missing Checklist");
+    assert.isFunction(models.ChecklistItem, "Missing ChecklistItem");
+    assert.isFunction(models.CSVImport, "Missing CSVImport");
+    assert.isFunction(models.Department, "Missing Department");
+    assert.isFunction(models.DeviceMapping, "Missing DeviceMapping");
+    assert.isFunction(models.Esri, "Missing Esri");
+    assert.isFunction(models.GSTMapping, "Missing GSTMapping");
+    assert.isFunction(models.IncidentEvent, "Missing IncidentEvent");
+    assert.isFunction(models.IncidentNotified, "Missing IncidentNotified");
+    assert.isFunction(models.IncidentTakeover, "Missing IncidentTakeover");
+    assert.isFunction(models.JobLog, "Missing JobLog");
+    assert.isFunction(models.Location, "Missing Location");
+    assert.isFunction(models.MailLog, "Missing MailLog");
+    assert.isFunction(models.ManagedIncident, "Missing ManagedIncident");
+    assert.isFunction(models.Mark43IncidentRetry, "Missing Mark43IncidentRetry");
+    assert.isFunction(models.Message, "Missing Message");
+    assert.isFunction(models.Monitor, "Missing Monitor");
+    assert.isFunction(models.PersonnelImport, "Missing PersonnelImport");
+    assert.isFunction(models.PersonnelKnown, "Missing PersonnelKnown");
+    assert.isFunction(models.PersonnelRoster, "Missing PersonnelRoster");
+    assert.isFunction(models.RateLimit, "Missing RateLimit");
+    assert.isFunction(models.ReleaseNote, "Missing ReleaseNote");
+    assert.isFunction(models.RemoteLog, "Missing RemoteLog");
+    assert.isFunction(models.RemoteLogStream, "Missing RemoteLogStream");
+    assert.isFunction(models.Session, "Missing Session");
+    assert.isFunction(models.SMTPUnhandled, "Missing SMTPUnhandled");
+    assert.isFunction(models.Template, "Missing Template");
+    assert.isFunction(models.User, "Missing User");
+    assert.isFunction(models.UserDevice, "Missing UserDevice");
+    assert.isFunction(models.UserRegistration, "Missing UserRegistration");
+    assert.isFunction(models.ValidationReport, "Missing ValidationReport");
+  });
+});

package/src/test/action-log.ts

@@ -0,0 +1,41 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("ActionLog", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.ActionLog>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.actionLog;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.ActionLog(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.action, sut.action);
+    assert.equal(testItem.email, sut.email);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.object, sut.object);
+    assert.equal(testItem.before, sut.before);
+    assert.equal(testItem.after, sut.after);
+    assert.equal(testItem.delta, sut.delta);
+    const expectedDate = new Date().valueOf() / 1000.0;
+    const timeDelta = expectedDate - sut.modified_unix_date;
+    assert.isTrue(timeDelta < 1);
+  });
+});

package/src/test/agency.ts

@@ -0,0 +1,41 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Agency", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Agency>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.agency;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Agency(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.active, sut.active);
+    assert.equal(testItem.code, sut.code);
+    assert.equal(testItem.name, sut.name);
+    assert.equal(testItem.administrators?.length, 1);
+    assert.equal(testItem.personnelIntegration, sut.personnelIntegration);
+    assert.equal(testItem.personnelMonitorHours, sut.personnelMonitorHours);
+    assert.equal(testItem.crossStaffing?.length, 1);
+    const expectedDate = new Date().valueOf() / 1000.0;
+    const timeDelta = expectedDate - sut.modified_unix_date;
+    assert.isTrue(timeDelta < 1);
+  });
+});

package/src/test/arcgis-group.ts

@@ -1,58 +1,22 @@
-
 import { assert } from "chai";
 import "mocha";
-// import * as _ from "lodash";
-
-import { url as mongoURL } from "./config";
-
-import { connect } from "..";
-// import MockModule from "./mock";
-
-describe("ArcGISGroup", function() {
-  // let models, 
-  //   mongoose: typeof import("mongoose"),
-  //   mock;
-
-  beforeEach(async function() {
-    const result = await connect(mongoURL);
-    console.log(result);
-    // models = result.models;
-    // mongoose = result.mongoose;
-
-    // mock = MockModule({
-    //   models,
-    // });
-    // await mock.cleanup();
-
-    // console.log("x", result);
-    console.log(mongoURL);
-  });
-
-  afterEach(async function() {
-    // await mongoose.disconnect();
-  });
-
-  it("is saved", async function() {
-    assert.isTrue(true);
-  });
-});
-
-
-/*
-
-const m = require("..");
+import * as _ from "lodash";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
 
 describe("ArcGISGroup", function() {
-  let models, mongoose, mock;
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.ArcGISGroup>;
 
   beforeEach(async function() {
     const c = await m.connect(config.url);
     models = c.models;
     mongoose = c.mongoose;
-    mock = require("./mock")({
-      models,
-      mongoose,
+    const mock = mockModule({
+      mongoose
     });
+    testItem = mock.arcGISGroup;
     await mock.cleanup();
   });
 
@@ -61,7 +25,6 @@ describe("ArcGISGroup", function() {
   });
 
   it("is saved", async function() {
-    const testItem = mock.arcGISGroup;
     assert.isObject(testItem);
     const item = new models.ArcGISGroup(testItem);
     const sut = await item.save();
@@ -78,29 +41,28 @@ describe("ArcGISGroup", function() {
 
     assert.equal(sut.linkedDepartments.length, 1);
     const dept = _.first(sut.linkedDepartments);
-    assert.equal(dept.department, "Demo RTS Fire Department");
-    assert.equal(dept.departmentId, "558365a198b2fa4278000053");
-    assert.equal(dept.authUsername, "tabletcmd");
+    assert.equal(dept?.department, "Demo RTS Fire Department");
+    assert.equal(dept?.departmentId, "558365a198b2fa4278000053");
+    assert.equal(dept?.authUsername, "tabletcmd");
 
-    assert.equal(dept.users.length, 1);
-    const deptUser = _.first(dept.users);
-    assert.equal(deptUser.username, "tc_someone");
-    assert.equal(deptUser.email, "hello@tc.com");
-    assert.equal(deptUser.userId, "558365a198a2aa42780000aa");
+    assert.equal(dept?.users.length, 1);
+    const deptUser = _.first(dept?.users);
+    assert.equal(deptUser?.username, "tc_someone");
+    assert.equal(deptUser?.email, "hello@tc.com");
+    assert.equal(deptUser?.userId, "558365a198a2aa42780000aa");
 
     assert.equal(sut.outsiders.length, 1);
     const outsider = _.first(sut.outsiders);
-    assert.equal(outsider.username, "Michael_Kallum");
-    assert.equal(outsider.fullName, "Michael Kallum");
-    assert.equal(outsider.memberType, "member");
-    assert.equal(outsider.orgId, "MyTOuXKXZoizaaa");
+    assert.equal(outsider?.username, "Michael_Kallum");
+    assert.equal(outsider?.fullName, "Michael Kallum");
+    assert.equal(outsider?.memberType, "member");
+    assert.equal(outsider?.orgId, "MyTOuXKXZoizaaa");
 
     assert.equal(sut.users.length, 1);
     const user = _.first(sut.users);
-    assert.equal(user.username, "jane_tabletcommand");
-    assert.equal(user.fullName, "Jane Serrano");
-    assert.equal(user.memberType, "admin");
-    assert.equal(user.orgId, "zGXMcUaDlMGoAAAg");
+    assert.equal(user?.username, "jane_tabletcommand");
+    assert.equal(user?.fullName, "Jane Serrano");
+    assert.equal(user?.memberType, "admin");
+    assert.equal(user?.orgId, "zGXMcUaDlMGoAAAg");
   });
 });
-*/

package/src/test/assignment.ts

@@ -0,0 +1,41 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Assignment", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Assignment>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.assignment;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Assignment(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(sut._id.toString(), sut.id);
+
+    assert.equal(testItem.position, sut.position);
+    assert.equal(testItem.active, sut.active);
+    assert.equal(testItem.name, sut.name);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.isMandatory, sut.isMandatory);
+    const expectedDate = new Date().valueOf() / 1000.0;
+    const timeDelta = expectedDate - sut.modified_unix_date;
+    assert.isTrue(timeDelta < 1);
+  });
+});

package/src/test/battalion.ts

@@ -0,0 +1,45 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Battalion", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Battalion>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.battalion;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Battalion(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.active, sut.active);
+    assert.equal(testItem.isMandatory, sut.isMandatory);
+    assert.equal(testItem.name, sut.name);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.position, sut.position);
+    assert.equal(testItem.agencyId, sut.agencyId);
+    assert.equal(testItem.local_id, sut.local_id);
+    assert.equal(testItem.units?.length, 1);
+    const expectedDate = new Date().valueOf() / 1000.0;
+    let timeDelta = 1;
+    if (sut.modified_unix_date) {
+      timeDelta = expectedDate - sut.modified_unix_date;
+    }
+    assert.isTrue(timeDelta < 1);
+  });
+});

package/src/test/cad-incident-block.ts

@@ -0,0 +1,44 @@
+import { assert } from "chai";
+import "mocha";
+import * as _ from "lodash";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("CADIncidentBlock", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.CADIncidentBlock>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.cadIncidentBlock;
+    await mock.beforeEach();
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CADIncidentBlock(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.EntryDateTime, testItem.EntryDateTime);
+    assert.equal(sut.ClosedDateTime, testItem.ClosedDateTime);
+    assert.equal(sut.source, testItem.source);
+    assert.equal(sut.IncidentNumber, testItem.IncidentNumber);
+    assert.equal(sut.departmentId, testItem.departmentId);
+    assert.equal(sut.AgencyIncidentCallTypeDescription, testItem.AgencyIncidentCallTypeDescription);
+    // No longer in models? EntryDateTime seems replacement
+    // assert.equal(sut.createdAt.toISOString(), new Date(testItem.createdAt).toISOString());
+    assert.equal(sut.ReportNumber.length, 1);
+    const rn = _.first(sut.ReportNumber);
+    assert.equal(rn?.name, "Incident");
+    assert.equal(rn?.number, "CA68");
+  });
+});

package/src/test/cad-incident.ts

@@ -0,0 +1,168 @@
+import { assert } from "chai";
+import * as _ from "lodash";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+import "mocha";
+
+describe("CADIncident", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.CADIncident>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.cadIncident;
+    await mock.beforeEach();
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CADIncident(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.uuid, testItem.uuid);
+    assert.equal(sut.departmentId, testItem.departmentId);
+    assert.equal(sut.AgencyID, testItem.AgencyID);
+    assert.equal(sut.IncidentNumber, testItem.IncidentNumber);
+    assert.equal(sut.TransactionID, testItem.TransactionID);
+    assert.equal(sut.AgencyIncidentCallTypeDescription, testItem.AgencyIncidentCallTypeDescription);
+    assert.equal(sut.StreetName, testItem.StreetName);
+    assert.equal(sut.StreetSuffix, testItem.StreetSuffix);
+    assert.equal(sut.Predirectional, testItem.Predirectional);
+    assert.equal(sut.Postdirectional, testItem.Postdirectional);
+    assert.equal(sut.CityOrLocality, testItem.CityOrLocality);
+    assert.equal(sut.Floor, testItem.Floor);
+    assert.equal(sut.Suite, testItem.Suite);
+    assert.equal(sut.City, testItem.City);
+    assert.equal(sut.Building, testItem.Building);
+    assert.equal(sut.StateOrProvince, testItem.StateOrProvince);
+    assert.equal(sut.CommonPlaceName, testItem.CommonPlaceName);
+    assert.equal(sut.LocationComment, testItem.LocationComment);
+    assert.equal(sut.CrossStreet1, testItem.CrossStreet1);
+    assert.equal(sut.CrossStreet2, testItem.CrossStreet2);
+    assert.equal(sut.cross_streets, testItem.cross_streets);
+    assert.equal(sut.PostalCode, testItem.PostalCode);
+    assert.equal(sut.CallerNumber, testItem.CallerNumber);
+    assert.equal(sut.Latitude, testItem.Latitude);
+    assert.equal(sut.Longitude, testItem.Longitude);
+    assert.equal(sut.preference_location, testItem.preference_location);
+    assert.equal(sut.EntryDateTime, testItem.EntryDateTime);
+    assert.equal(sut.ClosedDateTime, testItem.ClosedDateTime);
+    assert.equal(sut.closed_unix_date, testItem.closed_unix_date);
+    assert.equal(sut.start_unix_date, testItem.start_unix_date);
+    assert.equal(sut.modified_unix_date, testItem.modified_unix_date);
+
+    assert.isTrue(sut.PriorIncidentChanged);
+    assert.equal(sut.PriorIncidentChanged, testItem.PriorIncidentChanged);
+    assert.equal(sut.PriorIncident.length, 1);
+    if (sut.PriorIncident.length === 1) {
+      const pi = sut.PriorIncident[0];
+      const pid = testItem.PriorIncident?.length ? testItem.PriorIncident[0] : null;
+      assert.isNotNull(pid);
+      assert.equal(pi?.IncidentNumber, pid?.IncidentNumber);
+      assert.equal(pi?.IncidentDateTime, pid?.IncidentDateTime);
+      assert.equal(pi?.Problem, pid?.Problem);
+      assert.equal(pi?.Address, pid?.Address);
+      assert.equal(pi?.Suite, pid?.Suite);
+      assert.equal(pi?.Jurisdiction, pid?.Jurisdiction);
+      assert.equal(pi?.Comment[0]?.Comment, pid?.Comment[0]?.Comment);
+      assert.equal(pi?.Comment[0]?.CommentSource, pid?.Comment[0]?.CommentSource);
+      assert.equal(pi?.Comment[0]?.CommentDateTime, pid?.Comment[0]?.CommentDateTime);
+    }
+
+    if (testItem.units?.length) {
+      assert.equal(sut?.units[0]?.UnitDispatchNumber, testItem?.units[0]?.UnitDispatchNumber);
+      assert.equal(sut?.units[0]?.UnitID, testItem?.units[0]?.UnitID);
+      assert.equal(sut?.units[0]?.TimeDispatched, testItem?.units[0]?.TimeDispatched);
+    } else {
+      assert.equal(sut.units.length, 1);
+    }
+
+    const unit = _.first(sut.units.filter((x) => x.UnitID === "MA31"));
+    assert.equal(unit?.Personnel.length, 2);
+    const p1 = _.first(unit?.Personnel.filter((x: { PersonnelID: string; }) => x.PersonnelID === "X14"));
+    assert.equal(p1?.PersonnelName, "Mary Smith");
+    assert.equal(p1?.PersonnelNote, "X");
+    assert.equal(p1?.PersonnelRank, "Captain");
+    assert.equal(p1?.PersonnelWorkCode, "TRD");
+
+    assert.equal(sut.Comment.length, 1);
+    if (testItem.Comment?.length) {
+      assert.equal(sut?.Comment[0]?.Comment, testItem?.Comment[0]?.Comment);
+      assert.equal(sut?.Comment[0]?.CommentSource, testItem?.Comment[0]?.CommentSource);
+      assert.equal(sut?.Comment[0]?.CommentDateTime, testItem?.Comment[0]?.CommentDateTime);
+    } else {
+      assert.equal(sut.Comment.length, 1);
+    }
+
+    // Share incident properties
+    assert.isArray(sut.ReportNumber);
+    assert.equal(sut.ReportNumber.length, 2);
+    const rna = _.first(sut.ReportNumber.filter((x) => x.name === "A"));
+    assert.isObject(rna);
+    assert.equal(rna?.number, "07-0351");
+    const rnb = _.first(sut.ReportNumber.filter((x) => x.name === "B"));
+    assert.isObject(rnb);
+    assert.equal(rnb?.number, "UM-02210");
+
+    assert.isArray(sut.radioChannels);
+    assert.equal(sut.radioChannels.length, 2);
+    const rca = _.first(sut.radioChannels.filter((x) => x.name === "CMD"));
+    assert.isObject(rca);
+    assert.equal(rca?.channel, "LOCAL Tone: 3");
+    assert.equal(rca?.url, "http://example.com/stream1");
+    const rcb = _.first(sut.radioChannels.filter((x) => x.name === "TAC"));
+    assert.isObject(rcb);
+    assert.equal(rcb?.channel, "CDF TAC 10");
+    assert.equal(rcb?.url, "http://example.com/stream2");
+
+    assert.isObject(sut.record);
+    assert.equal(sut.record.name, "John");
+    assert.equal(sut.record.value, "Smith");
+
+    assert.isObject(sut.sharedSource);
+    assert.equal(sut.sharedSource.isExternal, true);
+    assert.equal(sut.sharedSource.name, "Demo RTS Fire Department");
+    assert.isArray(sut.sharedSource.reasons);
+    assert.equal(sut.sharedSource.reasons.length, 1);
+    const ssr1 = _.first(sut.sharedSource.reasons);
+    assert.isObject(ssr1);
+    assert.equal(ssr1?.name, "Unit B10 assigned");
+    assert.equal(ssr1?.date.toISOString(), "2024-05-03T00:00:00.000Z");
+
+    assert.isArray(sut.sharedTo);
+    assert.equal(sut.sharedTo.length, 1);
+    const st1 = _.first(sut.sharedTo);
+    assert.equal(st1?.active, true);
+    assert.equal(st1?.departmentId, "5195426cc4e016a988000965");
+    assert.equal(st1?.expireAt.toISOString(), "2024-08-01T10:20:30.400Z");
+    assert.equal(st1?.name, "Test Fire Department");
+    assert.equal(st1?.startAt.toISOString(), "2024-05-01T01:02:03.040Z");
+    assert.equal(st1?.reasons.length, 1);
+    const str1 = _.first(st1?.reasons);
+    assert.equal(str1?.name, "Unit M10 assigned");
+    assert.equal(str1?.date.toISOString(), "2024-05-03T01:01:01.010Z");
+  });
+
+  it("no virtuals id if _id not present", async function() {
+    const item = new models.CADIncident(testItem);
+    await item.save();
+
+    const sut = await models.CADIncident.findOne({ _id: item._id }).lean({
+      virtuals: true
+    });
+    assert.equal(sut?.units.length, 1);
+    assert.isUndefined(sut?.units[0]?.id);
+
+    assert.equal(sut?.Comment.length, 1);
+    assert.isUndefined(sut?.Comment[0]?.id);
+  });
+});

package/src/test/cad-simulation.ts

@@ -0,0 +1,33 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("CadSimulation", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.CADSimulation>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.cadSimulation;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CADSimulation(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.title, sut.title);
+    assert.equal(testItem.friendlyId, sut.friendlyId);
+  });
+});

package/src/test/cad-status-map.ts

@@ -0,0 +1,41 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("CADStatusMap", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.CADStatusMap>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.cadStatusMap;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CADStatusMap(testItem);
+    const sut = await item.save();
+
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.modifiedDate, sut.modifiedDate);
+
+    assert.equal(testItem.fromStatusId, sut.fromStatusId);
+    if (sut.toStatusIds.length && testItem.toStatusIds?.length) {
+      assert.equal(testItem.toStatusIds[0]?.statusId, sut.toStatusIds[0]?.statusId);
+      assert.isTrue(sut.toStatusIds[0]?.userEnabled);
+      assert.equal(sut.toStatusIds[0]?.position, 0);
+    } else {
+      assert.equal(sut.toStatusIds.length, 1);
+      assert.equal(testItem.toStatusIds?.length, 1);
+    }
+  });
+});