sxy-test-runner 1.0.0

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

@@ -0,0 +1,85 @@
+import { promises as fs } from 'fs';
+import { watchFilesChokidar } from './watchFilesChokidar.js';
+import { applyConfigDefaults } from './applyConfigDefaults.js'; // watchFiles(config, testFiles, dependencyTrees, failingTests) ???
+
+await mochaDescribe('watchFilesChokidar() function', async function () {
+  await mochaIt('should call back when when a file change occurs', async function () {
+    await this.timeout(12000);
+    const config = await applyConfigDefaults({});
+    let eventComplete = false;
+    await watchFilesChokidar(config, async (filename, event) => {
+      eventComplete = true;
+    });
+    await fs.writeFile('temp/watchFilesChokidar-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(12000);
+    const config = await applyConfigDefaults({
+      watch: {
+        watchFilesBase: 'temp/watchFilesChokidar',
+        watchFiles: '**/*.js'
+      }
+    });
+    let eventComplete = false;
+    await watchFilesChokidar(config, async (filename, event) => {
+      eventComplete = true;
+    });
+    await fs.writeFile('temp/watchFilesChokidar/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);
+  });
+  await mochaIt('ignores a file based on ignore glob', async function () {
+    await this.timeout(12000);
+    const config = await applyConfigDefaults({
+      watch: {
+        watchFilesBase: 'temp/watchFilesChokidar',
+        watchFiles: '**/*.js',
+        watchFilesIgnore: 'ignore-file.js'
+      }
+    });
+    let eventComplete = false;
+    await watchFilesChokidar(config, async (filename, event) => {
+      eventComplete = true;
+    });
+    await fs.writeFile('temp/watchFilesChokidar/ignore-file.js', 'abc');
+    await new Promise(async (resolve, reject) => {
+      await setTimeout(resolve, 1000);
+    });
+    await eventComplete.should.not.equal(true);
+  });
+  await mochaIt('ignores a file based on ignore globs array', async function () {
+    //this.timeout(100000)
+    const config = await applyConfigDefaults({
+      watch: {
+        watchFilesBase: 'temp/watchFilesChokidar',
+        watchFiles: '**/*.js',
+        watchFilesIgnore: ['first-ignore-file.js', 'ignore-file.js']
+      }
+    });
+    let eventComplete = false;
+    await watchFilesChokidar(config, async (filename, event) => {
+      eventComplete = true;
+    });
+    await fs.writeFile('temp/watchFilesChokidar/ignore-file.js', 'abc');
+    await new Promise(async (resolve, reject) => {
+      await setTimeout(resolve, 1000);
+    });
+    await eventComplete.should.not.equal(true);
+  });
+});

package/dist/cli/lib/watchFilesNodeWatch.js

@@ -0,0 +1,42 @@
+import { createTimeProfiler } from 'sxy-dev-tools';
+import { showTimeProfiling } from '../../config.js';
+import chalk from 'chalk-extensions';
+import minimatch from 'minimatch';
+import slash from 'slash';
+import watch from 'node-watch'; //import chokidar from 'chokidar'
+//import nsfw from 'nsfw'
+
+import fs from 'fs';
+import { out, log, debug } from '../../output.js';
+import { globArgCombine } from './globArgCombine.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function watchFilesNodeWatch(config, onEvent) {
+  await timeProfileAsync('start watching', async () => {
+    //const testGlobs = addBaseToGlobs(config.testsBase, config.tests)
+    //const ignoreGlobs = addBaseToGlobs(config.testsBase, config.testsIgnore)
+    // indentify a test file
+    // identify a file we should be watching and responding to
+    const watchFilter = file => (!config.watch.watchFiles || minimatch(file, globArgCombine(config.watch.watchFiles))) && (!config.watch.watchFilesIgnore || !minimatch(file, globArgCombine(config.watch.watchFilesIgnore)));
+
+    if (!config.watch.watchFilesBase) {
+      await out(`No config.watch.watchFilesBase provided, defaulting to '.'`);
+      config.watch.watchFilesBase = '.';
+    }
+
+    const watcher = await watch(config.watch.watchFilesBase, {
+      recursive: true,
+      filter: watchFilter
+    }, async function (event, filename) {
+      filename = await slash(filename);
+      await debug('watch event');
+      await onEvent(filename, event);
+    }); // wait until the watcher is ready
+
+    await new Promise(async (resolve, reject) => {
+      await watcher.on('ready', resolve);
+    });
+    return watcher;
+  }); //return new Promise( () => {} ) // infinite promise to let us watch
+}

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

@@ -0,0 +1,48 @@
+import { promises as fs } from 'fs';
+import { watchFilesNodeWatch } from './watchFilesNodeWatch.js';
+import { applyConfigDefaults } from './applyConfigDefaults.js'; // watchFiles(config, callback)
+
+await mochaDescribe('watchFilesNodeWatch() function', async function () {
+  await mochaIt('should call back when when a file change occurs', async function () {
+    //this.timeout(100000)
+    const config = await applyConfigDefaults({});
+    let eventComplete = false;
+    await watchFilesNodeWatch(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 () {
+    //this.timeout(100000)
+    const tempFolder = 'temp/watchFilesNodeWatcher';
+    const config = await applyConfigDefaults({
+      watch: {
+        watchFilesBase: tempFolder,
+        watchFiles: '**/*.js'
+      }
+    });
+    let eventComplete = false;
+    await watchFilesNodeWatch(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/once.js

@@ -0,0 +1,47 @@
+import { createTimeProfiler } from 'sxy-dev-tools';
+import chalk from 'chalk-extensions';
+import { packageName, configFileName, configLocations, showTimeProfiling } from '../config.js';
+import { out, log, debug } from '../output.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function once() {
+  await out(chalk.brightblue`[${packageName}]...`);
+  const startTime = await new Date().getTime();
+  const {
+    loadConfig
+  } = await import('./lib/loadConfig.js'); //// async function
+
+  const userConfig = await loadConfig();
+  const {
+    applyConfigDefaults
+  } = await import('./lib/applyConfigDefaults.js'); //// sync function
+
+  const config = await applyConfigDefaults(userConfig);
+  await log(chalk.brightblue`finding tests...`);
+  const {
+    findTestFiles
+  } = await import('./lib/findTestFiles.js'); //// async function
+
+  const testFiles = await findTestFiles(config);
+
+  if (testFiles.length === 0) {
+    await out(await chalk.orange(`[${packageName}] Found no tests.` + `\nTests patterns [${await config.tests.join(', ')}].` + `\nCreate tests matching the patterns, ` + `\nor set new patterns in ${configFileName}.* { tests: }`));
+    const endTime = await new Date().getTime();
+    const time = endTime - startTime;
+    await out(await chalk.brightblue(`[${packageName}] time: ${await time.toLocaleString()}ms`));
+    await process.exit(0);
+  }
+
+  const {
+    runTests
+  } = await import('./lib/runTests.js');
+
+  if (testFiles.length > 0) {
+    await log(chalk.brightblue`running tests...`);
+    await runTests(config, testFiles, []); //// async function, run in thread
+  }
+
+  const time = (await new Date().getTime()) - startTime;
+  await out(chalk.grey`\n${await time.toLocaleString()}ms\n`);
+}

package/dist/cli/once.unitTest.js

@@ -0,0 +1,39 @@
+/*
+import figures from 'figures'
+
+import { once } from './once.js'
+
+mochaDescribe('once command', function() {
+
+    mochaIt('should run tests and output results', async function() {
+        this.timeout(12000)
+
+        const originalConsoleLog = console.log
+        let consoleLogBuffer = ''
+        console.log = sync(function testLog(...texts) {
+            consoleLogBuffer += texts.join(' ') + '\n'
+        })
+
+        global.commandLineArguments = []
+        
+        promise( once() )
+        await new Promise( (resolve, reject) => { setTimeout(resolve, 8000) } )
+
+        console.log = originalConsoleLog
+        
+        console.log(consoleLogBuffer)
+        
+        const testFileName = `trialTests/example.test.js`
+        const thing = 'The example'
+        const should = '1 should equal 1'
+
+        consoleLogBuffer.should.include( testFileName )
+        consoleLogBuffer.should.include( thing )
+        consoleLogBuffer.should.include( should )
+        consoleLogBuffer.should.include( figures.tick )
+
+    })
+
+})
+
+*/

package/dist/cli/watch.js

@@ -0,0 +1,100 @@
+import { createTimeProfiler } from 'sxy-dev-tools'
+import chalk from 'chalk-extensions'
+import { packageName, showTimeProfiling } from '../config.js'
+import { out, log, debug } from '../output.js'
+const {
+    timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling)
+export async function watch() {
+    await out(chalk.brightblue`[${packageName}]...`)
+    const {
+        parseCommandLineArguments
+    } = await import('./lib/parseCommandLineArguments.js') //// async function
+
+    const allowedClArguments = {
+        'config': {
+            flag: 'c',
+            hasValue: true
+        }
+    }
+    const clArguments = await parseCommandLineArguments(allowedClArguments)
+    await debug('clArguments', clArguments)
+    const {
+        loadConfig
+    } = await import('./lib/loadConfig.js') //// async function
+
+    const userConfig = 'config' in clArguments ? await loadConfig(clArguments.config) : await loadConfig()
+    const {
+        applyConfigDefaults
+    } = await import('./lib/applyConfigDefaults.js') //// sync function
+
+    const config = await applyConfigDefaults(userConfig)
+    const {
+        validateConfig
+    } = await import('./lib/validateConfig.js') //// sync function
+
+    await validateConfig(config)
+    const {
+        doUserSetup
+    } = await import('./lib/doUserSetup.js')
+    await doUserSetup(config)
+    await out(chalk.brightblue`finding tests...`)
+    const {
+        findTestFiles
+    } = await import('./lib/findTestFiles.js') //// async function
+
+    const testFiles = await findTestFiles(config)
+    await debug(testFiles) // global store of the dependencies of tests
+
+    let dependencyTrees = {} // store failing tests so we can re-run them.
+
+    const failingTests = []
+
+    if (testFiles.length > 0) {
+        const {
+            buildDependencyTrees
+        } = await import('./lib/buildDependencyTrees.js')
+        await out(chalk.brightblue`finding initial dependency trees...`)
+        dependencyTrees = await buildDependencyTrees(config, testFiles) //// sync function
+
+        if (config.watch.runAllOnStartup) {
+            const {
+                runTests
+            } = await import('./lib/runTests.js')
+            await out(chalk.brightblue`running initial tests...`)
+            runTests(config, testFiles, failingTests).then(async () => {
+                await out(chalk.brightblue`watching...`)
+            }) //// async function, run in separate thread
+        }
+    } else {
+        await out(chalk.brightblue`no tests founds`)
+    }
+
+    const {
+        watchFilesAndRunTests
+    } = await import('./lib/watchFilesAndRunTests.js')
+    await watchFilesAndRunTests(config, testFiles, dependencyTrees, failingTests) //// async function run in thread
+
+    await new Promise(async () => {}) // won't run because promise will never finish
+
+    const {
+        doUserTeardown
+    } = await import('./lib/doUserTeardown.js')
+    await doUserTeardown(config) /////// SET UP?
+  // if ( typeof config.setup === 'function' ) {
+  //     await timeProfile('run setup function', config.setup(/* can we pass anything here? */))
+  // }
+} // runInitialTests
+//--find tests
+//if found tests, 
+//  find dependencyTrees
+//  also, run tests
+//else
+//  warn
+// dn't run initial tests
+// do we need to find initial test? yes
+// find tests
+// if found tests
+//     make dep trees
+// else
+//   warn

package/dist/cli/watch.unitTest.js

@@ -0,0 +1,117 @@
+import figures from 'figures';
+import { applyConfigDefaults } from './lib/applyConfigDefaults.js';
+import { watch } from './watch.js';
+await mochaDescribe('watch command', async function () {
+  await mochaIt('should run tests and output results and display correct tallies', async function () {
+    await this.timeout(10000);
+    const originalConsoleLog = console.log;
+    let consoleLogBuffer = '';
+
+    console.log = function testLog(...texts) {
+      consoleLogBuffer += texts.join(' ') + '\n';
+    };
+
+    global.commandLineArguments = ['--config', 'unitTesting/watch/sxy-test-runner.config.js'];
+    watch();
+    await new Promise(async (resolve, reject) => {
+      await setTimeout(resolve, 8000);
+    });
+    console.log = originalConsoleLog; //console.log(consoleLogBuffer)
+
+    const testFileName = `unitTesting/watch/1.test.js`;
+    const thing = 'Sample test 1';
+    const should = '1 should equal 1';
+    await consoleLogBuffer.should.include(testFileName);
+    await consoleLogBuffer.should.include(thing);
+    await consoleLogBuffer.should.include(should);
+    await consoleLogBuffer.should.include(figures.tick);
+    await consoleLogBuffer.should.include('Tests: 3/3');
+    await consoleLogBuffer.should.include('Items: 2/2');
+    await consoleLogBuffer.should.include('Test Files: 2/2');
+  });
+  await mochaIt('should run tests and display correct tallies', async function () {
+    await this.timeout(10000);
+    const originalConsoleLog = console.log;
+    let consoleLogBuffer = '';
+
+    console.log = function testLog(...texts) {
+      consoleLogBuffer += texts.join(' ') + '\n';
+    };
+
+    global.commandLineArguments = ['--config', 'unitTesting/watch/sxy-test-runner.config.js'];
+    watch();
+    await new Promise(async (resolve, reject) => {
+      await setTimeout(resolve, 8000);
+    });
+    console.log = originalConsoleLog; //console.log(consoleLogBuffer)
+
+    const testFileName = `unitTesting/watch/1.test.js`;
+    const thing = 'Sample test 1';
+    const should = '1 should equal 1';
+    await consoleLogBuffer.should.include(testFileName);
+    await consoleLogBuffer.should.include(thing);
+    await consoleLogBuffer.should.include(should);
+    await consoleLogBuffer.should.include(figures.tick);
+  });
+  await mochaIt('should warn us when there are no tests', async function () {
+    await this.timeout(6000);
+    const originalConsoleLog = console.log;
+    let consoleLogBuffer = '';
+
+    console.log = function testLog(...texts) {
+      consoleLogBuffer += texts.join(' ') + '\n';
+    };
+
+    global.commandLineArguments = ['--config', 'sxy-test-runner.no-tests.config.js'];
+    watch();
+    await new Promise(async (resolve, reject) => {
+      await setTimeout(resolve, 4000);
+    });
+    console.log = originalConsoleLog; //console.log('saved console.log output:')
+    //console.log(consoleLogBuffer)
+
+    await consoleLogBuffer.should.include('no tests found');
+    await consoleLogBuffer.should.not.include('describing');
+  });
+  await mochaIt('should not run tests when asked not to run initial tests', async function () {
+    await this.timeout(6000);
+    const originalConsoleLog = console.log;
+    let consoleLogBuffer = '';
+
+    console.log = function testLog(...texts) {
+      consoleLogBuffer += texts.join(' ') + '\n';
+    };
+
+    global.commandLineArguments = ['--config', 'sxy-test-runner.no-initial-tests.config.js'];
+    watch();
+    await new Promise(async (resolve, reject) => {
+      await setTimeout(resolve, 4000);
+    });
+    console.log = originalConsoleLog; //console.log('saved console.log output:')
+    //console.log(consoleLogBuffer)
+
+    await consoleLogBuffer.should.not.include('no tests found');
+    await consoleLogBuffer.should.not.include('describing');
+    await consoleLogBuffer.should.include('watching');
+  });
+  await mochaIt('setup function and setup file from the config should have run', async function () {
+    await this.timeout(6000);
+    global.configBasedSetupFunctionRan = false;
+    global.watchSetupFileHasRun = false;
+    const originalConsoleLog = console.log;
+    let consoleLogBuffer = '';
+
+    console.log = function testLog(...texts) {
+      consoleLogBuffer += texts.join(' ') + '\n';
+    };
+
+    global.commandLineArguments = ['--config', 'sxy-test-runner.setup-tasks.config.js'];
+    watch();
+    await new Promise(async (resolve, reject) => {
+      await setTimeout(resolve, 2000);
+    });
+    console.log = originalConsoleLog;
+    await global.configBasedSetupFunctionRan.should.equal(true);
+    await global.watchSetupFileHasRun.should.equal(true);
+  });
+});

package/dist/config.js

@@ -0,0 +1,7 @@
+export const packageName = 'sxy-test-runner';
+export const cliName = 'sxy-test';
+export const configFileName = 'sxy-test-runner.config';
+export const configLocations = ['', 'config']; // locations where the configs may be placed in proj folder
+
+export const debugging = false;
+export const showTimeProfiling = false;