sxy-test-runner 1.0.4 → 1.0.7

package/dist/cli/init.js

@@ -0,0 +1,170 @@
+import { join } from 'path';
+import chalk from 'chalk-extensions';
+import { packageName, cliName, configFileName, configLocations } from '../config.js';
+import { out, log, debug } from '../output.js';
+import fs from 'fs';
+export async function init() {
+  const projectDir = await process.cwd();
+
+  for (const configLocation of configLocations) {
+    let loc;
+    loc = await join(projectDir, configLocation, configFileName + '.js');
+
+    if (await fs.existsSync(loc)) {
+      await configAlreadyExists(loc);
+    }
+
+    loc = await join(projectDir, configLocation, configFileName + '.cjs');
+
+    if (await fs.existsSync(loc)) {
+      await configAlreadyExists(loc);
+    }
+
+    loc = await join(projectDir, configLocation, configFileName + '.mjs');
+
+    if (await fs.existsSync(loc)) {
+      await configAlreadyExists(loc);
+    }
+  }
+
+  async function configAlreadyExists(loc) {
+    await out(chalk.orange`[${packageName}] A matching config already exists at ${loc}` + `\nPlease remove this config before generating a new one with \`${cliName} init\``);
+  }
+
+  const projectPackageJsonLocation = await join(projectDir, 'package.json');
+
+  if (!(await fs.existsSync(projectPackageJsonLocation))) {
+    await out(chalk.orange`[${packageName}] No package.json exists in this location` + `\nPlease initialise the package with \`yarn init\` on \`npm init\`` + ` before running this command, and run this command from the project root folder`);
+  } //const packageJsonRaw = await fs.promises.readFile( projectPackageJsonLocation )
+
+
+  const packageJsonRaw = await fs.readFileSync(projectPackageJsonLocation);
+  const packageJson = await JSON.parse(packageJsonRaw);
+  let targetConfigName;
+
+  if (packageJson.type === 'module') {
+    // ES6 module
+    targetConfigName = await join(projectDir, configLocations[0], configFileName + '.js');
+  } else {
+    // common 
+    targetConfigName = await join(projectDir, configLocations[0], configFileName + '.mjs');
+  }
+
+  const defaultConfig = `export default {
+
+    // base folder for tests match and ignore patterns
+    testsBase: '.',
+
+    // glob pattern or array of glob patterns of test files
+    tests: [
+        '**/*.test.{js,mjs,jsx}',
+        '**/*.spec.{js,mjs,jsx}',
+        '**/tests?/*.{js,mjs,jsx}',
+        '**/__tests?__/*.{js,mjs,jsx}'
+    ],
+
+    // glob pattern or array of patterns of test files to ignore
+    testsIgnore: ['**/node_modules/**/*'],
+
+    // whether to show the full error trace when an error occurs in a test file
+    showErrorTrace: false,
+
+    // tasks to run on startup
+    // accepts a function, file location (relative to project base), or array of functions and or files
+    setup: undefined,
+
+    // tasks to run before each test file is run
+    beforeEachFile: undefined,
+
+    // tasks to run after each test file is run
+    afterEachFile:  undefined,
+
+    // tasks to run before each describe block is processed
+    // if the function returns an object with named properties, or the file exports named exports,
+    // these will be passed to the callback function in argument 0, and can be access by destructruing e.g.
+    // describe('thing', ({exportA, exportB}) => { it('should', ...) })
+    beforeEachDescribe: undefined,
+
+    // tasks to run after each describe block
+    afterEachDescribe: undefined,
+
+    // tasks to run before each it/test block
+    // function returns and file exports will be passed to the it/test block as with describe above, e.g.
+    // it('should', ({exportA, exportB}) => { assert('something') }) 
+    beforeEachTest: undefined,
+
+    // tasks to run after each it/test block
+    afterEachTest: undefined,
+
+    // how to execute the different parts of test files
+    execution: {
+
+        // run test files in 'parallel' or 'sequential'ly
+        files: 'parallel',
+
+        // run describe blocks within a test file in 'parallel' or 'sequential'ly
+        describes: 'sequential',
+
+        // run it/test blocks within a describe blocks in 'parallel' or 'sequential'ly
+        tests: 'sequential'
+
+    },
+
+    // watch mode configurations
+    watch: {
+
+        //// the base directory to watch files in
+        watchFilesBase: '.',
+
+        //// glob filter or array of glob filters of files to watch
+        watchFiles: '**/*.js',
+
+        //// glob filter or array of globl filters of files to ignore
+        watchFilesIgnore: '**/node_modules/**/*',
+
+        // run all tests when starting the watcher
+        runAllOnStartup: true,
+    
+        // re run all previously failed tests on each test run, until they pass
+        reRunFailingTests: true,
+
+    },
+
+}`; // `export default {
+  //     // base folder for tests match and ignore patterns
+  //     testsBase: '.',
+  //     // glob pattern or array of glob patterns of test files
+  //     tests: [
+  //         '**/*.test.{js,mjs,jsx}',
+  //         '**/*.spec.{js,mjs,jsx}',
+  //         '**/tests?/*.{js,mjs,jsx}',
+  //         '**/__tests?__/*.{js,mjs,jsx}'
+  //     ],
+  //     // glob pattern or array of patterns of test files to ignore
+  //     testsIgnore: ['**/node_modules/**/*'],
+  //     // function to run on startup
+  //     setup: undefined,
+  //     // function to run before each test file
+  //     setupEach: undefined,
+  //     // function to run after test run
+  //     teardown: undefined,
+  //     // function to run after each test file
+  //     teardownEach: undefined,
+  //     // watch mode configurations
+  //     watch: {
+  //         //// the base directory to watch files in
+  //         watchFilesBase: '.',
+  //         //// glob filter or array of glob filters of files to watch
+  //         watchFiles: '**/*.js',
+  //         //// glob filter or array of globl filters of files to ignore
+  //         watchFilesIgnore: '**/node_modules/**/*',
+  //         // run all tests when starting the watcher
+  //         runAllOnStartup: true,
+  //         // re run all previously failed tests on each test run, until they pass
+  //         reRunFailingTests: true,
+  //     },
+  // }`
+
+  await fs.writeFileSync(targetConfigName, defaultConfig);
+  await out(chalk.mediumgreen`[${packageName}] Created config at ` + (await chalk.blue(targetConfigName)));
+}

package/dist/cli/lib/addBasePath.js

@@ -0,0 +1,15 @@
+import { createTimeProfiler } from 'sxy-dev-tools';
+import { showTimeProfiling } from '../../config.js';
+import { out, log, debug } from '../../output.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function addBasePath(base, items) {
+  return await timeProfileAsync('add base to globs', async () => {
+    if (base !== undefined && base !== '.' && base !== '') {
+      items = (await Array.isArray(items)) ? await items.map(item => `${base}/${item}`) : `${base}/${items}`;
+    }
+
+    return items;
+  });
+}

package/dist/cli/lib/addBasePath.unitTest.js

@@ -0,0 +1,31 @@
+import { addBasePath } from './addBasePath.js';
+import { join } from 'path'; // addBaseToGlobs(base, globs)
+// base: string
+// globs: string or array of strings
+
+await mochaDescribe('addBaseToGlobs() function', async function () {
+  await mochaIt('adds a base to a glob string', async function () {
+    const result = await addBasePath('src', '**/*.js');
+    await result.should.equal('src/**/*.js');
+  });
+  await mochaIt('adds a base to an array of glob strings', async function () {
+    const result = await addBasePath('src', ['**/*.test.js', '**/*.mocha.js']);
+    await result.should.have.members(['src/**/*.test.js', 'src/**/*.mocha.js']);
+  });
+  await mochaIt('it handles an empty string base', async function () {
+    const result = await addBasePath('', ['**/*.test.js', '**/*.mocha.js']);
+    await result.should.have.members(['**/*.test.js', '**/*.mocha.js']);
+  });
+  await mochaIt('it handles a . base', async function () {
+    const result = await addBasePath('.', ['**/*.test.js', '**/*.mocha.js']);
+    await result.should.have.members(['**/*.test.js', '**/*.mocha.js']);
+  });
+  await mochaIt('it handles an undefined base', async function () {
+    const result = await addBasePath(undefined, ['**/*.test.js', '**/*.mocha.js']);
+    await result.should.have.members(['**/*.test.js', '**/*.mocha.js']);
+  });
+  await mochaIt('it handles adding a base to a file path', async function () {
+    const result = await addBasePath('base', 'test/file.js');
+    await result.should.equal('base/test/file.js');
+  });
+});

package/dist/cli/lib/addExports.js

@@ -0,0 +1,12 @@
+import { out as mainOut, log, debug, out } from '../../output.js';
+export async function addExports(exports, newProperties, event, from, customOut = undefined) {
+  for (const key in newProperties) {
+    if (key in exports) {
+      const message = `Error loading '${event}' task exports, key '${key}' has already been exported`;
+      await out(message);
+      throw new Error(message);
+    } else {
+      exports[key] = newProperties[key];
+    }
+  }
+}

package/dist/cli/lib/addExports.unitTest.js

@@ -0,0 +1,29 @@
+import { expect } from 'chai';
+import { defaultConfig } from './defaultConfig.js';
+import { addExports } from './addExports.js'; // applyConfigDefaults( userConfig: {} )
+
+import { makeCustomOut } from '../../../unitTesting/makeCustomOut.js';
+await mochaDescribe('addExports() function', async function () {
+  await mochaIt('should add passed properties to a base object', async function () {
+    const exports = {};
+    const newProperties = {
+      a: 1,
+      b: 2
+    };
+    await addExports(exports, newProperties);
+    await exports.should.have.keys(['a', 'b']);
+  });
+  await mochaIt('should complain about duplicates', async function () {
+    //const { customOut, getOutBuffer, setOutBuffer } = makeCustomOut()
+    const exports = {
+      a: 1,
+      b: 2
+    };
+    const newProperties = {
+      a: 3,
+      b: 4
+    };
+    const errorText = 'already been exported';
+    await addExports(exports, newProperties, 'placeholder', 'placeholder').should.be.rejectedWith(errorText);
+  });
+});

package/dist/cli/lib/applyConfigDefaults.js

@@ -0,0 +1,41 @@
+import { mergeStructuredConfig, createTimeProfiler } from 'sxy-dev-tools';
+import { packageName, cliName, configFileName, configLocations, showTimeProfiling } from '../../config.js';
+import chalk from 'chalk-extensions';
+import { out, log, debug } from '../../output.js';
+import { defaultConfig } from './defaultConfig.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function applyConfigDefaults(userConfig) {
+  return await timeProfileAsync('apply config defaults', async () => {
+    const configStructure = {
+      execution: {},
+      watch: {}
+    }; //const config = mergeConfig(configStructure, defaultConfig, userConfig)
+
+    const config = await mergeStructuredConfig(configStructure, defaultConfig, userConfig); // I don't think we need to do these - the glob combine func can handle it
+    //if ( ! Array.isArray(config.tests) ) config.tests = [config.tests]
+    //if ( ! Array.isArray(config.testsIgnore) ) config.tests = [config.testsIgnore]
+    // watchFiles
+    // watchFilesIgnore
+    //log('final config', config)
+
+    return config;
+  });
+}
+
+async function mergeConfig(structure, baseConfig, ...extraConfigs) {
+  const finalConfig = await Object.copy(baseConfig);
+
+  for (const extraConfig of extraConfigs) {
+    for (const key in extraConfig) {
+      if (key in structure) {
+        finalConfig[key] = await mergeConfig(structure[key], finalConfig[key], extraConfig[key]);
+      } else {
+        finalConfig[key] = extraConfig[key];
+      }
+    }
+  }
+
+  return finalConfig;
+}

package/dist/cli/lib/applyConfigDefaults.unitTest.js

@@ -0,0 +1,25 @@
+import { defaultConfig } from './defaultConfig.js';
+import { applyConfigDefaults } from './applyConfigDefaults.js'; // applyConfigDefaults( userConfig: {} )
+
+await mochaDescribe('applyConfigDefaults() function', async function () {
+  await mochaIt('has sensible defaults when passed an empty user config', async function () {
+    const finalConfig = await applyConfigDefaults({});
+    await finalConfig.should.include.keys(['tests', 'testsIgnore', 'watch']);
+  });
+  await mochaIt('retains a passed config setting', async function () {
+    const finalConfig = await applyConfigDefaults({
+      tests: 'foo'
+    }); //console.log(finalConfig)
+
+    await finalConfig.tests.should.equal('foo');
+  });
+  await mochaIt('fills in defaults in a watch object with missing params', async function () {
+    const finalConfig = await applyConfigDefaults({
+      watch: {
+        watchFilesBase: 'src'
+      }
+    }); //console.log(finalConfig)
+
+    await finalConfig.watch.watchFiles.should.equal(defaultConfig.watch.watchFiles);
+  });
+});

package/dist/cli/lib/buildDependencyTree.js

@@ -0,0 +1,32 @@
+import dependencyTree from 'dependency-tree';
+import { out, log, debug } from '../../output.js';
+import slash from 'slash';
+import 'sxy-standard/light.js';
+export async function buildDependencyTree(config, filename) {
+  filename = await slash(filename); // convert to forward slashes
+  // const filter = path => 
+  //    minimatch(path, watchFiles)
+  //    && ! minimatch(path, watchFilesIgnores)
+
+  const dependencyTreeConfig = {
+    filename,
+    isListForm: true,
+    //directory: './src',
+    directory: config.watch.watchFilesBase,
+    filter: path => path.indexOf('node_modules') === -1
+  }; //// this filter needs to be replaced
+
+  const dt = await dependencyTree(dependencyTreeConfig); // process the results into final format
+  // (forward slashes and convert full path to rel path)
+
+  const cwd = await process.cwd();
+  await dt.process(file => slash(file).slice(cwd.length + 1)); // remove the current file
+
+  await dt.forEach(file => {
+    if (file === filename) {
+      dt.remove(file);
+    }
+  });
+  await debug('found dep tree', dt);
+  return dt;
+}

package/dist/cli/lib/buildDependencyTree.unitTest.js

@@ -0,0 +1,15 @@
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { buildDependencyTree } from './buildDependencyTree.js';
+import { join } from 'path'; // buildDependencyTree(config, file)
+// config:
+// file: relative to config.watch.watchFilesBase
+
+await mochaDescribe('buildDependencyTree() function', async function () {
+  await mochaIt('identifies the dependencies for a js file passed to it', async function () {
+    // get the default configs
+    const config = await applyConfigDefaults({});
+    const sampleFile = await join('unitTesting/sampleFiles/c.js');
+    const depTree = await buildDependencyTree(config, sampleFile);
+    await depTree.should.have.members(['unitTesting/sampleFiles/a.js', 'unitTesting/sampleFiles/b.js']);
+  });
+});

package/dist/cli/lib/buildDependencyTrees.js

@@ -0,0 +1,34 @@
+import { loadConfig as sxyLoadConfig, createTimeProfiler } from 'sxy-dev-tools';
+import { packageName, cliName, configFileName, configLocations, showTimeProfiling } from '../../config.js';
+import chalk from 'chalk-extensions';
+import slash from 'slash';
+import { out, log, debug } from '../../output.js';
+import { buildDependencyTree } from './buildDependencyTree.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function buildDependencyTrees(config, testFiles) {
+  return await timeProfileAsync('build dependency trees', async () => {
+    const projectDir = await process.cwd();
+    const dependencyTrees = {};
+
+    for (const testFile of testFiles) {
+      //newTest(testFile.replace('./', ''))
+      const dependencyTree = await buildDependencyTree(config, testFile);
+      dependencyTrees[testFile] = dependencyTree; //    .map ( sync( file => immed(immed(slash(file)).slice(projectDir.length + 1) )) )
+      //    .filter( sync(f => immed(f !== testFile)) )
+
+      await debug('final dep tree', dependencyTrees[testFile]);
+    }
+
+    return dependencyTrees;
+  });
+} // function newTest(testFile) {
+//     debug('new test', testFile)
+//     const dependencyTree = buildDependencyTree(testFile)
+//     //out('AA dependencyTree', testFile, dependencyTree)
+//     dependencyTrees[testFile]
+//         = dependencyTree
+//             .map ( file => slash(file).slice(projectDir.length + 1) )
+//             .filter(f => f !== testFile)
+// }

package/dist/cli/lib/buildDependencyTrees.unitTest.js

@@ -0,0 +1,17 @@
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { buildDependencyTrees } from './buildDependencyTrees.js';
+import { join } from 'path'; // buildDependencyTrees(config, files)
+// config:
+// files: relative to config.watch.watchFilesBase
+
+await mochaDescribe('buildDependencyTrees() function', async function () {
+  await mochaIt('identifies the dependencies for multiple js files', async function () {
+    // get the default configs
+    const config = await applyConfigDefaults({});
+    const sampleFiles = ['unitTesting/sampleFiles/c.js', 'unitTesting/sampleFiles/d.js'];
+    const depTrees = await buildDependencyTrees(config, sampleFiles);
+    await depTrees.should.have.keys(sampleFiles);
+    await depTrees[sampleFiles[0]].should.have.members(['unitTesting/sampleFiles/a.js', 'unitTesting/sampleFiles/b.js']);
+    await depTrees[sampleFiles[1]].should.have.members(['unitTesting/sampleFiles/a.js']);
+  });
+});

package/dist/cli/lib/configBeforeAfterFuncs.js

@@ -0,0 +1,35 @@
+import { runTasks } from './runTasks.js';
+import { addExports } from './addExports.js';
+export async function configBeforeEachFile(config, exports) {
+  if (config.beforeEachFile) {
+    const theExports = await runTasks(config.beforeEachFile, undefined);
+    await addExports(exports, theExports);
+  }
+}
+export async function configAfterEachFile(config, exports) {
+  if (config.afterEachFile) {
+    await runTasks(config.afterEachFile, exports);
+  }
+}
+export async function configBeforeEachDescribe(config, exports) {
+  if (config.beforeEachDescribe) {
+    const theExports = await runTasks(config.beforeEachDescribe, undefined);
+    await addExports(exports, theExports);
+  }
+}
+export async function configAfterEachDescribe(config, exports) {
+  if (config.afterEachDescribe) {
+    await runTasks(config.afterEachDescribe, exports);
+  }
+}
+export async function configBeforeEachTest(config, exports) {
+  if (config.beforeEachTest) {
+    const theExports = await runTasks(config.beforeEachTest, undefined);
+    await addExports(exports, theExports);
+  }
+}
+export async function configAfterEachTest(config, exports) {
+  if (config.afterEachTest) {
+    await runTasks(config.afterEachTest, exports);
+  }
+}

package/dist/cli/lib/defaultConfig.js

@@ -0,0 +1,22 @@
+export const defaultConfig = {
+  testsBase: '.',
+  tests: ['**/*.test.{js,mjs,jsx}', '**/*.spec.{js,mjs,jsx}', '**/tests?/*.{js,mjs,jsx}', '**/__tests?__/*.{js,mjs,jsx}'],
+  testsIgnore: ['node_modules'],
+  showErrorTrace: false,
+  //setup
+  //setupEach
+  //teardown
+  //teardownEach
+  execution: {
+    files: 'parallel',
+    describes: 'sequential',
+    tests: 'sequential'
+  },
+  watch: {
+    watchFilesBase: '.',
+    watchFiles: '**/*',
+    watchFilesIgnore: '**/node_modules/**/*',
+    runAllOnStart: true,
+    reRunFailingTests: true
+  }
+};

package/dist/cli/lib/defaultConfig.test.js

@@ -0,0 +1,7 @@
+import { defaultConfig } from './defaultConfig.js'; // applyConfigDefaults( userConfig: {} )
+
+await mochaDescribe('the defaultConfig', async function () {
+  await mochaIt('has sensible defaults', async function () {
+    await defaultConfig.should.include.keys(['tests', 'testsIgnore', 'watch']);
+  });
+});

package/dist/cli/lib/doUserSetup.js

@@ -0,0 +1,30 @@
+import { join } from 'path';
+import { out, log, debug } from '../../output.js';
+export async function doUserSetup(config) {
+  if (config.setup) {
+    const setupTasks = (await Array.isArray(config.setup)) ? config.setup : [config.setup];
+
+    for (const setupTask of setupTasks) {
+      //console.log( typeof setupTask, setupTask)
+      switch (typeof setupTask) {
+        case 'function':
+          {
+            await setupTask();
+            break;
+          }
+
+        case 'string':
+          {
+            await import(`file://${await join(await process.cwd(), setupTask)}`);
+            break;
+          }
+
+        default:
+          {
+            await out(`Error: setup entry has an invalid type, expected 'function' or 'string' of an file to import.`);
+            await out(`Received ${typeof setupTask}.`);
+          }
+      }
+    }
+  }
+}

package/dist/cli/lib/doUserSetup.unitTest.js

@@ -0,0 +1,39 @@
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { doUserSetup } from './doUserSetup.js'; // applyConfigDefaults( userConfig: {} )
+
+await mochaDescribe('the doUserSetup() function', async function () {
+  await mochaIt('executes a user setup function', async function () {
+    let setupFunctionHasRun = false;
+    const config = await applyConfigDefaults({
+      setup: async function () {
+        setupFunctionHasRun = true;
+      }
+    });
+    await doUserSetup(config);
+    await setupFunctionHasRun.should.equal(true);
+  }), await mochaIt('runs a user specified file', async function () {
+    global.setupFileHasRun = false;
+    const config = await applyConfigDefaults({
+      setup: 'unitTesting/setupFiles/setup.js'
+    });
+    await doUserSetup(config);
+    await global.setupFileHasRun.should.equal(true);
+  }), await mochaIt('runs an array of functions and or files', async function () {
+    let setupFunction1HasRun = false;
+    let setupFunction2HasRun = false;
+    global.setupFile1HasRun = false;
+    global.setupFile2HasRun = false;
+    const config = await applyConfigDefaults({
+      setup: [async function setup1() {
+        setupFunction1HasRun = true;
+      }, async function setup2() {
+        setupFunction2HasRun = true;
+      }, 'unitTesting/setupFiles/setup-1.js', 'unitTesting/setupFiles/setup-2.js']
+    });
+    await doUserSetup(config);
+    await setupFunction1HasRun.should.equal(true);
+    await setupFunction2HasRun.should.equal(true);
+    await global.setupFile1HasRun.should.equal(true);
+    await global.setupFile2HasRun.should.equal(true);
+  });
+});

package/dist/cli/lib/doUserTeardown.js

@@ -0,0 +1,30 @@
+import { join } from 'path';
+import { out, log, debug } from '../../output.js';
+export async function doUserTeardown(config) {
+  if (config.teardown) {
+    const teardownTasks = (await Array.isArray(config.teardown)) ? config.teardown : [config.teardown];
+
+    for (const teardownTask of teardownTasks) {
+      //console.log( typeof teardownTask, teardownTask)
+      switch (typeof teardownTask) {
+        case 'function':
+          {
+            await teardownTask();
+            break;
+          }
+
+        case 'string':
+          {
+            await import(`file://${await join(await process.cwd(), teardownTask)}`);
+            break;
+          }
+
+        default:
+          {
+            await out(`Error: teardown entry has an invalid type, expected 'function' or 'string' of an file to import.`);
+            await out(`Received ${typeof teardownTask}.`);
+          }
+      }
+    }
+  }
+}

package/dist/cli/lib/doUserTeardown.unitTest.js

@@ -0,0 +1,39 @@
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { doUserTeardown } from './doUserTeardown.js'; // applyConfigDefaults( userConfig: {} )
+
+await mochaDescribe('the doUserTeardown() function', async function () {
+  await mochaIt('executes a user teardown function', async function () {
+    let teardownFunctionHasRun = false;
+    const config = await applyConfigDefaults({
+      teardown: async function () {
+        teardownFunctionHasRun = true;
+      }
+    });
+    await doUserTeardown(config);
+    await teardownFunctionHasRun.should.equal(true);
+  }), await mochaIt('runs a user specified file', async function () {
+    global.teardownFileHasRun = false;
+    const config = await applyConfigDefaults({
+      teardown: 'unitTesting/teardownFiles/teardown.js'
+    });
+    await doUserTeardown(config);
+    await global.teardownFileHasRun.should.equal(true);
+  }), await mochaIt('runs an array of functions and or files', async function () {
+    let teardownFunction1HasRun = false;
+    let teardownFunction2HasRun = false;
+    global.teardownFile1HasRun = false;
+    global.teardownFile2HasRun = false;
+    const config = await applyConfigDefaults({
+      teardown: [async function teardown1() {
+        teardownFunction1HasRun = true;
+      }, async function teardown2() {
+        teardownFunction2HasRun = true;
+      }, 'unitTesting/teardownFiles/teardown-1.js', 'unitTesting/teardownFiles/teardown-2.js']
+    });
+    await doUserTeardown(config);
+    await teardownFunction1HasRun.should.equal(true);
+    await teardownFunction2HasRun.should.equal(true);
+    await global.teardownFile1HasRun.should.equal(true);
+    await global.teardownFile2HasRun.should.equal(true);
+  });
+});