tabletcommand-backend-models 7.0.0 → 7.0.2

package/test/managed-incident.js

@@ -2,110 +2,116 @@
 
 const _ = require("lodash");
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("ManagedIncident", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("ManagedIncident", 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.managedIncident;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
+  it("is saved", async function() {
+    const item = new models.ManagedIncident(testItem);
+    const sut = await item.save();
 
-  it("is saved", function () {
-    var item = new models.ManagedIncident(testItem);
-    item.save().then((ress) => {
-
-      assert.isNotNull(testItem._id);
-      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(ress.active);
-      assert.isTrue(ress.is_closed);
+    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);
 
-      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");
-      assert.equal(p1.PersonnelNote, "X");
-      assert.equal(p1.PersonnelRank, "Captain");
-      assert.equal(p1.PersonnelWorkCode, "TRD");
+    assert.isTrue(sut.active);
+    assert.isTrue(sut.is_closed);
 
-      // Share incident properties
-      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(ress.ReportNumber.filter((x) => x.name === "B"));
-      assert.isObject(rnb);
-      assert.equal(rnb.number, "UM-02210");
+    const unit = _.first(sut.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");
+    assert.equal(p1.PersonnelNote, "X");
+    assert.equal(p1.PersonnelRank, "Captain");
+    assert.equal(p1.PersonnelWorkCode, "TRD");
 
-      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(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");
+    // Share incident properties
+    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(sut.ReportNumber.filter((x) => x.name === "B"));
+    assert.isObject(rnb);
+    assert.equal(rnb.number, "UM-02210");
 
-      assert.isObject(ress.record);
-      assert.equal(ress.record.name, "John");
-      assert.equal(ress.record.value, "Smith");
+    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(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.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.isObject(sut.record);
+    assert.equal(sut.record.name, "John");
+    assert.equal(sut.record.value, "Smith");
 
-      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");
-      assert.equal(st1.name, "Test Fire Department");
-      assert.equal(st1.startAt.toISOString(), "2024-05-01T01:02:03.040Z");
-      assert.equal(st1.reasons.length, 1);
-      const str1 = _.first(st1.reasons);
-      assert.equal(str1.name, "Unit M10 assigned");
-      assert.equal(str1.date.toISOString(), "2024-05-03T01:01:01.010Z");
+    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");
 
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    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");
+    assert.equal(st1.name, "Test Fire Department");
+    assert.equal(st1.startAt.toISOString(), "2024-05-01T01:02:03.040Z");
+    assert.equal(st1.reasons.length, 1);
+    const str1 = _.first(st1.reasons);
+    assert.equal(str1.name, "Unit M10 assigned");
+    assert.equal(str1.date.toISOString(), "2024-05-03T01:01:01.010Z");
   });
 });

package/test/mark43-incident-retry.js

@@ -1,28 +1,35 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("Mark43IncidentRetry", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("Mark43IncidentRetry", 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.mark43IncidentRetry;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
+  it("is saved", async function() {
+    const item = new models.Mark43IncidentRetry(testItem);
+    const sut = await item.save();
 
-  it("is saved", function () {
-    var item = new models.Mark43IncidentRetry(testItem);
-    item.save().then((ress) => {
-      assert.isNotNull(testItem._id);
-      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"); });
+    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));
   });
 });

package/test/message.js

@@ -1,34 +1,40 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("Message", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("Message", 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.message;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
+  it("is saved", async function() {
+    const item = new models.Message(testItem);
+    const sut = await item.save();
 
-  it("is saved", function () {
-    var item = new models.Message(testItem);
-    item.save().then((ress) => {
-
-      assert.isNotNull(testItem._id);
-      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"); });
+    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));
   });
 });

package/test/monitor.js

@@ -1,29 +1,36 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("Monitor", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("Monitor", 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.monitor;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", async function () {
+  it("is saved", async function() {
     const item = new models.Monitor(testItem);
-    const ress = await item.save();
-    assert.isNotNull(ress._id);
+    const sut = await item.save();
+    assert.isNotNull(sut._id);
 
-    assert.equal(testItem.departmentId, ress.departmentId);
-    assert.equal(testItem.agencyId, ress.agencyId);
-    assert.equal(testItem.notificationType, ress.notificationType);
-    assert.equal(testItem.status, ress.status);
-    assert.equal(testItem.sentUnixDate, ress.sentUnixDate);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.agencyId, sut.agencyId);
+    assert.equal(testItem.notificationType, sut.notificationType);
+    assert.equal(testItem.status, sut.status);
+    assert.equal(testItem.sentUnixDate, sut.sentUnixDate);
   });
 });

package/test/personnel-import.js

@@ -1,44 +1,51 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("PersonnelImport", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("PersonnelImport", 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.personnelImport;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", async function () {
+  it("is saved", async function() {
     const item = new models.PersonnelImport(testItem);
-    const ress = await item.save();
-    assert.equal(testItem._id, ress._id);
-    assert.equal(testItem.PersonnelID, ress.PersonnelID);
-    assert.equal(testItem.PersonnelName, ress.PersonnelName);
-    assert.equal(testItem.PersonnelRank, ress.PersonnelRank);
-    assert.equal(testItem.PersonnelWorkCode, ress.PersonnelWorkCode);
-    assert.equal(testItem.PersonnelNote, ress.PersonnelNote);
-    assert.equal(testItem.departmentId, ress.departmentId);
-    assert.equal(testItem.radioNames[0], ress.radioNames[0]);
-    assert.equal(testItem.radioNames[1], ress.radioNames[1]);
-    assert.equal(ress.radioNames.length, 2);
-    assert.equal(testItem.shiftStartTime, ress.shiftStartTime);
-    assert.equal(testItem.shiftEndTime, ress.shiftEndTime);
-    assert.equal(testItem.modified_unix_date, ress.modified_unix_date);
-    assert.equal(testItem.active, ress.active);
-    assert.equal(testItem.agencyName, ress.agencyName);
-    assert.equal(testItem.agencyCode, ress.agencyCode);
-    assert.equal(testItem.agencyId, ress.agencyId);
-    assert.equal(testItem.importNotes, ress.importNotes);
-    assert.equal(testItem.modified.toString(), ress.modified.toISOString());
-    assert.equal(testItem.shiftStart.toString(), ress.shiftStart.toISOString());
-    assert.equal(testItem.shiftEnd.toString(), ress.shiftEnd.toISOString());
+    const sut = await item.save();
+    assert.equal(testItem._id, sut._id);
+    assert.equal(testItem.PersonnelID, sut.PersonnelID);
+    assert.equal(testItem.PersonnelName, sut.PersonnelName);
+    assert.equal(testItem.PersonnelRank, sut.PersonnelRank);
+    assert.equal(testItem.PersonnelWorkCode, sut.PersonnelWorkCode);
+    assert.equal(testItem.PersonnelNote, sut.PersonnelNote);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.radioNames[0], sut.radioNames[0]);
+    assert.equal(testItem.radioNames[1], sut.radioNames[1]);
+    assert.equal(sut.radioNames.length, 2);
+    assert.equal(testItem.shiftStartTime, sut.shiftStartTime);
+    assert.equal(testItem.shiftEndTime, sut.shiftEndTime);
+    assert.equal(testItem.modified_unix_date, sut.modified_unix_date);
+    assert.equal(testItem.active, sut.active);
+    assert.equal(testItem.agencyName, sut.agencyName);
+    assert.equal(testItem.agencyCode, sut.agencyCode);
+    assert.equal(testItem.agencyId, sut.agencyId);
+    assert.equal(testItem.importNotes, sut.importNotes);
+    assert.equal(testItem.modified.toString(), sut.modified.toISOString());
+    assert.equal(testItem.shiftStart.toString(), sut.shiftStart.toISOString());
+    assert.equal(testItem.shiftEnd.toString(), sut.shiftEnd.toISOString());
   });
 });
 

package/test/rate-limit.js

@@ -1,29 +1,34 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("RateLimit", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("RateLimit", 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.rateLimit;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
+  it("is saved", async function() {
+    const item = new models.RateLimit(testItem);
+    const sut = await item.save();
 
-  it("is saved", function () {
-    var item = new models.RateLimit(testItem);
-    item.save().then((ress) => {
-
-      assert.isNotNull(testItem._id);
-      assert.equal(ress.user, testItem.user);
-      assert.equal(ress.modified_unix_date, testItem.modified_unix_date);
-      assert.equal(ress.count, testItem.count);
-
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.user, testItem.user);
+    assert.equal(sut.modified_unix_date, testItem.modified_unix_date);
+    assert.equal(sut.count, testItem.count);
   });
 });

package/test/release-note.js

@@ -5,10 +5,10 @@ const assert = require("chai").assert;
 const m = require("..");
 const config = require("./config");
 
-describe("ReleaseNote", function () {
+describe("ReleaseNote", 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;
@@ -18,17 +18,19 @@ describe("ReleaseNote", function () {
     });
     testItem = mock.releaseNote;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-  it("is saved", function () {
-    var item = new models.ReleaseNote(testItem);
-    item.save().then((ress) => {
-      assert.isNotNull(testItem._id);
-      assert.equal(testItem.title, sut.title);
-      assert.equal(testItem.notes, sut.notes);
-      assert.equal(testItem.version, sut.version);
-      assert.equal(testItem.releaseDate, sut.releaseDate);
-      assert.equal(testItem.status, sut.status);
+  it("is saved", async function() {
+    const item = new models.ReleaseNote(testItem);
+    const sut = await item.save();
 
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    assert.isNotNull(testItem._id);
+    assert.equal(testItem.title, sut.title);
+    assert.equal(testItem.notes, sut.notes);
+    assert.equal(testItem.version, sut.version);
+    assert.equal(testItem.releaseDate, sut.releaseDate);
+    assert.equal(testItem.status, sut.status);
   });
 });

package/test/session.js

@@ -1,40 +1,45 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("Session", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("Session", 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.session;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
+  it("is saved", async function() {
+    const item = new models.Session(testItem);
+    const sut = await item.save();
 
-  it("is saved", function () {
-    var item = new models.Session(testItem);
-    item.save().then((ress) => {
-
-      assert.isNotNull(testItem._id);
-      assert.equal(ress.user, testItem.user);
-      assert.equal(ress.email, testItem.email);
-      assert.equal(ress.nick, testItem.nick);
-      assert.equal(ress.departmentId, testItem.departmentId);
-      assert.isFalse(ress.active);
-      assert.equal(ress.deviceId, testItem.deviceId);
-      assert.equal(ress.remoteAddress, testItem.remoteAddress);
-      assert.equal(ress.userAgent, testItem.userAgent);
-      assert.equal(ress.source, testItem.source);
-      assert.equal(ress.token, testItem.token);
-      assert.equal(ress.ended, testItem.ended);
-      assert.equal(ress.departmentId, testItem.departmentId);
-      assert.equal(ress.when, testItem.when);
-      assert.equal(ress.id, ress._id);
-
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.user, testItem.user);
+    assert.equal(sut.email, testItem.email);
+    assert.equal(sut.nick, testItem.nick);
+    assert.equal(sut.departmentId, testItem.departmentId);
+    assert.isFalse(sut.active);
+    assert.equal(sut.deviceId, testItem.deviceId);
+    assert.equal(sut.remoteAddress, testItem.remoteAddress);
+    assert.equal(sut.userAgent, testItem.userAgent);
+    assert.equal(sut.source, testItem.source);
+    assert.equal(sut.token, testItem.token);
+    assert.equal(sut.ended, testItem.ended);
+    assert.equal(sut.departmentId, testItem.departmentId);
+    assert.equal(sut.when, testItem.when);
+    assert.equal(sut.id, sut._id);
   });
 });