feat(data-point): add tests and new verification of arguments

add checks for locals, tracer and cache arguments

closes ViacomInc#395

Author: acatl

packages/data-point/src/DataPoint.js

@@ -0,0 +1,125 @@
+const { createReducer } = require("./create-reducer");
+const { Accumulator } = require("./Accumulator");
+const { resolve } = require("./resolve");
+const { Cache } = require("./Cache");
+const isPlainObject = require("./is-plain-object");
+
+/**
+ * Applies a reducer from an accumulator object.
+ *
+ * @param {Accumulator} acc accumulator object to be used.
+ * @param {Reducer} reducer
+ * @returns {Promise<any>} resolved value
+ */
+async function resolveFromAccumulator(acc, reducer) {
+  const parsedReducers = createReducer(reducer);
+  return resolve(acc, parsedReducers);
+}
+
+/**
+ * Applies a reducer to the provided input value.
+ *
+ * @param {any} input value to process.
+ * @param {Reducer} reducer valid reducer to process the value.
+ * @param {Object} options
+ * @param {Cache|undefined} options.cache cache manager, see Cache for options.
+ * @param {Object|undefined} options.locals persistent object that is
+ * accessible via the Accumulator object on every reducer.
+ * @param {OpenTrace.Span|undefined} options.tracer when provided it should
+ * comply with the **opentracing** Span API.
+ * @returns {Promise<any>} resolved value
+ */
+async function resolveFromInput(input, reducer, options = {}) {
+  const acc = new Accumulator({
+    value: input,
+    locals: options.locals,
+    resolve: resolveFromAccumulator,
+    cache: options.cache,
+    tracer: options.tracer
+  });
+
+  return resolveFromAccumulator(acc, reducer);
+}
+
+/**
+ * @param {Object} locals
+ * @throws Error if the value is not a simple object. To kow which values are
+ * considered as simple objects please read the unit test for `isPlainObject`.
+ */
+function validateLocals(locals) {
+  if (locals === undefined || isPlainObject(locals)) {
+    return;
+  }
+
+  throw new Error("'options.locals' must be undefined or an object");
+}
+
+/**
+ * @param {OpenTrace.Span} tracer when provided it should
+ * comply with the **opentracing** Span API.
+ * @throws Error if the object does not expose the methods `startSpan`,
+ * `setTag`, `log`.
+ */
+function validateTracer(tracer) {
+  if (tracer) {
+    if (typeof tracer.startSpan !== "function") {
+      throw new Error(
+        "tracer.startSpan must be a function, tracer expects opentracing API (see https://opentracing.io)"
+      );
+    }
+
+    if (typeof tracer.setTag !== "function") {
+      throw new Error(
+        "tracer.setTag must be a function, tracer expects opentracing API (see https://opentracing.io)"
+      );
+    }
+
+    if (typeof tracer.log !== "function") {
+      throw new Error(
+        "tracer.log must be a function, tracer expects opentracing API (see https://opentracing.io)"
+      );
+    }
+  }
+}
+
+class DataPoint {
+  constructor() {
+    Object.defineProperty(this, "cache", {
+      enumerable: false,
+      value: new Cache()
+    });
+  }
+
+  static create() {
+    return new DataPoint();
+  }
+
+  /**
+   * @param {any} input value to run the provided reducer thru.
+   * @param {Reducer} reducer reducer to process the input.
+   * @param {Object} options
+   * @param {Object|undefined} options.locals persistent object that is
+   * accessible via the Accumulator object on every reducer.
+   * @param {OpenTrace.Span|undefined} options.tracer when provided it should
+   * comply with the **opentracing** Span API.
+   * @returns {Promise<any>} result from running the input thru the
+   * provided reducer.
+   */
+  async resolve(input, reducer, options = {}) {
+    validateLocals(options.locals);
+    validateTracer(options.tracer);
+
+    return resolveFromInput(input, reducer, {
+      ...options,
+      cache: this.cache
+    });
+  }
+}
+
+module.exports = {
+  resolveFromAccumulator,
+  resolveFromInput,
+  DataPoint,
+  validateLocals,
+  validateTracer
+};

packages/data-point/src/DataPoint.test.js

@@ -0,0 +1,198 @@
+const dataPoint = require("./DataPoint");
+const { Accumulator } = require("./Accumulator");
+const { Cache } = require("./Cache");
+
+const sayHello = value => `Hello ${value}`;
+const getAccumulator = (input, acc) => acc;
+
+const shallowTracer = {
+  startSpan: () => Object.create(shallowTracer),
+  setTag: () => true,
+  log: () => true
+};
+
+describe("resolveFromAccumulator", () => {
+  it("should run reducers using accumulator as input", async () => {
+    const acc = new Accumulator({ value: "world" });
+    const result = await dataPoint.resolveFromAccumulator(acc, sayHello);
+    expect(result).toEqual("Hello world");
+  });
+});
+
+describe("resolveFromInput", () => {
+  it("should run reducers against input", async () => {
+    const result = await dataPoint.resolveFromInput("world", sayHello);
+    expect(result).toEqual("Hello world");
+  });
+
+  describe("passing options object to accumulator", () => {
+    const options = {
+      locals: {
+        key: "value"
+      },
+      cache: {
+        get: () => true,
+        set: () => true
+      },
+      tracer: "tracer"
+    };
+    it("should pass locals object", async () => {
+      const result = await dataPoint.resolveFromInput(
+        "input",
+        getAccumulator,
+        options
+      );
+      expect(result).toHaveProperty("locals", options.locals);
+    });
+
+    it("should pass cache object", async () => {
+      const result = await dataPoint.resolveFromInput(
+        "input",
+        getAccumulator,
+        options
+      );
+      expect(result).toHaveProperty("cache", options.cache);
+    });
+
+    it("should pass tracer object", async () => {
+      const result = await dataPoint.resolveFromInput(
+        "input",
+        getAccumulator,
+        options
+      );
+      expect(result).toHaveProperty("tracer", options.tracer);
+    });
+
+    it("should pass resolveFromAccumulator method", async () => {
+      const nestedResolver = (input, acc) => `nested ${acc.value}`;
+
+      const resolveNestedReducer = (input, acc) => {
+        return acc.resolve(nestedResolver);
+      };
+
+      const result = await dataPoint.resolveFromInput(
+        "input",
+        resolveNestedReducer,
+        options
+      );
+      expect(result).toEqual("nested input");
+    });
+  });
+});
+
+describe("validateLocals", () => {
+  it("should only allow undefined or plain object", () => {
+    expect(() => {
+      dataPoint.validateLocals();
+    }).not.toThrow();
+
+    expect(() => {
+      dataPoint.validateLocals({});
+    }).not.toThrow();
+  });
+
+  it("should throw error on any un-valid value", () => {
+    expect(() => {
+      dataPoint.validateLocals(null);
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"'options.locals' must be undefined or an object"`
+    );
+
+    expect(() => {
+      dataPoint.validateLocals("string");
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"'options.locals' must be undefined or an object"`
+    );
+
+    expect(() => {
+      dataPoint.validateLocals([]);
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"'options.locals' must be undefined or an object"`
+    );
+  });
+});
+
+describe("validateTracer", () => {
+  it("should only allow undefined or well defined tracer span API", () => {
+    expect(() => {
+      dataPoint.validateTracer();
+    }).not.toThrow();
+
+    expect(() => {
+      dataPoint.validateTracer(shallowTracer);
+    }).not.toThrow();
+  });
+
+  it("should throw error on any un-valid value", () => {
+    expect(() => {
+      dataPoint.validateTracer({});
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"tracer.startSpan must be a function, tracer expects opentracing API (see https://opentracing.io)"`
+    );
+
+    expect(() => {
+      dataPoint.validateTracer({
+        startSpan: () => true
+      });
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"tracer.setTag must be a function, tracer expects opentracing API (see https://opentracing.io)"`
+    );
+
+    expect(() => {
+      dataPoint.validateTracer({
+        startSpan: () => true,
+        setTag: () => true
+      });
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"tracer.log must be a function, tracer expects opentracing API (see https://opentracing.io)"`
+    );
+  });
+});
+
+describe("DataPoint", () => {
+  const DataPoint = dataPoint.DataPoint;
+
+  describe("constructor", () => {
+    it("should initialize cache", () => {
+      const dp = new DataPoint();
+      expect(dp.cache).toBeInstanceOf(Cache);
+    });
+  });
+
+  describe("create", () => {
+    it("should create instance of itself", () => {
+      const dp = DataPoint.create();
+      expect(dp).toBeInstanceOf(DataPoint);
+    });
+  });
+
+  describe("resolve", () => {
+    it("should resolve input", async () => {
+      const dp = new DataPoint();
+      const result = await dp.resolve("world", sayHello);
+      expect(result).toEqual("Hello world");
+    });
+
+    it("should pass cache object", async () => {
+      const dp = new DataPoint();
+      dp.cache.get = () => true;
+      dp.cache.set = () => true;
+
+      const result = await dp.resolve("input", getAccumulator);
+      expect(result).toHaveProperty("cache", dp.cache);
+    });
+
+    it("should pass options object", async () => {
+      const dp = new DataPoint();
+      const options = {
+        locals: {
+          key: "value"
+        },
+        tracer: shallowTracer
+      };
+      const result = await dp.resolve("input", getAccumulator, options);
+      expect(result).toHaveProperty("locals", options.locals);
+      expect(result).toHaveProperty("tracer");
+    });
+  });
+});

packages/data-point/src/data-point.js

@@ -1,3 +1,3 @@
-const { DataPoint } = require("./data-point");
+const { DataPoint } = require("./DataPoint");
 
 module.exports = DataPoint.create;