updating validation

Author: mavarazy

src/checkField.js

@@ -1,9 +1,7 @@
 import predicate from "predicate";
 import { isObject } from "./utils";
 
-export const OR = "or";
-export const AND = "and";
-export const NOT = "not";
+import { OR, AND, NOT } from './constants';
 
 const POSITIVE_PREDICATE = predicate;
 const NEGATIVE_PREDICATE = predicate.not;

src/conditionsMeet.js

@@ -1,5 +1,6 @@
 import { isObject, toError } from "./utils";
-import checkField, { OR, AND, NOT} from "./checkField";
+import checkField from "./checkField";
+import { OR, AND, NOT } from './constants';
 import selectn from "selectn";
 
 export default function conditionsMeet(conditions, formData) {

src/constants.js

@@ -0,0 +1,3 @@
+export const OR = "or";
+export const AND = "and";
+export const NOT = "not";

src/validation.js

@@ -1,7 +1,6 @@
 import predicate from "predicate";
 import { flatMap, isObject, toError } from "./utils";
-
-import { NOT, AND, OR } from './checkField';
+import { OR, AND, NOT } from './constants';
 
 export function predicatesFromRule(rule) {
   if (isObject(rule)) {
@@ -33,6 +32,8 @@ export function predicatesFromCondition(condition) {
   return flatMap(Object.keys(condition), ref => {
     if (ref === OR || ref === AND) {
       return flatMap(condition[ref], w => predicatesFromRule(w));
+    } else if (ref === NOT) {
+      return predicatesFromCondition(condition[ref]);
     } else {
       return predicatesFromRule(condition[ref]);
     }
@@ -43,15 +44,23 @@ export function listAllPredicates(conditions) {
   let allPredicates = flatMap(conditions, condition =>
     predicatesFromCondition(condition)
   );
-  return new Set(allPredicates);
+  return allPredicates.filter((v, i, a) => allPredicates.indexOf(v) === i);
+}
+
+export function listInvalidPredicates(conditions) {
+  let refPredicates = listAllPredicates(conditions);
+  return refPredicates.filter((p) => predicate[p] === undefined);
 }
 
-export function listInvalidPredicates(rules) {
-  let rulePredicates = listAllPredicates(rules);
-  Object.keys(predicate).forEach(p => rulePredicates.delete(p));
-  return Array.from(rulePredicates);
+export function validatePredicates(conditions) {
+  let invalidPredicates = listInvalidPredicates(conditions);
+  if (invalidPredicates.length !== 0) {
+    toError(`Rule contains invalid predicates ${invalidPredicates}`);
+  }
 }
 
+
+
 export function fieldsFromCondition(condition) {
   return flatMap(Object.keys(condition), ref => {
     if (ref === OR || ref === AND) {
@@ -66,13 +75,12 @@ export function listAllFields(conditions) {
   let allFields = flatMap(conditions, condition =>
     fieldsFromCondition(condition)
   );
-  return new Set(allFields);
+  return allFields.filter((v, i, a) => allFields.indexOf(v) === i);
 }
 
 export function listInvalidFields(conditions, schema) {
   let ruleFields = listAllFields(conditions);
-  Object.keys(schema.properties).forEach(f => ruleFields.delete(f));
-  return Array.from(ruleFields);
+  return ruleFields.filter(field => schema.properties[field] === undefined);
 }
 
 export function validateConditionFields(conditions, schema) {
@@ -82,9 +90,3 @@ export function validateConditionFields(conditions, schema) {
   }
 }
 
-export function validatePredicates(conditions) {
-  let invalidPredicates = listInvalidPredicates(conditions);
-  if (invalidPredicates.length !== 0) {
-    toError(`Rule contains invalid predicates ${invalidPredicates}`);
-  }
-}

test/validation.test.js

@@ -42,10 +42,10 @@ test("Two field rule ", () => {
   ]);
 
   let predicates = listAllPredicates(conditions);
-  expect(predicates).toEqual(new Set(["empty", "greater", "less"]));
+  expect(predicates).toEqual(["empty", "greater", "less"]);
 
   let fields = listAllFields(conditions);
-  expect(fields).toEqual(new Set(["firstName", "age"]));
+  expect(fields).toEqual(["firstName", "age"]);
 });
 
 test("3 field rule ", () => {
@@ -66,19 +66,19 @@ test("3 field rule ", () => {
   ]);
 
   let predicates = listAllPredicates(conditions);
-  expect(predicates).toEqual(new Set(["empty", "greater", "less"]));
+  expect(predicates).toEqual(["empty", "greater", "less"]);
 
   let fields = listAllFields(conditions);
-  expect(fields).toEqual(new Set(["firstName", "age"]));
+  expect(fields).toEqual(["firstName", "age"]);
 });
 
-test("list all predicates", () => {
+test("invalidate predicates", () => {
   let invalidConditions = conditionsFrom([
     {
       event: { type: "remove" },
       conditions: {
         age: {
-          some: {
+          wtf: {
             greater: 5,
             less: 70,
           },
@@ -87,9 +87,10 @@ test("list all predicates", () => {
     },
   ]);
 
-  expect(listAllPredicates(invalidConditions)).toEqual(
-    new Set(["greater", "less", "some"])
-  );
+  expect(listAllPredicates(invalidConditions)).toEqual(["greater", "less", "wtf"]);
+  expect(listInvalidPredicates(invalidConditions)).toEqual(["wtf"]);
+  expect(() => validatePredicates(invalidConditions)).toThrow();
+  expect(() => testInProd(validatePredicates(invalidConditions))).not.toBeUndefined();
 });
 
 let schema = {
@@ -114,7 +115,7 @@ test("invalid field", () => {
     },
   ]);
 
-  expect(listAllFields(invalidFieldConditions)).toEqual(new Set(["lastName", "firstName"]));
+  expect(listAllFields(invalidFieldConditions)).toEqual(["lastName", "firstName"]);
   expect(listInvalidFields(invalidFieldConditions, schema)).toEqual([ "lastName",]);
   expect(() => validateConditionFields(invalidFieldConditions, schema)).toThrow();
 });
@@ -152,6 +153,21 @@ test("invalid field or", () => {
   expect(() => validate(invalidFieldOr, schema)).toThrow();
 });
 
+test("invalid field NOT or", () => {
+  let invalidFieldNotWithOr = conditionsFrom([
+    {
+      conditions: {
+        not: {
+          firstName: "or"
+        }
+      },
+      event: { type: "remove" },
+    },
+  ]);
+
+  expect(() => validate(invalidFieldNotWithOr, schema)).toThrow();
+});
+
 test("valid field or", () => {
   let validFieldOr = conditionsFrom([
     {