sxy-test-runner 1.0.4 → 1.0.7

package/dist/cli/lib/findTestFiles.js

@@ -0,0 +1,24 @@
+import { loadConfig as sxyLoadConfig, createTimeProfiler } from 'sxy-dev-tools';
+import { packageName, cliName, configFileName, configLocations, showTimeProfiling } from '../../config.js';
+import chalk from 'chalk-extensions';
+import { globby } from 'globby';
+import { out, log, debug } from '../../output.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+import { addBasePath } from './addBasePath.js';
+export async function findTestFiles(config) {
+  return await timeProfileAsync('find test files', async () => {
+    const testsGlobs = await addBasePath(config.testsBase, config.tests);
+    const testsIgnoreGlobs = await addBasePath(config.testsBase, config.testsIgnore);
+    await debug('testsGlobs', testsGlobs);
+    await debug('testsIgnoreGlobs', testsIgnoreGlobs);
+    const globOptions = {
+      //cwd: projectDir,
+      ignore: testsIgnoreGlobs
+    };
+    const testFiles = await globby(testsGlobs, testsIgnoreGlobs);
+    await debug('testFiles', testFiles);
+    return testFiles;
+  });
+}

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

@@ -0,0 +1,22 @@
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { findTestFiles } from './findTestFiles.js'; // findTestFiles(config)
+
+await mochaDescribe('findTestFiles() function', async function () {
+  await mochaIt('finds the tests files', async function () {
+    // get the default configs
+    const config = await applyConfigDefaults({
+      tests: 'unitTesting/**/*.test.js'
+    });
+    const testFiles = await findTestFiles(config);
+    await testFiles.should.include.members(['unitTesting/sampleTests/1.test.js', 'unitTesting/sampleTests/2.test.js']);
+  });
+  await mochaIt('respects tests base config entry', async function () {
+    // get the default configs
+    const config = await applyConfigDefaults({
+      testsBase: 'src',
+      tests: 'unitTesting/**/*.test.js'
+    });
+    const testFiles = await findTestFiles(config);
+    await testFiles.length.should.equal(0);
+  });
+});

package/dist/cli/lib/getAllowedFlags.js

@@ -0,0 +1,11 @@
+export async function getAllowedFlags(allowedArguments) {
+  const allowedFlags = {};
+
+  for (const option in allowedArguments) {
+    if ('flag' in allowedArguments[option]) {
+      allowedFlags[allowedArguments[option].flag] = option;
+    }
+  }
+
+  return allowedFlags;
+}

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

@@ -0,0 +1,20 @@
+import { getAllowedFlags } from './getAllowedFlags.js'; // findTestFiles(config)
+
+await mochaDescribe('getAllowedFlags() function', async function () {
+  await mochaIt('extracts the flags from an allowedArguments object', async function () {
+    const allowedArguments = {
+      'config': {
+        flag: 'c',
+        hasValue: true
+      },
+      'watch': {
+        flag: 'w',
+        hasValue: false
+      }
+    };
+    const allowedFlags = await getAllowedFlags(allowedArguments);
+    await allowedFlags.should.have.keys(['c', 'w']);
+    await allowedFlags.c.should.equal('config');
+    await allowedFlags.w.should.equal('watch');
+  });
+});

package/dist/cli/lib/globArgCombine.js

@@ -0,0 +1 @@
+export const globArgCombine = patterns => Array.isArray(patterns) ? patterns.length > 1 ? '{' + patterns.join(',') + '}' : patterns[0] : patterns;

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

@@ -0,0 +1,18 @@
+import { globArgCombine } from "./globArgCombine.js";
+await mochaDescribe('globArgCombine() function', async function () {
+  await mochaIt('leaves strings alone', async function () {
+    const testString = '*.test.js';
+    const result = await globArgCombine(testString);
+    await result.should.equal(testString);
+  });
+  await mochaIt('extracts the item from a single item array', async function () {
+    const testStringsArray = ['*.test.js'];
+    const result = await globArgCombine(testStringsArray);
+    await result.should.equal(testStringsArray[0]);
+  });
+  await mochaIt('combined an array into a multi option glob e.g. {a,b}', async function () {
+    const testStringsArray = ['*.test.js', '*.spec.js'];
+    const result = await globArgCombine(testStringsArray);
+    await result.should.equal(`{${testStringsArray[0]},${testStringsArray[1]}}`);
+  });
+});

package/dist/cli/lib/injectProperties.js

@@ -0,0 +1,11 @@
+import { out as mainOut, log, debug } from '../../output.js';
+const reservedKeys = ['describe', 'test', 'it', 'before', 'after', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'];
+export async function injectProperties(basePackage, injectProperties, from, customOut = undefined) {
+  const out = customOut ? async (...texts) => await customOut(...texts) : async (...texts) => await mainOut(...texts);
+
+  for (const key in injectProperties) {
+    if (await reservedKeys.includes(key)) {
+      await out(`Error: key '${key}' is reserved. Please do not use this key. From '${from}'.`); //process.exit(1)
+    }
+  }
+}

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

@@ -0,0 +1,75 @@
+import { injectProperties } from "./injectProperties.js";
+import chalk from 'chalk-extensions';
+await mochaDescribe('injectProperties() function', async function () {
+  await mochaIt('complains if a reserved property is given', async function () {
+    let outBuffer = '';
+
+    const customOut = (...texts) => {
+      //console.log(chalk.red`outBuffer1`, outBuffer)
+      console.log(...texts);
+      outBuffer += texts.join(' ') + '\n'; // join and save to the buffer
+      //console.log(chalk.red`outBuffer2`, outBuffer)
+    };
+
+    const errorString = 'is reserved';
+    const basePacket = {};
+    let properties;
+    outBuffer = '';
+    properties = {
+      describe: true
+    };
+    await injectProperties(basePacket, properties, '', customOut);
+    await outBuffer.should.include(errorString);
+    outBuffer = '';
+    properties = {
+      it: true
+    };
+    await injectProperties(basePacket, properties, '', customOut);
+    await outBuffer.should.include(errorString);
+    outBuffer = '';
+    properties = {
+      test: true
+    };
+    await injectProperties(basePacket, properties, '', customOut);
+    await outBuffer.should.include(errorString);
+    outBuffer = '';
+    properties = {
+      before: true
+    };
+    await injectProperties(basePacket, properties, '', customOut);
+    await outBuffer.should.include(errorString);
+    outBuffer = '';
+    properties = {
+      after: true
+    };
+    await injectProperties(basePacket, properties, '', customOut);
+    await outBuffer.should.include(errorString);
+    outBuffer = '';
+    properties = {
+      beforeEach: true
+    };
+    await injectProperties(basePacket, properties, '', customOut);
+    await outBuffer.should.include(errorString);
+    outBuffer = '';
+    properties = {
+      afterEach: true
+    };
+    await injectProperties(basePacket, properties, '', customOut);
+    await outBuffer.should.include(errorString);
+  }); // mochaIt('complains if a passed property conflics with a base property', function() {
+  //     let outBuffer = ''
+  //     const customOut = sync((...texts) => {
+  //         console.log(...texts)
+  //         outBuffer += texts.join(' ') + '\n' // join and save to the buffer
+  //     })
+  //     const errorString = 'is reserved'
+  //     const basePacket = {}
+  //     let properties
+  //     outBuffer = ''
+  //     properties = {
+  //         describe: true
+  //     }
+  //     injectProperties(basePacket, properties, '', customOut)
+  //     outBuffer.should.include(errorString)
+  // })
+});

package/dist/cli/lib/load.js

@@ -0,0 +1,3 @@
+import sxyLoaderConfig from '../../../sxy-loader.config.js';
+import { createLoad } from 'sxy-loader';
+export const load = await createLoad(import.meta.url, sxyLoaderConfig);

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

@@ -0,0 +1,7 @@
+import { load } from "./load.js";
+await mochaDescribe('load import (sxy loader)', async function () {
+  await mochaIt('load is a function with a cache', async function () {
+    await load.should.be.a('function');
+    await load.should.include.key('cache');
+  });
+});

package/dist/cli/lib/loadConfig.js

@@ -0,0 +1,21 @@
+import { loadConfig as sxyLoadConfig, loadConfigExact as sxyLoadConfigExact, createTimeProfiler } from 'sxy-dev-tools';
+import { packageName, cliName, configFileName, configLocations, showTimeProfiling } from '../../config.js';
+import chalk from 'chalk-extensions';
+import { out, log, debug } from '../../output.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+export async function loadConfig(customLocation = undefined) {
+  return await timeProfileAsync('load config', async () => {
+    const configOrNull = customLocation !== undefined ? await sxyLoadConfigExact(customLocation) : await sxyLoadConfig(configFileName, configLocations);
+    await debug('configOrNull', typeof configOrNull, configOrNull);
+
+    if (!configOrNull) {
+      await out(await chalk.orange(`[${packageName}] No config found.` + `\nPlease create a ${configFileName}.js/cjs/mjs file in your project root or /config folder.` + `\nOr run \`npx ${cliName} init\` to create one.`));
+      await process.exit(0);
+    } //log('user config', configOrNull)
+
+
+    return configOrNull;
+  });
+}

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

@@ -0,0 +1,15 @@
+import { loadConfig } from "./loadConfig.js"; // loadConfig(location)
+// location is option
+
+await mochaDescribe('loadConfig() function', async function () {
+  await mochaIt('loads a user config', async function () {
+    const userConfig = await loadConfig();
+    userConfig.should.not.be.null;
+  });
+  await mochaIt('loads a user config from a location passed to it', async function () {
+    const configLocation = 'unitTesting/sampleConfig/sxy-test-runner.config.js';
+    const userConfig = await loadConfig(configLocation);
+    userConfig.should.not.be.null;
+    await userConfig.tests.should.equal('alt-config-location');
+  });
+});

package/dist/cli/lib/loadTestFile.js

@@ -0,0 +1,75 @@
+import { createTimeProfiler } from 'sxy-dev-tools';
+import { showTimeProfiling } from '../../config.js';
+import { out, log, debug, error } from '../../output.js';
+import { join } from 'path';
+import chalk from 'chalk-extensions';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+import { load } from './load.js';
+let loading = null;
+export async function loadTestFile(config, testFile) {
+  if (loading !== null) {
+    await debug(chalk.yellow`loadTestFile - another file is loading - waiting for it to finish`);
+    await loading;
+    await debug(chalk.yellow`previous file complete - will now load the file`);
+  }
+
+  const loadPromise = timeProfileAsync(`load test ${testFile}`, async () => {
+    const projectDir = await process.cwd(); // eslint-disable-next-line camelcase
+
+    global.__sxy_test_runner__ = {
+      describes: [],
+      describeCounter: 1
+    };
+    const testFileFullUrl = 'file://' + (await join(projectDir, testFile)); //console.log('testFileFullUrl', testFileFullUrl)
+
+    const test = {
+      file: testFile
+    };
+    const capturingConsoleLog = config.execution.files === 'sequential'; //// capture console.log output
+
+    let previousConsoleLog;
+    const logs = [];
+
+    if (capturingConsoleLog) {
+      previousConsoleLog = console.log; // eslint-disable-line no-console
+
+      console.log = async (...texts) => await logs.push(texts); // eslint-disable-line no-console
+
+    } ////
+
+
+    try {
+      await load(testFileFullUrl, {// scopeObject: { // experimental idea
+        //     name: 'scope',
+        //     contents: {},
+        //     exposeObject: 'scope'
+        // }
+      });
+      test.describes = global.__sxy_test_runner__.describes;
+      test.error = false;
+    } catch (e) {
+      //error(chalk.red`Error loading file ${testFileFullUrl}`)
+      test.error = `Error loading file`;
+    } finally {
+      test.logs = logs; //// restore previous console.log function
+
+      if (capturingConsoleLog) {
+        if (capturingConsoleLog) {
+          console.log = previousConsoleLog; // eslint-disable-line no-console
+        }
+      } ////
+
+    } // console.log()
+    // console.log('test', test)
+    // console.log('describes', test.describes)
+    // console.log('its', test.describes[0].its)
+    // console.log()
+
+
+    return test;
+  });
+  loading = loadPromise;
+  return await loadPromise;
+}

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

@@ -0,0 +1,45 @@
+import { loadTestFile } from "./loadTestFile.js";
+import { defaultConfig } from './defaultConfig.js'; // loadTestFile(config, testFile) ???
+
+await mochaDescribe('loadTestFile() function', async function () {
+  /*
+      mochaIt('should load a test file, retreiving describes', function() {
+  
+          const config = defaultConfig
+  
+          const sampleTestFile = 'unitTesting/sampleTests/1.test.js'
+  
+          const test = loadTestFile(config, sampleTestFile)
+  
+          test.describes.length.should.equal(1)
+          test.describes.at(-1).counter.should.equal(1)
+          test.describes[0].tests.should.be.a('function')
+          //test.describes.at(-1).its.at(-1).counter.should.equal(1)
+  
+      })
+  
+      mochaIt('should correctly load a second test file', function() {
+  
+          const config = defaultConfig
+  
+          const sampleTestFile = 'unitTesting/sampleTests/2.test.js'
+  
+          const test = loadTestFile(config, sampleTestFile)
+  
+          test.describes.length.should.equal(1)
+          test.describes.at(-1).counter.should.equal(1)
+          test.describes[0].tests.should.be.a('function')
+          //test.describes.at(-1).its.at(-1).counter.should.equal(2)
+  
+      })
+  */
+  await mochaIt('should correctly load a file with describes without any its/tests', async function () {
+    const config = defaultConfig;
+    const sampleTestFile = 'unitTesting/sampleTests/describesWithoutTests.test.js';
+    const test = await loadTestFile(config, sampleTestFile); //console.log('ut test', test)
+
+    await test.describes.length.should.equal(2);
+    await (await test.describes.at(-1)).counter.should.equal(2);
+    await test.describes[0].tests.should.be.a('function'); //test.describes.at(-1).its.at(-1).counter.should.equal(2)
+  });
+});

package/dist/cli/lib/loadTestFileStatic.js

@@ -0,0 +1,40 @@
+/*
+
+I can't remember what this was for.
+
+Would need updating to the new file load system if used
+
+import { createTimeProfiler } from 'sxy-dev-tools'
+import { packageName, cliName, configFileName, configLocations, showTimeProfiling } from '../../config.js'
+import { join } from 'path'
+const { timeProfileAsync } = createTimeProfiler(showTimeProfiling)
+
+// could be used within runTests
+// think its not used now
+
+export function loadTestFileStatic(config, testFile) {
+
+    return timeProfileAsync(`load test ${testFile} statically (standard import)`, () => {
+
+        //console.log('loadTestFileStatic', config, testFile)
+        
+        const projectDir = process.cwd()
+
+        global.testState = {
+            describes: [],
+            describeCounter: 1
+        }
+
+        import( 'file://' + join(projectDir, testFile) )
+
+        const test = {
+            file: testFile,
+            describes: global.testState.describes
+        }
+
+        return test
+
+    } )
+
+}
+*/

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

@@ -0,0 +1,29 @@
+/*
+import { loadTestFileStatic } from "./loadTestFileStatic.js"
+import { applyConfigDefaults } from './applyConfigDefaults.js'
+
+// loadTestFile(config, testFile) ???
+
+mochaDescribe('loadTestFileStatic() function', function() {
+
+    mochaIt('should load a test file, retreiving describes', function() {
+
+        const config = applyConfigDefaults({})
+
+        const sampleTestFile = 'unitTesting/sampleTests/1.test.js'
+
+        const test = loadTestFileStatic(config, sampleTestFile)
+
+        test.describes.length.should.equal(1)
+        test.describes[0].counter.should.equal(1)
+        test.describes[0].its[0].counter.should.equal(1)
+
+    })
+
+    // mochaIt('should be able to load a test file again, after cache is cleard', function() {
+
+
+    // })
+
+})
+*/

package/dist/cli/lib/overrideConsoleLog.js

@@ -0,0 +1,20 @@
+export async function overrideConsoleLog() {
+  // save the original func
+  const originalConsoleLog = console.log; // eslint-disable-line no-console
+  // create a catcher func
+
+  async function logCatcher(...texts) {
+    await logCatcher.logs.push(texts);
+  } // initise a variable on it
+
+
+  logCatcher.logs = []; // assign the new func to console.log
+
+  console.log = logCatcher; // eslint-disable-line no-console
+  // return the original func (for restoring) and the new func (for retreiving caught logging)
+
+  return {
+    originalConsoleLog,
+    replacementConsoleLog: logCatcher
+  };
+}

package/dist/cli/lib/parseCommandLineArguments.js

@@ -0,0 +1,57 @@
+// watch:
+// once:
+// // --config configLocation
+import { createTimeProfiler } from 'sxy-dev-tools';
+import { packageName, cliName, configFileName, configLocations, showTimeProfiling } from '../../config.js';
+import { join } from 'path';
+import { out, log, debug } from '../../output.js';
+const {
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling);
+import { getAllowedFlags } from './getAllowedFlags.js';
+export async function parseCommandLineArguments(allowedArguments) {
+  const allowedFlags = await getAllowedFlags(allowedArguments);
+  const returnArgs = {};
+
+  for (let position = 0; position < commandLineArguments.length; position++) {
+    const arg = commandLineArguments[position];
+
+    if ((await arg.slice(0, 2)) === '--') {
+      const longFlag = await arg.slice(2);
+
+      if (longFlag in allowedArguments) {
+        if (allowedArguments[longFlag].hasValue) {
+          const value = commandLineArguments[++position]; // increment position
+
+          returnArgs[longFlag] = value;
+        } else {
+          returnArgs[longFlag] = true;
+        }
+      } else {
+        await log(`[${packageName}] Unknown option ${longFlag}`);
+      }
+    } else if ((await arg.slice(0, 1)) === '-') {
+      const shortFlag = await arg.slice(1);
+
+      if (shortFlag in allowedFlags) {
+        const longFlag = allowedFlags[shortFlag];
+
+        if (longFlag in returnArgs) {
+          await log(`[${packageName}] Option ${longFlag} already set, being overwritten by ${shortFlag}`);
+        }
+
+        if (allowedArguments[longFlag].hasValue) {
+          const value = commandLineArguments[++position]; // increment position
+
+          returnArgs[longFlag] = value;
+        } else {
+          returnArgs[longFlag] = true;
+        }
+      } else {
+        await log(`[${packageName}] Unknown flag ${shortFlag}`);
+      }
+    }
+  }
+
+  return returnArgs;
+}

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

@@ -0,0 +1,21 @@
+import { parseCommandLineArguments } from './parseCommandLineArguments.js'; // parseCommandLineArguments(allowedArguments)
+
+await mochaDescribe('getAllowedFlags() function', async function () {
+  await mochaIt('extracts the flags from an allowedArguments object', async function () {
+    const allowedArguments = {
+      'config': {
+        flag: 'c',
+        hasValue: true
+      },
+      'watch': {
+        flag: 'w',
+        hasValue: false
+      }
+    };
+    global.commandLineArguments = ['--config', 'foo bar'];
+    const parsedArgs = await parseCommandLineArguments(allowedArguments); //console.log('parsed Args', parsedArgs)
+
+    await parsedArgs.should.have.key('config');
+    await parsedArgs.config.should.equal('foo bar');
+  });
+});

package/dist/cli/lib/parseDescribe.js

@@ -0,0 +1,88 @@
+import { timeProfileAsync } from './timeProfier.js';
+import { runTasks } from './runTasks.js';
+import { addExports } from './addExports.js';
+import { debug } from '../../output.js';
+import { runIt } from './runIt.js';
+export async function parseDescribe(config, describe) {
+  return await timeProfileAsync(`parse its from describe ${describe.thing}`, async () => {
+    let itCounter = 1;
+    const its = []; // create functions to pass back
+    // afterDescribe
+
+    let afterDescribeFunc;
+
+    async function afterDescribe(func) {
+      if (typeof func !== 'function') {
+        throw new Error(`afterDescribe() error, argument passed to afterDescribe() must be a function,` + ` received ${typeof func}`);
+      }
+
+      afterDescribeFunc = func;
+    } // beforeEachTest
+
+
+    let beforeEachTestFunc;
+
+    async function beforeEachTest(func) {
+      if (typeof func !== 'function') {
+        throw new Error(`afterDescribe() error, argument passed to afterDescribe() must be a function,` + ` received ${typeof func}`);
+      }
+
+      beforeEachTestFunc = func;
+    } // afterEachTest
+
+
+    let afterEachTestFunc;
+
+    async function afterEachTest(func) {
+      if (typeof func !== 'function') {
+        throw new Error(`afterDescribe() error, argument passed to afterDescribe() must be a function,` + ` received ${typeof func}`);
+      }
+
+      afterEachTestFunc = func;
+    } // it
+
+
+    async function it(should, test) {
+      const thisItCounter = itCounter++;
+      await its.push({
+        counter: thisItCounter,
+        should,
+        test //beforeEachTestExports
+
+      });
+    }
+
+    const test = it;
+    const beforeDescribeExports = {};
+    await configBeforeEachDescribe(config, beforeDescribeExports);
+    const describeParcel = {
+      it,
+      test,
+      afterDescribe,
+      beforeEachTest,
+      afterEachTest
+    };
+    await addExports(describeParcel, beforeDescribeExports);
+    await describe.tests(describeParcel);
+    return {
+      its,
+      beforeDescribeExports,
+      afterDescribeFunc,
+      beforeEachTestFunc,
+      afterEachTestFunc
+    };
+  });
+}
+
+async function configBeforeEachDescribe(config, exports) {
+  if (config.beforeEachDescribe) {
+    const theExports = await runTasks(config.beforeEachDescribe, undefined);
+    await addExports(exports, theExports);
+  }
+}
+
+async function configAfterEachDescribe(config, exports) {
+  if (config.afterEachDescribe) {
+    await runTasks(config.afterEachDescribe, exports);
+  }
+}

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

@@ -0,0 +1,17 @@
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { loadTestFile } from './loadTestFile.js';
+import { parseDescribe } from './parseDescribe.js';
+const defaultConfig = await applyConfigDefaults({}); // const beforeAfterTestFile = 'unitTesting/runTest/beforeAfter.test.js'
+// const beforeAfterTest = loadTestFile(defaultConfig, beforeAfterTestFile)
+
+await mochaDescribe('runDescribe() function', async function () {
+  await mochaIt('should run an it block that was loaded from a test file', async function () {
+    const sampleTestFile = 'unitTesting/runTest/1.test.js';
+    const sampleTest = await loadTestFile(defaultConfig, sampleTestFile);
+    const sampleDescribe = sampleTest.describes[0];
+    const parsedDescribe = await parseDescribe(defaultConfig, sampleDescribe);
+    await parsedDescribe.should.include.keys(['its', 'beforeDescribeExports', 'afterDescribeFunc', 'beforeEachTestFunc', 'afterEachTestFunc']); //console.log('parsedDescribe', parsedDescribe)
+
+    await parsedDescribe.its[0]['should'].should.equal('1 should equal 1');
+  });
+});

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

@@ -0,0 +1,7 @@
+//import { processWatchEvent } from './processWatchEvent.js'
+// parseCommandLineArguments(allowedArguments)
+// mochaDescribe('processWatchEvent() function', function() {
+//     mochaIt('identifies a test in a watch event', function() {
+//         processWatchEvent('temp/a.test.js', 'update')
+//     })
+// })

package/dist/cli/lib/reservedExportKeys.js

@@ -0,0 +1 @@
+export const reservedExportKeys = ['describe', 'test', 'it', 'before', 'after', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'];