tabletcommand-backend-models 7.0.0 → 7.0.1

package/test/action-log.js

@@ -2,34 +2,41 @@
 
 const assert = require("chai").assert;
 
+const m = require("..");
+const config = require("./config");
 
-const mongoose = require('mongoose');
-
-describe("ActionLog", function () {
-  let models = mongoose.models;
+describe("ActionLog", function() {
+  let models, mongoose;
   let testItem;
-  before(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.actionLog;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-  it("is saved", async function () {
+  it("is saved", async function() {
     const item = new models.ActionLog(testItem);
-    await item.save().then((ress) => {
-      assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.action, ress.action);
-      assert.equal(testItem.email, ress.email);
-      assert.equal(testItem.userId, ress.userId);
-      assert.equal(testItem.object, ress.object);
-      assert.equal(testItem.before, ress.before);
-      assert.equal(testItem.after, ress.after);
-      assert.equal(testItem.delta, ress.delta);
-      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"); });
+    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/test/agency.js

@@ -1,33 +1,42 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
 
-describe("Agency", function () {
-  let models = mongoose.models;;
+const m = require("..");
+const config = require("./config");
+
+describe("Agency", 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.agency;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-  it("is saved", async function () {
+  it("is saved", async function() {
     const item = new models.Agency(testItem);
-    item.save().then((ress) => {
-      assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.active, ress.active);
-      assert.equal(testItem.code, ress.code);
-      assert.equal(testItem.name, ress.name);
-      assert.equal(testItem.administrators.length, 1);
-      assert.equal(testItem.personnelIntegration, ress.personnelIntegration);
-      assert.equal(testItem.personnelMonitorHours, ress.personnelMonitorHours);
-      assert.equal(testItem.crossStaffing.length, 1);
-      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"); });
+    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/test/arcgis-group.js

@@ -3,12 +3,16 @@
 const assert = require("chai").assert;
 const _ = require("lodash");
 
-const mongoose = require('mongoose');
+const m = require("..");
+const config = require("./config");
 
-describe("ArcGISGroup", function () {
-  const models = mongoose.models;
-  let mock;
-  beforeEach(async function () {
+describe("ArcGISGroup", function() {
+  let models, mongoose, mock;
+
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
     mock = require("./mock")({
       models,
       mongoose,
@@ -16,7 +20,11 @@ describe("ArcGISGroup", function () {
     await mock.cleanup();
   });
 
-  it("is saved", async function () {
+  afterEach(function() {
+    mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
     const testItem = mock.arcGISGroup;
     assert.isObject(testItem);
     const item = new models.ArcGISGroup(testItem);

package/test/assignment.js

@@ -2,33 +2,41 @@
 
 const assert = require("chai").assert;
 
-const mongoose = require('mongoose');
+const m = require("..");
+const config = require("./config");
 
-describe("Assignment", function () {
-  let models = mongoose.models;
+describe("Assignment", 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.assignment;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-  it("is saved", async function () {
+  it("is saved", async function() {
     const item = new models.Assignment(testItem);
-    const ress = await item.save();
+    const sut = await item.save();
 
     assert.isNotNull(testItem._id);
-    assert.equal(ress._id.toString(), ress.id.toString());
+    assert.equal(sut._id.toString(), sut.id.toString());
 
-    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.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 - ress.modified_unix_date;
+    const timeDelta = expectedDate - sut.modified_unix_date;
     assert.isTrue(timeDelta < 1);
   });
 });

package/test/battalion.js

@@ -2,35 +2,42 @@
 
 const assert = require("chai").assert;
 
-const mongoose = require('mongoose');
+const m = require("..");
+const config = require("./config");
 
 describe("Battalion", function() {
-  let models = mongoose.models;
+  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.battalion;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-  it("is saved", function() {
-    var item = new models.Battalion(testItem);
-    item.save().then((ress) => {
+  it("is saved", async function() {
+    const item = new models.Battalion(testItem);
+    const sut = await item.save();
 
-      assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.active, ress.active);
-      assert.equal(testItem.isMandatory, ress.isMandatory);
-      assert.equal(testItem.name, ress.name);
-      assert.equal(testItem.userId, ress.userId);
-      assert.equal(testItem.position, ress.position);
-      assert.equal(testItem.agencyId, ress.agencyId);
-      assert.equal(testItem.local_id, ress.local_id);
-      assert.equal(testItem.units.length, 1);
-      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(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;
+    const timeDelta = expectedDate - sut.modified_unix_date;
+    assert.isTrue(timeDelta < 1);
   });
 });

package/test/cad-incident-block.js

@@ -3,12 +3,16 @@
 const _ = require("lodash");
 const assert = require("chai").assert;
 
-const mongoose = require('mongoose');
+const m = require("..");
+const config = require("./config");
 
 describe("CADIncidentBlock", function() {
-  let models = mongoose.models;
+  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
@@ -16,22 +20,24 @@ describe("CADIncidentBlock", function() {
     testItem = mock.cadIncidentBlock;
     await mock.beforeEach();
   });
-
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
   it("is saved", async function() {
     const item = new models.CADIncidentBlock(testItem);
-    const ress = await item.save();
+    const sut = await item.save();
 
     assert.isNotNull(testItem._id);
-    assert.equal(ress.EntryDateTime, testItem.EntryDateTime);
-    assert.equal(ress.ClosedDateTime, testItem.ClosedDateTime);
-    assert.equal(ress.source, testItem.source);
-    assert.equal(ress.IncidentNumber, testItem.IncidentNumber);
-    assert.equal(ress.departmentId, testItem.departmentId);
-    assert.equal(ress.AgencyIncidentCallTypeDescription, testItem.AgencyIncidentCallTypeDescription);
-    assert.equal(ress.createdAt.toISOString(), new Date(testItem.createdAt).toISOString());
-    assert.equal(ress.ReportNumber.length, 1);
-    const rn = _.first(ress.ReportNumber);
+    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);
+    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/test/cad-incident.js

@@ -3,62 +3,69 @@
 const _ = require("lodash");
 const assert = require("chai").assert;
 
-const mongoose = require('mongoose');
+const m = require("..");
+const config = require("./config");
 
 describe("CADIncident", function() {
-  let models = mongoose.models;
+  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.cadIncident;
     await mock.beforeEach();
   });
-
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
   it("is saved", async function() {
     const item = new models.CADIncident(testItem);
-    const ress = await item.save();
+    const sut = await item.save();
 
     assert.isNotNull(testItem._id);
-    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];
+    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];
       var pid = testItem.PriorIncident[0];
       assert.equal(pi.IncidentNumber, pid.IncidentNumber);
       assert.equal(pi.IncidentDateTime, pid.IncidentDateTime);
@@ -71,12 +78,12 @@ describe("CADIncident", function() {
       assert.equal(pi.Comment[0].CommentDateTime, pid.Comment[0].CommentDateTime);
     }
 
-    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(ress.units.filter((x) => x.UnitID === "MA31"));
+    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);
+
+    const unit = _.first(sut.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");
@@ -84,49 +91,49 @@ describe("CADIncident", function() {
     assert.equal(p1.PersonnelRank, "Captain");
     assert.equal(p1.PersonnelWorkCode, "TRD");
 
-    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);
+    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);
 
     // Share incident properties
-    assert.isArray(ress.ReportNumber);
-    assert.equal(ress.ReportNumber.length, 2);
-    const rna = _.first(ress.ReportNumber.filter((x) => x.name === "A"));
+    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(ress.ReportNumber.filter((x) => x.name === "B"));
+    const rnb = _.first(sut.ReportNumber.filter((x) => x.name === "B"));
     assert.isObject(rnb);
     assert.equal(rnb.number, "UM-02210");
 
-    assert.isArray(ress.radioChannels);
-    assert.equal(ress.radioChannels.length, 2);
-    const rca = _.first(ress.radioChannels.filter((x) => x.name === "CMD"));
+    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(ress.radioChannels.filter((x) => x.name === "TAC"));
+    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(ress.record);
-    assert.equal(ress.record.name, "John");
-    assert.equal(ress.record.value, "Smith");
+    assert.isObject(sut.record);
+    assert.equal(sut.record.name, "John");
+    assert.equal(sut.record.value, "Smith");
 
-    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(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(ress.sharedTo);
-    assert.equal(ress.sharedTo.length, 1);
-    const st1 = _.first(ress.sharedTo);
+    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");

package/test/cad-simulation.js

@@ -2,28 +2,33 @@
 
 const assert = require("chai").assert;
 
-const mongoose = require('mongoose');
+const m = require("..");
+const config = require("./config");
 
-describe("CadSimulation", function () {
-  let models = mongoose.models;
+describe("CadSimulation", 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.cadSimulation;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
+  it("is saved", async function() {
+    const item = new models.CADSimulation(testItem);
+    const sut = await item.save();
 
-  it("is saved", function () {
-    var item = new models.CADSimulation(testItem);
-    item.save().then((ress) => {
-      assert.isNotNull(testItem._id);
-      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"); });
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.title, sut.title);
+    assert.equal(testItem.friendlyId, sut.friendlyId);
   });
 });

package/test/cad-status-map.js

@@ -2,33 +2,37 @@
 
 const assert = require("chai").assert;
 
-const mongoose = require('mongoose');
+const m = require("..");
+const config = require("./config");
 
 describe("CADStatusMap", function() {
-  let models = mongoose.models;
+  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.cadStatusMap;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", function() {
+  it("is saved", async function() {
     const item = new models.CADStatusMap(testItem);
-    item.save().then((ress) => {
-
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.modifiedDate, ress.modifiedDate);
+    const sut = await item.save();
 
-      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);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.modifiedDate, sut.modifiedDate);
 
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    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);
   });
 });