Adding more tests (#18)

* Adding tests for cleanAuthLevels

Bonus: updating the glob for ava so it catches the things in the top level __tests__ folder

* Tests for embedPermissions

* Upgrading to latest version of ava

* Updating tests to support latest version of ava

- Async specific methods for throwing exceptions
- Making sure authIsDisabled returns a boolean in all cases

Author: makinde

__tests__/cleanAuthLevels.test.js

@@ -1,16 +1,78 @@
 const test = require('ava');
 const mongoose = require('mongoose');
-// const cleanAuthLevels = require('../src/cleanAuthLevels');
+const cleanAuthLevels = require('../src/cleanAuthLevels');
 
 test.before((t) => {
-  t.context.schema = new mongoose.Schema({ friend: String });
+  const schema = new mongoose.Schema({ friend: String });
+  schema.permissions = { default: {}, manager: {}, report: {} };
+  t.context.schema = schema;
 });
 
-test.todo('Schema passed in is not valid');
-test.todo('Falsey authLevel value');
-test.todo('Empty array authLevel value');
-test.todo('Remove duplicate entries');
-test.todo('Remove false entries');
-test.todo('Remove entries that are not in the permissions object');
-test.todo('authLevel with no issues');
+test('Schema passed in is not valid', (t) => {
+  t.deepEqual(
+    cleanAuthLevels(false, ['foo']),
+    [],
+    'should return empty list when schema is falsy',
+  );
+
+  t.deepEqual(
+    cleanAuthLevels(false, []),
+    [],
+    'should return empty list when schema is falsy and there are no authLevels',
+  );
+
+  t.deepEqual(
+    cleanAuthLevels({}, ['foo']),
+    [],
+    'should return empty list when schema is empty object',
+  );
+
+  t.deepEqual(
+    cleanAuthLevels({}, []),
+    [],
+    'should return empty list when schema is empty object & there are no authLevels',
+  );
+});
+
+test('Falsey authLevel value', (t) => {
+  t.deepEqual(cleanAuthLevels(t.context.schema, false), []);
+  t.deepEqual(cleanAuthLevels(t.context.schema, 0), []);
+});
+
+test('Empty array authLevel value', (t) => {
+  t.deepEqual(cleanAuthLevels(t.context.schema, []), []);
+});
+
+test('Remove duplicate entries', (t) => {
+  t.deepEqual(cleanAuthLevels(t.context.schema, ['manager', 'manager']), ['manager']);
+});
+
+test('Remove false entries', (t) => {
+  t.deepEqual(cleanAuthLevels(t.context.schema, [0, 'manager', false]), ['manager']);
+});
+
+test('Remove entries that are not in the permissions object', (t) => {
+  t.deepEqual(cleanAuthLevels(t.context.schema, ['fake', 'manager', 'notthere']), ['manager']);
+  t.deepEqual(cleanAuthLevels(t.context.schema, ['fake', 'notthere']), []);
+});
+
+test('authLevel with no issues', (t) => {
+  t.deepEqual(
+    cleanAuthLevels(t.context.schema, ['manager']),
+    ['manager'],
+    'should handle single item array',
+  );
+
+  t.deepEqual(
+    cleanAuthLevels(t.context.schema, ['manager', 'report']),
+    ['manager', 'report'],
+    'should handle mutliple item array',
+  );
+
+  t.deepEqual(
+    cleanAuthLevels(t.context.schema, 'manager'),
+    ['manager'],
+    'should handle single level, not in array',
+  );
+});
 

__tests__/embedPermissions.test.js

@@ -1,3 +1,124 @@
 const test = require('ava');
+const mongoose = require('mongoose');
+const embedPermissions = require('../src/embedPermissions');
 
-test.todo('Migrate tests for embedPermissions');
+test.before((t) => {
+  const schema = new mongoose.Schema({ friend: String });
+  schema.permissions = {
+    default: {},
+    manager: {
+      read: ['friend'],
+      write: ['friend'],
+      create: true,
+      remove: true,
+    },
+  };
+  t.context.schema = schema;
+});
+
+test('No schema', (t) => {
+  const blankDoc = {};
+  embedPermissions(false, { permissions: true }, ['manager'], blankDoc);
+  t.deepEqual(blankDoc, {}, 'Nothing should have been added to doc');
+});
+
+test('No document', (t) => {
+  t.notThrows(() => { embedPermissions(t.context.schema, { permissions: true }, ['manager'], false); });
+});
+
+test('Options say to do nothing', (t) => {
+  const blankDoc = {};
+  embedPermissions(t.context.schema, false, ['manager'], blankDoc);
+  t.deepEqual(blankDoc, {}, 'Should not add permissions for false options');
+
+  embedPermissions(t.context.schema, {}, ['manager'], blankDoc);
+  t.deepEqual(blankDoc, {}, 'Should not add permissions for {} options');
+
+  embedPermissions(t.context.schema, { permissions: false }, ['manager'], blankDoc);
+  t.deepEqual(blankDoc, {}, 'Should not add permissions for { permissions: false} options');
+});
+
+test('Permissions embeded under default key', (t) => {
+  const managerDoc = {};
+  embedPermissions(t.context.schema, { permissions: true }, ['manager'], managerDoc);
+  t.deepEqual(
+    managerDoc.permissions,
+    {
+      read: ['friend'],
+      write: ['friend'],
+      remove: true,
+    },
+    'Incorrect permissions embedded',
+  );
+
+  const defaultDoc = {};
+  embedPermissions(t.context.schema, { permissions: true }, [], defaultDoc);
+  t.deepEqual(
+    defaultDoc.permissions,
+    {
+      read: [],
+      write: [],
+      remove: false,
+    },
+    'Incorrect permissions embedded',
+  );
+});
+test('Permissions embded under custom key', (t) => {
+  const managerDoc = {};
+  embedPermissions(t.context.schema, { permissions: 'customKey' }, ['manager'], managerDoc);
+  t.deepEqual(
+    managerDoc.customKey,
+    {
+      read: ['friend'],
+      write: ['friend'],
+      remove: true,
+    },
+    'Incorrect permissions embedded',
+  );
+
+  const defaultDoc = {};
+  embedPermissions(t.context.schema, { permissions: 'customKey' }, [], defaultDoc);
+  t.deepEqual(
+    defaultDoc.customKey,
+    {
+      read: [],
+      write: [],
+      remove: false,
+    },
+    'Incorrect permissions embedded',
+  );
+});
+
+test('If there\'s already a permissions field', (t) => {
+  const doc = { permissions: 'app level info' };
+  t.throws(
+    () => {
+      embedPermissions(t.context.schema, { permissions: true }, ['manager'], doc);
+    },
+    Error,
+    'An error should be thrown when a permissions key is already present in the target object',
+  );
+});
+
+test('Verify that the permissions data cannot be changed', (t) => {
+  const doc = {};
+  embedPermissions(t.context.schema, { permissions: true }, ['manager'], doc);
+
+  t.throws(
+    () => { doc.permissions.read = []; },
+    Error,
+    'The permissions object shouldn\'t be writable [read]',
+  );
+
+  t.throws(
+    () => { doc.permissions.write = []; },
+    Error,
+    'The permissions object shouldn\'t be writable [write]',
+  );
+
+  t.throws(
+    () => { doc.permissions.remove = false; },
+    Error,
+    'The permissions object shouldn\'t be writable [remove]',
+  );
+});

__tests__/methods/Model.create.test.js

@@ -22,7 +22,7 @@ test('Model.create should be callable without the plugin installed', async (t) =
   const schema = new mongoose.Schema({ friend: String });
   const MyModel = mongoose.model('ModelCreateWithoutPluggin', schema);
 
-  await t.notThrows(MyModel.create({ friend: 'bar' }));
+  await t.notThrowsAsync(MyModel.create({ friend: 'bar' }));
 });
 
 test.after.always(async () => {

__tests__/methods/Model.remove.test.js

@@ -22,7 +22,7 @@ test('Model.remove should be callable without the plugin installed', async (t) =
   const schema = new mongoose.Schema({ friend: String });
   const MyModel = mongoose.model('ModelRemoveWithoutPlugin', schema);
 
-  await t.notThrows(MyModel.remove({}).exec());
+  await t.notThrowsAsync(MyModel.remove({}).exec());
 });
 
 test.after.always(async () => {