Fix #10, circular reference, release as 4.2.0

Author: doesdev

.travis.yml

@@ -1,5 +1,5 @@
 language: node_js
 node_js:
-  - 13
+  - 16
+  - 14
   - 12
-  - 10

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is (loosely) based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.1.1](https://github.com/doesdev/mvt/compare/4.1.1...4.2.0)
+#### 2021-07-10
+
+### Changed
+- Fix #10, caused by circular require
+- Update Travis to use node 16, 14, 12
+- Update ava
+
 ## [4.1.1](https://github.com/doesdev/mvt/compare/4.1.0...4.1.1)
 #### 2020-07-16
 

lib/runners.js

@@ -3,86 +3,89 @@
 const { state } = require('./state')
 const { assert } = require('./assertions')
 const { handleError } = require('./errors')
-const { failing } = require('./tests')
 const { reporter, info } = require('./reporters')
 const { char, color, fmtMs } = require('./utility')
 
-const runner = async (t, noExit) => {
-  const { msg, fn, failing, benchOpts, fileName: currFile } = t
+const getRunner = (tests) => {
+  const runner = async (t, noExit) => {
+    const { msg, fn, failing, benchOpts, fileName: currFile } = t
 
-  if (currFile) {
-    if (currFile !== state.lastFileName) {
-      state.fileTestCount = 0
-      info(`\nRunning tests for ${currFile}\n\n`)
-    }
+    if (currFile) {
+      if (currFile !== state.lastFileName) {
+        state.fileTestCount = 0
+        info(`\nRunning tests for ${currFile}\n\n`)
+      }
 
-    state.lastFileName = currFile
-  }
+      state.lastFileName = currFile
+    }
 
-  if (benchOpts) return benchRunner(t)
+    if (benchOpts) return benchRunner(t)
 
-  const start = Date.now()
+    const start = Date.now()
 
-  try {
-    await fn(assert(msg, failing))
-  } catch (error) {
-    if (!failing) return handleError(msg, error, noExit)
+    try {
+      await fn(assert(msg, failing))
+    } catch (error) {
+      if (!failing) return handleError(msg, error, noExit)
 
-    const ms = ` (${fmtMs(Date.now() - start)})`
-    const out = `${char('okFail')} ${color.red}${msg}${ms}`
-    return reporter({ msg, out, error, pass: false, mod: 'failing' })
-  }
+      const ms = ` (${fmtMs(Date.now() - start)})`
+      const out = `${char('okFail')} ${color.red}${msg}${ms}`
+      return reporter({ msg, out, error, pass: false, mod: 'failing' })
+    }
 
-  const ms = Date.now() - start
+    const ms = Date.now() - start
 
-  if (failing) {
-    return handleError(msg, new Error('Passed test called with test.failing'))
-  }
+    if (failing) {
+      return handleError(msg, new Error('Passed test called with test.failing'))
+    }
 
-  if (!msg) return
+    if (!msg) return
 
-  const out = `${char('good')} ${msg} (${fmtMs(ms)})`
-  return reporter({ msg, out, pass: true })
-}
+    const out = `${char('good')} ${msg} (${fmtMs(ms)})`
+    return reporter({ msg, out, pass: true })
+  }
 
-const benchRunner = async ({ msg, fn, benchOpts }) => {
-  const { samples, max } = benchOpts
-  const start = process.hrtime()
-  let msAvg
-
-  try {
-    if (benchOpts.parallel) {
-      const wrapped = async () => {
-        const iStart = process.hrtime()
-        await fn(assert(msg, failing))
-        return process.hrtime(iStart)
+  const benchRunner = async ({ msg, fn, benchOpts }) => {
+    const { samples, max } = benchOpts
+    const start = process.hrtime()
+    let msAvg
+
+    try {
+      if (benchOpts.parallel) {
+        const wrapped = async () => {
+          const iStart = process.hrtime()
+          await fn(assert(msg, tests.failing))
+          return process.hrtime(iStart)
+        }
+        const times = await Promise.all([...Array(samples)].map(wrapped))
+        msAvg = parseInt(times.reduce((accum, curval) => {
+          return accum + (curval[0] * 1e3 + curval[1] / 1e6)
+        }, 0) / samples, 10)
+      } else {
+        for (let i = 0; i < samples; i++) await fn(assert(msg, tests.failing))
       }
-      const times = await Promise.all([...Array(samples)].map(wrapped))
-      msAvg = parseInt(times.reduce((accum, curval) => {
-        return accum + (curval[0] * 1e3 + curval[1] / 1e6)
-      }, 0) / samples, 10)
-    } else {
-      for (let i = 0; i < samples; i++) await fn(assert(msg, failing))
+    } catch (ex) {
+      return handleError(msg, ex)
     }
-  } catch (ex) {
-    return handleError(msg, ex)
-  }
 
-  const ranFor = process.hrtime(start)
-  const msTotal = ranFor[0] * 1e3 + ranFor[1] / 1e6
-  msAvg = msAvg || parseInt(msTotal / samples, 10)
+    const ranFor = process.hrtime(start)
+    const msTotal = ranFor[0] * 1e3 + ranFor[1] / 1e6
+    msAvg = msAvg || parseInt(msTotal / samples, 10)
 
-  if (typeof benchOpts.cb === 'function') {
-    benchOpts.cb({ msTotal, msAvg })
-  }
+    if (typeof benchOpts.cb === 'function') {
+      benchOpts.cb({ msTotal, msAvg })
+    }
+
+    if (msAvg > max) {
+      const maxErr = new Error(`Bench failed: (${fmtMs(msAvg)} > ${fmtMs(max)})`)
+      return handleError(msg, maxErr)
+    }
 
-  if (msAvg > max) {
-    const maxErr = new Error(`Bench failed: (${fmtMs(msAvg)} > ${fmtMs(max)})`)
-    return handleError(msg, maxErr)
+    const out = `${char('good')} ${msg} (${fmtMs(msAvg)} avg)`
+    return reporter({ msg, out, pass: true })
   }
 
-  const out = `${char('good')} ${msg} (${fmtMs(msAvg)} avg)`
-  return reporter({ msg, out, pass: true })
+  return { runner, benchRunner }
 }
 
-module.exports = { runner, benchRunner }
+module.exports = { getRunner }

lib/tests.js

@@ -2,14 +2,15 @@
 
 const { state, setup } = require('./state')
 const { finalizeError } = require('./errors')
-const { runner } = require('./runners')
+const { getRunner } = require('./runners')
 const { assert } = require('./assertions')
 const { reporter, summary } = require('./reporters')
 const { color, parseMs, char } = require('./utility')
 
 const test = async (msg, fn) => {
   if (msg && fn) state.queue.push({ msg, fn, fileName: state.fileName })
 
+  const { runner } = getRunner(test)
   const curLen = state.queue.length
   process.nextTick(async () => {
     if (curLen !== state.queue.length) return