Added tests for serialiser module

Author: marziply

src/node.js

@@ -30,6 +30,8 @@ export default class Node {
     return this
   }
 
+  self = () => this
+
   children = []
 
   options = {

src/serialiser.js

@@ -23,18 +23,18 @@ export default class Serialiser {
    * @returns {void}
    */
   yank (root, data, parent) {
-    const node = root.filter(data)
-    const value = this.get(data, node.key.path, node.options)
-    const set = this.set.bind(this, node, parent)
+    const { children, options, key } = root.filter(data)
+    const value = this.get(data, key.path, options)
+    const set = child => this.set(parent, key, child)
 
-    if (node.children.length) {
-      if (value || node.options.nullable) {
-        const children = this.dig(node, value)
+    if (children.length) {
+      if (value || options.nullable) {
+        const items = this.dig(value, children)
 
-        if (node.options.extract) {
-          assign(parent, children)
+        if (options.extract) {
+          assign(parent, items)
         } else {
-          set(children)
+          set(items)
         }
       }
     } else {
@@ -46,19 +46,19 @@ export default class Serialiser {
    * Digs into the next level of hierarchy and yanks all properties from the
    * data source via the AST schema node at that level.
    *
-   * @param {Node} node - Current level node.
-   * @param {object} data - Data to extract properties from.
+   * @param {object} value - Data to extract properties from.
+   * @param {Array.<Node>} children - Child nodes.
    *
    * @returns {object} - Yanked properties.
    */
-  dig (node, data) {
+  dig (value, children) {
+    const nullable = children.every(n => !n.options.nullable)
     const result = {}
-    const nullable = node.children.every(n => !n.options.nullable)
 
-    if (!data && nullable) return null
+    if (!value && nullable) return null
 
-    for (const child of node.children) {
-      this.yank(child, data, result)
+    for (const child of children) {
+      this.yank(child, value, result)
     }
 
     return result
@@ -81,14 +81,14 @@ export default class Serialiser {
   /**
    * Similar to Lodash.get, this retrieves properties at the given path.
    *
-   * @param {object} data - Data to obtain the value from.
+   * @param {object} item - Data to obtain the value from.
    * @param {Array.<string>} path - Segments of a path to the value.
-   * @param {object} options - Configuration for retrieving the value.
+   * @param {object} [options] - Configuration for retrieving the value.
    *
    * @returns {any | null} - Value at the given path, if it exists.
    */
-  get (data, path, options) {
-    const value = path.reduce((acc, curr) => acc?.[curr], data)
+  get (item, path, options = {}) {
+    const value = path.reduce((acc, curr) => acc?.[curr], item)
     const result = options.exec
       ? options.exec(value)
       : value
@@ -101,14 +101,14 @@ export default class Serialiser {
   /**
    * Sets a vaLue on the given parent value.
    *
-   * @param {Node} node - Current level node.
    * @param {Node} parent - Parent node value.
+   * @param {Key} key - Key instance on the current Node.
    * @param {any} value - Value to set onto the parent node.
    *
    * @returns {void}
    */
-  set (node, parent, value) {
-    parent[node.key.name] = value
+  set (parent, key, value) {
+    parent[key.name] = value
   }
 
   result = {}

tests/serialiser.spec.js

@@ -6,6 +6,7 @@ const data = () => ({
   ...original
 })
 const node = () => ({
+  filter: jest.fn(),
   children: [],
   filters: [],
   options: {},
@@ -35,54 +36,214 @@ describe('src/serialiser', () => {
     })
   })
 
-  describe.skip('yank', () => {
-    it('should apply filters by running filter method', () => {
+  describe('yank', () => {
+    const setup = ({ options = {}, children = [] } = {}) => {
       const serialiser = new Serialiser(data(), ast())
-      const value = data()
-      const parent = 'test-parent'
-      const curr = {
-        ...node()
+      const value = 'test-value'
+      const set = 'test-set'
+      const child = {
+        value: true
+      }
+      const root = {
+        options,
+        children,
+        filter () {
+          return this
+        },
+        key: {
+          path: []
+        }
       }
 
-      serialiser.filter = jest
+      serialiser.get = jest
+        .fn()
+        .mockReturnValue(value)
+      serialiser.set = jest
         .fn()
-        .mockReturnValue(curr)
+        .mockReturnValue(set)
+      serialiser.dig = jest
+        .fn()
+        .mockReturnValue(child)
 
-      serialiser.yank(curr, value, parent)
+      return {
+        serialiser,
+        value,
+        child,
+        root
+      }
+    }
+
+    it('should assign to parent if extract is truthy', () => {
+      const { serialiser, root } = setup({
+        options: {
+          extract: true
+        },
+        children: [
+          'test-child'
+        ]
+      })
+      const parent = {}
+
+      serialiser.yank(root, data, parent)
 
-      expect(serialiser.filter).toBeCalledWith({
-        data: value,
-        node: curr,
-        parent: {}
+      expect(parent.value).toEqual(true)
+      expect(serialiser.set).not.toBeCalled()
+    })
+
+    it('should set all children to the parent', () => {
+      const { serialiser, root, child } = setup({
+        children: [
+          'test-child'
+        ]
       })
+      const parent = {}
+
+      serialiser.yank(root, data, parent)
+
+      const { length } = Object.keys(parent)
+
+      expect(serialiser.set).toBeCalledWith(parent, root.key, child)
+      expect(length).toEqual(0)
     })
 
-    it('should descend through all children', () => {
-      const serialiser = new Serialiser(data(), ast())
+    it('should set value on the parent', () => {
+      const { serialiser, root, value } = setup()
+      const parent = {}
 
-      serialiser.filter = jest.fn()
+      serialiser.yank(root, data, parent)
 
-      serialiser.yank()
+      expect(serialiser.set).toBeCalledWith(parent, root.key, value)
     })
   })
 
   describe('dig', () => {
+    it('should return null if data is falsey and is nullable', () => {
+      const serialiser = new Serialiser(data(), ast())
+      const result = serialiser.dig(undefined, [])
 
-  })
+      expect(result).toBeNull()
+    })
+
+    it('should return result', () => {
+      const serialiser = new Serialiser(data(), ast())
+      const value = 'test-value'
 
-  describe('filter', () => {
+      serialiser.yank = jest.fn()
+
+      const result = serialiser.dig(value, [])
+
+      expect(result).toEqual({})
+    })
 
+    it('should call yank for each child', () => {
+      const serialiser = new Serialiser(data(), ast())
+      const value = 'test-value'
+      const children = [
+        {
+          options: {}
+        },
+        {
+          options: {}
+        }
+      ]
+
+      serialiser.yank = jest.fn()
+      serialiser.dig(value, children)
+
+      expect(serialiser.yank).toBeCalledTimes(children.length)
+      expect(serialiser.yank).toBeCalledWith(children[0], value, {})
+    })
   })
 
   describe('serialise', () => {
+    it('should call yank for each item in the AST', () => {
+      const value = 'test-value'
+      const ast = [
+        'test-1',
+        'test-2'
+      ]
+      const data = {
+        value
+      }
+      const serialiser = new Serialiser(data, ast)
+
+      serialiser.yank = jest.fn()
+      serialiser.serialise()
 
+      expect(serialiser.yank).toBeCalledTimes(ast.length)
+    })
+
+    it('should return result', () => {
+      const serialiser = new Serialiser(data(), ast())
+      const value = 'test-result'
+
+      serialiser.result = value
+      serialiser.yank = jest.fn()
+
+      const result = serialiser.serialise()
+
+      expect(result).toEqual(value)
+    })
   })
 
   describe('get', () => {
+    const path = [
+      'nested',
+      'data',
+      'items',
+      'one'
+    ]
+
+    it('should retrieve a value from a given path', () => {
+      const source = data()
+      const serialiser = new Serialiser(source, ast())
+      const result = serialiser.get(source, path)
 
+      expect(result).toEqual('one')
+    })
+
+    it('should run exec() if available in options', () => {
+      const source = data()
+      const serialiser = new Serialiser(source, ast())
+      const value = 'test-value'
+      const options = {
+        exec: jest
+          .fn()
+          .mockReturnValue(value)
+      }
+      const result = serialiser.get(source, path, options)
+
+      expect(result).toEqual(value)
+    })
+
+    it('should return null if options.nullable is truthy and result is not', () => {
+      const source = data()
+      const serialiser = new Serialiser(source, ast())
+      const path = [
+        'foo',
+        'bar'
+      ]
+      const options = {
+        nullable: true
+      }
+      const result = serialiser.get(source, path, options)
+
+      expect(result).toBeNull()
+    })
   })
 
   describe('set', () => {
+    it('should set the value at the given key location', () => {
+      const serialiser = new Serialiser(data(), ast())
+      const parent = {}
+      const key = {
+        name: 'foo'
+      }
+      const value = 'test-value'
+
+      serialiser.set(parent, key, value)
 
+      expect(parent.foo).toEqual(value)
+    })
   })
 })