tabletcommand-backend-models 5.39.6 → 7.0.0

package/test/cad-incident.js

@@ -3,69 +3,62 @@
 const _ = require("lodash");
 const assert = require("chai").assert;
 
-const m = require("..");
-const config = require("./config");
+const mongoose = require('mongoose');
 
 describe("CADIncident", function() {
-  let models, mongoose;
+  let models = mongoose.models;
   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.cadIncident;
     await mock.beforeEach();
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
+
 
   it("is saved", async function() {
     const item = new models.CADIncident(testItem);
-    const sut = await item.save();
+    const ress = 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) {
-      var pi = sut.PriorIncident[0];
+    assert.equal(ress.uuid, testItem.uuid);
+    assert.equal(ress.departmentId, testItem.departmentId);
+    assert.equal(ress.AgencyID, testItem.AgencyID);
+    assert.equal(ress.IncidentNumber, testItem.IncidentNumber);
+    assert.equal(ress.TransactionID, testItem.TransactionID);
+    assert.equal(ress.AgencyIncidentCallTypeDescription, testItem.AgencyIncidentCallTypeDescription);
+    assert.equal(ress.StreetName, testItem.StreetName);
+    assert.equal(ress.StreetSuffix, testItem.StreetSuffix);
+    assert.equal(ress.Predirectional, testItem.Predirectional);
+    assert.equal(ress.Postdirectional, testItem.Postdirectional);
+    assert.equal(ress.CityOrLocality, testItem.CityOrLocality);
+    assert.equal(ress.Floor, testItem.Floor);
+    assert.equal(ress.Suite, testItem.Suite);
+    assert.equal(ress.City, testItem.City);
+    assert.equal(ress.Building, testItem.Building);
+    assert.equal(ress.StateOrProvince, testItem.StateOrProvince);
+    assert.equal(ress.CommonPlaceName, testItem.CommonPlaceName);
+    assert.equal(ress.LocationComment, testItem.LocationComment);
+    assert.equal(ress.CrossStreet1, testItem.CrossStreet1);
+    assert.equal(ress.CrossStreet2, testItem.CrossStreet2);
+    assert.equal(ress.cross_streets, testItem.cross_streets);
+    assert.equal(ress.PostalCode, testItem.PostalCode);
+    assert.equal(ress.CallerNumber, testItem.CallerNumber);
+    assert.equal(ress.Latitude, testItem.Latitude);
+    assert.equal(ress.Longitude, testItem.Longitude);
+    assert.equal(ress.preference_location, testItem.preference_location);
+    assert.equal(ress.EntryDateTime, testItem.EntryDateTime);
+    assert.equal(ress.ClosedDateTime, testItem.ClosedDateTime);
+    assert.equal(ress.closed_unix_date, testItem.closed_unix_date);
+    assert.equal(ress.start_unix_date, testItem.start_unix_date);
+    assert.equal(ress.modified_unix_date, testItem.modified_unix_date);
+
+    assert.isTrue(ress.PriorIncidentChanged);
+    assert.equal(ress.PriorIncidentChanged, testItem.PriorIncidentChanged);
+    assert.equal(ress.PriorIncident.length, 1);
+    if (ress.PriorIncident.length === 1) {
+      var pi = ress.PriorIncident[0];
       var pid = testItem.PriorIncident[0];
       assert.equal(pi.IncidentNumber, pid.IncidentNumber);
       assert.equal(pi.IncidentDateTime, pid.IncidentDateTime);
@@ -78,12 +71,12 @@ describe("CADIncident", function() {
       assert.equal(pi.Comment[0].CommentDateTime, pid.Comment[0].CommentDateTime);
     }
 
-    assert.equal(sut.units.length, 1);
-    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);
+    assert.equal(ress.units.length, 1);
+    assert.equal(ress.units[0].UnitDispatchNumber, testItem.units[0].UnitDispatchNumber);
+    assert.equal(ress.units[0].UnitID, testItem.units[0].UnitID);
+    assert.equal(ress.units[0].TimeDispatched, testItem.units[0].TimeDispatched);
     
-    const unit = _.first(sut.units.filter((x) => x.UnitID === "MA31"));
+    const unit = _.first(ress.units.filter((x) => x.UnitID === "MA31"));
     assert.equal(unit.Personnel.length, 2);
     const p1 = _.first(unit.Personnel.filter((x) => x.PersonnelID === "X14"));
     assert.equal(p1.PersonnelName, "Mary Smith");
@@ -91,49 +84,49 @@ describe("CADIncident", function() {
     assert.equal(p1.PersonnelRank, "Captain");
     assert.equal(p1.PersonnelWorkCode, "TRD");
 
-    assert.equal(sut.Comment.length, 1);
-    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);
+    assert.equal(ress.Comment.length, 1);
+    assert.equal(ress.Comment[0].Comment, testItem.Comment[0].Comment);
+    assert.equal(ress.Comment[0].CommentSource, testItem.Comment[0].CommentSource);
+    assert.equal(ress.Comment[0].CommentDateTime, testItem.Comment[0].CommentDateTime);
 
     // Share incident properties
-    assert.isArray(sut.ReportNumber);
-    assert.equal(sut.ReportNumber.length, 2);
-    const rna = _.first(sut.ReportNumber.filter((x) => x.name === "A"));
+    assert.isArray(ress.ReportNumber);
+    assert.equal(ress.ReportNumber.length, 2);
+    const rna = _.first(ress.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"));
+    const rnb = _.first(ress.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.isArray(ress.radioChannels);
+    assert.equal(ress.radioChannels.length, 2);
+    const rca = _.first(ress.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"));
+    const rcb = _.first(ress.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(ress.record);
+    assert.equal(ress.record.name, "John");
+    assert.equal(ress.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(ress.sharedSource);
+    assert.equal(ress.sharedSource.isExternal, true);
+    assert.equal(ress.sharedSource.name, "Demo RTS Fire Department");
+    assert.isArray(ress.sharedSource.reasons);
+    assert.equal(ress.sharedSource.reasons.length, 1);
+    const ssr1 = _.first(ress.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.isArray(ress.sharedTo);
+    assert.equal(ress.sharedTo.length, 1);
+    const st1 = _.first(ress.sharedTo);
     assert.equal(st1.active, true);
     assert.equal(st1.departmentId, "5195426cc4e016a988000965");
     assert.equal(st1.expireAt.toISOString(), "2024-08-01T10:20:30.400Z");

package/test/cad-simulation.js

@@ -2,36 +2,28 @@
 
 const assert = require("chai").assert;
 
-const m = require("..");
-const config = require("./config");
+const mongoose = require('mongoose');
 
-describe("CadSimulation", function() {
-  let models, mongoose;
+describe("CadSimulation", function () {
+  let models = mongoose.models;
   let testItem;
-  beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
+  beforeEach(async function () {
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.cadSimulation;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     var item = new models.CADSimulation(testItem);
-    item.save(function(err, sut) {
-      console.log("err", err);
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
       assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, sut.departmentId);
-      assert.equal(testItem.title, sut.title);
-      assert.equal(testItem.friendlyId, sut.friendlyId);
-      return done();
-    });
+      assert.equal(testItem.departmentId, ress.departmentId);
+      assert.equal(testItem.title, ress.title);
+      assert.equal(testItem.friendlyId, ress.friendlyId);
+
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/cad-status-map.js

@@ -2,41 +2,33 @@
 
 const assert = require("chai").assert;
 
-const m = require("..");
-const config = require("./config");
+const mongoose = require('mongoose');
 
 describe("CADStatusMap", function() {
-  let models, mongoose;
+  let models = mongoose.models;
   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.cadStatusMap;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function() {
     const item = new models.CADStatusMap(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
 
-      assert.equal(testItem.departmentId, sut.departmentId);
-      assert.equal(testItem.modifiedDate, sut.modifiedDate);
+      assert.equal(testItem.departmentId, ress.departmentId);
+      assert.equal(testItem.modifiedDate, ress.modifiedDate);
 
-      assert.equal(testItem.fromStatusId, sut.fromStatusId);
-      assert.equal(sut.toStatusIds.length, 1);
-      assert.equal(testItem.toStatusIds[0].statusId, sut.toStatusIds[0].statusId);
-      assert.isTrue(sut.toStatusIds[0].userEnabled);
-      assert.equal(sut.toStatusIds[0].position, 0);
+      assert.equal(testItem.fromStatusId, ress.fromStatusId);
+      assert.equal(ress.toStatusIds.length, 1);
+      assert.equal(testItem.toStatusIds[0].statusId, ress.toStatusIds[0].statusId);
+      assert.isTrue(ress.toStatusIds[0].userEnabled);
+      assert.equal(ress.toStatusIds[0].position, 0);
 
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/cad-status.js

@@ -1,57 +1,48 @@
 "use strict";
 
 const assert = require("chai").assert;
+const mongoose = require('mongoose');
 
-const m = require("..");
-const config = require("./config");
-
-describe("CADStatus", function() {
-  let models, mongoose;
+describe("CADStatus", function () {
+  let models = mongoose.models;
   let testItem;
-  beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
+  beforeEach(async function () {
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.cadStatus;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     const item = new models.CADStatus(testItem);
-    item.save(function(err, sut) {
-      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.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);
-
-      return done();
-    });
+    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"); });
   });
 });

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

@@ -1,40 +1,31 @@
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("CADVehicleStatusHistory", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("CADVehicleStatusHistory", function () {
+  let models = mongoose.models;
   let testItem;
-  beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
+  beforeEach(async function () {
+
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.cadVehicleStatusHistory;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     const item = new models.CADVehicleStatusHistory(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
 
-      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);
+      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);
 
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/cad-vehicle-status.js

@@ -1,47 +1,38 @@
 "use strict";
 
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("CADVehicleStatus", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("CADVehicleStatus", function () {
+  let models = mongoose.models;
   let testItem;
-  beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
+  beforeEach(async function () {
+
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.cadVehicleStatus;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     const item = new models.CADVehicleStatus(testItem);
-    item.save(function(err, sut) {
-      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)
+    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)
 
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/cad-vehicle.js

@@ -1,43 +1,34 @@
 "use strict";
 
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("CADVehicle", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("CADVehicle", function () {
+  let models = mongoose.models;
   let testItem;
-  beforeEach(async function() {
-    const c = await m.connect(config.url);
-    models = c.models;
-    mongoose = c.mongoose;
+  beforeEach(async function () {
+
 
     const mock = require("./mock")({
       mongoose
     });
     testItem = mock.cadVehicle;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     const item = new models.CADVehicle(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
 
-      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);
+      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);
 
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });