tabletcommand-backend-models 7.0.13 → 7.0.15

package/src/test/cad-status.ts

@@ -0,0 +1,57 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("CADStatus", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.CADStatus>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.cadStatus;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CADStatus(testItem);
+    const sut = await item.save();
+
+    assert.equal(testItem.uuid, sut.uuid);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.modifiedDate, sut.modifiedDate);
+    assert.equal(testItem.code, sut.code);
+    assert.equal(testItem.codeDisplay, sut.codeDisplay);
+    assert.equal(testItem.color?.background, sut.color.background);
+    assert.equal(testItem.color?.text, sut.color.text);
+    assert.equal(testItem.name, sut.name);
+    assert.equal(testItem.normalized, sut.normalized);
+    assert.isFalse(sut.roaming);
+    assert.isTrue(sut.selfAssignable);
+    assert.equal(testItem.status, sut.status);
+    assert.equal(testItem.statusId, sut.statusId);
+    if (testItem.options?.length && sut.options.length) {
+      assert.equal(testItem.options[0]?.cadKey, sut.options[0]?.cadKey);
+      assert.equal(testItem.options[0]?.name, sut.options[0]?.name);
+      assert.equal(testItem.options[0]?.position, sut.options[0]?.position);
+      assert.isTrue(sut.options[0]?.visible);
+      assert.equal(testItem.options[0]?.cadValues[0]?.name, sut.options[0]?.cadValues[0]?.name);
+      assert.equal(testItem.options[0]?.cadValues[0]?.type, sut.options[0]?.cadValues[0]?.type);
+      assert.equal(testItem.options[0]?.cadValues[0]?.value, sut.options[0]?.cadValues[0]?.value);
+      assert.isTrue(sut.options[0]?.cadValues[0]?.visible);
+      assert.isFalse(sut.options[0]?.cadValues[0]?.favorite);
+    } else {
+      assert.equal(testItem.options?.length, 1);
+      assert.equal(sut.options?.length, 1);
+
+    }
+  });
+});

package/src/test/cad-vehicle-status-history.ts

@@ -0,0 +1,37 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("CADVehicleStatusHistory", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.CADVehicleStatusHistory>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.cadVehicleStatusHistory;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CADVehicleStatusHistory(testItem);
+    const sut = await item.save();
+
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.vehicleId, sut.vehicleId);
+    assert.equal(testItem.radioName, sut.radioName);
+    assert.equal(testItem.status, sut.status);
+    assert.equal(testItem.statusCode, sut.statusCode);
+    assert.equal(testItem.requestedAt, sut.requestedAt);
+    assert.equal(testItem.requestedBy, sut.requestedBy);
+    assert.equal(testItem.incidentNumber, sut.incidentNumber);
+  });
+});

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

@@ -0,0 +1,43 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("CADVehicleStatus", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.CADVehicleStatus>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.cadVehicleStatus;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CADVehicleStatus(testItem);
+    const sut = await item.save();
+
+    assert.equal(testItem.uuid, sut.uuid);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.vehicleId, sut.vehicleId);
+    assert.equal(testItem.radioName, sut.radioName);
+    assert.equal(testItem.requestTime, sut.requestTime);
+    assert.equal(testItem.responseTime, sut.responseTime);
+    assert.equal(testItem.status, sut.status);
+    assert.equal(testItem.statusCode, sut.statusCode);
+    assert.equal(testItem.modifiedDate, sut.modifiedDate);
+    assert.equal(testItem.requestStatus, sut.requestStatus);
+    assert.equal(testItem.incidentNumber, sut.incidentNumber);
+    assert.equal(testItem.capability, sut.capability);
+    assert.equal(testItem.owner, sut.owner);
+    assert.equal(testItem.ownerId, sut.ownerId);
+  });
+});

package/src/test/cad-vehicle.ts

@@ -0,0 +1,38 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("CADVehicle", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.CADVehicle>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.cadVehicle;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CADVehicle(testItem);
+    const sut = await item.save();
+
+    assert.equal(testItem.uuid, sut.uuid);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.modifiedDate, sut.modifiedDate);
+    assert.equal(testItem.vehicleId, sut.vehicleId);
+    assert.equal(testItem.radioName, sut.radioName);
+    assert.equal(testItem.station?.code, sut.station.code);
+    assert.equal(testItem.station?.name, sut.station.name);
+    assert.equal(testItem.capability, sut.capability);
+    assert.isFalse(sut.locationToCAD);
+  });
+});

package/src/test/checklist-item.ts

@@ -0,0 +1,43 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("ChecklistItem", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.ChecklistItem>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.checklistItem;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.ChecklistItem(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(item._id);
+    assert.equal(item._id, 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);
+    assert.equal(testItem.api_checklist_id, sut.api_checklist_id);
+    assert.equal(testItem.checklist_uuid, sut.checklist_uuid);
+    assert.equal(testItem.description, sut.description);
+    const expectedDate = new Date().valueOf() / 1000.0;
+    const timeDelta = expectedDate - sut.modified_unix_date;
+    assert.isTrue(timeDelta < 1);
+  });
+});

package/src/test/checklist.ts

@@ -0,0 +1,44 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Checklist", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Checklist>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.checklist;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.Checklist(testItem);
+    const sut = await item.save();
+    assert.isNotNull(item._id);
+    assert.equal(item._id, 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);
+    assert.equal(testItem.agencyId, sut.agencyId);
+    const expectedDate = new Date().valueOf() / 1000.0;
+    const timeDelta = expectedDate - sut.modified_unix_date;
+    assert.isTrue(timeDelta < 1);
+
+    const items = sut.items;
+    assert.isArray(items);
+    assert.equal(items.length, 1);
+  });
+});

package/src/test/config.ts

@@ -1,6 +1,4 @@
-"use strict";
-
-export const url = process.env.NODE_MONGO_URL || "mongodb://127.0.0.1/incident-test";
+export const url = process.env.NODE_MONGO_URL || "";
 
 export function checkIfTestDatabase() {
   if (!/massive-test/i.exec(url)) {
@@ -8,3 +6,5 @@ export function checkIfTestDatabase() {
     process.exit(1);
   }
 }
+
+checkIfTestDatabase();

package/src/test/csv-import.ts

@@ -0,0 +1,44 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("CSVImport", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.CSVImport>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.csvImport;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.CSVImport(testItem);
+    const sut = await item.save();
+    assert.equal(testItem._id, sut._id);
+    assert.equal(testItem.batchId, sut.batchId);
+    // assert.equal(testItem.importCreated, sut.importCreated);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.agencyId, sut.agencyId);
+    assert.equal(testItem.importType, sut.importType);
+    assert.equal(testItem.fileType, sut.fileType);
+    assert.equal(testItem.fileName, sut.fileName);
+    assert.equal(testItem.fileSize, sut.fileSize);
+    assert.equal(testItem.status, sut.status);
+    // assert.equal(testItem.modifiedDate, sut.modifiedDate);
+    // assert.equal(testItem.fileLastModified, sut.fileLastModified);
+    assert.equal(testItem.records?.length, 0);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.sendNotification, sut.sendNotification);
+  });
+});
+

package/src/test/department.ts

@@ -0,0 +1,95 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("Department", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Department>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.department;
+  });
+
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    assert.isObject(testItem);
+    const item = new models.Department(testItem);
+    const sut = await item.save();
+    await models.Department.findOne({ _id: testItem._id }).lean();
+    assert.isNotNull(sut._id);
+    assert.isNotNull(sut.id);
+    assert.equal(sut.department, testItem.department);
+    assert.equal(sut.addressDetails.city, testItem.addressDetails?.city);
+    assert.isTrue(sut.active);
+    assert.equal(sut.apikey, testItem.apikey);
+    assert.equal(sut.partialApiKey, testItem.partialApiKey);
+    assert.isTrue(sut.personnelStaffingEnabled);
+    assert.isTrue(sut.rtsEnabled);
+    assert.equal(sut.rtsChannelPrefix, testItem.rtsChannelPrefix);
+    assert.equal(sut.pubNubV3.token, testItem.pubNubV3?.token);
+    assert.equal(sut.pubNubV3.expireAt.toISOString(), testItem.pubNubV3?.expireAt.toISOString());
+    assert.equal(sut.pubNubV3.runAt.toISOString(), testItem.pubNubV3?.runAt.toISOString());
+    assert.equal(sut.signupKey, testItem.signupKey);
+    assert.equal(sut.incidentTypes.length, 1);
+    assert.equal(sut.agencyIds.length, 1);
+    if (testItem.agencyIds?.length) {
+      assert.equal(sut.agencyIds[0], testItem.agencyIds[0]);
+    } else {
+      assert.equal(testItem.agencyIds?.length, 1);
+    }
+    assert.equal(sut.safetyPriorityKeywords.length, 3);
+    if (testItem.incidentTypes?.length) {
+      assert.equal(sut.incidentTypes[0]?.name, testItem.incidentTypes[0]?.name);
+    } else {
+      assert.equal(testItem.incidentTypes?.length, 1);
+    }
+    assert.isFalse(sut.shareLocationPhones);
+    assert.isTrue(sut.shareLocationTablets);
+    assert.isFalse(sut.cadOneWayVehiclesEnabled);
+    assert.isFalse(sut.cadGetLocationEnabled);
+    assert.isTrue(sut.mowsEnabled);
+    assert.isTrue(sut.shareAVL.enabled);
+    assert.equal(sut.shareAVL.opAreaCode, testItem.shareAVL?.opAreaCode);
+    assert.equal(sut.shareAVL.opAreaName, testItem.shareAVL?.opAreaName);
+    assert.equal(sut.accountType, testItem.accountType);
+    assert.equal(sut.timeZone, testItem.timeZone);
+    assert.equal(sut.firstArrivingEnabled, testItem.firstArrivingEnabled);
+    assert.equal(sut.simpleSense.token, testItem.simpleSense?.token);
+    assert.equal(sut.firstArriving.token, testItem.firstArriving?.token);
+    assert.equal(sut.simpleSenseEnabled, testItem.simpleSenseEnabled);
+    assert.equal(sut.webDisclaimer.message, testItem.webDisclaimer?.message);
+    assert.equal(sut.webDisclaimer.enabled, testItem.webDisclaimer?.enabled);
+    assert.equal(JSON.stringify(sut.licensing), JSON.stringify(testItem.licensing));
+    assert.equal(sut.externalNotificationsEnabled, testItem.externalNotificationsEnabled);
+    assert.equal(sut.notificationEmails.length, testItem.notificationEmails?.length);
+    assert.equal(sut.restrictedComments.callTypesAllowed.length, testItem.restrictedComments?.callTypesAllowed.length);
+    assert.equal(sut.restrictedComments.statusesAllowed.length, testItem.restrictedComments?.statusesAllowed.length);
+    assert.equal(sut.restrictedComments.restrictedFields.length, testItem.restrictedComments?.restrictedFields.length);
+    assert.equal(sut.restrictedComments.restrictedMessage, testItem.restrictedComments?.restrictedMessage);
+    assert.equal(sut.restrictedComments.enabled, testItem.restrictedComments?.enabled);
+    if (testItem.customButtons?.length) {
+      assert.equal(sut.customButtons[0]?.name, testItem.customButtons[0]?.name);
+      assert.equal(sut.customButtons[0]?.url, testItem.customButtons[0]?.url);
+      assert.equal(sut.customButtons[0]?.order, testItem.customButtons[0]?.order);
+      assert.equal(sut.customButtons[0]?.allowExternal, testItem.customButtons[0]?.allowExternal);
+      assert.equal(sut.customButtons[0]?.defaultExternal, testItem.customButtons[0]?.defaultExternal);
+      assert.equal(sut.customButtons[0]?.allowFloating, testItem.customButtons[0]?.allowFloating);
+      assert.equal(JSON.stringify(sut.customButtons[0]?.color), JSON.stringify(testItem.customButtons[0]?.color));
+    } else {
+      assert.equal(testItem.customButtons?.length, 1);
+    }
+    assert.equal(sut.reportNumberEnabled, testItem.reportNumberEnabled);
+    assert.equal(JSON.stringify(sut.samsara), JSON.stringify(testItem.samsara));
+    assert.equal(sut.reportOdometer, "status");
+  });
+});

package/src/test/device-mapping.ts

@@ -0,0 +1,53 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("DeviceMapping", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.DeviceMapping>, testItemForTrim: Partial<m.DeviceMapping>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.deviceMapping;
+    testItemForTrim = mock.deviceMappingWithWhiteSpaces;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.DeviceMapping(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.deviceType, sut.deviceType);
+    assert.equal(testItem.mapId, sut.mapId);
+    assert.equal(testItem.deviceId, sut.deviceId);
+    assert.equal(testItem.modified_unix_date, sut.modified_unix_date);
+    assert.equal(testItem.remoteAddress, sut.remoteAddress);
+    assert.equal(testItem.note, sut.note);
+    assert.isFalse(sut.active);
+    assert.isFalse(sut.mapHidden);
+  });
+
+
+  it("is saved with trim", async function() {
+    const item = new models.DeviceMapping(testItemForTrim);
+    const sut = await item.save();
+    assert.isNotNull(testItemForTrim._id);
+    assert.equal(testItemForTrim.departmentId, sut.departmentId);
+    assert.equal(testItemForTrim.modified_unix_date, sut.modified_unix_date);
+    assert.equal(testItemForTrim.mapId?.trim(), sut.mapId); // Should be trimmed by Schema
+    assert.equal(testItemForTrim.deviceId?.trim(), sut.deviceId); // Should be trimmed by Schema
+    assert.equal(testItemForTrim.remoteAddress?.trim(), sut.remoteAddress); // Should be trimmed by Schema
+    assert.equal(testItemForTrim.note?.trim(), sut.note); // Should be trimmed by Schema
+  });
+});

package/src/test/esri.ts

@@ -0,0 +1,69 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+describe("Esri", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.Esri>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.esri;
+    await mock.cleanup();
+  });
+
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    assert.isObject(testItem);
+    const item = new models.Esri(testItem);
+    const sut = await item.save();
+    assert.isNotNull(sut._id);
+    assert.isNotNull(sut.id);
+    assert.equal(sut._id.toString(), testItem._id?.toString());
+    assert.equal(sut.toJSON().id, testItem._id?.toString());
+    assert.equal(sut.departmentId, testItem.departmentId);
+
+    assert.equal(sut.auth.username, testItem.auth?.username);
+    assert.equal(sut.auth.encrypted.iv, testItem.auth?.encrypted.iv);
+    assert.equal(sut.auth.encrypted.encryptedData, testItem.auth?.encrypted.encryptedData);
+
+    assert.equal(sut.fireMapperAuth.username, testItem.fireMapperAuth?.username);
+    assert.equal(sut.fireMapperAuth.encrypted.iv, testItem.fireMapperAuth?.encrypted.iv);
+    assert.equal(sut.fireMapperAuth.encrypted.encryptedData, testItem.fireMapperAuth?.encrypted.encryptedData);
+    assert.equal(sut.fireMapperAuth.encryptedAccessCode.iv, testItem.fireMapperAuth?.encryptedAccessCode.iv);
+    assert.equal(sut.fireMapperAuth.encryptedAccessCode.encryptedData, testItem.fireMapperAuth?.encryptedAccessCode.encryptedData);
+
+    assert.equal(sut.maps.length, 1);
+    const sutm = sut.maps[0];
+    let testItemM;
+    if (testItem.maps?.length) {
+      testItemM = testItem.maps[0];
+    }
+    assert.equal(sutm?.itemId, testItemM?.itemId);
+    assert.equal(sutm?.title, testItemM?.title);
+    assert.equal(sutm?.url, testItemM?.url);
+    assert.equal(sutm?.access, testItemM?.access);
+    assert.equal(sutm?.owner, testItemM?.owner);
+    assert.equal(sutm?.type, testItemM?.type);
+    assert.equal(sutm?.mapLayers.length, 3);
+    assert.equal(sutm?.mapLayers.length, 3);
+    assert.equal(sutm?.baseMap.baseMapLayers.length, 1);
+    assert.equal(sutm?.baseMap.title, testItemM?.baseMap.title);
+
+    const itemId = "01cebf7aede94ed3a9f4c260e18a7d7e";
+    // compare saved items
+    assert.equal(sut.mapsProperties.length, 1, "all items");
+    const mapPropsFound = sut.mapsProperties.filter(p => { return p.itemId === itemId; });
+    assert.equal(mapPropsFound.length, 1, "found items");
+    const props = mapPropsFound[0];
+    assert.equal(props?.download, true);
+  });
+});

package/src/test/gst-mapping.ts

@@ -0,0 +1,38 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("GSTMapping", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.GSTMapping>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.gstMapping;
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.GSTMapping(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.deviceType, sut.deviceType);
+    assert.equal(testItem.unitId, sut.unitId);
+    assert.equal(testItem.modified_unix_date, sut.modified_unix_date);
+    assert.equal(testItem.remoteAddress, sut.remoteAddress);
+    assert.equal(testItem.note, sut.note);
+    assert.isFalse(sut.active);
+    assert.isFalse(sut.mapHidden);
+  });
+});

package/src/test/helpers.ts

@@ -0,0 +1,15 @@
+"use strict";
+
+import { assert } from "chai";
+import "mocha";
+import * as m from "../helpers";
+
+describe("helpers", function() {
+  it("retrieveCurrentUnixTime", function() {
+    const item = m.retrieveCurrentUnixTime();
+    const expected = new Date().valueOf() / 1000.0;
+
+    const delta = Math.abs(expected - item);
+    assert.isTrue(delta < 1);
+  });
+});

package/src/test/incident-event.ts

@@ -0,0 +1,53 @@
+import { assert } from "chai";
+import "mocha";
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("IncidentEvent", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.IncidentEvent>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.incidentEvent;
+    await models.IncidentEvent.deleteMany({
+      departmentId: testItem.departmentId
+    });
+  });
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    const item = new models.IncidentEvent(testItem);
+    const sut = await item.save();
+
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.IncidentNumber, sut.IncidentNumber);
+    assert.equal(testItem.modified_unix_date, sut.modified_unix_date);
+    assert.equal(testItem.message, sut.message);
+    assert.equal(testItem.userTime, sut.userTime);
+    assert.equal(testItem.type, sut.type);
+    assert.equal(testItem.uuid, sut.uuid);
+    assert.equal(testItem.location?.latitude, sut.location.latitude);
+    assert.equal(testItem.location?.longitude, sut.location.longitude);
+    assert.equal(testItem.user?.email, sut.user.email);
+    assert.equal(testItem.user?.username, sut.user.username);
+    assert.equal(testItem.user?.radioName, sut.user.radioName);
+    assert.equal(testItem.user?.userId, sut.user.userId);
+
+    const items = await models.IncidentEvent.find({
+      departmentId: item.departmentId
+    }).lean({
+      virtuals: true
+    });
+    assert.equal(items.length, 1);
+  });
+});