sxy-test-runner 1.0.0

package/dist/cli/lib/watchFilesAndRunTestsChokidar.js

@@ -0,0 +1,142 @@
+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 { runTests } from './runTests.js';
+import { buildDependencyTree } from './buildDependencyTree.js';
+import { globArgCombine } from './globArgCombine.js';
+import { load } from './load.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+import { watchFilesChokidar } from './watchFilesChokidar.js';
+export async function watchFilesAndRunTestsChokidar(config, testFiles, dependencyTrees, failingTests, customOut = undefined) {
+  const projectDir = await process.cwd();
+  await timeProfileAsync('start watching', async () => {
+    let changedFiles = [];
+    let timeout = null;
+
+    const testFilter = file => minimatch(file, globArgCombine(config.tests)) && (!config.testsIgnore || !minimatch(file, globArgCombine(config.testsIgnore))); // start watching
+
+
+    await watchFilesChokidar(config, watchEvent);
+
+    async function watchEvent(filename, event) {
+      await debug('chokidar watch event', filename, event); //filename = slash(filename)
+      // remove dep tree for any tests that are deleted, avoiding trying to run it later
+
+      if (event === 'remove' && filename in dependencyTrees) {
+        await testFiles.remove(filename);
+        delete dependencyTrees[filename];
+      } // info on the event found
+
+
+      await out(chalk.grey`change: ${filename} (${event})`); // add the file to changed files
+
+      await changedFiles.push([filename, event]); // wait 100ms after any change before processing, to avoid multiple execution?
+
+      if (timeout) {
+        await clearTimeout(timeout);
+      }
+
+      timeout = await setTimeout(async () => {
+        await timeProfileAsync('handle changed files', async () => {
+          await debug('changed files', changedFiles); //out('changed files', changedFiles)
+
+          try {
+            // build related test list
+            const tests = [];
+
+            for (const [file, event] of changedFiles) {
+              await debug('check', file);
+              await debug('1 tests', tests);
+
+              if (event !== 'remove') {
+                // only check to see if its a test if it exists (has not just been removed)
+                if (await testFilter(file)) {
+                  // it is a test file itself, add to run list
+                  await debug('its a test', file);
+                  await tests.push(file);
+
+                  if (!(file in dependencyTrees)) {
+                    // if its a new test
+                    await debug('try to add a new test', file), await addNewTest(file);
+                  }
+                }
+              }
+
+              await debug('dtrees', dependencyTrees);
+              await debug('2 tests', tests);
+
+              for (const f of await Object.getOwnPropertyNames(dependencyTrees)) {
+                await debug('dep tree', f, dependencyTrees[f]);
+
+                if (await dependencyTrees[f].some(dep => {
+                  debug('checking dep', dep, file);
+                  return dep === file;
+                })) {
+                  // a test depends on this file
+                  await debug('its a dependency', file);
+                  await debug('its a dependency', file);
+                  await tests.push(f);
+                }
+              }
+            }
+
+            changedFiles = [];
+            await debug('tests', tests);
+            await debug('3 tests', tests);
+
+            if (tests.length) {
+              await timeProfileAsync('run tests related to changes', async () => {
+                await debug('tests', tests);
+
+                if (config.reRunFailingTests) {
+                  for (const failingTest of failingTests) {
+                    if (!(await fs.existsSync(failingTest))) {
+                      //debug('remove failing test', failingTest)
+                      await failingTests.remove(failingTest); //(failingTests)
+                    }
+                  }
+                }
+
+                await debug('tests', tests);
+                await debug('failingTests', failingTests);
+                await debug('reRunFailingTests', config.watch.reRunFailingTests);
+                const toTest = config.watch.reRunFailingTests ? await (await [...tests, ...failingTests].dedupeSlow()).reverse() // dedupe return new? // reverse in place
+                : await [...tests].reverse(); // reverse in place
+
+                const results = {
+                  total: 0,
+                  passed: 0
+                };
+                await debug('run tests on change');
+                await debug('toTest', toTest); // clear load cache to allow accesing the new tets
+
+                await load.cache.clear();
+                const testResults = await runTests(config, toTest, failingTests, customOut);
+              });
+            }
+          } catch (e) {
+            await log('watch handler error', e);
+          } finally {//
+          }
+        });
+      }, 33);
+    } // end of watch event
+
+
+    async function addNewTest(testFile) {
+      await debug('new test', testFile);
+      const dependencyTree = await buildDependencyTree(config, testFile);
+      dependencyTrees[testFile] = await (await dependencyTree.map(async file => await (await slash(file)).slice(projectDir.length + 1))).filter(async f => f !== testFile);
+    }
+  });
+  await out(chalk.brightblue`watching...`);
+}

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

@@ -0,0 +1,133 @@
+import { promises as fs, existsSync } from 'fs';
+import figures from 'figures';
+import { watchFilesAndRunTestsChokidar } from './watchFilesAndRunTestsChokidar.js';
+import { applyConfigDefaults } from './applyConfigDefaults.js'; // watchFiles(config, testFiles, dependencyTrees, failingTests)
+
+await mochaDescribe('watchFilesAndRunTestsChokidar() function', async function () {
+  const tempFolder = 'temp/watchFilesAndRunTestsChokidar';
+  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); // ignore the file from the last test, causing load errors
+
+    config.testsIgnore = '**/c.test.js'; // 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 = 'temp/watchFilesAndRunTestsChokidar/a.test.js';
+    const thing = 'Sample test 1';
+    const should = '1 should equal 1';
+    await watchFilesAndRunTestsChokidar(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(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 () {
+    //this.timeout(100000)
+    const config = await Object.copy(baseConfig); // ignore the file from the last test, causing load errors
+
+    config.testsIgnore = '**/c.test.js'; // 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 watchFilesAndRunTestsChokidar(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 watchFilesAndRunTestsChokidar(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]);
+  });
+});

package/dist/cli/lib/watchFilesAndRunTestsNodeWatch.js

@@ -0,0 +1,162 @@
+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 { runTests } from './runTests.js';
+import { buildDependencyTree } from './buildDependencyTree.js';
+import { globArgCombine } from './globArgCombine.js';
+import { load } from './load.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+import { addBasePath } from './addBasePath.js';
+import { watchFilesNodeWatch } from './watchFilesNodeWatch.js';
+export async function watchFilesAndRunTestsNodeWatch(config, testFiles, dependencyTrees, failingTests, customOut = undefined) {
+  const projectDir = await process.cwd();
+  let watcher;
+  await timeProfileAsync('init watching', async () => {
+    await debug('failingTests', failingTests);
+    const testsGlobs = await addBasePath(config.testsBase, config.tests);
+    const testsIgnoreGlobs = await addBasePath(config.testsBase, config.testsIgnore); // indentify a test file
+
+    const testFilter = //file => minimatch(file, globArgCombine(config.tests))
+    //    && ! minimatch(file, globArgCombine(config.testsIgnore))
+    file => {
+      debug('test filter', file, globArgCombine(testsGlobs), globArgCombine(testsIgnoreGlobs), minimatch(file, globArgCombine(testsGlobs)), minimatch(file, globArgCombine(testsIgnoreGlobs)), minimatch(file, globArgCombine(testsGlobs)) && !minimatch(file, globArgCombine(testsIgnoreGlobs)));
+      return minimatch(file, globArgCombine(testsGlobs)) && !minimatch(file, globArgCombine(testsIgnoreGlobs));
+    }; //log('tests glob', globArgCombine(testsGlobs))
+    //log('testsIgnore glob', globArgCombine(testsIgnoreGlobs))
+
+
+    let changedFiles = [];
+    let timeout = null;
+
+    if (!config.watch.watchFilesBase) {
+      await out(`No config.watch.watchFilesBase provided, defaulting to '.'`);
+      config.watch.watchFilesBase = '.';
+    }
+
+    watcher = await watchFilesNodeWatch(config, watchEvent);
+
+    async function watchEvent(filename, event) {
+      await debug('handle watch event ', filename, event);
+      filename = await slash(filename); // remove dep tree for any tests that are deleted, avoiding trying to run it later
+
+      if (event === 'remove') {
+        await debug('removing test', filename);
+
+        if (filename in dependencyTrees) {
+          await testFiles.remove(filename);
+          delete dependencyTrees[filename];
+        }
+      } // info on the event found
+
+
+      await out(chalk.grey`change: ${filename} (${event})`); // add the file to changed files
+
+      await changedFiles.push([filename, event]); // wait 100ms after any change before processing, to avoid multiple execution?
+
+      if (timeout) {
+        await clearTimeout(timeout);
+      }
+
+      timeout = await setTimeout(async () => {
+        await timeProfileAsync('handle changed files', async () => {
+          await debug('changedFiles', changedFiles);
+
+          try {
+            // build related test list
+            const tests = [];
+
+            for (const [file, event] of changedFiles) {
+              await debug('check', file);
+              await debug('1 tests', tests);
+
+              if (event !== 'remove') {
+                // only check to see if its a test if it exists (has not just been removed)
+                if (await testFilter(file)) {
+                  // it is a test file itself, add to run list
+                  await debug('its a test', file);
+                  await tests.push(file);
+
+                  if (!(file in dependencyTrees)) {
+                    // if its a new test
+                    await debug('try to add a new test', file), await addNewTest(file);
+                  }
+                }
+              }
+
+              await debug('dtrees', dependencyTrees);
+              await debug('2 tests', tests);
+
+              for (const f of await Object.getOwnPropertyNames(dependencyTrees)) {
+                await debug('dep tree', f, dependencyTrees[f]);
+
+                if (await dependencyTrees[f].some(dep => {
+                  debug('checking dep', dep, file);
+                  return dep === file;
+                })) {
+                  // a test depends on this file
+                  await debug('its a dependency', file);
+                  await debug('its a dependency', file);
+                  await tests.push(f);
+                }
+              }
+            }
+
+            changedFiles = [];
+            await debug('tests', tests);
+            await debug('3 tests', tests);
+
+            if (tests.length) {
+              await timeProfileAsync('run tests related to changes', async () => {
+                await debug('tests', tests);
+
+                if (config.reRunFailingTests) {
+                  for (const failingTest of failingTests) {
+                    if (!(await fs.existsSync(failingTest))) {
+                      //debug('remove failing test', failingTest)
+                      await failingTests.remove(failingTest); //(failingTests)
+                    }
+                  }
+                }
+
+                await debug('tests', tests);
+                await debug('failingTests', failingTests);
+                await debug('reRunFailingTests', config.watch.reRunFailingTests);
+                const toTest = config.watch.reRunFailingTests ? await (await [...tests, ...failingTests].dedupeSlow()).reverse() // dedupe return new? // reverse in place
+                : await [...tests].reverse(); // reverse in place
+
+                const results = {
+                  total: 0,
+                  passed: 0
+                };
+                await debug('run tests on change');
+                await debug('toTest', toTest); // clear load cache to allow accesing the new tets
+
+                await load.cache.clear();
+                const testResults = await runTests(config, toTest, failingTests, customOut);
+              });
+            }
+          } catch (e) {
+            await log('watch handler error', e);
+          } finally {//
+          }
+        });
+      }, 33);
+    }
+  });
+  await out(chalk.brightblue`watching...`); //return new Promise( () => {} ) // infinite promise to let us watch
+
+  async function addNewTest(testFile) {
+    await debug('new test', testFile);
+    const dependencyTree = await buildDependencyTree(config, testFile);
+    dependencyTrees[testFile] = await (await dependencyTree.map(async file => await (await slash(file)).slice(projectDir.length + 1))).filter(async f => f !== testFile);
+  }
+}

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

@@ -0,0 +1,131 @@
+import { promises as fs, existsSync } from 'fs';
+import figures from 'figures';
+import { watchFilesAndRunTestsNodeWatch } from './watchFilesAndRunTestsNodeWatch.js';
+import { applyConfigDefaults } from './applyConfigDefaults.js'; // watchFiles(config, testFiles, dependencyTrees, failingTests)
+
+await mochaDescribe('watchFilesAndRunTestsNodeWatch() function', async function () {
+  const tempFolder = 'temp/watchFilesAndRunTestsNodeWatch';
+  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
+    };
+
+    watchFilesAndRunTestsNodeWatch(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.not.equal('');
+    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 watchFilesAndRunTestsNodeWatch(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)); //console.log('out', outBuffer)
+
+    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 watchFilesAndRunTestsNodeWatch(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]);
+  });
+});

package/dist/cli/lib/watchFilesChokidar.js

@@ -0,0 +1,56 @@
+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, { watch } from 'fs';
+import { out, log, debug } from '../../output.js';
+import { globArgCombine } from './globArgCombine.js';
+import { addBasePath } from './addBasePath.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function watchFilesChokidar(config, onEvent) {
+  return await timeProfileAsync('start watching', async () => {
+    //const testGlobs = addBaseToGlobs(config.testsBase, config.tests)
+    //const ignoreGlobs = addBaseToGlobs(config.testsBase, config.testsIgnore)
+    // indentify a test file
+    const testFilter = file => minimatch(file, globArgCombine(config.tests)) && (!config.testsIgnore || !minimatch(file, globArgCombine(config.testsIgnore))); // 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 ignoreGlob = config.watch.watchFilesIgnore ? await addBasePath(config.watch.watchFilesBase, config.watch.watchFilesIgnore) : null; //log(`watch: ${config.watch.watchFilesBase}`)
+    // log(`ignore: ${ignoreGlob}`)
+
+    const watcher = await chokidar.watch(config.watch.watchFilesBase, {
+      ignored: ignoreGlob,
+      ignoreInitial: true
+    });
+    await watcher.on('all', async (event, filename) => {
+      //log('[watch event]', path, event)
+      filename = await slash(filename);
+      await debug('[watch event]', filename, event);
+      await onEvent(filename, event === 'unlink' ? 'remove' : event);
+    });
+    return new Promise(async (resolve, reject) => {
+      await watcher.on('ready', async () => {
+        //log('chokidar watcher ready')
+        await debug('chokidar watcher ready');
+        await resolve(watcher);
+      });
+    }); // watch(config.watch.watchFilesBase, { recursive: true, filter: watchFilter }, function(event, filename) {
+    //     filename = slash(filename)
+    //     debug('watch event')
+    //     onEvent(filename, event)
+    // })
+  }); //return new Promise( () => {} ) // infinite promise to let us watch
+}