@ukhomeoffice/cop-react-form-renderer 5.45.2-alpha → 5.48.1-bravo

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

@@ -4,8 +4,8 @@ var _meetsCondition = _interopRequireDefault(require("./meetsCondition"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // Local imports
 
-describe('utils.Condition.meetsCondition', () => {
-  const getCondition = (operator, val) => {
+describe('utils.Condition.meetsCondition', function () {
+  var getCondition = function getCondition(operator, val) {
     if (['in', 'nin'].includes(operator)) {
       return {
         op: operator,
@@ -17,759 +17,759 @@ describe('utils.Condition.meetsCondition', () => {
       value: val
     };
   };
-  const TEST_VALUES = ['a', 'b', 3, 4, null, undefined, true, false, 0];
-  describe('equality operators', () => {
-    ['eq', '='].forEach(op => {
-      describe("operator ".concat(op), () => {
+  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', () => {
-          const VALUE = null;
-          const CONDITION = getCondition(op, null);
+        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', () => {
-          const VALUE = undefined;
-          const CONDITION = getCondition(op, undefined);
+        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', () => {
-          const VALUE = 'value';
-          const CONDITION = getCondition(op, 'value');
+        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', () => {
-          const VALUE = '';
-          const CONDITION = getCondition(op, '');
+        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', () => {
-          const VALUE = 3;
-          const CONDITION = getCondition(op, 3);
+        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', () => {
-          const VALUE = 0;
-          const CONDITION = getCondition(op, 0);
+        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', () => {
-          const VALUE = true;
-          const CONDITION = getCondition(op, true);
+        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', () => {
-          const VALUE = false;
-          const CONDITION = getCondition(op, false);
+        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', () => {
-          const VALUE = 'Bob';
-          const DATA = {
+        it('should match environmentContext value with data object', function () {
+          var VALUE = 'Bob';
+          var DATA = {
             environmentContext: {
               currentUser: 'Bob'
             }
           };
-          const CONDITION = getCondition(op, 'field::environmentContext.currentUser');
+          var CONDITION = getCondition(op, 'field::environmentContext.currentUser');
           expect((0, _meetsCondition.default)(CONDITION, VALUE, DATA)).toBeTruthy();
         });
 
         // Should reject...
-        it('should reject a null and undefined', () => {
-          const VALUE = null;
-          const CONDITION = getCondition(op, undefined);
+        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', () => {
-          const VALUE = null;
-          const CONDITION = getCondition(op, '');
+        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', () => {
-          const VALUE = undefined;
-          const CONDITION = getCondition(op, '');
+        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', () => {
-          const VALUE = ' ';
-          const CONDITION = getCondition(op, '');
+        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", () => {
-          const VALUE = '3';
-          const CONDITION = getCondition(op, 3);
+        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', () => {
-          const VALUE = true;
-          const CONDITION = getCondition(op, 1);
+        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', () => {
-          const VALUE = false;
-          const CONDITION = getCondition(op, 0);
+        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', () => {
-    ['ne', 'neq', '!=', '<>'].forEach(op => {
-      describe("operator ".concat(op), () => {
+  describe('inequality operators', function () {
+    ['ne', 'neq', '!=', '<>'].forEach(function (op) {
+      describe("operator ".concat(op), function () {
         // Should reject...
-        it('should reject two nulls', () => {
-          const VALUE = null;
-          const CONDITION = getCondition(op, null);
+        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', () => {
-          const VALUE = undefined;
-          const CONDITION = getCondition(op, undefined);
+        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', () => {
-          const VALUE = 'value';
-          const CONDITION = getCondition(op, 'value');
+        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', () => {
-          const VALUE = '';
-          const CONDITION = getCondition(op, '');
+        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', () => {
-          const VALUE = 3;
-          const CONDITION = getCondition(op, 3);
+        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', () => {
-          const VALUE = 0;
-          const CONDITION = getCondition(op, 0);
+        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', () => {
-          const VALUE = true;
-          const CONDITION = getCondition(op, true);
+        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', () => {
-          const VALUE = false;
-          const CONDITION = getCondition(op, false);
+        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', () => {
-          const VALUE = 'Bob';
-          const DATA = {
+        it('should reject environmentContext value with data object', function () {
+          var VALUE = 'Bob';
+          var DATA = {
             environmentContext: {
               currentUser: 'Bob'
             }
           };
-          const CONDITION = getCondition(op, 'field::environmentContext.currentUser');
+          var CONDITION = getCondition(op, 'field::environmentContext.currentUser');
           expect((0, _meetsCondition.default)(CONDITION, VALUE, DATA)).toBeFalsy();
         });
 
         // Should match...
-        it('should match a null and undefined', () => {
-          const VALUE = null;
-          const CONDITION = getCondition(op, undefined);
+        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', () => {
-          const VALUE = null;
-          const CONDITION = getCondition(op, '');
+        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', () => {
-          const VALUE = undefined;
-          const CONDITION = getCondition(op, '');
+        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', () => {
-          const VALUE = ' ';
-          const CONDITION = getCondition(op, '');
+        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", () => {
-          const VALUE = '3';
-          const CONDITION = getCondition(op, 3);
+        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', () => {
-          const VALUE = true;
-          const CONDITION = getCondition(op, 1);
+        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', () => {
-          const VALUE = false;
-          const CONDITION = getCondition(op, 0);
+        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', () => {
-    const op = 'in';
+  describe('operator in', function () {
+    var op = 'in';
 
     // Should match...
-    it('should match a string that is in the values array', () => {
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+    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', () => {
-      const VALUE = 4;
-      const CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie', 4]);
+    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', () => {
-      const VALUE = 'delta';
-      const CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+    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', () => {
-      const VALUE = 4;
-      const CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+    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', () => {
-      const CONDITION = getCondition(op, []);
-      ['a', 'b', 'c', 'd', 'e', 6, 7, 8, 9, 'ten'].forEach(value => {
+    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', () => {
-      const CONDITION = getCondition(op, null);
-      ['a', 'b', 'c', 'd', 'e', 6, 7, 8, 9, 'ten'].forEach(value => {
+    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', () => {
-    const op = 'nin';
+  describe('operator nin', function () {
+    var op = 'nin';
 
     // Should reject...
-    it('should reject a string that is in the values array', () => {
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+    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', () => {
-      const VALUE = 4;
-      const CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie', 4]);
+    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', () => {
-      const VALUE = 'delta';
-      const CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+    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', () => {
-      const VALUE = 4;
-      const CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+    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', () => {
-      const CONDITION = getCondition(op, []);
-      TEST_VALUES.forEach(value => {
+    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', () => {
-      const CONDITION = getCondition(op, null);
-      TEST_VALUES.forEach(value => {
+    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', () => {
-    const op = 'contains';
+  describe('operator contains', function () {
+    var op = 'contains';
 
     // Should match...
-    it('should match a string that is in the field array', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = 'alp';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = [1, 2, 3];
-      const VALUE = 1;
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = 'alphabravocharlie';
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['Alpha', 'bravo', 'charlie'];
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = 'delta';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = [1, 2, 3];
-      const VALUE = 4;
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = 'alphabravocharlie';
-      const VALUE = 'delta';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = [];
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = '';
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = null;
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = undefined;
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = null;
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = undefined;
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-    const op = '!contains';
+  describe('operator !contains', function () {
+    var op = '!contains';
 
     // Should match...
-    it('should match a string that is not in the field array', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = 'delta';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = [];
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = null;
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = undefined;
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = '';
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = [1, 2, 3];
-      const VALUE = 4;
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = 'alphabravocharlie';
-      const VALUE = 'delta';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = null;
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = undefined;
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['alpha', 'bravo', 'charlie'];
-      const VALUE = 'alp';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = [1, 2, 3];
-      const VALUE = 1;
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = 'alphabravocharlie';
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-      const FIELD = ['Alpha', 'bravo', 'charlie'];
-      const VALUE = 'alpha';
-      const CONDITION = getCondition(op, VALUE);
+    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', () => {
-    it('less than should reject when value is null', () => {
-      const CONDITION = {
+  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', () => {
-      const CONDITION = {
+    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', () => {
-      const CONDITION = {
+    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', () => {
-      const CONDITION = {
+    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', () => {
-      const CONDITION = {
+    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('less than should handle values with commas in', () => {
-      const CONDITION = {
+    it('less than should handle values with commas in', function () {
+      var CONDITION = {
         op: '<',
         value: '10,000'
       };
       expect((0, _meetsCondition.default)(CONDITION, '9,999')).toBeTruthy();
     });
-    it('greater than should reject when value is null', () => {
-      const CONDITION = {
+    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', () => {
-      const CONDITION = {
+    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', () => {
-      const CONDITION = {
+    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', () => {
-      const CONDITION = {
+    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', () => {
-      const CONDITION = {
+    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();
     });
-    it('greater than should handle values with commas in', () => {
-      const CONDITION = {
+    it('greater than should handle values with commas in', function () {
+      var CONDITION = {
         op: '>',
         value: '10,000'
       };
       expect((0, _meetsCondition.default)(CONDITION, '10,000,000')).toBeTruthy();
     });
   });
-  describe('operator includes', () => {
-    it('should accept a string that exists within the value', () => {
-      const VALUE = ['red', 'green', 'blue'];
-      const CONDITION = {
+  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', () => {
-      const VALUE = [4, 5, 6];
-      const CONDITION = {
+    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', () => {
-      const VALUE = ['red', 'green', 'blue'];
-      const CONDITION = {
+    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', () => {
-      const VALUE = [4, 5, 6];
-      const CONDITION = {
+    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', () => {
-      const VALUE = 'badValue';
-      const CONDITION = {
+    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', () => {
-      const VALUE = [];
-      const CONDITION = {
+    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', () => {
-    it('should reject a string that exists within the value', () => {
-      const VALUE = ['red', 'green', 'blue'];
-      const CONDITION = {
+  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', () => {
-      const VALUE = [4, 5, 6];
-      const CONDITION = {
+    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', () => {
-      const VALUE = ['red', 'green', 'blue'];
-      const CONDITION = {
+    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', () => {
-      const VALUE = [4, 5, 6];
-      const CONDITION = {
+    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', () => {
-      const VALUE = 'badValue';
-      const CONDITION = {
+    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', () => {
-      const VALUE = [];
-      const CONDITION = {
+    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', () => {
-    it('should reject when value is not an array', () => {
-      const VALUE = 'Not an array';
-      const CONDITION = {
+  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', () => {
-      const VALUE = [];
-      const CONDITION = {
+    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', () => {
-      const VALUE = ['a', 'b', 'c'];
-      const CONDITION = {
+    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', () => {
-      const VALUE = ['a', 'b', 'c'];
-      const CONDITION = {
+    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', () => {
-      const VALUE = ['a', 'b', 'c'];
-      const CONDITION = {
+    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', () => {
-    it('should accept when value is not an array', () => {
-      const VALUE = 'Not an array';
-      const CONDITION = {
+  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', () => {
-      const VALUE = [];
-      const CONDITION = {
+    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', () => {
-      const VALUE = ['a', 'b', 'c'];
-      const CONDITION = {
+    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', () => {
-      const VALUE = ['a', 'b', 'c'];
-      const CONDITION = {
+    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', () => {
-      const VALUE = ['a', 'b', 'c'];
-      const CONDITION = {
+    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', () => {
-    const op = 'definitely_not_a_real_operator';
-    it('should reject anything regardless of the value', () => {
-      const CONDITION = getCondition(op, 'a');
-      TEST_VALUES.forEach(value => {
+  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', () => {
-      const CONDITION = getCondition(op, null);
-      TEST_VALUES.forEach(value => {
+    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', () => {
-      const CONDITION = getCondition(op, null);
-      TEST_VALUES.forEach(value => {
+    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', () => {
-    it('should accept anything when the condition is null', () => {
-      TEST_VALUES.forEach(value => {
+  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', () => {
-      TEST_VALUES.forEach(value => {
+    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', () => {
-      TEST_VALUES.forEach(value => {
+    it('should accept anything when the condition is not an object', function () {
+      TEST_VALUES.forEach(function (value) {
         expect((0, _meetsCondition.default)('condition', value)).toBeTruthy();
       });
     });