fix #6

Author: mavarazy

src/applicableActions.js

@@ -1,10 +1,10 @@
-import { flatMap } from "./utils";
+import { flatMap, toArray } from "./utils";
 import conditionsMeet from "./conditionsMeet";
 
 export default function applicableActions(rules, formData) {
   return flatMap(rules, ({ conditions, event }) => {
     if (conditionsMeet(conditions, formData)) {
-      return [event];
+      return toArray(event);
     } else {
       return [];
     }

src/utils.js

@@ -6,6 +6,14 @@ export function isDevelopment() {
   return process.env.NODE_ENV !== "production";
 }
 
+export function toArray(event) {
+  if (Array.isArray(event)) {
+    return event;
+  } else {
+    return [event];
+  }
+}
+
 export function toError(message) {
   if (isDevelopment()) {
     throw new ReferenceError(message);
@@ -34,6 +42,7 @@ function fetchSchema(ref, schema) {
     toError(
       "Only local references supported at this point use json-schema-deref"
     );
+    return undefined;
   }
 }
 
@@ -43,6 +52,7 @@ export function extractRefSchema(field, schema) {
   } else if (schema.properties[field] && schema.properties[field]["$ref"]) {
     return fetchSchema(schema.properties[field]["$ref"], schema);
   } else {
+    toError(`${field} has no $ref field ref schema extraction is impossible`);
     return undefined;
   }
 }

test/applicableActions.eventArray.test.js

@@ -0,0 +1,18 @@
+import applicableActions from "../src/applicableActions";
+
+let rules = [
+  {
+    conditions: {
+      address: "empty",
+    },
+    event: [{ type: "remove" }, { type: "add" }],
+  },
+];
+
+test("check nested fields work", function() {
+  expect(applicableActions(rules, {})).toEqual([
+    { type: "remove" },
+    { type: "add" },
+  ]);
+  expect(applicableActions(rules, { address: { line: "some" } })).toEqual([]);
+});

test/utils.test.js

@@ -5,6 +5,7 @@ import {
   toError,
   extractRefSchema,
   isRefArray,
+  toArray,
 } from "../src/utils";
 import { testInProd } from "./utils";
 
@@ -57,6 +58,9 @@ test("extract referenced schema", () => {
       primaryMedication: {
         $ref: "#/definitions/medication",
       },
+      externalConfig: {
+        $ref: "http://example.com/oneschema.json",
+      },
     },
   };
 
@@ -67,4 +71,19 @@ test("extract referenced schema", () => {
   expect(extractRefSchema("primaryMedication", schema)).toEqual(
     schema.definitions.medication
   );
+
+  expect(() => extractRefSchema("externalConfig", schema)).toThrow();
+  expect(testInProd(() => extractRefSchema("externalConfig", schema))).toEqual(
+    undefined
+  );
+
+  expect(() => extractRefSchema("lastName", schema)).toThrow();
+  expect(testInProd(() => extractRefSchema("lastName", schema))).toEqual(
+    undefined
+  );
+});
+
+test("array transformation", () => {
+  expect(toArray("Yes")).toEqual(["Yes"]);
+  expect(toArray(["Yes", "No"])).toEqual(["Yes", "No"]);
 });

test/validation.ref.test.js

@@ -0,0 +1,63 @@
+import { predicatesFromCondition } from "../src/validation";
+import { testInProd } from "./utils";
+
+let schema = {
+  definitions: {
+    medication: {
+      type: "object",
+      properties: {
+        type: { type: "string" },
+        isLiquid: { type: "boolean" },
+      },
+    },
+  },
+  type: "object",
+  required: ["medications", "firstName", "lastName"],
+  properties: {
+    firstName: {
+      type: "string",
+    },
+    lastName: {
+      type: "string",
+    },
+    medications: {
+      type: "array",
+      items: { $ref: "#/definitions/medication" },
+    },
+    primaryMedication: {
+      $ref: "#/definitions/medication",
+    },
+    externalConfig: {
+      $ref: "http://example.com/oneschema.json",
+    },
+  },
+};
+
+test("condition with external ref", () => {
+  expect(() =>
+    predicatesFromCondition({ "externalConfig.name": "empty" }, schema)
+  ).toThrow();
+  expect(
+    testInProd(() =>
+      predicatesFromCondition({ "externalConfig.name": "empty" }, schema)
+    )
+  ).toEqual([]);
+});
+
+test("condition with fake ref field", () => {
+  expect(() =>
+    predicatesFromCondition({ "fakeRef.name": "empty" }, schema)
+  ).toThrow();
+  expect(
+    testInProd(() =>
+      predicatesFromCondition({ "fakeRef.name": "empty" }, schema)
+    )
+  ).toEqual([]);
+});
+
+test("condition with fake field", () => {
+  expect(() => predicatesFromCondition({ fakeRef: "empty" }, schema)).toThrow();
+  expect(
+    testInProd(() => predicatesFromCondition({ fakeRef: "empty" }, schema))
+  ).toEqual([]);
+});

test/validation.test.js

@@ -122,16 +122,19 @@ test("invalid field", () => {
     {
       conditions: {
         or: [{ lastName: "empty" }, { firstName: "empty" }],
+        and: [{ otherName: "empty" }],
       },
     },
   ]);
 
   expect(listAllFields(invalidFieldConditions)).toEqual([
     "lastName",
     "firstName",
+    "otherName",
   ]);
   expect(listInvalidFields(invalidFieldConditions, defSchema)).toEqual([
     "lastName",
+    "otherName",
   ]);
   expect(() =>
     validateConditionFields(invalidFieldConditions, defSchema)
@@ -257,3 +260,19 @@ test("extract predicates from condition when with or & and", () => {
     )
   ).toEqual(["is", "less"]);
 });
+
+test("invalid or in rule", () => {
+  expect(() => predicatesFromRule({ or: { is: 1 } })).toThrow();
+  expect(() => predicatesFromRule({ and: { is: 1 } })).toThrow();
+
+  expect(testInProd(() => predicatesFromRule({ or: { is: 1 } }))).toEqual([]);
+  expect(testInProd(() => predicatesFromRule({ and: { is: 1 } }))).toEqual([]);
+});
+
+test("invalid or in condition", () => {
+  expect(() => predicatesFromCondition({ or: {} })).toThrow();
+  expect(() => predicatesFromCondition({ and: {} })).toThrow();
+
+  expect(testInProd(() => predicatesFromCondition({ or: {} }))).toEqual([]);
+  expect(testInProd(() => predicatesFromCondition({ and: {} }))).toEqual([]);
+});