tabletcommand-backend-models 7.0.0 → 7.0.1

package/test/cad-status.js

@@ -1,48 +1,53 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
 
-describe("CADStatus", function () {
-  let models = mongoose.models;
+const m = require("..");
+const config = require("./config");
+
+describe("CADStatus", function() {
+  let models, mongoose;
   let testItem;
-  beforeEach(async function () {
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.cadStatus;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", function () {
+  it("is saved", async function() {
     const item = new models.CADStatus(testItem);
-    item.save().then((ress) => {
-
-      assert.equal(testItem.uuid, ress.uuid);
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.modifiedDate, ress.modifiedDate);
-      assert.equal(testItem.code, ress.code);
-      assert.equal(testItem.codeDisplay, ress.codeDisplay);
-      assert.equal(testItem.color.background, ress.color.background);
-      assert.equal(testItem.color.text, ress.color.text);
-      assert.equal(testItem.name, ress.name);
-      assert.equal(testItem.normalized, ress.normalized);
-      assert.isFalse(ress.roaming);
-      assert.isTrue(ress.selfAssignable);
-      assert.equal(testItem.status, ress.status);
-      assert.equal(testItem.statusId, ress.statusId);
-
-      assert.equal(testItem.options[0].cadKey, ress.options[0].cadKey);
-      assert.equal(testItem.options[0].name, ress.options[0].name);
-      assert.equal(testItem.options[0].position, ress.options[0].position);
-      assert.isTrue(ress.options[0].visible);
-      assert.equal(testItem.options[0].cadValues[0].name, ress.options[0].cadValues[0].name);
-      assert.equal(testItem.options[0].cadValues[0].type, ress.options[0].cadValues[0].type);
-      assert.equal(testItem.options[0].cadValues[0].value, ress.options[0].cadValues[0].value);
-      assert.isTrue(ress.options[0].cadValues[0].visible);
-      assert.isFalse(ress.options[0].cadValues[0].favorite);
-
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    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);
+
+    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);
   });
 });

package/test/cad-vehicle-status-history.js

@@ -1,31 +1,36 @@
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("CADVehicleStatusHistory", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("CADVehicleStatusHistory", function() {
+  let models, mongoose;
+  let testItem;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.cadVehicleStatusHistory;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", function () {
+  it("is saved", async function() {
     const item = new models.CADVehicleStatusHistory(testItem);
-    item.save().then((ress) => {
-
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.vehicleId, ress.vehicleId);
-      assert.equal(testItem.radioName, ress.radioName);
-      assert.equal(testItem.status, ress.status);
-      assert.equal(testItem.statusCode, ress.statusCode);
-      assert.equal(testItem.requestedAt, ress.requestedAt);
-      assert.equal(testItem.requestedBy, ress.requestedBy);
-      assert.equal(testItem.incidentNumber, ress.incidentNumber);
+    const sut = await item.save();
 
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    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/test/cad-vehicle-status.js

@@ -1,38 +1,44 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("CADVehicleStatus", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("CADVehicleStatus", function() {
+  let models, mongoose;
+  let testItem;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.cadVehicleStatus;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", function () {
+  it("is saved", async function() {
     const item = new models.CADVehicleStatus(testItem);
-    item.save().then((ress) => {
-      assert.equal(testItem.uuid, ress.uuid);
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.vehicleId, ress.vehicleId);
-      assert.equal(testItem.radioName, ress.radioName);
-      assert.equal(testItem.requestTime, ress.requestTime);
-      assert.equal(testItem.responseTime, ress.responseTime);
-      assert.equal(testItem.status, ress.status);
-      assert.equal(testItem.statusCode, ress.statusCode);
-      assert.equal(testItem.modifiedDate, ress.modifiedDate);
-      assert.equal(testItem.requestStatus, ress.requestStatus);
-      assert.equal(testItem.incidentNumber, ress.incidentNumber);
-      assert.equal(testItem.capability, resFs.capability)
-      assert.equal(testItem.owner, ress.owner)
-      assert.equal(testItem.ownerId, ress.ownerId)
+    const sut = await item.save();
 
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    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/test/cad-vehicle.js

@@ -1,34 +1,39 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("CADVehicle", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("CADVehicle", function() {
+  let models, mongoose;
+  let testItem;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.cadVehicle;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", function () {
+  it("is saved", async function() {
     const item = new models.CADVehicle(testItem);
-    item.save().then((ress) => {
-
-      assert.equal(testItem.uuid, ress.uuid);
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.modifiedDate, ress.modifiedDate);
-      assert.equal(testItem.vehicleId, ress.vehicleId);
-      assert.equal(testItem.radioName, ress.radioName);
-      assert.equal(testItem.station.code, ress.station.code);
-      assert.equal(testItem.station.name, ress.station.name);
-      assert.equal(testItem.station.capability, ress.station.capability);
-      assert.isFalse(ress.locationToCAD);
+    const sut = await item.save()
 
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    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.station.capability, sut.station.capability);
+    assert.isFalse(sut.locationToCAD);
   });
 });

package/test/checklist-item.js

@@ -1,38 +1,44 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("ChecklistItem", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("ChecklistItem", function() {
+  let models, mongoose;
+  let testItem;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.checklistItem;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
+  it("is saved", async function() {
+    const item = new models.ChecklistItem(testItem);
+    const sut = await item.save();
 
-  it("is saved", function () {
-    var item = new models.ChecklistItem(testItem);
-    item.save().then((ress) => {
-
-      assert.isNotNull(item._id);
-      assert.equal(item._id, ress.id);
-      assert.equal(testItem.position, ress.position);
-      assert.equal(testItem.active, ress.active);
-      assert.equal(testItem.name, ress.name);
-      assert.equal(testItem.userId, ress.userId);
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.isMandatory, ress.isMandatory);
-      assert.equal(testItem.api_checklist_id, ress.api_checklist_id);
-      assert.equal(testItem.checklist_uuid, ress.checklist_uuid);
-      assert.equal(testItem.description, ress.description);
-      const expectedDate = new Date().valueOf() / 1000.0;
-      const timeDelta = expectedDate - ress.modified_unix_date;
-      assert.isTrue(timeDelta < 1);
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    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/test/checklist.js

@@ -1,37 +1,44 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("Checklist", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("Checklist", function() {
+  let models, mongoose;
+  let testItem;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.checklist;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", async function () {
+  it("is saved", async function() {
     const item = new models.Checklist(testItem);
-    const ress = await item.save();
+    const sut = await item.save();
     assert.isNotNull(item._id);
-    assert.equal(item._id, ress.id);
-    assert.equal(testItem.position, ress.position);
-    assert.equal(testItem.active, ress.active);
-    assert.equal(testItem.name, ress.name);
-    assert.equal(testItem.userId, ress.userId);
-    assert.equal(testItem.departmentId, ress.departmentId);
-    assert.equal(testItem.isMandatory, ress.isMandatory);
-    assert.equal(testItem.agencyId, ress.agencyId);
+    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 - ress.modified_unix_date;
+    const timeDelta = expectedDate - sut.modified_unix_date;
     assert.isTrue(timeDelta < 1);
 
-    const items = ress.items;
+    const items = sut.items;
     assert.isArray(items);
     assert.equal(items.length, 1);
   });

package/test/csv-import.js

@@ -1,38 +1,45 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("CSVImport", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("CSVImport", function() {
+  let models, mongoose;
+  let testItem;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.csvImport;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", async function () {
+  it("is saved", async function() {
     const item = new models.CSVImport(testItem);
-    const ress = await item.save();
-    assert.equal(testItem._id, ress._id);
-    assert.equal(testItem.batchId, ress.batchId);
-    // assert.equal(testItem.importCreated, ress.importCreated);
-    assert.equal(testItem.departmentId, ress.departmentId);
-    assert.equal(testItem.agencyId, ress.agencyId);
-    assert.equal(testItem.importType, ress.importType);
-    assert.equal(testItem.fileType, ress.fileType);
-    assert.equal(testItem.fileName, ress.fileName);
-    assert.equal(testItem.fileSize, ress.fileSize);
-    assert.equal(testItem.status, ress.status);
-    // assert.equal(testItem.modifiedDate, ress.modifiedDate);
-    // assert.equal(testItem.fileLastModified, ress.fileLastModified);
+    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, ress.userId);
-    assert.equal(testItem.sendNotification, ress.sendNotification);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.sendNotification, sut.sendNotification);
   });
 });
 

package/test/department.js

@@ -1,77 +1,81 @@
 const assert = require("chai").assert;
 
-const mongoose = require('mongoose');
+const m = require("..");
+const config = require("./config");
 
-describe("Department", function () {
-  let models = mongoose.models;
-  let mock;
-
-  beforeEach(async function () {
+describe("Department", function() {
+  let models, mongoose, mock;
 
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
     mock = require("./mock")({
       mongoose
     });
   });
 
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", async function () {
+  it("is saved", async function() {
     const testItem = mock.department;
     assert.isObject(testItem);
     const item = new models.Department(testItem);
-    const ress = await item.save();
+    const sut = await item.save();
     const result = await models.Department.findOne({ _id: testItem._id }).lean();
-    assert.isNotNull(ress._id);
-    assert.isNotNull(ress.id);
-    assert.equal(ress.department, testItem.department);
-    assert.equal(ress.addressDetails.city, testItem.addressDetails.city);
-    assert.isTrue(ress.active);
-    assert.equal(ress.apikey, testItem.apikey);
-    assert.equal(ress.partialApiKey, testItem.partialApiKey);
-    assert.isTrue(ress.personnelStaffingEnabled);
-    assert.isTrue(ress.rtsEnabled);
-    assert.equal(ress.rtsChannelPrefix, testItem.rtsChannelPrefix);
-    assert.equal(ress.pubNubV3.token, testItem.pubNubV3.token);
-    assert.equal(ress.pubNubV3.expireAt.toISOString(), testItem.pubNubV3.expireAt);
-    assert.equal(ress.pubNubV3.runAt.toISOString(), testItem.pubNubV3.runAt);
-    assert.equal(ress.signupKey, testItem.signupKey);
-    assert.equal(ress.incidentTypes.length, 1);
-    assert.equal(ress.agencyIds.length, 1);
-    assert.equal(ress.agencyIds[0], testItem.agencyIds[0]);
-    assert.equal(ress.safetyPriorityKeywords.length, 3);
-    assert.equal(ress.incidentTypes[0].name, testItem.incidentTypes[0].name);
-    assert.isFalse(ress.shareLocationPhones);
-    assert.isTrue(ress.shareLocationTablets);
-    assert.isFalse(ress.cadOneWayVehiclesEnabled);
-    assert.isFalse(ress.cadGetLocationEnabled);
-    assert.isTrue(ress.mowsEnabled);
-    assert.isTrue(ress.shareAVL.enabled);
-    assert.equal(ress.shareAVL.opAreaCode, testItem.shareAVL.opAreaCode);
-    assert.equal(ress.shareAVL.opAreaName, testItem.shareAVL.opAreaName);
-    assert.equal(ress.accountType, testItem.accountType);
-    assert.equal(ress.timeZone, testItem.timeZone);
-    assert.equal(ress.firstArrivingEnabled, testItem.firstArrivingEnabled);
-    assert.equal(ress.simpleSense.token, testItem.simpleSense.token);
-    assert.equal(ress.firstArriving.token, testItem.firstArriving.token);
-    assert.equal(ress.simpleSenseEnabled, testItem.simpleSenseEnabled);
-    assert.equal(ress.webDisclaimer.message, testItem.webDisclaimer.message);
-    assert.equal(ress.webDisclaimer.enabled, testItem.webDisclaimer.enabled);
-    assert.equal(JSON.stringify(ress.licensing), JSON.stringify(testItem.licensing));
-    assert.equal(ress.externalNotificationsEnabled, testItem.externalNotificationsEnabled);
-    assert.equal(ress.notificationEmails.length, testItem.notificationEmails.length);
-    assert.equal(ress.restrictedComments.callTypesAllowed.length, testItem.restrictedComments.callTypesAllowed.length);
-    assert.equal(ress.restrictedComments.statusesAllowed.length, testItem.restrictedComments.statusesAllowed.length);
-    assert.equal(ress.restrictedComments.restrictedFields.length, testItem.restrictedComments.restrictedFields.length);
-    assert.equal(ress.restrictedComments.restrictedMessage, testItem.restrictedComments.restrictedMessage);
-    assert.equal(ress.restrictedComments.enabled, testItem.restrictedComments.enabled);
-    assert.equal(ress.customButtons[0].name, testItem.customButtons[0].name);
-    assert.equal(ress.customButtons[0].url, testItem.customButtons[0].url);
-    assert.equal(ress.customButtons[0].order, testItem.customButtons[0].order);
-    assert.equal(ress.customButtons[0].allow_external, testItem.customButtons[0].allow_external);
-    assert.equal(ress.customButtons[0].default_to_external, testItem.customButtons[0].default_to_external);
-    assert.equal(ress.customButtons[0].allow_floating, testItem.customButtons[0].allow_floating);
-    assert.equal(JSON.stringify(ress.customButtons[0].color), JSON.stringify(testItem.customButtons[0].color));
-    assert.equal(ress.reportNumberEnabled, testItem.reportNumberEnabled);
-    assert.equal(JSON.stringify(ress.samsara), JSON.stringify(testItem.samsara));
+    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);
+    assert.equal(sut.pubNubV3.runAt.toISOString(), testItem.pubNubV3.runAt);
+    assert.equal(sut.signupKey, testItem.signupKey);
+    assert.equal(sut.incidentTypes.length, 1);
+    assert.equal(sut.agencyIds.length, 1);
+    assert.equal(sut.agencyIds[0], testItem.agencyIds[0]);
+    assert.equal(sut.safetyPriorityKeywords.length, 3);
+    assert.equal(sut.incidentTypes[0].name, testItem.incidentTypes[0].name);
+    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);
+    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].allow_external, testItem.customButtons[0].allow_external);
+    assert.equal(sut.customButtons[0].default_to_external, testItem.customButtons[0].default_to_external);
+    assert.equal(sut.customButtons[0].allow_floating, testItem.customButtons[0].allow_floating);
+    assert.equal(JSON.stringify(sut.customButtons[0].color), JSON.stringify(testItem.customButtons[0].color));
+    assert.equal(sut.reportNumberEnabled, testItem.reportNumberEnabled);
+    assert.equal(JSON.stringify(sut.samsara), JSON.stringify(testItem.samsara));
   });
 });