sxy-test-runner 1.0.0

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

@@ -0,0 +1,59 @@
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { runTests } from './runTests.js'; // runTests(config, testFiles, failingTests)
+
+await mochaDescribe('runTests() function', async function () {
+  await mochaIt('should run provided test files and produce an output of results', async function () {
+    // create a custom out function to capture the output
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+    };
+
+    const config = await applyConfigDefaults({});
+    const testFiles = ['unitTesting/sampleTests/1.test.js'];
+    const results = await runTests(config, testFiles, [], customOut); //console.log(results)
+    //console.log(outBuffer)
+
+    await outBuffer.should.include('1 should equal 1');
+    await outBuffer.should.include('Tests: 1/1');
+    await outBuffer.should.include('Items: 1/1');
+    await outBuffer.should.include('Test Files: 1/1');
+  });
+  await mochaIt('should sensibly handle tallies when test files with no describes are included', async function () {
+    // create a custom out function to capture the output
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+    };
+
+    const config = await applyConfigDefaults({});
+    const testFiles = ['unitTesting/sampleTests/1.test.js', 'unitTesting/sampleTests/blank.test.js', 'unitTesting/sampleTests/describesWithoutTests.test.js'];
+    const results = await runTests(config, testFiles, [], customOut); //console.log(results)
+    //console.log(outBuffer)
+
+    await outBuffer.should.include('1 should equal 1');
+    await outBuffer.should.include('Tests: 1/1');
+    await outBuffer.should.include('Items: 1/1');
+    await outBuffer.should.include('(2 describes without tests)');
+    await outBuffer.should.include('Test Files: 1/1');
+    await outBuffer.should.include('(2 files without tests)');
+  });
+  await mochaIt('runs test files sequentially in test mode', async function () {
+    // create a custom out function to capture the output
+    // let outBuffer = ''
+    // const customOut = sync((...texts) => {
+    //     outBuffer += texts.join(' ') + '\n' // join and save to the buffer
+    // })
+    const config = await applyConfigDefaults({
+      execution: {
+        files: 'sequential'
+      }
+    });
+    const testFiles = ['unitTesting/runTests/sequential/1.test.js', 'unitTesting/runTests/sequential/2.test.js'];
+    const results = await runTests(config, testFiles, []);
+    global.sequential1Status.should.be.true;
+    global.sequential2Status.should.be.true;
+  });
+});

package/dist/cli/lib/showTestLoadingError.js

@@ -0,0 +1,22 @@
+import { createTimeProfiler } from 'sxy-dev-tools';
+import { packageName, cliName, configFileName, configLocations, showTimeProfiling } from '../../config.js';
+import chalk from 'chalk-extensions';
+import { out as mainOut, log, debug } from '../../output.js';
+import figures from 'figures'; //import { testsState } from '../../testsState.js'
+
+import 'sxy-standard/light.js';
+import { indexNumberToLetters } from '../../indexNumberToLetters.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function showTestLoadingError(config, test, customOut = undefined) {
+  await debug('customOut', customOut);
+  const out = customOut ? async (...texts) => await customOut(...texts) : async (...texts) => await mainOut(...texts); //console.log('testResult', testResult)
+
+  await timeProfileAsync('show test loading error', () => {
+    out();
+    out(chalk.grey`File ${test.file}`);
+    out(chalk.mediumred`Loading error: ${test.error}`);
+    out();
+  });
+}

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

@@ -0,0 +1,25 @@
+import { defaultConfig } from './defaultConfig.js';
+import { showTestLoadingError } from './showTestLoadingError.js';
+import { expect } from 'chai'; // showTestLoadingError(config, test) ???
+
+await mochaDescribe('showTestLoadingError() function', async function () {
+  await mochaIt('should show the loading error of a test after loading failure', async function () {
+    const config = defaultConfig;
+    const test = {
+      file: 'foo.js',
+      error: 'There was an error'
+    }; // create a custom out function to capture the output
+
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      //console.log('custom out received:', ...texts)
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+      //console.log('outBuffer:', outBuffer)
+    };
+
+    await showTestLoadingError(config, test, customOut);
+    await console.log(outBuffer);
+    await outBuffer.should.include(test.error);
+  });
+});

package/dist/cli/lib/showTestResult.js

@@ -0,0 +1,87 @@
+import { createTimeProfiler } from 'sxy-dev-tools';
+import { packageName, cliName, configFileName, configLocations, showTimeProfiling } from '../../config.js';
+import chalk from 'chalk-extensions';
+import { out as mainOut, log, debug } from '../../output.js';
+import figures from 'figures'; //import { testsState } from '../../testsState.js'
+
+import 'sxy-standard/light.js';
+import { indexNumberToLetters } from '../../indexNumberToLetters.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function showTestResult(config, testResult, customOut = undefined) {
+  await debug('customOut', customOut);
+  const out = customOut ? async (...texts) => await customOut(...texts) : async (...texts) => await mainOut(...texts); //console.log('testResult', testResult)
+
+  await timeProfileAsync('show test result', () => {
+    out();
+    out(chalk.grey`File ${testResult.file}`);
+    const indent = '    ';
+
+    if (testResult.logs.length > 0) {
+      out();
+      out(indent + chalk.grey`console.logs:`);
+      testResult.logs.forEach(async log => {
+        log[0] = indent + log[0];
+        await out(...log);
+      });
+      out();
+    }
+
+    let first = true;
+
+    for (const describeResult of testResult.describeResults) {
+      if (!first) out();
+      first = false;
+      out(chalk.lightgrey`${describeResult.counter}) describing ` + chalk.brightblue(describeResult.thing));
+      out();
+
+      if (describeResult.logs.length > 0) {
+        out(indent + chalk.grey`console.logs:`);
+        describeResult.logs.forEach(async log => {
+          log[0] = indent + log[0];
+          await out(...log);
+        });
+        out();
+      }
+
+      for (const itResult of describeResult.itResults) {
+        //console.log('itResult', itResult)
+        const letters = indexNumberToLetters(itResult.counter);
+
+        if (itResult.success) {
+          out(chalk.lightgrey`${indent}${letters})` + chalk.mediumgreen`  ${figures.tick}  ${itResult.should}`);
+        } else {
+          out(chalk.lightgrey`${indent}${letters})` + chalk.mediumred`  ${figures.cross}  ${itResult.should}`);
+          out();
+          const spacer = `${indent}${' '.repeat(letters.length)}   `;
+
+          if ('actual' in itResult.error && 'expected' in itResult.error) {
+            out(chalk.mediumred(`${spacer}${itResult.error.name}: ${itResult.error.message}` //+ `\n${spacer}expected: ${itResult.error.expected}`
+            //+ `\n${spacer}received: ${itResult.error.actual}`
+            ));
+          } else {
+            out(chalk.mediumred(`${spacer}${itResult.error.name}: ${itResult.error.message}`));
+          } // stack trace
+
+
+          if (config.showErrorTrace) {
+            out();
+            out(chalk.grey(itResult.error.stack));
+          }
+        }
+
+        out();
+
+        if (itResult.logs.length > 0) {
+          out(indent + indent + chalk.grey`console.logs:`);
+          itResult.logs.forEach(async log => {
+            log[0] = indent + indent + log[0];
+            await out(...log);
+          });
+          out();
+        }
+      }
+    }
+  });
+}

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

@@ -0,0 +1,180 @@
+import { defaultConfig } from './defaultConfig.js';
+import { showTestResult } from './showTestResult.js';
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { loadTestFile } from './loadTestFile.js';
+import { runTest } from './runTest.js'; // loadTestFile(config, testFile) ???
+
+await mochaDescribe('showTestResult() function', async function () {
+  await mochaIt('should show the result of a single test that has been run', async function () {
+    const config = defaultConfig;
+    const sampleTestResult = {
+      file: 'unitTesting/sampleTests/1.test.js',
+      success: true,
+      describeResults: [{
+        counter: 1,
+        thing: 'Sample test 1',
+        success: true,
+        itResults: [{
+          counter: 1,
+          should: '1 should equal 1',
+          success: true,
+          time: 1,
+          error: undefined
+        }],
+        itResultsSummary: {
+          total: 1,
+          passes: 1
+        }
+      }],
+      describeResultsSummary: {
+        total: 1,
+        passes: 1,
+        itsTotal: 1,
+        itsPasses: 1
+      }
+    }; // create a custom out function to capture the output
+
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      //console.log('custom out received:', ...texts)
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+      //console.log('outBuffer:', outBuffer)
+    };
+
+    await showTestResult(config, sampleTestResult, customOut); //console.log(outBuffer)
+
+    await outBuffer.should.include(sampleTestResult.file); //console.log('---', sampleTestResult.describeResults[0].thing)
+
+    await outBuffer.should.include(sampleTestResult.describeResults[0].thing);
+    await outBuffer.should.include(sampleTestResult.describeResults[0].itResults[0].should);
+  });
+  await mochaIt('should show the result of a test with an error', async function () {
+    const config = defaultConfig;
+    let error;
+
+    try {
+      await (await chaiExpect(1)).to.equal(2);
+    } catch (e) {
+      error = e;
+    }
+
+    const sampleTestResult = {
+      file: 'unitTesting/sampleTests/1.test.js',
+      success: true,
+      describeResults: [{
+        counter: 1,
+        thing: 'Sample test 1',
+        success: true,
+        itResults: [{
+          counter: 1,
+          should: '1 should equal 2',
+          success: false,
+          error
+        }],
+        itResultsSummary: {
+          total: 1,
+          passes: 1
+        }
+      }],
+      describeResultsSummary: {
+        total: 1,
+        passes: 1,
+        itsTotal: 1,
+        itsPasses: 1
+      }
+    }; // create a custom out function to capture the output
+
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      //console.log('custom out received:', ...texts)
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+      //console.log('outBuffer:', outBuffer)
+    };
+
+    await showTestResult(config, sampleTestResult, customOut); //console.log(outBuffer)
+
+    await outBuffer.should.include('AssertionError');
+    await outBuffer.should.include('expected 1 to equal 2');
+  });
+  await mochaIt('shows test results including captured log output', async function () {
+    const config = defaultConfig;
+    const sampleTestResult = {
+      file: 'unitTesting/sampleTests/1.test.js',
+      success: true,
+      describeResults: [{
+        counter: 1,
+        thing: 'Sample test 1',
+        success: true,
+        logs: [['foo']],
+        itResults: [{
+          counter: 1,
+          should: '1 should equal 1',
+          success: true,
+          time: 1,
+          error: undefined,
+          logs: [['bar']]
+        }],
+        itResultsSummary: {
+          total: 1,
+          passes: 1
+        }
+      }],
+      describeResultsSummary: {
+        total: 1,
+        passes: 1,
+        itsTotal: 1,
+        itsPasses: 1
+      }
+    }; // create a custom out function to capture the output
+
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      //console.log('custom out received:', ...texts)
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+      //console.log('outBuffer:', outBuffer)
+    };
+
+    await showTestResult(config, sampleTestResult, customOut); //console.log(outBuffer)
+
+    await outBuffer.should.include(sampleTestResult.file); //console.log('---', sampleTestResult.describeResults[0].thing)
+
+    await outBuffer.should.include(sampleTestResult.describeResults[0].thing);
+    await outBuffer.should.include('foo');
+    await outBuffer.should.include(sampleTestResult.describeResults[0].itResults[0].should);
+    await outBuffer.should.include('bar');
+  });
+  await mochaIt('shows test results including captured log output with a complex file', 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); // create a custom out function to capture the output
+
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      //console.log('custom out received:', ...texts)
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+      //console.log('outBuffer:', outBuffer)
+    };
+
+    await showTestResult(config, testResult, customOut);
+    await console.log(outBuffer);
+    await outBuffer.should.include(testResult.file); //console.log('---', sampleTestResult.describeResults[0].thing)
+
+    await outBuffer.should.include(testResult.describeResults[0].thing);
+    await outBuffer.should.include(testResult.describeResults[0].itResults[0].should);
+    await outBuffer.should.include('1st test log');
+    await outBuffer.should.include('3rd test log');
+    await outBuffer.should.include('4th test log');
+    await outBuffer.should.include('6th test log');
+  });
+});

package/dist/cli/lib/timeProfier.js

@@ -0,0 +1,7 @@
+import { createTimeProfiler } from 'sxy-dev-tools';
+import { showTimeProfiling } from '../../config.js';
+const {
+  timeProfile,
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export { timeProfile, timeProfileAsync };

package/dist/cli/lib/validateConfig.js

@@ -0,0 +1,29 @@
+import { out as mainOut, log, debug } from '../../output.js';
+export async function validateConfig(config, customOut = undefined) {
+  const out = customOut ? async (...texts) => await customOut(...texts) : async (...texts) => await mainOut(...texts);
+
+  if (config.execution === undefined) {
+    const message = `Config error, config.execution is not defined`;
+    await doError(message);
+  }
+
+  if (config.execution.files !== 'parallel' && config.execution.files !== 'sequential') {
+    const message = `Config error, config.execution.files should be 'parallel' or 'sequential'`;
+    await doError(message);
+  }
+
+  if (config.execution.describes !== 'parallel' && config.execution.describes !== 'sequential') {
+    const message = `Config error, config.execution.describes should be 'parallel' or 'sequential'`;
+    await doError(message);
+  }
+
+  if (config.execution.tests !== 'parallel' && config.execution.tests !== 'sequential') {
+    const message = `Config error, config.execution.tests should be 'parallel' or 'sequential'`;
+    await doError(message);
+  }
+
+  async function doError(message) {
+    await out(message);
+    throw new Error(message);
+  }
+}

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

@@ -0,0 +1,22 @@
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { validateConfig } from './validateConfig.js'; // loadTestFile(config, testFile) ???
+
+import { makeCustomOut } from '../../../unitTesting/makeCustomOut.js';
+await mochaDescribe('validateConfig() function', async function () {
+  await mochaIt('complains if execution values are not valid', async function () {
+    const customOut = await makeCustomOut();
+    const config = await applyConfigDefaults({
+      execution: {
+        files: 'typo'
+      }
+    });
+
+    try {
+      await validateConfig(config, customOut);
+    } catch (e) {} // eslint-disable-line
+
+
+    await (await customOut.getOutBuffer()).should.include('Config error');
+    await (await customOut.getOutBuffer()).should.include('execution.files');
+  });
+});

package/dist/cli/lib/watchFiles.js

@@ -0,0 +1 @@
+export { watchFilesChokidar as watchFiles } from './watchFilesChokidar.js';

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

@@ -0,0 +1,48 @@
+import { promises as fs } from 'fs';
+import { watchFiles } from './watchFiles.js';
+import { applyConfigDefaults } from './applyConfigDefaults.js'; // watchFiles(config, callback)
+
+await mochaDescribe('watchFiles() function', async function () {
+  await mochaIt('should call back when when a file change occurs', async function () {
+    await this.timeout(10000);
+    const config = await applyConfigDefaults({});
+    let eventComplete = false;
+    await watchFiles(config, async (filename, event) => {
+      eventComplete = true;
+    });
+    await fs.writeFile('temp/watchFiles-file.js', 'abc');
+    await new Promise(async (resolve, reject) => {
+      const interval = await setInterval(async () => {
+        if (eventComplete) {
+          await clearInterval(interval);
+          await resolve();
+        }
+      }, 50);
+    });
+    await eventComplete.should.equal(true);
+  });
+  await mochaIt('should call back when when a file change occurs in specified folder', async function () {
+    await this.timeout(10000);
+    const tempFolder = 'temp/watchFiles';
+    const config = await applyConfigDefaults({
+      watch: {
+        watchFilesBase: tempFolder,
+        watchFiles: '**/*.js'
+      }
+    });
+    let eventComplete = false;
+    await watchFiles(config, async (filename, event) => {
+      eventComplete = true;
+    });
+    await fs.writeFile(`${tempFolder}/a-file.js`, 'abc');
+    await new Promise(async (resolve, reject) => {
+      const interval = await setInterval(async () => {
+        if (eventComplete) {
+          await clearInterval(interval);
+          await resolve();
+        }
+      }, 50);
+    });
+    await eventComplete.should.equal(true);
+  });
+});

package/dist/cli/lib/watchFilesAndRunTests.js

@@ -0,0 +1,2 @@
+export { watchFilesAndRunTestsNodeWatch as watchFilesAndRunTests } from './watchFilesAndRunTestsNodeWatch.js'; //export { watchFilesAndRunTestsChokidar as watchFilesAndRunTests }
+//    from './watchFilesAndRunTestsChokidar.js'

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

@@ -0,0 +1,129 @@
+import { promises as fs, existsSync } from 'fs';
+import figures from 'figures';
+import { watchFilesAndRunTests } from './watchFilesAndRunTests.js';
+import { applyConfigDefaults } from './applyConfigDefaults.js'; // watchFiles(config, testFiles, dependencyTrees, failingTests)
+
+await mochaDescribe('watchFilesAndRunTests() function', async function () {
+  const tempFolder = 'temp/watchFilesAndRunTests';
+  const baseConfig = await applyConfigDefaults({
+    testsBase: tempFolder,
+    tests: '**/*.test.js',
+    watch: {
+      watchFilesBase: tempFolder,
+      watchFiles: '**/*.js'
+    }
+  });
+  await mochaIt('should run a test when a test file is changed', async function () {
+    //this.timeout(100000)
+    const config = await Object.copy(baseConfig); // create a custom out function to capture the output
+
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+    };
+
+    watchFilesAndRunTests(config, [], {}, [], customOut); //console.log('outBuffer', outBuffer)
+
+    await outBuffer.should.equal('');
+    const testFileName = `${tempFolder}/a.test.js`;
+    const thing = 'Sample test 1';
+    const should = '1 should equal 1';
+    await fs.writeFile(testFileName, `import { describe } from '../../dist/index.js'
+import { expect, should } from 'chai'
+should()
+
+describe('${thing}', ({it}) => {
+
+    it('${should}', () => {
+        expect(1).to.equal(1)
+    })
+
+})`);
+    await new Promise(async (resolve, reject) => await setTimeout(resolve, 1000));
+    await outBuffer.should.include(testFileName);
+    await outBuffer.should.include(thing);
+    await outBuffer.should.include(should);
+    await outBuffer.should.include(figures.tick);
+  });
+  await mochaIt('should run a test when a new test file is changed', async function () {
+    const config = await Object.copy(baseConfig); // create a custom out function to capture the output
+
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+    };
+
+    const testFileName = `${tempFolder}/b.test.js`;
+    const thing = 'Sample test 2';
+    const should = '2 should equal 2';
+
+    if (await existsSync(testFileName)) {
+      await fs.unlink(testFileName);
+    }
+
+    await (await existsSync(testFileName)).should.equal(false);
+    await watchFilesAndRunTests(config, [], {}, [], customOut);
+    await outBuffer.should.equal('');
+    await fs.writeFile(testFileName, `import { describe } from '../../dist/index.js'
+import { expect, should } from 'chai'
+should()
+
+describe('${thing}', ({it}) => {
+
+    it('${should}', () => {
+        expect(2).to.equal(2)
+    })
+
+})`);
+    await new Promise(async (resolve, reject) => await setTimeout(resolve, 1000));
+    await outBuffer.should.include(testFileName);
+    await outBuffer.should.include(thing);
+    await outBuffer.should.include(should);
+    await outBuffer.should.include(figures.tick);
+  });
+  await mochaIt('removes a test from tests and dependencyTrees when it is deleted', async function () {
+    //this.timeout(100000)
+    const config = await Object.copy(baseConfig); // create a custom out function to capture the output
+
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+    };
+
+    const testFileName = `${tempFolder}/c.test.js`;
+    const thing = 'Sample test 3';
+    const should = '3 should equal 3';
+
+    if (!(await existsSync(testFileName))) {
+      await fs.writeFile(testFileName, `import { describe } from '../../dist/index.js'
+import { expect, should } from 'chai'
+should()
+
+describe('${thing}', ({it}) => {
+
+    it('${should}', () => {
+        expect(3).to.equal(3)
+    })
+
+})`);
+    }
+
+    (await existsSync(testFileName)).should.be.true;
+    const originalTests = [testFileName];
+    const originalDependencyTrees = {
+      [testFileName]: ['dep-1.js', 'dep-2.js']
+    };
+    const tests = await Object.copy(originalTests);
+    const dependencyTrees = await Object.copy(originalDependencyTrees);
+    await tests.should.include.members([testFileName]);
+    await dependencyTrees.should.include.keys([testFileName]);
+    await watchFilesAndRunTests(config, tests, dependencyTrees, [], customOut);
+    await fs.unlink(testFileName);
+    await new Promise(async (resolve, reject) => await setTimeout(resolve, 1000));
+    await tests.should.not.include.members([testFileName]);
+    await dependencyTrees.should.not.include.keys([testFileName]);
+  });
+});