Fixing validation

Author: mavarazy

src/validation.js

@@ -32,23 +32,22 @@ export function predicatesFromRule(rule, schema) {
 
 export function predicatesFromCondition(condition, schema) {
   return flatMap(Object.keys(condition), ref => {
+    let refVal = condition[ref];
     if (ref === OR || ref === AND) {
-      if (Array.isArray(condition[ref])) {
-        return flatMap(condition[ref], w => predicatesFromRule(w, schema));
+      if (Array.isArray(refVal)) {
+        return flatMap(refVal, c => predicatesFromCondition(c, schema));
       } else {
-        toError(
-          `${ref} with ${JSON.stringify(condition[ref])} must be an Array`
-        );
+        toError(`${ref} with ${JSON.stringify(refVal)} must be an Array`);
         return [];
       }
     } else if (ref === NOT) {
-      return predicatesFromCondition(condition[ref], schema);
+      return predicatesFromCondition(refVal, schema);
     } else {
       // TODO disable validation of nested structures
       let isField = schema.properties[ref] !== undefined;
       let isArray = isField && schema.properties[ref].type === "array";
       if (isField && !isArray) {
-        return predicatesFromRule(condition[ref], schema);
+        return predicatesFromRule(refVal, schema);
       } else {
         return [];
       }

test/documentationExamples.test.js

@@ -185,32 +185,80 @@ test("OR", () => {
   ]);
 });
 
-/**
-### Boolean operations on multi fields
+test("multi field default AND", () => {
+  let rules = [
+    {
+      conditions: {
+        age: { less: 70 },
+        country: { is: "USA" },
+      },
+      event: EVENT,
+    },
+  ];
 
-To support cases, when action depends on more, than one field meeting criteria we introduced
-multi fields boolean operations.
+  let engine = new Engine(rules, schema);
+  expect.assertions(5);
 
-#### Default AND operation
+  return Promise.all([
+    engine
+      .run({ age: 16, country: "China" })
+      .then(res => expect(res).toEqual([])),
+    engine
+      .run({ age: 16, country: "Mexico" })
+      .then(res => expect(res).toEqual([])),
+    engine
+      .run({ age: 16, country: "USA" })
+      .then(res => expect(res).toEqual([EVENT])),
+    engine
+      .run({ age: 69, country: "USA" })
+      .then(res => expect(res).toEqual([EVENT])),
+    engine
+      .run({ age: 70, country: "USA" })
+      .then(res => expect(res).toEqual([])),
+  ]);
+});
 
-Let's say, when `age` is less than 70 and `country` is `USA` we want to `require` `bio`.
+test("multi field OR", () => {
+  let rules = [
+    {
+      conditions: {
+        or: [
+          {
+            age: { less: 70 },
+            country: { is: "USA" },
+          },
+          {
+            state: { is: "NY" },
+          },
+        ],
+      },
+      event: EVENT,
+    },
+  ];
 
-```js
-let rules = [{
-  conditions: {
-    age: { less : 70 },
-    country: { is: "USA" }
-  },
-  event: {
-    type: "require",
-    params: { fields: [ "bio" ]}
-  }
-}]
-  ```
+  let engine = new Engine(rules, schema);
+  expect.assertions(5);
 
-This is the way we can express this. By default each field is treated as a 
-separate condition and all conditions must be meet.
+  return Promise.all([
+    engine
+      .run({ age: 16, country: "China", state: "Beijing" })
+      .then(res => expect(res).toEqual([])),
+    engine
+      .run({ age: 16, country: "China", state: "NY" })
+      .then(res => expect(res).toEqual([EVENT])),
+    engine
+      .run({ age: 16, country: "USA" })
+      .then(res => expect(res).toEqual([EVENT])),
+    engine
+      .run({ age: 80, state: "NY" })
+      .then(res => expect(res).toEqual([EVENT])),
+    engine
+      .run({ age: 69, country: "USA" })
+      .then(res => expect(res).toEqual([EVENT])),
+  ]);
+});
 
+/**
 #### OR
 
 In addition to previous rule we need `bio`, if `state` is `NY`.

test/validation.test.js

@@ -209,13 +209,35 @@ test("valid field or", () => {
   expect(validateConditionFields(validFieldOr, defSchema)).toBeUndefined();
 });
 
-test("extract predicates from when with or & and", () => {
-  expect(predicatesFromCondition({ or: [{ is: 1 }, { less: 10 }] })).toEqual([
+test("extract predicates from rule when with or & and", () => {
+  expect(predicatesFromRule({ or: [{ is: 1 }, { less: 10 }] })).toEqual([
     "is",
     "less",
   ]);
-  expect(predicatesFromCondition({ and: [{ is: 1 }, { less: 10 }] })).toEqual([
+  expect(predicatesFromRule({ and: [{ is: 1 }, { less: 10 }] })).toEqual([
     "is",
     "less",
   ]);
 });
+
+test("extract predicates from condition when with or & and", () => {
+  let schema = {
+    properties: {
+      age: { type: "integer" },
+      grade: { type: "integer" },
+    },
+  };
+
+  expect(
+    predicatesFromCondition(
+      { or: [{ age: { is: 1 } }, { grade: { less: 10 } }] },
+      schema
+    )
+  ).toEqual(["is", "less"]);
+  expect(
+    predicatesFromCondition(
+      { and: [{ age: { is: 1 } }, { grade: { less: 10 } }] },
+      schema
+    )
+  ).toEqual(["is", "less"]);
+});