Merge pull request #158 from Kashoo/issue157-chai-upgrade

Issue #157 chai upgrade

Author: ziemek

CHANGELOG.md

@@ -2,6 +2,11 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [Unreleased]
+
+### Changed
+- [#157](https://github.com/Kashoo/synctos/issues/157): Swap in Chai as the assertion library used in specs throughout the project
+
 ## [1.9.3] - 2017-10-23
 ### Fixed
 - [#152](https://github.com/Kashoo/synctos/issues/152): Cannot append a new object with immutable properties to an array

etc/test-helper.js

@@ -233,8 +233,7 @@ exports.verifyAccessDenied = verifyAccessDenied;
  */
 exports.verifyUnknownDocumentType = verifyUnknownDocumentType;
 
-
-var expect = require('expect.js');
+var assert = require('assert');
 var simple = require('simple-mock');
 var fs = require('fs');
 var syncFunctionLoader = require('./sync-function-loader.js');
@@ -291,25 +290,25 @@ function init() {
 }
 
 function verifyRequireAccess(expectedChannels) {
-  expect(requireAccess.callCount).to.be.greaterThan(0);
+  assert.ok(requireAccess.callCount > 0, 'Require access not called when expected');
 
   checkAuthorizations(expectedChannels, requireAccess.calls[0].arg, 'channel');
 }
 
 function verifyRequireRole(expectedRoles) {
-  expect(requireRole.callCount).to.be.greaterThan(0);
+  assert.ok(requireRole.callCount > 0, 'Require role not called when expected');
 
   checkAuthorizations(expectedRoles, requireRole.calls[0].arg, 'role');
 }
 
 function verifyRequireUser(expectedUsers) {
-  expect(requireUser.callCount).to.be.greaterThan(0);
+  assert.ok(requireUser.callCount > 0, 'Require user not called when expected');
 
   checkAuthorizations(expectedUsers, requireUser.calls[0].arg, 'user');
 }
 
 function verifyChannelAssignment(expectedChannels) {
-  expect(channel.callCount).to.be(1);
+  assert.equal(channel.callCount, 1, 'Expected channel assignment was not made');
 
   checkAuthorizations(expectedChannels, channel.calls[0].arg, 'channel');
 }
@@ -328,14 +327,14 @@ function checkAuthorizations(expectedAuthorizations, actualAuthorizations, autho
   for (var expectedAuthIndex = 0; expectedAuthIndex < expectedAuthorizations.length; expectedAuthIndex++) {
     var expectedAuth = expectedAuthorizations[expectedAuthIndex];
     if (actualAuthorizations.indexOf(expectedAuth) < 0) {
-      expect().fail('Expected ' + authorizationType + ' was not encountered: ' + expectedAuth);
+      assert.fail('Expected ' + authorizationType + ' was not encountered: ' + expectedAuth);
     }
   }
 
   for (var actualAuthIndex = 0; actualAuthIndex < actualAuthorizations.length; actualAuthIndex++) {
     var actualAuth = actualAuthorizations[actualAuthIndex];
     if (expectedAuthorizations.indexOf(actualAuth) < 0) {
-      expect().fail('Unexpected ' + authorizationType + ' encountered: ' + actualAuth);
+      assert.fail('Unexpected ' + authorizationType + ' encountered: ' + actualAuth);
     }
   }
 }
@@ -409,7 +408,7 @@ function verifyChannelAccessAssignment(expectedAssignment) {
   }
 
   if (!accessAssignmentCallExists(access, expectedUsersAndRoles, expectedChannels)) {
-    expect().fail(
+    assert.fail(
       'Missing expected call to assign channel access (' +
       JSON.stringify(expectedChannels) +
       ') to users and roles (' +
@@ -442,7 +441,7 @@ function verifyRoleAccessAssignment(expectedAssignment) {
   }
 
   if (!accessAssignmentCallExists(role, expectedUsers, expectedRoles)) {
-    expect().fail(
+    assert.fail(
       'Missing expected call to assign role access (' +
       JSON.stringify(expectedRoles) +
       ') to users (' +
@@ -467,26 +466,26 @@ function verifyAccessAssignments(expectedAccessAssignments) {
   }
 
   if (access.callCount !== expectedAccessCalls) {
-    expect().fail('Number of calls to assign channel access (' + access.callCount + ') does not match expected (' + expectedAccessCalls + ')');
+    assert.fail('Number of calls to assign channel access (' + access.callCount + ') does not match expected (' + expectedAccessCalls + ')');
   }
 
   if (role.callCount !== expectedRoleCalls) {
-    expect().fail('Number of calls to assign role access (' + role.callCount + ') does not match expected (' + expectedRoleCalls + ')');
+    assert.fail('Number of calls to assign role access (' + role.callCount + ') does not match expected (' + expectedRoleCalls + ')');
   }
 }
 
 function verifyOperationChannelsAssigned(doc, oldDoc, expectedChannels) {
   if (channel.callCount !== 1) {
-    expect().fail('Document failed authorization and/or validation');
+    assert.fail('Document failed authorization and/or validation');
   }
 
   var actualChannels = channel.calls[0].arg;
   if (expectedChannels instanceof Array) {
     for (var channelIndex = 0; channelIndex < expectedChannels.length; channelIndex++) {
-      expect(actualChannels).to.contain(expectedChannels[channelIndex]);
+      assert.ok(actualChannels.indexOf(expectedChannels[channelIndex]) >= 0, 'Expected channel "' + expectedChannels[channelIndex] + '" was not authorized');
     }
   } else {
-    expect(actualChannels).to.contain(expectedChannels);
+    assert.ok(actualChannels.indexOf(expectedChannels) >= 0, 'Expected assignment channel not found: "' + expectedChannels + '" actual: "' + actualChannels + '"');
   }
 }
 
@@ -497,8 +496,8 @@ function verifyAuthorization(expectedAuthorization) {
     // for authorization
     expectedOperationChannels = expectedAuthorization;
     verifyRequireAccess(expectedAuthorization);
-    expect(requireRole.callCount).to.be(0);
-    expect(requireUser.callCount).to.be(0);
+    assert.equal(requireRole.callCount, 0, 'Require role called unexpectedly: ' + requireRole.calls);
+    assert.equal(requireUser.callCount, 0, 'Require user called unexpectedly: ' + requireUser.calls);
   } else {
     if (expectedAuthorization.expectedChannels) {
       expectedOperationChannels = expectedAuthorization.expectedChannels;
@@ -508,13 +507,13 @@ function verifyAuthorization(expectedAuthorization) {
     if (expectedAuthorization.expectedRoles) {
       verifyRequireRole(expectedAuthorization.expectedRoles);
     } else {
-      expect(requireRole.callCount).to.be(0);
+      assert.equal(requireRole.callCount, 0, 'Require role called unexpectedly: ' + requireRole.calls);
     }
 
     if (expectedAuthorization.expectedUsers) {
       verifyRequireUser(expectedAuthorization.expectedUsers);
     } else {
-      expect(requireUser.callCount).to.be(0);
+      assert.equal(requireUser.callCount, 0, 'Require user called unexpectedly: ' + requireUser.calls);
     }
 
     if (!(expectedAuthorization.expectedChannels) && !(expectedAuthorization.expectedRoles) && !(expectedAuthorization.expectedUsers)) {
@@ -550,13 +549,16 @@ function verifyDocumentDeleted(oldDoc, expectedAuthorization, expectedAccessAssi
 }
 
 function verifyDocumentRejected(doc, oldDoc, docType, expectedErrorMessages, expectedAuthorization) {
-  expect(syncFunction).withArgs(doc, oldDoc).to.throwException(function(ex) {
+  try {
+    syncFunction(doc, oldDoc);
+    assert.fail('No errors thrown when some expected');
+  } catch (ex) {
     verifyValidationErrors(docType, expectedErrorMessages, ex);
-  });
+  }
 
   verifyAuthorization(expectedAuthorization);
 
-  expect(channel.callCount).to.equal(0);
+  assert.equal(channel.callCount, 0, 'Channel assignment made unexpectedly: ' + channel.calls);
 }
 
 function verifyDocumentNotCreated(doc, docType, expectedErrorMessages, expectedAuthorization) {
@@ -582,26 +584,27 @@ function verifyValidationErrors(docType, expectedErrorMessages, exception) {
   var exceptionMessageMatches = validationErrorRegex.exec(exception.forbidden);
   var actualErrorMessages;
   if (exceptionMessageMatches) {
-    expect(exceptionMessageMatches.length).to.be(3);
+    assert.equal(exceptionMessageMatches.length, 3);
 
     var invalidDocMessage = exceptionMessageMatches[1].trim();
-    expect(invalidDocMessage).to.equal('Invalid ' + docType + ' document');
+    assert.equal(invalidDocMessage, 'Invalid ' + docType + ' document', 'Expected invalid document type message not reported');
 
     actualErrorMessages = exceptionMessageMatches[2].trim().split(/;\s*/);
   } else {
     actualErrorMessages = [ exception.forbidden ];
   }
 
   for (var expectedErrorIndex = 0; expectedErrorIndex < expectedErrorMessages.length; expectedErrorIndex++) {
-    expect(actualErrorMessages).to.contain(expectedErrorMessages[expectedErrorIndex]);
+    var expectedErrorMsg = expectedErrorMessages[expectedErrorIndex];
+    assert.ok(actualErrorMessages.indexOf(expectedErrorMsg) >= 0, 'Expected error message "' + expectedErrorMsg  +'" not reported');
   }
 
   // Rather than compare the sizes of the two lists, which leads to an obtuse error message on failure (e.g. "expected 2 to be 3"), ensure
   // that neither list of validation errors contains an element that does not exist in the other
   for (var actualErrorIndex = 0; actualErrorIndex < actualErrorMessages.length; actualErrorIndex++) {
     var errorMessage = actualErrorMessages[actualErrorIndex];
     if (expectedErrorMessages.indexOf(errorMessage) < 0) {
-      expect().fail('Unexpected validation error: ' + errorMessage);
+      assert.fail('Unexpected validation error: ' + errorMessage);
     }
   }
 }
@@ -631,32 +634,38 @@ function verifyAccessDenied(doc, oldDoc, expectedAuthorization) {
   requireRole = simple.stub().throwWith(roleAccessDenied);
   requireUser = simple.stub().throwWith(userAccessDenied);
 
-  expect(syncFunction).withArgs(doc, oldDoc).to.throwException(function(ex) {
+  try {
+    syncFunction(doc, oldDoc);
+    assert.fail('No errors thrown when some expected');
+  } catch (ex) {
     if (typeof(expectedAuthorization) === 'string' || expectedAuthorization instanceof Array) {
-      expect(ex).to.eql(channelAccessDenied);
+      assert.equal(ex, channelAccessDenied);
     } else if (countAuthorizationTypes(expectedAuthorization) === 0) {
       verifyRequireAccess([ ]);
     } else if (countAuthorizationTypes(expectedAuthorization) > 1) {
-      expect(ex.forbidden).to.equal(generalAuthFailedMessage);
+      assert.equal(ex.forbidden, generalAuthFailedMessage, 'Expected authorization exception not met: ' + ex.forbidden);
     } else if (expectedAuthorization.expectedChannels) {
-      expect(ex).to.eql(channelAccessDenied);
+      assert.ok(ex instanceof Error && ex.message === channelAccessDenied.message, 'Expected channel authorization error not triggered');
     } else if (expectedAuthorization.expectedRoles) {
-      expect(ex).to.eql(roleAccessDenied);
+      assert.ok(ex instanceof Error && ex.message === roleAccessDenied.message, 'Expected role authorization error not triggered');
     } else if (expectedAuthorization.expectedUsers) {
-      expect(ex).to.eql(userAccessDenied);
+      assert.ok(ex instanceof Error && ex.message === userAccessDenied.message, 'Expected user authorization error not triggered');
     }
-  });
+  }
 
   verifyAuthorization(expectedAuthorization);
 }
 
 function verifyUnknownDocumentType(doc, oldDoc) {
-  expect(syncFunction).withArgs(doc, oldDoc).to.throwException(function(ex) {
-    expect(ex.forbidden).to.equal('Unknown document type');
-  });
+  try {
+    syncFunction(doc, oldDoc);
+    assert.fail('Expected unknown document type error not thrown');
+  } catch (ex) {
+    assert.equal(ex.forbidden, 'Unknown document type');
+  }
 
-  expect(requireAccess.callCount).to.be(0);
-  expect(channel.callCount).to.be(0);
+  assert.equal(requireAccess.callCount, 0, 'Unexpected require access call');
+  assert.equal(channel.callCount, 0, 'Unexpected channel assignment call');
 }
 
 // Sync Gateway configuration files use the backtick character to denote the beginning and end of a multiline string. The sync function

package.json

@@ -5,7 +5,7 @@
     "indent.js": "^0.1.4"
   },
   "devDependencies": {
-    "expect.js": "^0.3.1",
+    "chai": "^4.1.2",
     "jshint": "^2.9.4",
     "mocha": "^3.3.0",
     "simple-mock": "^0.7.3"

test/access-assignment-spec.js

@@ -1,4 +1,4 @@
-var expect = require('expect.js');
+var expect = require('chai').expect;
 var testHelper = require('../etc/test-helper.js');
 
 describe('User and role access assignment:', function() {
@@ -56,9 +56,10 @@ describe('User and role access assignment:', function() {
         invalidProperty: 'foobar'
       };
 
-      expect(testHelper.syncFunction).withArgs(doc).to.throwException(function(ex) {
-        expect(testHelper.access.callCount).to.be(0);
-      });
+      expect(function() {
+        testHelper.syncFunction(doc);
+      }).to.throw();
+      expect(testHelper.access.callCount).to.equal(0);
     });
 
     it('is NOT applied when replacing an invalid document', function() {
@@ -68,9 +69,10 @@ describe('User and role access assignment:', function() {
       };
       var oldDoc = { _id: 'staticAccessDoc' };
 
-      expect(testHelper.syncFunction).withArgs(doc, oldDoc).to.throwException(function(ex) {
-        expect(testHelper.access.callCount).to.be(0);
-      });
+      expect(function() {
+        testHelper.syncFunction(doc, oldDoc);
+      }).to.throw();
+      expect(testHelper.access.callCount).to.equal(0);
     });
   });
 
@@ -164,9 +166,10 @@ describe('User and role access assignment:', function() {
         invalidProperty: 'foobar'
       };
 
-      expect(testHelper.syncFunction).withArgs(doc).to.throwException(function(ex) {
-        expect(testHelper.access.callCount).to.be(0);
-      });
+      expect(function() {
+        testHelper.syncFunction(doc);
+      }).to.throw();
+      expect(testHelper.access.callCount).to.equal(0);
     });
 
     it('is NOT applied when replacing an invalid document', function() {
@@ -178,9 +181,10 @@ describe('User and role access assignment:', function() {
       };
       var oldDoc = { _id: 'dynamicAccessDoc' };
 
-      expect(testHelper.syncFunction).withArgs(doc, oldDoc).to.throwException(function(ex) {
-        expect(testHelper.access.callCount).to.be(0);
-      });
+      expect(function() {
+        testHelper.syncFunction(doc, oldDoc);
+      }).to.throw();
+      expect(testHelper.access.callCount).to.equal(0);
     });
   });
 });