sxy-test-runner 1.0.0

package/dist/describe-old.js

@@ -0,0 +1,257 @@
+import chalk from 'chalk-extensions';
+import { out, log, debug } from './output.js';
+import { showTimeProfiling } from './config.js';
+import { createTimeProfiler } from 'sxy-dev-tools'; //console.log('sxyDevTools', sxyDevTools)
+//console.log('createTimeProfiler', createTimeProfiler)
+
+const {
+  timeProfile,
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling); //console.log('chalk', chalk)
+
+import { runTasks } from './cli/lib/runTasks.js';
+export async function describe(theThing, tests) {
+  const config = global.__sxy_test_runner__.config; // if config.beforeEachDescribe
+  // const beforeEachDescribeExports = runTasks(config, config.beforeEachDescribe)
+
+  const thisDescribeCounter = global.testState.describeCounter++; // ++: assign the value, THEN increment
+
+  let itCounter = 1;
+  const its = []; // create functions to pass back
+  // it
+
+  async function it(should, test) {
+    // if config.beforeEachTest
+    // const beforeEachTestExports = runTasks(config, config.beforeEachTest)
+    const thisItCounter = itCounter++;
+    await its.push({
+      counter: thisItCounter,
+      should,
+      test //beforeEachTestExports
+
+    }); // if config.afterEachTest
+    // runTasks(config, config.afterEachTest)
+  } // before
+
+
+  let beforeFunc;
+
+  async function before(func) {
+    beforeFunc = func;
+  } // after
+
+
+  let afterFunc;
+
+  async function after(func) {
+    afterFunc = func;
+  }
+
+  const provides = {
+    it,
+    before,
+    after
+  }; // addExports(provides, beforeEachDescribeExports)
+  // run the callback, to set the its
+
+  await tests({
+    it,
+    before,
+    after
+  }); //tests(provides)
+
+  const describe = {
+    counter: thisDescribeCounter,
+    thing: theThing,
+    its //beforeEachDescribeExports
+
+  };
+  await global.testState.describes.push(describe); // if config.afterEachDescribe
+  // runTasks(config, config.afterEachDescribe)
+
+  await debug(chalk.lightgrey`${thisDescribeCounter})` + chalk.lightgrey` Done with ` + chalk.brightblue`${theThing}\n`);
+}
+/*
+
+
+export async function describe(theThing, tests, testFilename) {
+
+    const timeProfiling = {}
+    timeProfiling.beforeDescribe = (new Date).getTime()
+
+    //log('tests state 1', testsState)
+
+    const thisDescribeCounter = testsState.describeCounter++ // ++: assign the value, THEN increment
+
+    //log('tests state 1.5', testsState)
+
+    let testCounter = 1
+    let testResults = []
+    
+    const its = []
+    async function it(should, test) {
+        its.push([should, test])
+    }
+
+
+    // async function it(should, test) {
+        
+    //     const timeProfiling = {}
+    //     timeProfiling.beforeIt = (new Date).getTime()
+ 
+    
+    //     const thisTestCounter = testCounter++ // ++: assign the value, THEN increment
+    //     let success = null
+    //     let error
+    //     try {
+    //         await test()
+    //         if (success === null) success = true
+    //     } catch (e) {
+    //         success = false
+    //         //console.log(e)
+    //         error = e
+    //     }
+
+    //     const testResult = {
+    //         counter: thisTestCounter,
+    //         should,
+    //         success,
+    //         error
+    //     }
+
+    //     testResults.push(testResult)
+    //     testsState.testResults.push(testResult)
+
+
+    //     timeProfiling.afterIt = (new Date).getTime()
+    //     timeProfilingOut(`it ${should}`, timeProfiling.beforeIt, timeProfiling.afterIt)
+        
+    // }
+
+    let beforeFunc
+    async function before(func) {
+        beforeFunc = func
+    }
+
+    let afterFunc
+    async function after(func) {
+        afterFunc = func
+    }
+
+    tests({it, before, after})
+
+    //log('tests state2', testsState)
+
+    testsState.theseDescribes.push({theThing, its, counter: thisDescribeCounter})
+
+    await run('do the tests', async () => {
+        for (const it of its) {
+            await testIt(...it)
+        }
+    })
+    
+    async function testIt(should, test) {
+
+        await timeProfileAsync(`it ${should}`, async () => {
+
+            const timeStart = (new Date).getTime()
+
+            const thisTestCounter = testCounter++ // ++: assign the value, THEN increment
+            let success = null
+            let error
+            try {
+                await test()
+                if (success === null) success = true
+            } catch (e) {
+                success = false
+                error = e
+            }
+
+            const timeEnd = (new Date).getTime()
+            const time = timeEnd - timeStart
+
+            const testResult = {
+                counter: thisTestCounter,
+                should,
+                success,
+                time,
+                error
+            }
+
+            testResults.push(testResult)
+            testsState.testResults.push(testResult)
+
+            // out(`${time.localeString()}ms`)
+        })
+
+    }
+
+    //console.log('testResults A', testResults)
+    testResults = testResults.sort( (a, b) => a.counter - b.counter )
+    //console.log('testResults B', testResults)
+
+    out(
+        chalk.lightgrey`${thisDescribeCounter})`
+        + chalk.lightgrey` Describing` + chalk.brightblue` ${theThing}\n`
+    )
+
+    let describeSuccess = null
+    const describeErrors = []
+
+    for (const testResult of testResults) {
+        const indexLetters = indexNumberToLetters(testResult.counter)
+        if (testResult.success) {
+            if (describeSuccess === null) describeSuccess = true
+            out(
+                chalk.lightgrey`    ${indexLetters})`
+                + chalk.mediumgreen(`  ${figures.tick}  ${testResult.should}`)
+            )
+        } else {
+            describeSuccess = false
+            describeErrors.push(testResult.error)
+            out(
+                chalk.lightgrey`    ${indexLetters})`
+                + chalk.mediumred`  ${figures.cross}  ${testResult.should}\n`
+                + chalk.mediumred`        ${testResult.error}`
+            )
+            // out(
+            //     chalk.lightgrey`    ${indexLetters})`
+            //     + chalk.brightred`  ${figures.cross}  ${testResult.should}\n`
+            //     + chalk.brightred`    ${testResult.errors}`
+            // )
+        }
+    }
+
+    const describeResult = {
+        counter: thisDescribeCounter,
+        theThing,
+        success: describeSuccess,
+        errors: describeErrors
+    }
+
+    testsState.describeResults.push(describeResult)
+
+    out(``)
+    
+    timeProfiling.afterDescribe = (new Date).getTime()
+    timeProfilingOut(`describe ${theThing}`, timeProfiling.beforeDescribe, timeProfiling.afterDescribe)
+
+    
+    global.endTest[testFilename] = (new Date).getTime()
+    timeProfilingOutSpecial(`full test ${testFilename}`, global.startTest[testFilename], global.endTest[testFilename])
+    
+}
+
+// export async function it(should, test) {
+//     out(chalk`theThing`)
+//     await test()
+// }
+
+//export const test = it
+
+
+function run(name, func) {
+    return func()
+}
+
+*/

package/dist/describe-old.unitTest.js

@@ -0,0 +1,21 @@
+import { describe } from './describe-old.js';
+await mochaDescribe('watch command', async function () {// mochaIt('should run tests and output results', async function() {
+  //     this.timeout(6000)
+  //     const originalConsoleLog = console.log
+  //     let consoleLogBuffer = ''
+  //     console.log = sync(function testLog(...texts) {
+  //         consoleLogBuffer += texts.join(' ') + '\n'
+  //     })
+  //     global.commandLineArguments = []
+  //     promise( watch() )
+  //     await new Promise( (resolve, reject) => { setTimeout(resolve, 3000) } )
+  //     console.log = originalConsoleLog
+  //     const testFileName = `dist/testing/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/describe.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk-extensions';
+import { out, log, debug } from './output.js';
+import { showTimeProfiling } from './config.js';
+import { createTimeProfiler } from 'sxy-dev-tools'; //console.log('sxyDevTools', sxyDevTools)
+//console.log('createTimeProfiler', createTimeProfiler)
+
+const {
+  timeProfile,
+  timeProfileAsync
+} = await createTimeProfiler(showTimeProfiling); //console.log('chalk', chalk)
+
+export async function describe(theThing, tests) {
+  //const thisDescribeCounter = global.testState.describeCounter++ // ++: assign the value, THEN increment
+  const thisDescribeCounter = global.__sxy_test_runner__.describeCounter;
+  global.__sxy_test_runner__.describeCounter++;
+  const describe = {
+    counter: thisDescribeCounter,
+    thing: theThing,
+    tests
+  }; //global.testState.describes.push( describe )
+
+  await global.__sxy_test_runner__.describes.push(describe);
+  await debug(chalk.lightgrey`${thisDescribeCounter})` + chalk.lightgrey` Done with ` + chalk.brightblue`${theThing}\n`);
+}

package/dist/describe.unitTest.js

@@ -0,0 +1,27 @@
+import { expect } from 'chai';
+import { describe } from './describe.js'; //import { createLoad } from 'sxy-loader'
+//const load = createLoad(import.meta.url)
+
+await mochaDescribe('new describe() function', async function () {
+  await mochaIt('should run tests and output results', async function () {
+    await this.timeout(6000); // eslint-disable-next-line camelcase
+
+    global.__sxy_test_runner__ = {
+      describes: [],
+      describeCounter: 1
+    };
+    await describe('a thing', async ({
+      it
+    }) => {
+      await it('should be great', async () => {
+        (await expect('it')).to.be.great;
+      });
+      await it('should be awesome', async () => {
+        (await expect('it')).to.be.awesome;
+      });
+    });
+    await global.__sxy_test_runner__.describes.length.should.equal(1);
+    await global.__sxy_test_runner__.describes[0].thing.should.equal('a thing');
+    await global.__sxy_test_runner__.describes[0].tests.should.be.a('function');
+  });
+});

package/dist/exported.eslintrc.js

@@ -0,0 +1,7 @@
+module.exports = {
+  "globals": {
+    "describe": "readonly",
+    "test": "readonly",
+    "it": "readonly"
+  }
+};

package/dist/index.js

@@ -0,0 +1 @@
+export { describe } from './describe.js';

package/dist/indexNumberToLetters.js

@@ -0,0 +1,13 @@
+export const indexNumberToLetters = function indexNumberToLetters(number, uppercase = false) {
+  const charCodeStart = uppercase ? 65 : 97;
+  var text = '',
+      letterIndex;
+
+  while (number > 0) {
+    letterIndex = (number - 1) % 26;
+    text = String.fromCharCode(charCodeStart + letterIndex) + text;
+    number = (number - letterIndex) / 26 | 0;
+  }
+
+  return text || undefined;
+};

package/dist/load.js

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

package/dist/output.js

@@ -0,0 +1,17 @@
+/* eslint-disable no-console */
+import { debugging } from './config.js';
+export async function out(...texts) {
+  await console.log(...texts);
+}
+export async function warn(...texts) {
+  await console.log(...texts);
+}
+export async function error(...texts) {
+  await console.log(...texts);
+}
+export async function log(...texts) {
+  await console.log(...texts);
+}
+export const debug = debugging ? async function debug(...texts) {
+  await console.log(...texts);
+} : async function () {};

package/dist/testing/example.test.js

@@ -0,0 +1,26 @@
+import { describe } from '../index.js';
+import { expect, should } from 'chai'; //console.log('chai', chai)
+//console.log('expect', expect)
+//console.log('should', should)
+
+await should();
+await describe('The example', async ({
+  it
+}) => {
+  await it('1 should equal 1', async () => {
+    await (await expect(1)).to.equal(1);
+  });
+  await it('2 should equal 2', async () => {
+    await (await expect(2)).to.equal(2);
+  });
+});
+await describe('The example 2nd thing', async ({
+  it
+}) => {
+  await it('1 should equal 1', async () => {
+    await (await expect(1)).to.equal(1);
+  });
+  await it('2 should equal 2', async () => {
+    await (await expect(2)).to.equal(2);
+  });
+});

package/dist/testing/example2.test.js

@@ -0,0 +1,19 @@
+import { describe } from '../index.js';
+import { expect, should } from 'chai';
+await should();
+await describe('Example 2', async ({
+  it
+}) => {
+  await it('3 should equal 3', async () => {
+    await (await expect(3)).to.equal(3);
+  });
+  await it('4 should equal 4', async () => {
+    await (await expect(4)).to.equal(4);
+  });
+  await it('5 should equal 5', async () => {
+    await (await expect(5)).to.equal(5);
+  });
+  await it('6 should equal 6', async () => {
+    await (await expect(5)).to.equal(5);
+  });
+});

package/dist/testing/example3.test.js

@@ -0,0 +1,16 @@
+import { describe } from '../index.js';
+import { expect, should } from 'chai';
+await should();
+await describe('Example 2', async ({
+  it
+}) => {
+  await it('3 should equal 3', async () => {
+    await (await expect(3)).to.equal(3);
+  });
+  await it('4 should equal 4', async () => {
+    await (await expect(4)).to.equal(4);
+  });
+  await it('6 should equal 6', async () => {
+    await (await expect(6)).to.equal(6);
+  });
+});

package/dist/testing/importTimeTarget.js

@@ -0,0 +1,9 @@
+import { describe } from '../index.js';
+import { expect, should } from 'chai';
+import { timeProfilingOut } from '../timeProfiling.js'; // function timeProfilingOut(name, start, finish) {
+//     //out(chalk.yellow(`[${packageName}] {${name}} time ${finish-start}ms`))
+//     console.log((`[import time test] time ${finish-start}ms`))
+// }
+//globalTimeProfiling.end = (new Date).getTime()
+
+await console.log('loaded');

package/dist/testing/importTimeTarget2.js

@@ -0,0 +1,11 @@
+import { describe } from './index.js';
+import { expect, should } from 'chai';
+import { timeProfilingOut } from './timeProfiling.js'; // function timeProfilingOut(name, start, finish) {
+//     //out(chalk.yellow(`[${packageName}] {${name}} time ${finish-start}ms`))
+//     console.log((`[import time test] time ${finish-start}ms`))
+// }
+//globalTimeProfiling.end = (new Date).getTime()
+
+const timeProfilingEnd = await new Date().getTime(); //timeProfilingOut('', timeStart, timeEnd)
+
+await console.log(timeProfilingEnd - timeProfilingStart + 'ms');

package/dist/testing/importTimeTest.js

@@ -0,0 +1,8 @@
+import { timeProfilingOut } from './timeProfiling.js'; //const globalTimeProfiling = {}
+//globalTimeProfiling.start = (new Date).getTime()
+
+await console.log('-----');
+global.timeProfilingStart = await new Date().getTime();
+await import('./importTimeTarget.js');
+global.timeProfilingStart = await new Date().getTime();
+await import('./importTimeTarget2.js');

package/dist/testsState.js

@@ -0,0 +1,4 @@
+export const testsState = {//describeCounter: 1,
+  //describeResults: [],
+  //testResults: []
+};

package/dist/timeProfiling.js

@@ -0,0 +1,9 @@
+import chalk from 'chalk-extensions';
+import { packageName, cliName, showTimeProfiling } from './config.js';
+import { out } from './output.js';
+export const timeProfilingOut = showTimeProfiling ? async function timeProfilingOut(name, start, finish) {
+  await out(await chalk.yellow(`[${packageName}] {${name}} time ${finish - start}ms`));
+} : async function () {};
+export const timeProfilingOutSpecial = showTimeProfiling ? async function timeProfilingOutSpecial(name, start, finish) {
+  await out(await chalk.orange(`[${packageName}] {${name}} time ${finish - start}ms`));
+} : async function () {};

package/package.json

@@ -0,0 +1,68 @@
+{
+    "name": "sxy-test-runner",
+    "version": "1.0.0",
+    "license": "UNLICENSED",
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "bin": {
+        "sxy-test": "./dist/cli/index.js",
+        "sxy-test-runner": "./dist/cli/index.js"
+    },
+    "files": [
+        "./dist"
+    ],
+    "scripts": {
+        "build": "babel --watch --out-dir dist src",
+        "dev": "cross-env NODE_OPTIONS=\"--experimental-specifier-resolution=node\" nodemon --experimental-specifier-resolution=node --watch dist/cli --watch dist/cli/lib --watch sxy-test-runner.config.js --watch sxy-loader.config.js dist/cli/index.js",
+        "dev-once": "nodemon --experimental-specifier-resolution=node --watch dist/cli --watch sxy-test-runner.config.js --watch sxy-loader.config.js dist/cli/index.js once",
+        "dev-init": "node --experimental-specifier-resolution=node dist/cli/index.js init",
+        "unit-test": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/*.unitTest.js",
+        "unit-test-show-test-result": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/showTestResult.unitTest.js",
+        "unit-test-load-config": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/loadConfig.unitTest.js",
+        "unit-test-watch-files": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/watchFiles.unitTest.js",
+        "unit-test-watch-files-chokidar": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/watchFilesChokidar.unitTest.js",
+        "unit-test-watch-files-and-run-tests": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/watchFilesAndRunTests.unitTest.js",
+        "unit-test-watch-files-and-run-tests-chokidar": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/watchFilesAndRunTestsChokidar.unitTest.js",
+        "unit-test-watch": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/watch.unitTest.js",
+        "unit-test-inject-properties": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/injectProperties.unitTest.js",
+        "unit-test-run-it": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/runIt.unitTest.js",
+        "unit-test-run-describe": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/runDescribe.unitTest.js",
+        "unit-test-parse-describe": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/parseDescribe.unitTest.js",
+        "unit-test-run-describe-run": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/runDescribeRun.unitTest.js",
+        "unit-test-run-test": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/runTest.unitTest.js",
+        "unit-test-load-test-file": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/loadTestFile.unitTest.js",
+        "unit-test-add-exports": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/addExports.unitTest.js",
+        "unit-test-describe": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/describe.unitTest.js",
+        "unit-test-run-tests": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/runTests.unitTest.js",
+        "mocha-trial": "mocha --watch --parallel --config unitTesting/.mocharc.cjs --watch-files dist,unitTesting dist/**/runTest.unitTest.js"
+    },
+    "dependencies": {
+        "@babel/core": "^7.16.5",
+        "chalk-extensions": "^1.0.0",
+        "cross-env": "^7.0.3",
+        "dependency-tree": "^8.1.2",
+        "figures": "^4.0.0",
+        "glob": "^7.2.0",
+        "globby": "^12.0.2",
+        "node-watch": "^0.7.2",
+        "sinon-chai": "^3.7.0",
+        "slash": "^4.0.0",
+        "sxy-dev-tools": "file:../sxy-dev-tools",
+        "sxy-loader": "^1.0.0",
+        "sxy-standard": "^1.0.0",
+        "sxy-standard-object-copy": "^1.0.0"
+    },
+    "devDependencies": {
+        "@babel/cli": "^7.16.0",
+        "babel-plugin-transform-awaitful": "^1.0.0",
+        "chai": "^4.3.4",
+        "chai-as-promised": "^7.1.1",
+        "eslint": "^7.32.0",
+        "eslint-config-sandi": "^1.0.5",
+        "mocha": "^9.1.3",
+        "mocha-steps": "^1.3.0",
+        "nodemon": "^2.0.15",
+        "sinon": "^12.0.1"
+    }
+}