sxy-test-runner 1.0.0

package/dist/cli/lib/runTest-old.unitTest.js

@@ -0,0 +1,183 @@
+/*
+import { applyConfigDefaults } from './applyConfigDefaults.js'
+import { loadTestFile } from './loadTestFile.js'
+import { runTest } from './runTest.js'
+
+// loadTestFile(config, testFile) ???
+
+const defaultConfig = applyConfigDefaults({})
+
+const beforeAfterTestFile = 'unitTesting/runTest/beforeAfter.test.js'
+const beforeAfterTest = loadTestFile(defaultConfig, beforeAfterTestFile)
+
+mochaDescribe('runTest() function', function() {
+
+    mochaIt('should run a test that was previously loaded from a test file', function() {
+
+        //const config = applyConfigDefaults({})
+
+        const sampleTestFile = 'unitTesting/runTest/1.test.js'
+        const sampleTest = loadTestFile(defaultConfig, sampleTestFile)
+
+        const testResult = runTest(defaultConfig, sampleTest)
+
+        //console.log(testResult)
+        //console.log(testResult.describeResults[0].itResults)
+        //console.log(testResult.describeResults[0].itResultsSummary)
+
+        testResult.should.include.keys([
+            'file',
+            'success',
+            'describeResults',
+            'describeResultsSummary'
+        ])
+
+        testResult.success.should.equal(true)
+
+        testResult.describeResultsSummary.total.should.equal(1)
+        testResult.describeResultsSummary.passes.should.equal(1)
+        testResult.describeResultsSummary.itsTotal.should.equal(1)
+        testResult.describeResultsSummary.itsPasses.should.equal(1)
+
+    })
+
+    mochaIt("should run beforeEachFile tasks (before - can't test)", function() {
+
+        let functionHasRun = false
+        global.beforeEachFileFileHasRun = false
+
+        const ourConfig = {
+            beforeEachFile: [
+                function() {
+                    functionHasRun = true
+                },
+                'unitTesting/runTest/beforeEachFile.js'
+            ]
+        }
+
+        const config = applyConfigDefaults(ourConfig)
+        
+        runTest(config, beforeAfterTest)
+
+        functionHasRun.should.equal(true)
+        global.beforeEachFileFileHasRun.should.equal(true)
+
+    })
+    
+    mochaIt("should run afterEachFile tasks (after - can't test)", function() {
+
+        let functionHasRun = false
+        global.afterEachFileFileHasRun = false
+
+        const ourConfig = {
+            afterEachFile: [
+                function() {
+                    functionHasRun = true
+                },
+                'unitTesting/runTest/afterEachFile.js'
+            ]
+        }
+
+        const config = applyConfigDefaults(ourConfig)
+
+        runTest(config, beforeAfterTest)
+
+        functionHasRun.should.equal(true)
+        global.afterEachFileFileHasRun.should.equal(true)
+
+    })
+
+    mochaIt("should run beforeEachDescribe tasks (before - can't test) each describe block", function() {
+
+        let functionHasRunTimes = 0
+        global.beforeEachDescribeFileHasRun = false
+
+        const ourConfig = {
+            beforeEachDescribe: [
+                function() {
+                    functionHasRunTimes++
+                },
+                'unitTesting/runTest/beforeEachDescribe.js'
+            ]
+        }
+
+        const config = applyConfigDefaults(ourConfig)
+        
+        runTest(config, beforeAfterTest)
+
+        functionHasRunTimes.should.equal(2)
+        global.beforeEachDescribeFileHasRun.should.equal(true)
+
+    })
+
+    mochaIt("should run afterEachDescribe tasks (after - can't test) each describe block", function() {
+
+        let functionHasRunTimes = 0
+        global.afterEachDescribeFileHasRun = false
+
+        const ourConfig = {
+            afterEachDescribe: [
+                function() {
+                    functionHasRunTimes++
+                },
+                'unitTesting/runTest/afterEachDescribe.js'
+            ]
+        }
+
+        const config = applyConfigDefaults(ourConfig)
+        
+        runTest(config, beforeAfterTest)
+
+        functionHasRunTimes.should.equal(2)
+        global.afterEachDescribeFileHasRun.should.equal(true)
+
+    })
+
+    mochaIt("should run beforeEachTest tasks (before - can't test) each test/it block", function() {
+
+        let functionHasRunTimes = 0
+        global.beforeEachTestbeforeEachFileFileHasRun = false
+
+        const ourConfig = {
+            beforeEachTest: [
+                function() {
+                    functionHasRunTimes++
+                },
+                'unitTesting/runTest/beforeEachTest.js'
+            ]
+        }
+
+        const config = applyConfigDefaults(ourConfig)
+        
+        runTest(config, beforeAfterTest)
+
+        functionHasRunTimes.should.equal(3)
+        global.beforeEachTestFileHasRun.should.equal(true)
+
+    })
+
+    mochaIt("should run afterEachTest tasks (after - can't test) each test/it block", function() {
+
+        let functionHasRunTimes = 0
+        global.afterEachTestFileFileHasRun = false
+
+        const ourConfig = {
+            afterEachTest: [
+                function() {
+                    functionHasRunTimes++
+                },
+                'unitTesting/runTest/afterEachTest.js'
+            ]
+        }
+
+        const config = applyConfigDefaults(ourConfig)
+        
+        runTest(config, beforeAfterTest)
+
+        functionHasRunTimes.should.equal(3)
+        global.afterEachTestFileHasRun.should.equal(true)
+
+    })
+    
+})
+*/

package/dist/cli/lib/runTest.js

@@ -0,0 +1,71 @@
+import { createTimeProfiler } from 'sxy-dev-tools'; //import chalk from 'chalk-extensions'
+
+import { out, log, debug } from '../../output.js';
+import { showTimeProfiling } from '../../config.js';
+import { runTasks } from './runTasks.js';
+import { addExports } from './addExports.js';
+import { runDescribe } from './runDescribe.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function runTest(config, test) {
+  return await timeProfileAsync(`run test ${test.file}`, async () => {
+    await debug('test', test); // run before test file
+
+    const fileExports = {};
+    await configBeforeEachFile(config, fileExports); // const beforeEachFileExports = (config.beforeEachFile)
+    //     ? runTasks(config, config.beforeEachFile)
+    //     : {}
+    //const describeCounter = 1
+
+    const runDescribePromises = [];
+
+    for (const describe of test.describes) {
+      await runDescribePromises.push(runDescribe(config, describe));
+      if (config.execution.describes === 'sequential') await runDescribePromises.at(-1);
+    } //console.log('runDescribePromises', runDescribePromises)
+
+
+    const describeResults = await Promise.all(runDescribePromises); //console.log('describeResults', describeResults)
+
+    const describeResultsSummary = {
+      total: 0,
+      passes: 0,
+      invalid: 0,
+      itsTotal: 0,
+      itsPasses: 0
+    };
+
+    for (const describeResult of describeResults) {
+      describeResultsSummary.total += +(describeResult.success !== null);
+      describeResultsSummary.passes += +describeResult.success;
+      describeResultsSummary.invalid += +(describeResult.success === null);
+      describeResultsSummary.itsTotal += describeResult.itResultsSummary.total;
+      describeResultsSummary.itsPasses += describeResult.itResultsSummary.passes;
+    }
+
+    const testResults = {
+      file: test.file,
+      success: describeResultsSummary.total > 0 ? describeResultsSummary.total === describeResultsSummary.passes : null,
+      describeResults,
+      describeResultsSummary,
+      logs: test.logs
+    }; // run after test
+
+    await configAfterEachFile(config, fileExports);
+    return testResults;
+  });
+}
+
+async function configBeforeEachFile(config, exports) {
+  if (config.beforeEachFile) {
+    const theExports = await runTasks(config.beforeEachFile, undefined);
+    await addExports(exports, theExports);
+  }
+}
+
+async function configAfterEachFile(config, exports) {
+  if (config.afterEachFile) {
+    await runTasks(config.afterEachFile, exports);
+  }
+}

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

@@ -0,0 +1,269 @@
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { loadTestFile } from './loadTestFile.js';
+import { runTest } from './runTest.js';
+const defaultConfig = await applyConfigDefaults({});
+const beforeAfterTestFile = 'unitTesting/runTest/beforeAfter.test.js';
+const beforeAfterTest = await loadTestFile(defaultConfig, beforeAfterTestFile);
+await mochaDescribe('runTest() function', async function () {
+  await mochaIt('should run a test that was previously loaded from a test file', async function () {
+    //const config = applyConfigDefaults({})
+    const sampleTestFile = 'unitTesting/runTest/1.test.js';
+    const sampleTest = await loadTestFile(defaultConfig, sampleTestFile);
+    const testResult = await runTest(defaultConfig, sampleTest); //console.log(testResult)
+    //console.log(testResult.describeResults[0].itResults)
+    //console.log(testResult.describeResults[0].itResultsSummary)
+
+    await testResult.should.include.keys(['file', 'success', 'describeResults', 'describeResultsSummary']);
+    await testResult.success.should.equal(true);
+    await testResult.describeResultsSummary.total.should.equal(1);
+    await testResult.describeResultsSummary.passes.should.equal(1);
+    await testResult.describeResultsSummary.itsTotal.should.equal(1);
+    await testResult.describeResultsSummary.itsPasses.should.equal(1);
+  });
+  await mochaIt('should return sensible results from a test file without any describes', async function () {
+    //const config = applyConfigDefaults({})
+    const sampleTestFile = 'unitTesting/sampletests/blank.test.js';
+    const sampleTest = await loadTestFile(defaultConfig, sampleTestFile);
+    const testResult = await runTest(defaultConfig, sampleTest); //console.log(testResult)
+    //console.log(testResult.describeResults[0].itResults)
+    //console.log(testResult.describeResults[0].itResultsSummary)
+
+    await testResult.should.include.keys(['file', 'success', 'describeResults', 'describeResultsSummary']);
+    (await chaiExpect(testResult.success)).to.be.null; //testResult.describeResultsSummary.total.should.equal(1)
+    //testResult.describeResultsSummary.passes.should.equal(1)
+    //testResult.describeResultsSummary.itsTotal.should.equal(1)
+    //testResult.describeResultsSummary.itsPasses.should.equal(1)
+  });
+  await mochaIt('should return sensible results from a test file with describes without any its/tests', async function () {
+    //const config = applyConfigDefaults({})
+    const sampleTestFile = 'unitTesting/sampletests/describesWithoutTests.test.js';
+    const sampleTest = await loadTestFile(defaultConfig, sampleTestFile);
+    const testResult = await runTest(defaultConfig, sampleTest); //console.log(testResult)
+    //console.log(testResult.describeResults[0].itResults)
+    //console.log(testResult.describeResults[0].itResultsSummary)
+
+    await testResult.should.include.keys(['file', 'success', 'describeResults', 'describeResultsSummary']);
+    (await chaiExpect(testResult.success)).to.be.null;
+    await testResult.describeResultsSummary.total.should.equal(0);
+    await testResult.describeResultsSummary.passes.should.equal(0);
+    await testResult.describeResultsSummary.invalid.should.equal(2);
+    await testResult.describeResultsSummary.itsTotal.should.equal(0);
+    await testResult.describeResultsSummary.itsPasses.should.equal(0);
+  });
+  await mochaIt("should run beforeEachFile tasks (before - can't test)", async function () {
+    let functionHasRun = false;
+    global.beforeEachFileFileHasRun = false;
+    const ourConfig = {
+      beforeEachFile: [async function () {
+        functionHasRun = true;
+      }, 'unitTesting/runTest/beforeEachFile.js']
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, beforeAfterTest);
+    await functionHasRun.should.equal(true);
+    await global.beforeEachFileFileHasRun.should.equal(true);
+  });
+  await mochaIt("should run afterEachFile tasks (after - can't test)", async function () {
+    let functionHasRun = false;
+    global.afterEachFileFileHasRun = false;
+    const ourConfig = {
+      afterEachFile: [async function () {
+        functionHasRun = true;
+      }, 'unitTesting/runTest/afterEachFile.js']
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, beforeAfterTest);
+    await functionHasRun.should.equal(true);
+    await global.afterEachFileFileHasRun.should.equal(true);
+  });
+  await mochaIt("should run beforeEachDescribe tasks (before - can't test) each describe block", async function () {
+    let functionHasRunTimes = 0;
+    global.beforeEachDescribeFileHasRun = false;
+    const ourConfig = {
+      beforeEachDescribe: [async function () {
+        functionHasRunTimes++;
+      }, 'unitTesting/runTest/beforeEachDescribe.js']
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, beforeAfterTest);
+    await functionHasRunTimes.should.equal(2);
+    await global.beforeEachDescribeFileHasRun.should.equal(true);
+  });
+  await mochaIt("should run afterEachDescribe tasks (after - can't test) each describe block", async function () {
+    let functionHasRunTimes = 0;
+    global.afterEachDescribeFileHasRun = false;
+    const ourConfig = {
+      afterEachDescribe: [async function () {
+        functionHasRunTimes++;
+      }, 'unitTesting/runTest/afterEachDescribe.js']
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, beforeAfterTest);
+    await functionHasRunTimes.should.equal(2);
+    await global.afterEachDescribeFileHasRun.should.equal(true);
+  });
+  await mochaIt("should run beforeEachTest tasks (before - can't test) each test/it block", async function () {
+    let functionHasRunTimes = 0;
+    global.beforeEachTestbeforeEachFileFileHasRun = false;
+    const ourConfig = {
+      beforeEachTest: [async function () {
+        functionHasRunTimes++;
+      }, 'unitTesting/runTest/beforeEachTest.js']
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, beforeAfterTest);
+    await functionHasRunTimes.should.equal(3);
+    await global.beforeEachTestFileHasRun.should.equal(true);
+  });
+  await mochaIt("should run afterEachTest tasks (after - can't test) each test/it block", async function () {
+    let functionHasRunTimes = 0;
+    global.afterEachTestFileFileHasRun = false;
+    const ourConfig = {
+      afterEachTest: [async function () {
+        functionHasRunTimes++;
+      }, 'unitTesting/runTest/afterEachTest.js']
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, beforeAfterTest);
+    await functionHasRunTimes.should.equal(3);
+    await global.afterEachTestFileHasRun.should.equal(true);
+  }); // exports provision to test file
+  // current beforeEachFile exports aren't provided
+  // perhaps extend sxy-loader to allow this
+
+  await mochaIt("should pass exported/returned data from beforeEachDescribe tasks", async function () {
+    const testFile = 'unitTesting/runTest/beforeEachDescribe.test.js';
+    const test = await loadTestFile(defaultConfig, testFile);
+    const ourConfig = {
+      beforeEachDescribe: [async function () {
+        return {
+          functionThing: 'foo'
+        };
+      }, 'unitTesting/runTest/beforeEachDescribeExport.js']
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, test);
+    await global.functionThing.should.equal('foo');
+    await global.fileThing.should.equal('bar');
+  });
+  await mochaIt("should pass exported/returned data from beforeEachTest tasks", async function () {
+    const testFile = 'unitTesting/runTest/beforeEachTest.test.js';
+    const test = await loadTestFile(defaultConfig, testFile);
+    const ourConfig = {
+      beforeEachTest: [async function () {
+        return {
+          functionThing: 'foo'
+        };
+      }, 'unitTesting/runTest/beforeEachTestExport.js']
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, test);
+    await global.functionThing.should.equal('foo');
+    await global.fileThing.should.equal('bar');
+  }); // exports pass through
+
+  await mochaIt("beforeEachFile exports are passed through to afterEachFile", async function () {
+    // don't try to reload test, fails due to module caching
+    //const testFile = 'unitTesting/runTest/beforeAfter.test.js'
+    //const test = loadTestFile(defaultConfig, testFile)
+    let exports;
+    const ourConfig = {
+      beforeEachFile: [async function () {
+        return {
+          functionThing: 'foo'
+        };
+      }, 'unitTesting/runTest/beforeEachExport.js'],
+      afterEachFile: [async function (theExports) {
+        await theExports.should.have.keys(['functionThing', 'fileThing']);
+        exports = theExports;
+      }]
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, beforeAfterTest);
+    await exports.functionThing.should.equal('foo');
+    await exports.fileThing.should.equal('bar');
+  });
+  await mochaIt("beforeEachDescribe exports are passed through to afterEachDescribe", async function () {
+    // don't try to reload test, fails due to module caching
+    //const testFile = 'unitTesting/runTest/beforeAfter.test.js'
+    //const test = loadTestFile(defaultConfig, testFile)
+    let exports;
+    const ourConfig = {
+      beforeEachDescribe: [async function () {
+        return {
+          functionThing: 'foo'
+        };
+      }, 'unitTesting/runTest/beforeEachExport.js'],
+      afterEachDescribe: [async function (theExports) {
+        exports = theExports;
+      }]
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, beforeAfterTest); //console.log('exports', exports)
+
+    await exports.functionThing.should.equal('foo');
+    await exports.fileThing.should.equal('bar');
+  });
+  await mochaIt("beforeEachTest exports are passed through to afterEachTest", async function () {
+    // don't try to reload test, fails due to module caching
+    //const testFile = 'unitTesting/runTest/beforeAfter.test.js'
+    //const test = loadTestFile(defaultConfig, testFile)
+    let exports;
+    const ourConfig = {
+      beforeEachTest: [async function () {
+        return {
+          functionThing: 'foo'
+        };
+      }, 'unitTesting/runTest/beforeEachExport.js'],
+      afterEachTest: [async function (theExports) {
+        exports = theExports;
+      }]
+    };
+    const config = await applyConfigDefaults(ourConfig);
+    await runTest(config, beforeAfterTest); //console.log('exports', exports)
+
+    await exports.functionThing.should.equal('foo');
+    await exports.fileThing.should.equal('bar');
+  });
+  await mochaIt("we can run code beforeEachTest and afterEachTest from within the test file", async function () {
+    // don't try to reload test, fails due to module caching
+    const testFile = 'unitTesting/runTest/internalBeforeAfterEachTest.test.js';
+    const test = await loadTestFile(defaultConfig, testFile);
+    const config = await applyConfigDefaults({});
+    global.internalBeforeEachTestRanNTimes = 0;
+    global.internalAfterEachTestRanNTimes = 0;
+    await runTest(config, test);
+    await global.internalBeforeAfterEachTest_test1Valid.should.equal(true);
+    await global.internalBeforeAfterEachTest_test2Valid.should.equal(true);
+    await global.internalBeforeAfterEachTest_test3Valid.should.equal(true);
+    await global.internalBeforeEachTestRanNTimes.should.equal(3);
+    await global.internalAfterEachTestRanNTimes.should.equal(3);
+  });
+  await mochaIt("we can run code afterDescribe from within descibe in the test file", async function () {
+    // don't try to reload test, fails due to module caching
+    const testFile = 'unitTesting/runTest/internalAfterDescribeTest.test.js';
+    const test = await loadTestFile(defaultConfig, testFile);
+    const config = await applyConfigDefaults({});
+    global.internalAfterDescribeRanNTimes = 0;
+    await runTest(config, test); //global.internalAfterDescribe_test1Valid.should.equal(true)
+    //global.internalAfterDescribe_test2Valid.should.equal(true)
+
+    await global.internalAfterDescribeRanNTimes.should.equal(2);
+  });
+  await mochaIt('should capture and returns logs from the test when using sequential execution', async function () {
+    const config = await applyConfigDefaults({
+      execution: {
+        files: 'sequential',
+        describes: 'sequential',
+        tests: 'sequential'
+      }
+    });
+    const sampleTestFile = 'unitTesting/sampleTests/logging.test.js';
+    const sampleTest = await loadTestFile(config, sampleTestFile);
+    const testResult = await runTest(config, sampleTest);
+    await testResult.describeResults[0].logs.length.should.equal(1);
+    await testResult.describeResults[0].itResults[0].logs.length.should.equal(1);
+  }); // mochaIt('should not capture logs when not running in sequential mode', function() {
+  //     throw new Error('to do')
+  // })
+});

package/dist/cli/lib/runTests.js

@@ -0,0 +1,137 @@
+import { createTimeProfiler } from 'sxy-dev-tools';
+import { showTimeProfiling } from '../../config.js';
+import chalk from 'chalk-extensions';
+import { out as mainOut, log, debug } from '../../output.js';
+import { join } from 'path';
+import figures from 'figures'; //import { testsState } from '../../testsState.js'
+
+import 'sxy-standard';
+import { loadTestFile } from './loadTestFile.js';
+import { runTest } from './runTest.js';
+import { showTestLoadingError } from './showTestLoadingError.js';
+import { showTestResult } from './showTestResult.js';
+import { load } from './load.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function runTests(config, testFiles, failingTests, customOut = undefined) {
+  await debug('runTests failingTests', failingTests);
+  const tests = {};
+  const testRunPromises = {};
+  const erroringTests = {};
+  const testRunOutPromises = {}; // exp
+
+  await timeProfileAsync('run tests', async () => {
+    const projectDir = await process.cwd(); ////out(``) // spacer before tests output
+
+    if (testFiles.length > 0) {
+      // clear load cache to allow accesing the new tets
+      await load.cache.clear();
+
+      for (const testFile of testFiles) {
+        const test = await loadTestFile(config, testFile);
+
+        if (test.error) {
+          erroringTests[testFile] = test;
+          await showTestLoadingError(config, test);
+        } else {
+          await debug('test', test);
+          const testRunPromise = runTest(config, test, customOut);
+          testRunPromises[testFile] = testRunPromise;
+          testRunOutPromises[testFile] = testRunPromise.then(async testResult => {
+            if (testResult.success === true || testResult.success === null) {
+              if (await failingTests.includes(testResult.file)) {
+                await failingTests.remove(testResult.file);
+              }
+            } else {
+              if (!(await failingTests.includes(testResult.file))) {
+                await failingTests.push(testResult.file);
+              }
+            }
+
+            await showTestResult(config, testResult, customOut);
+          }); // wait for the test to complete before proceeding if we are in 'sequential' mode
+
+          if (config.execution.files === 'sequential') await testRunOutPromises[testFile];
+        }
+      }
+    }
+  });
+  let runTestResults = {};
+  await timeProfileAsync('wait for tests to finish', async () => {
+    runTestResults = await Promise.allObj(testRunPromises); // wait for the output to complete
+
+    await Promise.allObj(testRunOutPromises);
+  });
+  await timeProfileAsync('show initial test run results', async () => {
+    const out = customOut ? async (...texts) => await customOut(...texts) : async (...texts) => await mainOut(...texts);
+    const testsResultsSummary = {
+      total: 0,
+      passes: 0,
+      invalid: 0,
+      describesTotal: 0,
+      describesPasses: 0,
+      describesInvalid: 0,
+      itsTotal: 0,
+      itsPasses: 0 // itsInvalid: 0 // we don't check whether tests run any asserts (we don't control the assertion lib)
+
+    }; //console.log('runTestResults', runTestResults)
+
+    for (const testFile in runTestResults) {
+      const runTestResult = runTestResults[testFile]; //console.log('runTestResult', runTestResult)
+
+      testsResultsSummary.total += +(runTestResult.success !== null);
+      testsResultsSummary.passes += +runTestResult.success;
+      testsResultsSummary.invalid += +(runTestResult.success === null);
+      testsResultsSummary.describesTotal += +runTestResult.describeResultsSummary.total;
+      testsResultsSummary.describesPasses += +runTestResult.describeResultsSummary.passes;
+      testsResultsSummary.describesInvalid += +runTestResult.describeResultsSummary.invalid;
+      testsResultsSummary.itsTotal += +runTestResult.describeResultsSummary.itsTotal;
+      testsResultsSummary.itsPasses += +runTestResult.describeResultsSummary.itsPasses; //testsResultsSummary.itsInvalid += +runTestResult.describeResultsSummary.itsInvalid // see comment above, not doing invalid tests
+    } //console.log('testsResultsSummary', testsResultsSummary)
+
+
+    await out(`\n`);
+
+    if (testsResultsSummary.itsPasses === testsResultsSummary.itsTotal) {
+      await out(await chalk.mediumgreen(`${figures.tick}`));
+    } else {
+      await out(await chalk.mediumred(`${figures.cross}`));
+    } // number of tests successful
+
+
+    const testsText = `Tests: ${testsResultsSummary.itsPasses}/${testsResultsSummary.itsTotal}`;
+
+    if (testsResultsSummary.itsPasses === testsResultsSummary.itsTotal) {
+      await out(await chalk.mediumgreen(`${testsText}`
+      /* ${figures.tick}`*/
+      ));
+    } else {
+      await out(await chalk.mediumred(`${testsText}`
+      /* ${figures.cross}`*/
+      ));
+    } // number of items successful
+
+
+    const describesText = `Items: ${testsResultsSummary.describesPasses}/${testsResultsSummary.describesTotal}`;
+    const invalidDescribesText = testsResultsSummary.describesInvalid >= 1 ? testsResultsSummary.describesInvalid === 1 ? await chalk.grey(`(1 describe without tests)`) : await chalk.grey(`(${testsResultsSummary.describesInvalid} describes without tests)`) : '';
+
+    if (testsResultsSummary.describesPasses === testsResultsSummary.describesTotal) {
+      await out((await chalk.mediumgreen(`${describesText}`)) + ' ' + invalidDescribesText);
+    } else {
+      await out((await chalk.mediumred(`${describesText}`)) + ' ' + invalidDescribesText);
+    } // number of test files successful
+
+
+    const testFilesText = `Test Files: ${testsResultsSummary.passes}/${testsResultsSummary.total}`;
+    const invalidTestFilesText = testsResultsSummary.invalid >= 1 ? testsResultsSummary.invalid === 1 ? await chalk.grey(`(1 file without tests)`) : await chalk.grey(`(${testsResultsSummary.invalid} files without tests)`) : '';
+
+    if (testsResultsSummary.passes === testsResultsSummary.total) {
+      await out((await chalk.mediumgreen(`${testFilesText}`)) + ' ' + invalidTestFilesText);
+    } else {
+      await out((await chalk.mediumred(`${testFilesText}`)) + ' ' + invalidTestFilesText);
+    }
+
+    await out(chalk.orange`To do: account for tests with loading errors`); // out(``)
+  });
+}