tabletcommand-backend-models 5.39.5 → 7.0.0

package/test/incident-notified.js

@@ -1,42 +1,33 @@
 "use strict";
 
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("IncidentNotified", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("IncidentNotified", 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.incidentNotified;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     const item = new models.IncidentNotified(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
 
       assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, sut.departmentId);
-      assert.equal(testItem.IncidentNumber, sut.IncidentNumber);
-      assert.deepEqual(testItem.incidentTypes, sut.incidentTypes);
-      assert.deepEqual(testItem.units, sut.units);
-      assert.equal(testItem.unitsByDispatch[0].UnitID, sut.unitsByDispatch[0].UnitID);
-      assert.equal(testItem.unitsByDispatch[0].UnitDispatchNumber, sut.unitsByDispatch[0].UnitDispatchNumber);
-      assert.equal(testItem.updated, sut.updated.toISOString());
+      assert.equal(testItem.departmentId, ress.departmentId);
+      assert.equal(testItem.IncidentNumber, ress.IncidentNumber);
+      assert.deepEqual(testItem.incidentTypes, ress.incidentTypes);
+      assert.deepEqual(testItem.units, ress.units);
+      assert.equal(testItem.unitsByDispatch[0].UnitID, ress.unitsByDispatch[0].UnitID);
+      assert.equal(testItem.unitsByDispatch[0].UnitDispatchNumber, ress.unitsByDispatch[0].UnitDispatchNumber);
+      assert.equal(testItem.updated, ress.updated.toISOString());
 
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/incident-takeover.js

@@ -1,44 +1,35 @@
 "use strict";
 
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("IncidentTakeover", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("IncidentTakeover", 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.incidentTakeover;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     var item = new models.IncidentTakeover(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
 
       assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, sut.departmentId);
-      assert.equal(testItem.incident_id, sut.incident_id);
-      assert.equal(testItem.incident_name, sut.incident_name);
-      assert.equal(testItem.incident_number, sut.incident_number);
-      assert.equal(testItem.old_owner, sut.old_owner);
-      assert.equal(testItem.new_owner, sut.new_owner);
-      assert.equal(testItem.status, sut.status);
-      assert.equal(testItem.request_time, sut.request_time);
-      assert.isTrue(sut.uuid !== "");
+      assert.equal(testItem.departmentId, ress.departmentId);
+      assert.equal(testItem.incident_id, ress.incident_id);
+      assert.equal(testItem.incident_name, ress.incident_name);
+      assert.equal(testItem.incident_number, ress.incident_number);
+      assert.equal(testItem.old_owner, ress.old_owner);
+      assert.equal(testItem.new_owner, ress.new_owner);
+      assert.equal(testItem.status, ress.status);
+      assert.equal(testItem.request_time, ress.request_time);
+      assert.isTrue(ress.uuid !== "");
 
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/job-log.js

@@ -1,41 +1,32 @@
 "use strict";
 
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("JobLog", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("JobLog", 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.jobLog;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     var item = new models.JobLog(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
 
       assert.isNotNull(testItem._id);
-      assert.equal(testItem.host, sut.host);
-      assert.equal(testItem.jobName, sut.jobName);
-      assert.equal(testItem.state, sut.state);
-      assert.equal(testItem.bidDate, sut.bidDate);
-      assert.equal(testItem.startDate, sut.startDate);
-      assert.equal(testItem.completedDate, sut.completedDate);
-      assert.equal(testItem.forceClosed, sut.forceClosed);
-      return done();
-    });
+      assert.equal(testItem.host, ress.host);
+      assert.equal(testItem.jobName, ress.jobName);
+      assert.equal(testItem.state, ress.state);
+      assert.equal(testItem.bidDate, ress.bidDate);
+      assert.equal(testItem.startDate, ress.startDate);
+      assert.equal(testItem.completedDate, ress.completedDate);
+      assert.equal(testItem.forceClosed, ress.forceClosed);
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/location.js

@@ -1,55 +1,48 @@
 "use strict";
 
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("Location", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("Location", 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.location;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", async function() {
+
+  it("is saved", async function () {
     const item = new models.Location(testItem);
-    const sut = await item.save();
-    const result = await models.Location.findOne({_id: testItem._id});
+    const ress = await item.save();
+    const result = await models.Location.findOne({ _id: testItem._id });
     assert.isNotNull(testItem._id);
-    assert.equal(testItem.departmentId, sut.departmentId);
-    assert.equal(testItem.userId, sut.userId);
-    assert.equal(testItem.uuid, sut.uuid);
-    assert.equal(testItem.username, sut.username);
-    assert.equal(testItem.device_type, sut.device_type);
-    assert.equal(testItem.session, sut.session);
-    assert.equal(testItem.active, sut.active);
-    assert.equal(testItem.heading, sut.heading);
-    assert.equal(testItem.locationGeoJSON.coordinates[0], sut.location.longitude);
-    assert.equal(testItem.locationGeoJSON.coordinates[1], sut.location.latitude);
+    assert.equal(testItem.departmentId, ress.departmentId);
+    assert.equal(testItem.userId, ress.userId);
+    assert.equal(testItem.uuid, ress.uuid);
+    assert.equal(testItem.username, ress.username);
+    assert.equal(testItem.device_type, ress.device_type);
+    assert.equal(testItem.session, ress.session);
+    assert.equal(testItem.active, ress.active);
+    assert.equal(testItem.heading, ress.heading);
+    assert.equal(testItem.locationGeoJSON.coordinates[0], ress.location.longitude);
+    assert.equal(testItem.locationGeoJSON.coordinates[1], ress.location.latitude);
     assert.equal(testItem.locationGeoJSON.type, "Point");
-    assert.equal(testItem.locationGeoJSON.coordinates[0], sut.locationGeoJSON.coordinates[0]);
-    assert.equal(testItem.locationGeoJSON.coordinates[1], sut.locationGeoJSON.coordinates[1]);
-    assert.equal(testItem.opAreaCode, sut.opAreaCode);
-    assert.equal(testItem.opAreaName, sut.opAreaName);
-    assert.equal(testItem.shared, sut.shared);
-    assert.equal(testItem.state, sut.state);
-    assert.equal(testItem.sendToCAD, sut.sendToCAD);
-    assert.equal(testItem.color.text, sut.color.text);
-    assert.equal(testItem.color.background, sut.color.background);
-    assert.isTrue(sut.uuid !== "");
+    assert.equal(testItem.locationGeoJSON.coordinates[0], ress.locationGeoJSON.coordinates[0]);
+    assert.equal(testItem.locationGeoJSON.coordinates[1], ress.locationGeoJSON.coordinates[1]);
+    assert.equal(testItem.opAreaCode, ress.opAreaCode);
+    assert.equal(testItem.opAreaName, ress.opAreaName);
+    assert.equal(testItem.shared, ress.shared);
+    assert.equal(testItem.state, ress.state);
+    assert.equal(testItem.sendToCAD, ress.sendToCAD);
+    assert.equal(testItem.color.text, ress.color.text);
+    assert.equal(testItem.color.background, ress.color.background);
+    assert.isTrue(ress.uuid !== "");
 
-    const { longitude, latitude } = sut.location;
+    const { longitude, latitude } = ress.location;
     const maxDistance = 10000;
     const geoQuery = {
       locationGeoJSON: {

package/test/mail-log.js

@@ -1,51 +1,42 @@
 "use strict";
 
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("MailLog", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("MailLog", 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.mailLog;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     var item = new models.MailLog(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
 
       assert.isNotNull(testItem._id);
-      assert.equal(testItem.mailId, sut.mailId);
-      assert.equal(testItem.event, sut.event);
-      assert.equal(testItem.timestamp, sut.timestamp);
-      assert.equal(testItem.recipient, sut.recipient);
-      assert.equal(testItem.recipientDomain, sut.recipientDomain);
-      assert.equal(testItem.tags[0], sut.tags[0]);
-      assert.equal(testItem.deliveryStatus, sut.deliveryStatus);
-      assert.equal(testItem.message, sut.message);
-      assert.equal(testItem.deliveryStatus, sut.deliveryStatus);
-      assert.equal(testItem.flags, sut.flags);
-      assert.equal(testItem.envelope, sut.envelope);
-      assert.equal(testItem.logLevel, sut.logLevel);
-      assert.equal(testItem.reason, sut.reason);
-      assert.equal(testItem.severity, sut.severity);
+      assert.equal(testItem.mailId, ress.mailId);
+      assert.equal(testItem.event, ress.event);
+      assert.equal(testItem.timestamp, ress.timestamp);
+      assert.equal(testItem.recipient, ress.recipient);
+      assert.equal(testItem.recipientDomain, ress.recipientDomain);
+      assert.equal(testItem.tags[0], ress.tags[0]);
+      assert.equal(testItem.deliveryStatus, ress.deliveryStatus);
+      assert.equal(testItem.message, ress.message);
+      assert.equal(testItem.deliveryStatus, ress.deliveryStatus);
+      assert.equal(testItem.flags, ress.flags);
+      assert.equal(testItem.envelope, ress.envelope);
+      assert.equal(testItem.logLevel, ress.logLevel);
+      assert.equal(testItem.reason, ress.reason);
+      assert.equal(testItem.severity, ress.severity);
       const expectedDate = new Date().valueOf() / 1000.0;
-      const timeDelta = expectedDate - sut.modified_unix_date;
+      const timeDelta = expectedDate - ress.modified_unix_date;
       assert.isTrue(timeDelta < 1);
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/managed-incident.js

@@ -2,63 +2,55 @@
 
 const _ = require("lodash");
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("ManagedIncident", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("ManagedIncident", 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.managedIncident;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     var item = new models.ManagedIncident(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
 
       assert.isNotNull(testItem._id);
-      assert.equal(sut.departmentId, testItem.departmentId);
-      assert.equal(sut.CallerNumber, testItem.CallerNumber);
-      assert.equal(sut.CommandChannel, testItem.CommandChannel);
-      assert.equal(sut.TacticalAltChannel, testItem.TacticalAltChannel);
-      assert.equal(sut.TacticalChannel, testItem.TacticalChannel);
-      assert.equal(sut.active, testItem.active);
-      assert.equal(sut.address, testItem.address);
-      assert.equal(sut.api_incident_number, testItem.api_incident_number);
-      assert.equal(sut.channel, testItem.channel);
-      assert.equal(sut.channel_owner, testItem.channel_owner);
-      assert.equal(sut.end_time, testItem.end_time);
-      assert.equal(sut.end_unix_time, testItem.end_unix_time);
-      assert.equal(sut.is_closed, testItem.is_closed);
-      assert.equal(sut.location, testItem.location);
-      assert.equal(sut.managed, testItem.managed);
-      assert.equal(sut.modified_date, testItem.modified_date);
-      assert.equal(sut.modified_unix_date, testItem.modified_unix_date);
-      assert.equal(sut.name, testItem.name);
-      assert.equal(sut.preference_location, testItem.preference_location);
-      assert.equal(sut.slave_map_changed, testItem.slave_map_changed);
-      assert.equal(sut.source, testItem.source);
-      assert.equal(sut.start_time, testItem.start_time);
-      assert.equal(sut.start_unix_time, testItem.start_unix_time);
-      assert.equal(sut.userId, testItem.userId);
-      assert.equal(sut.uuid, testItem.uuid);
+      assert.equal(ress.departmentId, testItem.departmentId);
+      assert.equal(ress.CallerNumber, testItem.CallerNumber);
+      assert.equal(ress.CommandChannel, testItem.CommandChannel);
+      assert.equal(ress.TacticalAltChannel, testItem.TacticalAltChannel);
+      assert.equal(ress.TacticalChannel, testItem.TacticalChannel);
+      assert.equal(ress.active, testItem.active);
+      assert.equal(ress.address, testItem.address);
+      assert.equal(ress.api_incident_number, testItem.api_incident_number);
+      assert.equal(ress.channel, testItem.channel);
+      assert.equal(ress.channel_owner, testItem.channel_owner);
+      assert.equal(ress.end_time, testItem.end_time);
+      assert.equal(ress.end_unix_time, testItem.end_unix_time);
+      assert.equal(ress.is_closed, testItem.is_closed);
+      assert.equal(ress.location, testItem.location);
+      assert.equal(ress.managed, testItem.managed);
+      assert.equal(ress.modified_date, testItem.modified_date);
+      assert.equal(ress.modified_unix_date, testItem.modified_unix_date);
+      assert.equal(ress.name, testItem.name);
+      assert.equal(ress.preference_location, testItem.preference_location);
+      assert.equal(ress.slave_map_changed, testItem.slave_map_changed);
+      assert.equal(ress.source, testItem.source);
+      assert.equal(ress.start_time, testItem.start_time);
+      assert.equal(ress.start_unix_time, testItem.start_unix_time);
+      assert.equal(ress.userId, testItem.userId);
+      assert.equal(ress.uuid, testItem.uuid);
 
-      assert.isTrue(sut.active);
-      assert.isTrue(sut.is_closed);
+      assert.isTrue(ress.active);
+      assert.isTrue(ress.is_closed);
 
-      const unit = _.first(sut.units.filter((x) => x.UnitID === "M12"));
+      const unit = _.first(ress.units.filter((x) => x.UnitID === "M12"));
       assert.equal(unit.Personnel.length, 2);
       const p1 = _.first(unit.Personnel.filter((x) => x.PersonnelID === "X14"));
       assert.equal(p1.PersonnelName, "Mary Smith");
@@ -67,43 +59,43 @@ describe("ManagedIncident", function() {
       assert.equal(p1.PersonnelWorkCode, "TRD");
 
       // 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");
@@ -114,7 +106,6 @@ describe("ManagedIncident", function() {
       assert.equal(str1.name, "Unit M10 assigned");
       assert.equal(str1.date.toISOString(), "2024-05-03T01:01:01.010Z");
 
-      return done();
-    });
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/mark43-incident-retry.js

@@ -1,37 +1,28 @@
 "use strict";
 
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("Mark43IncidentRetry", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("Mark43IncidentRetry", 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.mark43IncidentRetry;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     var item = new models.Mark43IncidentRetry(testItem);
-    item.save(function(err, sut) {
-      assert.isNull(err, "Should not err");
+    item.save().then((ress) => {
       assert.isNotNull(testItem._id);
-      assert.equal(testItem.departmentId, sut.departmentId);
-      assert.equal(testItem.active, sut.active);
-      assert.equal(testItem.mark43IncidentId, sut.mark43IncidentId);
-      assert.equal(JSON.stringify(testItem.retryPayload), JSON.stringify(sut.retryPayload));
-      return done();
-    });
+      assert.equal(testItem.departmentId, ress.departmentId);
+      assert.equal(testItem.active, ress.active);
+      assert.equal(testItem.mark43IncidentId, ress.mark43IncidentId);
+      assert.equal(JSON.stringify(testItem.retryPayload), JSON.stringify(ress.retryPayload));
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });

package/test/message.js

@@ -1,43 +1,34 @@
 "use strict";
 
 const assert = require("chai").assert;
-
-const m = require("..");
-const config = require("./config");
-
-describe("Message", function() {
-  let models, mongoose;
+const mongoose = require('mongoose');
+describe("Message", 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.message;
   });
-  afterEach(function() {
-    mongoose.disconnect();
-  });
 
-  it("is saved", function(done) {
+
+  it("is saved", function () {
     var item = new models.Message(testItem);
-    item.save(function(err, sut) {
-      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.uuid, sut.uuid);
-      assert.equal(testItem.requestId, sut.requestId);
-      assert.equal(testItem.body, sut.body);
-      assert.equal(testItem.actionTitle, sut.actionTitle);
-      assert.equal(testItem.url, sut.url);
-      assert.equal(testItem.priority, sut.priority);
-      assert.equal(JSON.stringify(testItem.type), JSON.stringify(sut.type));
-      return done();
-    });
+      assert.equal(testItem.departmentId, ress.departmentId);
+      assert.equal(testItem.title, ress.title);
+      assert.equal(testItem.uuid, ress.uuid);
+      assert.equal(testItem.requestId, ress.requestId);
+      assert.equal(testItem.body, ress.body);
+      assert.equal(testItem.actionTitle, ress.actionTitle);
+      assert.equal(testItem.url, ress.url);
+      assert.equal(testItem.priority, ress.priority);
+      assert.equal(JSON.stringify(testItem.type), JSON.stringify(ress.type));
+    }).catch((err) => { assert.isNull(err, "Should not err"); });
   });
 });