tabletcommand-backend-models 7.0.0 → 7.0.1

package/test/template.js

@@ -1,39 +1,45 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("Template", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("Template", 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.template;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
+  it("is saved", async function() {
+    const item = new models.Template(testItem);
+    const sut = await item.save();
 
-  it("is saved", function () {
-    var item = new models.Template(testItem);
-    item.save().then((ress) => {
-
-      assert.isNotNull(item._id);
-      assert.equal(item._id, ress.id);
-      assert.equal(ress.id, ress._id);
-      assert.equal(testItem.position, ress.position);
-      assert.equal(testItem.active, ress.active);
-      assert.equal(testItem.name, ress.name);
-      assert.equal(testItem.userId, ress.userId);
-      assert.equal(testItem.departmentId, ress.departmentId);
-      assert.equal(testItem.isMandatory, ress.isMandatory);
-      assert.isArray(testItem.group);
-      assert.isArray(testItem.checklist);
-      assert.equal(testItem.agencyId, ress.agencyId);
-      const expectedDate = new Date().valueOf() / 1000.0;
-      const timeDelta = expectedDate - ress.modified_unix_date;
-      assert.isTrue(timeDelta < 1);
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    assert.isNotNull(item._id);
+    assert.equal(item._id, sut.id);
+    assert.equal(sut.id, sut._id);
+    assert.equal(testItem.position, sut.position);
+    assert.equal(testItem.active, sut.active);
+    assert.equal(testItem.name, sut.name);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(testItem.isMandatory, sut.isMandatory);
+    assert.isArray(testItem.group);
+    assert.isArray(testItem.checklist);
+    assert.equal(testItem.agencyId, sut.agencyId);
+    const expectedDate = new Date().valueOf() / 1000.0;
+    const timeDelta = expectedDate - sut.modified_unix_date;
+    assert.isTrue(timeDelta < 1);
   });
 });

package/test/user-device.js

@@ -1,49 +1,56 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("UserDevice", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("UserDevice", 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.userDevice;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", async function () {
+  it("is saved", async function() {
     const item = new models.UserDevice(testItem);
-    const ress = await item.save();
+    const sut = await item.save();
 
     assert.isNotNull(testItem._id);
-    assert.equal(ress.id, ress._id);
-    assert.equal(testItem.userId, ress.userId);
-    assert.equal(testItem.departmentId, ress.departmentId);
-    assert.equal(ress.devices.length, 1);
-    assert.equal(testItem.devices[0].token, ress.devices[0].token);
-    assert.equal(testItem.devices[0].env, ress.devices[0].env);
-    assert.equal(testItem.devices[0].ua, ress.devices[0].ua);
-    assert.equal(testItem.devices[0].time, ress.devices[0].time);
-    assert.equal(testItem.devices[0].drift, ress.devices[0].drift);
-    assert.equal(testItem.devices[0].bundleIdentifier, ress.devices[0].bundleIdentifier);
-    assert.equal(testItem.devices[0].silentEnabled, ress.devices[0].silentEnabled);
-    assert.equal(testItem.devices[0].criticalAlertsEnabled, ress.devices[0].criticalAlertsEnabled);
-    assert.equal(testItem.devices[0].session, ress.devices[0].session);
-    assert.equal(testItem.devices[0].active, ress.devices[0].active);
-    assert.equal(testItem.devices[0].offDuty, ress.devices[0].offDuty);
-    assert.equal(testItem.notificationCount, ress.notificationCount);
-    assert.equal(JSON.stringify(testItem.notificationIncidentSettings[0]), JSON.stringify(ress.notificationIncidentSettings[0]));
-    assert.equal(JSON.stringify(testItem.notificationUnitSettings[0]), JSON.stringify(ress.notificationUnitSettings[0]));
+    assert.equal(sut.id, sut._id);
+    assert.equal(testItem.userId, sut.userId);
+    assert.equal(testItem.departmentId, sut.departmentId);
+    assert.equal(sut.devices.length, 1);
+    assert.equal(testItem.devices[0].token, sut.devices[0].token);
+    assert.equal(testItem.devices[0].env, sut.devices[0].env);
+    assert.equal(testItem.devices[0].ua, sut.devices[0].ua);
+    assert.equal(testItem.devices[0].time, sut.devices[0].time);
+    assert.equal(testItem.devices[0].drift, sut.devices[0].drift);
+    assert.equal(testItem.devices[0].bundleIdentifier, sut.devices[0].bundleIdentifier);
+    assert.equal(testItem.devices[0].silentEnabled, sut.devices[0].silentEnabled);
+    assert.equal(testItem.devices[0].criticalAlertsEnabled, sut.devices[0].criticalAlertsEnabled);
+    assert.equal(testItem.devices[0].session, sut.devices[0].session);
+    assert.equal(testItem.devices[0].active, sut.devices[0].active);
+    assert.equal(testItem.devices[0].offDuty, sut.devices[0].offDuty);
+    assert.equal(testItem.notificationCount, sut.notificationCount);
+    assert.equal(JSON.stringify(testItem.notificationIncidentSettings[0]), JSON.stringify(sut.notificationIncidentSettings[0]));
+    assert.equal(JSON.stringify(testItem.notificationUnitSettings[0]), JSON.stringify(sut.notificationUnitSettings[0]));
     assert.equal(testItem.offDuty, true);
     assert.equal(testItem.criticalAlertsVolume, "MED");
 
-    assert.isObject(ress.notificationSounds);
-    assert.deepEqual(ress.notificationSounds, item.notificationSounds);
-    assert.isObject(ress.notificationSounds.ios);
-    assert.isObject(ress.notificationSounds.android);
+    assert.isObject(sut.notificationSounds);
+    assert.deepEqual(sut.notificationSounds, item.notificationSounds);
+    assert.isObject(sut.notificationSounds.ios);
+    assert.isObject(sut.notificationSounds.android);
   });
 });

package/test/user-registration.js

@@ -1,41 +1,46 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("UserRegistration", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("UserRegistration", 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.userRegistration;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", function () {
+  it("is saved", async function() {
     const item = new models.UserRegistration(testItem);
-    item.save().then((ress) => {
-
-      assert.isNotNull(testItem._id);
-      assert.equal(ress.id, ress._id);
-      assert.equal(testItem.email, ress.email);
-      assert.equal(testItem.name, ress.name);
-      assert.equal(testItem.firstName, ress.firstName);
-      assert.equal(testItem.lastName, ress.lastName);
-      assert.equal(testItem.department, ress.department);
-      assert.equal(testItem.title, ress.title);
-      assert.equal(testItem.modifiedDate, ress.modifiedDate);
-      assert.equal(testItem.stage, ress.stage);
-      assert.equal(testItem.presentedAt, ress.presentedAt);
-      assert.equal(testItem.managedIncidentsCount, ress.managedIncidentsCount);
-      assert.equal(testItem.checklistsCount, ress.checklistsCount);
-      assert.equal(testItem.firstIncidentUnixTime, ress.firstIncidentUnixTime);
-      assert.equal(testItem.lastIncidentLocation, ress.lastIncidentLocation);
-      assert.equal(testItem.lastIncidentUnixTime, ress.lastIncidentUnixTime);
+    const sut = await item.save();
 
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.id, sut._id);
+    assert.equal(testItem.email, sut.email);
+    assert.equal(testItem.name, sut.name);
+    assert.equal(testItem.firstName, sut.firstName);
+    assert.equal(testItem.lastName, sut.lastName);
+    assert.equal(testItem.department, sut.department);
+    assert.equal(testItem.title, sut.title);
+    assert.equal(testItem.modifiedDate, sut.modifiedDate);
+    assert.equal(testItem.stage, sut.stage);
+    assert.equal(testItem.presentedAt, sut.presentedAt);
+    assert.equal(testItem.managedIncidentsCount, sut.managedIncidentsCount);
+    assert.equal(testItem.checklistsCount, sut.checklistsCount);
+    assert.equal(testItem.firstIncidentUnixTime, sut.firstIncidentUnixTime);
+    assert.equal(testItem.lastIncidentLocation, sut.lastIncidentLocation);
+    assert.equal(testItem.lastIncidentUnixTime, sut.lastIncidentUnixTime);
   });
 });

package/test/user.js

@@ -1,48 +1,54 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("User", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("User", 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.user;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", function () {
-    var item = new models.User(testItem);
+  it("is saved", async function() {
+    const item = new models.User(testItem);
     assert.isNotNull(item.uuid);
-    item.save().then((ress) => {
+    const sut = await item.save();
 
-      assert.isNotNull(testItem._id);
-      assert.equal(ress.nick, testItem.nick);
-      assert.equal(ress.email, testItem.email);
-      assert.equal(ress.mapId, testItem.mapId);
-      assert.equal(ress.departmentId, testItem.departmentId);
-      assert.isFalse(ress.active);
-      assert.isFalse(ress.admin);
-      assert.isFalse(ress.superuser);
-      assert.isTrue(ress.isPro);
-      assert.isTrue(ress.mobileAccess);
-      assert.isFalse(ress.webAccess);
-      assert.isFalse(ress.shareLocationPhone);
-      assert.isTrue(ress.shareLocationTablet);
-      assert.equal(item.uuid, ress.uuid);
-      assert.equal(item.agencyId, ress.agencyId);
-      assert.equal(item.offDutyEnabled, ress.offDutyEnabled);
-      assert.equal(item.managedAgencies[0], ress.managedAgencies[0]);
-      assert.isTrue(ress.offlineMapsEnabled);
-      assert.equal(item.webMapSettings.defaultZoomLevel, 10);
-      assert.equal(item.webMapSettings.defaultCenter[0], 1);
-      assert.equal(item.webMapSettings.defaultCenter[1], 1);
-      assert.equal(item.webMapSettings.defaultMap, "Default");
-      assert.equal(item.restrictedCommentsEnabled, true);
-    }).catch((err) => { assert.isNull(err, "Should not err"); });
+    assert.isNotNull(testItem._id);
+    assert.equal(sut.nick, testItem.nick);
+    assert.equal(sut.email, testItem.email);
+    assert.equal(sut.mapId, testItem.mapId);
+    assert.equal(sut.departmentId, testItem.departmentId);
+    assert.isFalse(sut.active);
+    assert.isFalse(sut.admin);
+    assert.isFalse(sut.superuser);
+    assert.isTrue(sut.isPro);
+    assert.isTrue(sut.mobileAccess);
+    assert.isFalse(sut.webAccess);
+    assert.isFalse(sut.shareLocationPhone);
+    assert.isTrue(sut.shareLocationTablet);
+    assert.equal(item.uuid, sut.uuid);
+    assert.equal(item.agencyId, sut.agencyId);
+    assert.equal(item.offDutyEnabled, sut.offDutyEnabled);
+    assert.equal(item.managedAgencies[0], sut.managedAgencies[0]);
+    assert.isTrue(sut.offlineMapsEnabled);
+    assert.equal(item.webMapSettings.defaultZoomLevel, 10);
+    assert.equal(item.webMapSettings.defaultCenter[0], 1);
+    assert.equal(item.webMapSettings.defaultCenter[1], 1);
+    assert.equal(item.webMapSettings.defaultMap, "Default");
+    assert.equal(item.restrictedCommentsEnabled, true);
   });
 });

package/test/validation-report.js

@@ -1,27 +1,34 @@
 "use strict";
 
 const assert = require("chai").assert;
-const mongoose = require('mongoose');
-describe("ValidationReport", function () {
-  let models = mongoose.models;
-  let testItem;
-  beforeEach(async function () {
 
+const m = require("..");
+const config = require("./config");
+
+describe("ValidationReport", 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.validationReport;
   });
+  afterEach(function() {
+    mongoose.disconnect();
+  });
 
-
-  it("is saved", async function () {
+  it("is saved", async function() {
     const item = new models.ValidationReport(testItem);
-    const ress = await item.save();
+    const sut = await item.save();
 
     assert.isNotNull(item._id);
-    assert.equal(testItem.departmentId.toString(), ress.departmentId.toString());
-    assert.equal(testItem.modified.toString(), ress.modified.toString());
+    assert.equal(testItem.departmentId.toString(), sut.departmentId.toString());
+    assert.equal(testItem.modified.toString(), sut.modified.toString());
     assert.deepEqual(testItem.location, []);
   });
 });