@ukhomeoffice/cop-react-form-renderer 5.0.0-alpha → 5.0.1

package/dist/utils/Condition/meetsCondition.test.js

@@ -0,0 +1,763 @@
+"use strict";
+
+var _meetsCondition = _interopRequireDefault(require("./meetsCondition"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Local imports
+
+describe('utils.Condition.meetsCondition', function () {
+  var getCondition = function getCondition(operator, val) {
+    if (['in', 'nin'].includes(operator)) {
+      return {
+        op: operator,
+        values: val
+      };
+    }
+    return {
+      op: operator,
+      value: val
+    };
+  };
+  var TEST_VALUES = ['a', 'b', 3, 4, null, undefined, true, false, 0];
+  describe('equality operators', function () {
+    ['eq', '='].forEach(function (op) {
+      describe("operator ".concat(op), function () {
+        // Should match...
+        it('should match two nulls', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, null);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two undefineds', function () {
+          var VALUE = undefined;
+          var CONDITION = getCondition(op, undefined);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two identical strings', function () {
+          var VALUE = 'value';
+          var CONDITION = getCondition(op, 'value');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two empty strings', function () {
+          var VALUE = '';
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two identical numbers', function () {
+          var VALUE = 3;
+          var CONDITION = getCondition(op, 3);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two zeroes', function () {
+          var VALUE = 0;
+          var CONDITION = getCondition(op, 0);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two boolean trues', function () {
+          var VALUE = true;
+          var CONDITION = getCondition(op, true);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two boolean falses', function () {
+          var VALUE = false;
+          var CONDITION = getCondition(op, false);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match environmentContext value with data object', function () {
+          var VALUE = 'Bob';
+          var DATA = {
+            environmentContext: {
+              currentUser: 'Bob'
+            }
+          };
+          var CONDITION = getCondition(op, 'field::environmentContext.currentUser');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE, DATA)).toBeTruthy();
+        });
+
+        // Should reject...
+        it('should reject a null and undefined', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, undefined);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject a null and empty string', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject an undefined and empty string', function () {
+          var VALUE = undefined;
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject a string of just whitespace and empty string', function () {
+          var VALUE = ' ';
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it("should reject the string number '3' and the number 3", function () {
+          var VALUE = '3';
+          var CONDITION = getCondition(op, 3);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject a boolean true and the number 1', function () {
+          var VALUE = true;
+          var CONDITION = getCondition(op, 1);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject a boolean false and a zero', function () {
+          var VALUE = false;
+          var CONDITION = getCondition(op, 0);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+      });
+    });
+  });
+  describe('inequality operators', function () {
+    ['ne', 'neq', '!=', '<>'].forEach(function (op) {
+      describe("operator ".concat(op), function () {
+        // Should reject...
+        it('should reject two nulls', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, null);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two undefineds', function () {
+          var VALUE = undefined;
+          var CONDITION = getCondition(op, undefined);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two identical strings', function () {
+          var VALUE = 'value';
+          var CONDITION = getCondition(op, 'value');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two empty strings', function () {
+          var VALUE = '';
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two identical numbers', function () {
+          var VALUE = 3;
+          var CONDITION = getCondition(op, 3);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two zeroes', function () {
+          var VALUE = 0;
+          var CONDITION = getCondition(op, 0);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two boolean trues', function () {
+          var VALUE = true;
+          var CONDITION = getCondition(op, true);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two boolean falses', function () {
+          var VALUE = false;
+          var CONDITION = getCondition(op, false);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject environmentContext value with data object', function () {
+          var VALUE = 'Bob';
+          var DATA = {
+            environmentContext: {
+              currentUser: 'Bob'
+            }
+          };
+          var CONDITION = getCondition(op, 'field::environmentContext.currentUser');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE, DATA)).toBeFalsy();
+        });
+
+        // Should match...
+        it('should match a null and undefined', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, undefined);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match a null and empty string', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match an undefined and empty string', function () {
+          var VALUE = undefined;
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match a string of just whitespace and empty string', function () {
+          var VALUE = ' ';
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it("should match the string number '3' and the number 3", function () {
+          var VALUE = '3';
+          var CONDITION = getCondition(op, 3);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match a boolean true and the number 1', function () {
+          var VALUE = true;
+          var CONDITION = getCondition(op, 1);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match a boolean false and a zero', function () {
+          var VALUE = false;
+          var CONDITION = getCondition(op, 0);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+      });
+    });
+  });
+  describe('operator in', function () {
+    var op = 'in';
+
+    // Should match...
+    it('should match a string that is in the values array', function () {
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should match a number that is in the values array', function () {
+      var VALUE = 4;
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie', 4]);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+
+    // Should reject...
+    it('should reject a string that is missing from the values array', function () {
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject a number that is missing from the values array', function () {
+      var VALUE = 4;
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject everything when the values array is empty', function () {
+      var CONDITION = getCondition(op, []);
+      ['a', 'b', 'c', 'd', 'e', 6, 7, 8, 9, 'ten'].forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+    it('should reject everything when the values array is null', function () {
+      var CONDITION = getCondition(op, null);
+      ['a', 'b', 'c', 'd', 'e', 6, 7, 8, 9, 'ten'].forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+  });
+  describe('operator nin', function () {
+    var op = 'nin';
+
+    // Should reject...
+    it('should reject a string that is in the values array', function () {
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject a number that is in the values array', function () {
+      var VALUE = 4;
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie', 4]);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+
+    // Should match...
+    it('should match a string that is missing from the values array', function () {
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should match a number that is missing from the values array', function () {
+      var VALUE = 4;
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should match anything when the values array is empty', function () {
+      var CONDITION = getCondition(op, []);
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeTruthy();
+      });
+    });
+    it('should match anything when the values array is null', function () {
+      var CONDITION = getCondition(op, null);
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeTruthy();
+      });
+    });
+  });
+  describe('operator contains', function () {
+    var op = 'contains';
+
+    // Should match...
+    it('should match a string that is in the field array', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a sub-string that is in the field array', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = 'alp';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a number that is in the field array', function () {
+      var FIELD = [1, 2, 3];
+      var VALUE = 1;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a sub-string that is in the field string', function () {
+      var FIELD = 'alphabravocharlie';
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a string that is in the field array regardless of case', function () {
+      var FIELD = ['Alpha', 'bravo', 'charlie'];
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+
+    // Should reject...
+    it('should reject a string that is missing from the field array', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject a number that is missing from the field array', function () {
+      var FIELD = [1, 2, 3];
+      var VALUE = 4;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject a substring that is missing from the field string', function () {
+      var FIELD = 'alphabravocharlie';
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any value when the field is an empty Array', function () {
+      var FIELD = [];
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any value when the field is an empty string', function () {
+      var FIELD = '';
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any field when the value is null', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = null;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any field when the value is undefined', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = undefined;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any value when the field is null', function () {
+      var FIELD = null;
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any value when the field is undefined', function () {
+      var FIELD = undefined;
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+  });
+  describe('operator !contains', function () {
+    var op = '!contains';
+
+    // Should match...
+    it('should match a string that is not in the field array', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match any value if the field array is empty', function () {
+      var FIELD = [];
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match any field when the value is null', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = null;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match any field when the value is undefined', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = undefined;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match any value when the field is an empty string', function () {
+      var FIELD = '';
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a number that is missing from the field array', function () {
+      var FIELD = [1, 2, 3];
+      var VALUE = 4;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a substring that is missing from the field string', function () {
+      var FIELD = 'alphabravocharlie';
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match any value when the field is null', function () {
+      var FIELD = null;
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match any value when the field is undefined', function () {
+      var FIELD = undefined;
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+
+    // Should reject...
+    it('should reject a string that is in the field array', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject a sub-string that is in the field array', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = 'alp';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject a number that is in the field array', function () {
+      var FIELD = [1, 2, 3];
+      var VALUE = 1;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject a sub-string that is in the field string', function () {
+      var FIELD = 'alphabravocharlie';
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject a string that is in the field array regardless of case', function () {
+      var FIELD = ['Alpha', 'bravo', 'charlie'];
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+  });
+  describe('numerical operators', function () {
+    it('less than should reject when value is null', function () {
+      var CONDITION = {
+        op: '<',
+        value: '100'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, null)).toBeFalsy();
+    });
+    it('less than should reject when condition.value is null', function () {
+      var CONDITION = {
+        op: '<',
+        value: null
+      };
+      expect((0, _meetsCondition.default)(CONDITION, '100')).toBeFalsy();
+    });
+    it('less than should reject when condition.value and value are null', function () {
+      var CONDITION = {
+        op: '<',
+        value: null
+      };
+      expect((0, _meetsCondition.default)(CONDITION, null)).toBeFalsy();
+    });
+    it('less than should reject when value is greater than condition.value', function () {
+      var CONDITION = {
+        op: '<',
+        value: '100'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, '101')).toBeFalsy();
+    });
+    it('less than should accept when value is less than condition.value', function () {
+      var CONDITION = {
+        op: '<',
+        value: '100'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, '99')).toBeTruthy();
+    });
+    it('greater than should reject when value is null', function () {
+      var CONDITION = {
+        op: '>',
+        value: '100'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, null)).toBeFalsy();
+    });
+    it('greater than should reject when condition.value is null', function () {
+      var CONDITION = {
+        op: '>',
+        value: null
+      };
+      expect((0, _meetsCondition.default)(CONDITION, '100')).toBeFalsy();
+    });
+    it('greater than should reject when condition.value and value are null', function () {
+      var CONDITION = {
+        op: '>',
+        value: null
+      };
+      expect((0, _meetsCondition.default)(CONDITION, null)).toBeFalsy();
+    });
+    it('greater than should reject when value is less than condition.value', function () {
+      var CONDITION = {
+        op: '>',
+        value: '100'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, '99')).toBeFalsy();
+    });
+    it('greater than should accept when value is greater than condition.value', function () {
+      var CONDITION = {
+        op: '>',
+        value: '100'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, '101')).toBeTruthy();
+    });
+  });
+  describe('operator includes', function () {
+    it('should accept a string that exists within the value', function () {
+      var VALUE = ['red', 'green', 'blue'];
+      var CONDITION = {
+        op: 'includes',
+        value: 'blue'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should accept a number that exists within the value', function () {
+      var VALUE = [4, 5, 6];
+      var CONDITION = {
+        op: 'includes',
+        value: 6
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should reject a string that doesnt exist within the value', function () {
+      var VALUE = ['red', 'green', 'blue'];
+      var CONDITION = {
+        op: 'includes',
+        value: 'purple'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject a number that doesnt exist within the value', function () {
+      var VALUE = [4, 5, 6];
+      var CONDITION = {
+        op: 'includes',
+        value: 7
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject a value that is not an array', function () {
+      var VALUE = 'badValue';
+      var CONDITION = {
+        op: 'includes',
+        value: 7
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject an empty array', function () {
+      var VALUE = [];
+      var CONDITION = {
+        op: 'includes',
+        value: 7
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+  });
+  describe('operator !includes', function () {
+    it('should reject a string that exists within the value', function () {
+      var VALUE = ['red', 'green', 'blue'];
+      var CONDITION = {
+        op: '!includes',
+        value: 'blue'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject a number that exists within the value', function () {
+      var VALUE = [4, 5, 6];
+      var CONDITION = {
+        op: '!includes',
+        value: 6
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should accept a string that doesnt exist within the value', function () {
+      var VALUE = ['red', 'green', 'blue'];
+      var CONDITION = {
+        op: '!includes',
+        value: 'purple'
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should accept a number that doesnt exist within the value', function () {
+      var VALUE = [4, 5, 6];
+      var CONDITION = {
+        op: '!includes',
+        value: 7
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should accept a value that is not an array', function () {
+      var VALUE = 'badValue';
+      var CONDITION = {
+        op: '!includes',
+        value: 7
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should accept an empty array', function () {
+      var VALUE = [];
+      var CONDITION = {
+        op: '!includes',
+        value: 7
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+  });
+  describe('operator includesAllOf', function () {
+    it('should reject when value is not an array', function () {
+      var VALUE = 'Not an array';
+      var CONDITION = {
+        op: 'includesAllOf',
+        values: ['a', 'c']
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject when value is an empty array', function () {
+      var VALUE = [];
+      var CONDITION = {
+        op: 'includesAllOf',
+        values: ['a', 'c']
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should accept when the list of values is an empty array', function () {
+      var VALUE = ['a', 'b', 'c'];
+      var CONDITION = {
+        op: 'includesAllOf',
+        values: []
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should accept a list of values that are all in field', function () {
+      var VALUE = ['a', 'b', 'c'];
+      var CONDITION = {
+        op: 'includesAllOf',
+        values: ['a', 'c']
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should reject a list of values if any are missing from field', function () {
+      var VALUE = ['a', 'b', 'c'];
+      var CONDITION = {
+        op: 'includesAllOf',
+        values: ['a', 'd']
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+  });
+  describe('operator !includesAllOf', function () {
+    it('should accept when value is not an array', function () {
+      var VALUE = 'Not an array';
+      var CONDITION = {
+        op: '!includesAllOf',
+        values: ['a', 'c']
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should accept when value is an empty array', function () {
+      var VALUE = [];
+      var CONDITION = {
+        op: '!includesAllOf',
+        values: ['a', 'c']
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should reject when the list of values is an empty array', function () {
+      var VALUE = ['a', 'b', 'c'];
+      var CONDITION = {
+        op: '!includesAllOf',
+        values: []
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject a list of values that are all in value', function () {
+      var VALUE = ['a', 'b', 'c'];
+      var CONDITION = {
+        op: '!includesAllOf',
+        values: ['a', 'c']
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should accept a list of values if any are missing from value', function () {
+      var VALUE = ['a', 'b', 'c'];
+      var CONDITION = {
+        op: '!includesAllOf',
+        values: ['a', 'd']
+      };
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+  });
+  describe('unknown operator', function () {
+    var op = 'definitely_not_a_real_operator';
+    it('should reject anything regardless of the value', function () {
+      var CONDITION = getCondition(op, 'a');
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+    it('should accept anything even with a null value', function () {
+      var CONDITION = getCondition(op, null);
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+    it('should accept anything even with a undefined value', function () {
+      var CONDITION = getCondition(op, null);
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+  });
+  describe('invalid condition', function () {
+    it('should accept anything when the condition is null', function () {
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(null, value)).toBeTruthy();
+      });
+    });
+    it('should accept anything when the condition is undefined', function () {
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(undefined, value)).toBeTruthy();
+      });
+    });
+    it('should accept anything when the condition is not an object', function () {
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)('condition', value)).toBeTruthy();
+      });
+    });
+  });
+});