js-build-tools 1.2.2 → 2.1.0

package/functions/test-helpers/deepReferenceObject.js

@@ -0,0 +1,25 @@
+/**
+ * Sample object with deep references.
+ * @memberOf module:testHelpers
+ * @type {Object.<string, string|number|Object>}
+ */
+const deepReferenceObject = {
+  object1: {
+    name: 'someName',
+    object2: {
+      age: 12,
+      array1: [
+        'someString',
+        'anotherString'
+      ]
+    },
+    array2: [
+      89,
+      32
+    ]
+  },
+  title: 'Some Title',
+  item: 45
+}
+
+module.exports = deepReferenceObject

package/functions/test-helpers/deepReferenceObject.test.js

@@ -0,0 +1,7 @@
+const deepReferenceObject = require('./deepReferenceObject')
+
+describe('deepReferenceObject', () => {
+  test('has sample deep reference object', () => {
+    expect(deepReferenceObject).toHaveProperty('object1.object2.array1')
+  })
+})

package/functions/test-helpers/domItem.js

@@ -0,0 +1,31 @@
+/**
+ * Sample of domItem child with nested child and optional details
+ * @memberOf module:testHelpers
+ * @type {Object.<string, string|number|Array|Object>}
+ */
+const domItem = [
+  {
+    attributes: { className: 'row', style: {} },
+    axis: 'y',
+    children: [
+      {
+        attributes: { style: {} },
+        axis: 'x',
+        children: [],
+        element: {},
+        eventListeners: {},
+        hasShip: false,
+        isHit: false,
+        parentItem: {},
+        point: {},
+        tagName: 'div'
+      }
+    ],
+    element: null,
+    eventListeners: {},
+    parentItem: {},
+    tagName: 'div'
+  }
+]
+
+module.exports = domItem

package/functions/test-helpers/domItem.test.js

@@ -0,0 +1,12 @@
+const domItem = require('./domItem')
+
+describe('domItem', () => {
+  test('has sample domItem object', () => {
+    expect(domItem[0]).toHaveProperty('attributes')
+    expect(domItem[0]).toHaveProperty('children')
+    expect(domItem[0]).toHaveProperty('element')
+    expect(domItem[0]).toHaveProperty('eventListeners')
+    expect(domItem[0]).toHaveProperty('parentItem')
+    expect(domItem[0]).toHaveProperty('tagName')
+  })
+})

package/functions/test-helpers/jsonDom.js

@@ -0,0 +1,16 @@
+/**
+ * Sample of jsonDom object containing empty nested array and objects
+ * @memberOf module:testHelpers
+ * @type {Object.<string, string|number|Array|Object>}
+ */
+const jsonDom = {
+  tagName: 'div',
+  attributes: { style: {}, className: 'column' },
+  element: null,
+  eventListeners: {},
+  parentItem: {},
+  children: [],
+  axis: 'x'
+}
+
+module.exports = jsonDom

package/functions/test-helpers/jsonDom.test.js

@@ -0,0 +1,12 @@
+const jsonDom = require('./jsonDom')
+
+describe('jsonDom', () => {
+  test('has sample jsonDom object', () => {
+    expect(jsonDom).toHaveProperty('attributes')
+    expect(jsonDom).toHaveProperty('children')
+    expect(jsonDom).toHaveProperty('element')
+    expect(jsonDom).toHaveProperty('eventListeners')
+    expect(jsonDom).toHaveProperty('parentItem')
+    expect(jsonDom).toHaveProperty('tagName')
+  })
+})

package/functions/test-helpers/linkedList.js

@@ -0,0 +1,10 @@
+/**
+ * Sample LinkedList for testing circular references.
+ * @memberOf module:testHelpers
+ * @type {Object.<string, string|Object>}
+ */
+const linkedList = { name: 'one', prev: null, next: null }
+linkedList.next = { name: 'two', prev: linkedList, next: null }
+linkedList.next.next = { name: 'three', prev: linkedList.next, next: null }
+
+module.exports = linkedList

package/functions/test-helpers/linkedList.test.js

@@ -0,0 +1,22 @@
+const linkedList = require('./linkedList')
+
+describe('linkedList', () => {
+  test('has sample linkedList object', () => {
+    expect(linkedList.name).toBe('one')
+    expect(linkedList).toHaveProperty('prev')
+    expect(linkedList.prev).toBeNull()
+
+    expect(linkedList).toHaveProperty('next')
+    expect(linkedList.next.name).toBe('two')
+    expect(linkedList).toHaveProperty('next.prev')
+    expect(linkedList.next.prev).toBe(linkedList)
+
+    expect(linkedList).toHaveProperty('next.next')
+    expect(linkedList.next.next.name).toBe('three')
+    expect(linkedList).toHaveProperty('next.prev')
+    expect(linkedList.next.next.prev).toBe(linkedList.next)
+
+    expect(linkedList).toHaveProperty('next.next.next')
+    expect(linkedList.next.next.next).toBeNull()
+  })
+})

package/functions/test-helpers/logObject.js

@@ -0,0 +1,18 @@
+/**
+ * Log out an object in a nicely formatted way.
+ * @function
+ * @memberOf module:testHelpers
+ * @param {Object} object
+ * @param {string} [label=logging]
+ * @param {string} [outputType=log]
+ * @returns {string|undefined}
+ */
+const logObject = (object, label = 'logging', outputType = 'log') => {
+  const logger = outputType === 'string' ? (label, object) => `'${label}' | ` + JSON.stringify(object) : console[outputType]
+  if (typeof require === 'undefined' || outputType === 'string') {
+    return logger(label, object)
+  }
+  return logger(label, require('util').inspect(object, false, null, true))
+}
+
+module.exports = logObject

package/functions/test-helpers/logObject.test.js

@@ -0,0 +1,20 @@
+const logObject = require('./logObject')
+const util = require('util')
+
+describe('logObject', () => {
+  test('can nicely output objects', () => {
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(jest.fn())
+    const inspectSpy = jest.spyOn(util, 'inspect')
+    const someObject = { one: 1, two: 2, three: 3 }
+    logObject(someObject, 'someObject')
+    expect(inspectSpy).toHaveBeenCalledWith(someObject, false, null, true)
+    expect(logSpy).toHaveBeenCalledWith('someObject', util.inspect(someObject, false, null, true))
+  })
+
+  test('output to string when that argument is provided', () => {
+    const someObject = { one: 1, two: 2, three: 3 }
+    const label = 'someObject'
+    const result = logObject(someObject, label, 'string')
+    expect(result).toEqual(`'${label}' | ` + JSON.stringify(someObject))
+  })
+})

package/functions/test-helpers/multiReferenceObject.js

@@ -0,0 +1,25 @@
+/**
+ * Sample of object containing multiple references.
+ * @memberOf module:testHelpers
+ * @type {Object.<string, string|number|Object>}
+ */
+const multiReferenceObject = {
+  object1: {
+    name: 'someName'
+  },
+  object2: {
+    age: 12
+  },
+  array1: [
+    'someString',
+    'anotherString'
+  ],
+  array2: [
+    89,
+    32
+  ],
+  title: 'Some Title',
+  item: 45
+}
+
+module.exports = multiReferenceObject

package/functions/test-helpers/multiReferenceObject.test.js

@@ -0,0 +1,14 @@
+const multiReferenceObject = require('./multiReferenceObject')
+
+describe('multiReferenceObject', () => {
+  test('has sample multiReferenceObject object', () => {
+    expect(multiReferenceObject).toHaveProperty('object1.name')
+    expect(multiReferenceObject).toHaveProperty('object2.age')
+    expect(multiReferenceObject).toHaveProperty('array1.0')
+    expect(multiReferenceObject).toHaveProperty('array1.1')
+    expect(multiReferenceObject).toHaveProperty('array2.0')
+    expect(multiReferenceObject).toHaveProperty('array2.1')
+    expect(multiReferenceObject).toHaveProperty('title')
+    expect(multiReferenceObject).toHaveProperty('item')
+  })
+})

package/functions/test-helpers/nodeTree.js

@@ -0,0 +1,11 @@
+/**
+ * Sample NodeTree for testing circular references and arrays.
+ * @memberOf module:testHelpers
+ * @type {Object.<string, string|Object|Array>}
+ */
+const nodeTree = { name: 'one', parent: null, children: [] }
+nodeTree.children[0] = { name: 'child one', parent: nodeTree, children: [] }
+nodeTree.children[1] = { name: 'child two', parent: nodeTree, children: [] }
+nodeTree.children[0].children[0] = { name: 'grandchild one', parent: nodeTree.children[0], children: [] }
+
+module.exports = nodeTree

package/functions/test-helpers/nodeTree.test.js

@@ -0,0 +1,18 @@
+import nodeTree from './nodeTree'
+
+describe('nodeTree', () => {
+  test('has sample nodeTree object', () => {
+    expect(nodeTree.name).toBe('one')
+    expect(nodeTree.parent).toBeNull()
+    expect(nodeTree.children.length).toBe(2)
+    expect(nodeTree.children[0].name).toBe('child one')
+    expect(nodeTree.children[0].parent).toBe(nodeTree)
+    expect(nodeTree.children[0].children.length).toBe(1)
+    expect(nodeTree.children[0].children[0].name).toBe('grandchild one')
+    expect(nodeTree.children[0].children[0].parent).toBe(nodeTree.children[0])
+    expect(nodeTree.children[0].children[0].children.length).toBe(0)
+    expect(nodeTree.children[1].name).toBe('child two')
+    expect(nodeTree.children[1].parent).toBe(nodeTree)
+    expect(nodeTree.children[1].children.length).toBe(0)
+  })
+})

package/functions/test-helpers/setUp.js

@@ -0,0 +1,67 @@
+const fs = require('fs')
+const del = require('del')
+// Import the configurations and override some of them in order to direct to the temp directory.
+const gulpConfig = require('../../gulp.config.js')
+
+let tempDir = 'test-temp/'
+let srcPath = `${tempDir}src`
+
+/**
+ * Update the gulp configurations with the test data. Set the test directory where temp files will be created for testing.
+ * @function
+ * @memberOf module:testHelpers
+ * @param {string} testDir
+ */
+const setDefaults = (testDir = 'test-temp') => {
+  tempDir = `${testDir}/`
+  srcPath = `${tempDir}src`
+  gulpConfig.set('browserPath', `${tempDir}browser`)
+  gulpConfig.set('distMain', `${tempDir}dist/main`)
+  gulpConfig.set('distPath', `${tempDir}dist`)
+  gulpConfig.set('distSearch', `${tempDir}dist/**/*.js`)
+  gulpConfig.set('readmeTemplate', `${tempDir}MAIN.md`)
+  gulpConfig.set('readmePath', tempDir)
+  gulpConfig.set('rootPath', tempDir)
+  gulpConfig.set('srcPath', srcPath)
+  gulpConfig.set('srcSearch', `${tempDir}src/**/!(*.test).js`)
+  gulpConfig.set('tsSearch', `${tempDir}src/**/*.ts`)
+  gulpConfig.set('watchSearch', `${tempDir}src/**/*.js`)
+}
+
+exports.setDefaults = setDefaults
+
+exports.gulpConfig = gulpConfig
+
+/**
+ * Ensure that the del has completed, recursively attempt to delete and recreate
+ * @function
+ * @memberOf module:testHelpers
+ * @param {boolean} [exists=true]
+ * @returns {Promise<*|void>}
+ */
+const createTempDir = async (exists = true) => {
+  if (exists) {
+    return del(tempDir)
+      .then(() => createTempDir(fs.existsSync(tempDir)))
+  }
+  await fs.mkdirSync(tempDir)
+  return fs.mkdirSync(srcPath)
+}
+
+exports.createTempDir = createTempDir
+
+/**
+ * In the Jest.beforeEach function call this one to set up the temp directory.
+ * @function
+ * @memberOf module:testHelpers
+ * @returns {Promise<*|void>}
+ */
+exports.beforeEach = () => createTempDir()
+
+/**
+ * In the Jest.afterEach function call this one to clean up and remove the temp directory.
+ * @function
+ * @memberOf module:testHelpers
+ * @returns {Promise<*>}
+ */
+exports.afterEach = async () => await del(tempDir)

package/functions/test-helpers/setUp.test.js

@@ -0,0 +1,18 @@
+import { afterEach, createTempDir, gulpConfig, setDefaults } from './setUp'
+import fs from 'fs'
+
+setDefaults()
+
+describe('setUp', () => {
+  test('able to create the test-temp/src directory', async () => {
+    expect(fs.existsSync(gulpConfig.get('srcPath'))).toBeFalsy()
+    await createTempDir()
+    expect(fs.existsSync(gulpConfig.get('srcPath'))).toBeTruthy()
+  })
+
+  test('able to delete the test-temp/src directory', async () => {
+    expect(fs.existsSync(gulpConfig.get('srcPath'))).toBeTruthy()
+    await afterEach()
+    expect(fs.existsSync(gulpConfig.get('srcPath'))).toBeFalsy()
+  })
+})

package/functions/testFull.js

@@ -1,10 +1,20 @@
-const gulpConfig = require('../gulp.config.js');
-const { runCLI: jest } = require('jest')
-
-/**
- * Run all tests with jest.
- * @returns {Promise<*>}
- */
-const testFull = async () => await jest({}, gulpConfig.testPath)
-
-module.exports = testFull
+const gulpConfig = require('../gulp.config.js')
+const { runCLI } = require('jest')
+
+/**
+ * Run all tests with jest.
+ * @function
+ * @memberOf module:js-build-tools
+ * @param {function} [done=null]
+ * @param {Array.<string>|string} [testPath='path/config/test/files']
+ * @returns {Promise<*>}
+ */
+const testFull = (done = null, testPath = gulpConfig.get('testPath')) => {
+  if (!Array.isArray(testPath)) {
+    // The testPath must be an array of strings
+    testPath = [testPath]
+  }
+  return runCLI(gulpConfig.get('testOptions'), testPath)
+}
+
+module.exports = testFull

package/functions/testFull.test.js

@@ -0,0 +1,16 @@
+const { setUp } = require('./testHelpers')
+const gulpConfig = setUp.gulpConfig
+const { runCLI } = require('jest')
+const testFull = require('./testFull')
+
+jest.mock('jest', () => ({
+  'runCLI': jest.fn(() => Promise.resolve(true))
+}))
+
+describe('testFull', () => {
+  test('runs the Jest CLI with the configured options', () => {
+    expect.assertions(1)
+    testFull()
+    expect(runCLI).toHaveBeenCalledWith(gulpConfig.get('testOptions'), [gulpConfig.get('testPath')])
+  })
+})

package/functions/testHelpers.js

@@ -1,142 +1,32 @@
 /**
- * Log out an object in a nicely formatted way.
- * @param {Object} object
- * @param {string} [label='logging']
+ * An assortment of objects that can be used in tests and some functions to help debug and write tests.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 2.0.0
+ * @module testHelpers
+ * @memberOf module:js-build-tools
  */
-export const logObject = (object, label = 'logging') => {
-  if (typeof require === 'undefined') {
-    console.log(label, object)
-    return
-  }
-  console.log(label, require('util').inspect(object, false, null, true))
-}
-
-/**
- * Multilayered node tree-like structure with parent references
- * @type {Object.<string, string|Object|Array>}
- */
-export const circularObject = { name: 'root', parent: {}, body: {}, head: {}, children: [] }
-circularObject.children = [
-  { name: 'body', parent: {}, children: [] },
-  { name: 'head', parent: {}, children: [] }
-]
-circularObject.body = circularObject.children[0]
-circularObject.head = circularObject.children[1]
-circularObject.body.parent = circularObject
-circularObject.head.parent = circularObject
-circularObject.body.children = [
-  { name: 'body child one', parent: {}, children: [] },
-  { name: 'body child two', parent: {}, children: [] }
-]
-circularObject.body.children[0].parent = circularObject.body
-circularObject.body.children[1].parent = circularObject.body
-circularObject.head.children = [
-  { name: 'head child one', parent: {}, children: [] },
-  { name: 'head child two', parent: {}, children: [] }
-]
-circularObject.head.children[0].parent = circularObject.head
-circularObject.head.children[1].parent = circularObject.head
-
-/**
- * Sample object with deep references.
- * @type {Object.<string, string|number|Object>}
- */
-export const deepReferenceObject = {
-  object1: {
-    name: 'someName',
-    object2: {
-      age: 12,
-      array1: [
-        'someString',
-        'anotherString'
-      ]
-    },
-    array2: [
-      89,
-      32
-    ]
-  },
-  title: 'Some Title',
-  item: 45
-}
-
-/**
- * Sample LinkedList for testing circular references.
- * @type {Object.<string, string|Object>}
- */
-export const linkedList = { name: 'one', prev: null, next: null }
-linkedList.next = { name: 'two', prev: linkedList, next: null }
-linkedList.next.next = { name: 'three', prev: linkedList.next, next: null }
 
-/**
- * Sample of jsonDom object containing empty nested array and objects
- */
-export const jsonDom = {
-  tagName: 'div',
-  attributes: { style: {}, className: 'column' },
-  element: null,
-  eventListeners: {},
-  parentItem: {},
-  children: [],
-  axis: 'x'
-}
-
-/**
- * Sample of domItem child with nested child and optional details
- */
-export const domItem = [
-  {
-    attributes: { className: 'row', style: {} },
-    axis: 'y',
-    children: [
-      {
-        attributes: { style: {} },
-        axis: 'x',
-        children: [],
-        element: {},
-        eventListeners: {},
-        hasShip: false,
-        isHit: false,
-        parentItem: {},
-        point: {},
-        tagName: 'div'
-      }
-    ],
-    element: null,
-    eventListeners: {},
-    parentItem: {},
-    tagName: 'div'
-  }
-]
+const circularObject = require('./test-helpers/circularObject')
+const countMatches = require('./test-helpers/countMatches')
+const deepReferenceObject = require('./test-helpers/deepReferenceObject')
+const domItem = require('./test-helpers/domItem')
+const jsonDom = require('./test-helpers/jsonDom')
+const linkedList = require('./test-helpers/linkedList')
+const logObject = require('./test-helpers/logObject')
+const multiReferenceObject = require('./test-helpers/multiReferenceObject')
+const nodeTree = require('./test-helpers/nodeTree')
+const setUp = require('./test-helpers/setUp')
 
-/**
- * Sample of object containing multiple references.
- * @type {Object.<string, string|number|Object>}
- */
-export const multiReferenceObject = {
-  object1: {
-    name: 'someName'
-  },
-  object2: {
-    age: 12
-  },
-  array1: [
-    'someString',
-    'anotherString'
-  ],
-  array2: [
-    89,
-    32
-  ],
-  title: 'Some Title',
-  item: 45
+module.exports = {
+  circularObject,
+  countMatches,
+  deepReferenceObject,
+  domItem,
+  jsonDom,
+  linkedList,
+  logObject,
+  multiReferenceObject,
+  nodeTree,
+  setUp,
 }
-
-/**
- * Sample NodeTree for testing circular references and arrays.
- * @type {Object.<string, string|Object|Array>}
- */
-export const nodeTree = { name: 'one', parent: null, children: [] }
-nodeTree.children[0] = { name: 'child one', parent: nodeTree, children: [] }
-nodeTree.children[1] = { name: 'child two', parent: nodeTree, children: [] }
-nodeTree.children[0].children[0] = { name: 'grandchild one', parent: nodeTree.children[0], children: [] }

package/functions/testHelpers.test.js

@@ -1,100 +1,7 @@
-const {
-  circularObject,
-  deepReferenceObject,
-  domItem,
-  jsonDom,
-  linkedList,
-  logObject,
-  multiReferenceObject,
-  nodeTree
-} = require('./testHelpers.js')
-const util = require('util')
-
-describe('testHelpers', () => {
-  test('can nicely output objects with logObject', () => {
-    const logSpy = jest.spyOn(console, 'log')
-    const inspectSpy = jest.spyOn(util, 'inspect')
-    const someObject = { one: 1, two: 2, three: 3 }
-    logObject(someObject, 'someObject')
-    expect(inspectSpy).toHaveBeenCalledWith(someObject, false, null, true)
-    expect(logSpy).toHaveBeenCalledWith('someObject', util.inspect(someObject, false, null, true))
-  })
-
-  test('has sample circular object', () => {
-    expect(circularObject.body.parent).toBe(circularObject)
-    expect(circularObject.body.children[0].parent).toBe(circularObject.body)
-    expect(circularObject.body.children[1].parent).toBe(circularObject.body)
-    expect(circularObject.children[0]).toBe(circularObject.body)
-    expect(circularObject.head.parent).toBe(circularObject)
-    expect(circularObject.head.children[0].parent).toBe(circularObject.head)
-    expect(circularObject.head.children[1].parent).toBe(circularObject.head)
-    expect(circularObject.children[1]).toBe(circularObject.head)
-  })
-
-  test('has sample deep reference object', () => {
-    expect(deepReferenceObject).toHaveProperty('object1.object2.array1')
-  })
-
-  test('has sample domItem object', () => {
-    expect(domItem[0]).toHaveProperty('attributes')
-    expect(domItem[0]).toHaveProperty('children')
-    expect(domItem[0]).toHaveProperty('element')
-    expect(domItem[0]).toHaveProperty('eventListeners')
-    expect(domItem[0]).toHaveProperty('parentItem')
-    expect(domItem[0]).toHaveProperty('tagName')
-  })
-
-  test('has sample jsonDom object', () => {
-    expect(jsonDom).toHaveProperty('attributes')
-    expect(jsonDom).toHaveProperty('children')
-    expect(jsonDom).toHaveProperty('element')
-    expect(jsonDom).toHaveProperty('eventListeners')
-    expect(jsonDom).toHaveProperty('parentItem')
-    expect(jsonDom).toHaveProperty('tagName')
-  })
-
-  test('has sample linkedList object', () => {
-    expect(linkedList.name).toBe('one')
-    expect(linkedList).toHaveProperty('prev')
-    expect(linkedList.prev).toBeNull()
-
-    expect(linkedList).toHaveProperty('next')
-    expect(linkedList.next.name).toBe('two')
-    expect(linkedList).toHaveProperty('next.prev')
-    expect(linkedList.next.prev).toBe(linkedList)
-
-    expect(linkedList).toHaveProperty('next.next')
-    expect(linkedList.next.next.name).toBe('three')
-    expect(linkedList).toHaveProperty('next.prev')
-    expect(linkedList.next.next.prev).toBe(linkedList.next)
-
-    expect(linkedList).toHaveProperty('next.next.next')
-    expect(linkedList.next.next.next).toBeNull()
-  })
-
-  test('has sample multiReferenceObject object', () => {
-    expect(multiReferenceObject).toHaveProperty('object1.name')
-    expect(multiReferenceObject).toHaveProperty('object2.age')
-    expect(multiReferenceObject).toHaveProperty('array1.0')
-    expect(multiReferenceObject).toHaveProperty('array1.1')
-    expect(multiReferenceObject).toHaveProperty('array2.0')
-    expect(multiReferenceObject).toHaveProperty('array2.1')
-    expect(multiReferenceObject).toHaveProperty('title')
-    expect(multiReferenceObject).toHaveProperty('item')
-  })
-
-  test('has sample nodeTree object', () => {
-    expect(nodeTree.name).toBe('one')
-    expect(nodeTree.parent).toBeNull()
-    expect(nodeTree.children.length).toBe(2)
-    expect(nodeTree.children[0].name).toBe('child one')
-    expect(nodeTree.children[0].parent).toBe(nodeTree)
-    expect(nodeTree.children[0].children.length).toBe(1)
-    expect(nodeTree.children[0].children[0].name).toBe('grandchild one')
-    expect(nodeTree.children[0].children[0].parent).toBe(nodeTree.children[0])
-    expect(nodeTree.children[0].children[0].children.length).toBe(0)
-    expect(nodeTree.children[1].name).toBe('child two')
-    expect(nodeTree.children[1].parent).toBe(nodeTree)
-    expect(nodeTree.children[1].children.length).toBe(0)
-  })
-})
+const testHelpers = require('./testHelpers')
+
+describe('testHelpers', () => {
+  test('is object with all helper exports', () => {
+    expect(Object.keys(testHelpers).length).toBe(10)
+  })
+})