sxy-test-runner 1.0.0

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

@@ -0,0 +1,294 @@
+//import { should } from 'chai'
+import { applyConfigDefaults } from './applyConfigDefaults.js';
+import { loadTestFile } from './loadTestFile.js';
+import { parseDescribe } from './parseDescribe.js';
+import { runIt } from './runIt.js';
+const defaultConfig = await applyConfigDefaults({}); // const beforeAfterTestFile = 'unitTesting/runTest/beforeAfter.test.js'
+// const beforeAfterTest = loadTestFile(defaultConfig, beforeAfterTestFile)
+
+await mochaDescribe('runIt() 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); //console.log('sample describe', sampleDescribe)
+
+    await parsedDescribe.its.length.should.equal(1);
+    const sampleIt = parsedDescribe.its[0];
+    const itResult = await runIt(defaultConfig, sampleIt); // should causes errors because our obj contains a field called 'should'
+
+    await (await chaiExpect(itResult)).to.include.keys(['counter', 'should', 'success', 'time', 'error']);
+    await itResult['should'].should.equal('1 should equal 1');
+    await itResult.success.should.equal(true);
+    await chaiShould.not.exist(itResult.error);
+  }); // mochaIt('should return sensible results from a test file without any describes', function() {
+  //     //const config = applyConfigDefaults({})
+  //     const sampleTestFile = 'unitTesting/sampletests/blank.test.js'
+  //     const sampleTest = loadTestFile(defaultConfig, sampleTestFile)
+  //     const testResult = runTest(defaultConfig, sampleTest)
+  //     //console.log(testResult)
+  //     //console.log(testResult.describeResults[0].itResults)
+  //     //console.log(testResult.describeResults[0].itResultsSummary)
+  //     testResult.should.include.keys([
+  //         'file',
+  //         'success',
+  //         'describeResults',
+  //         'describeResultsSummary'
+  //     ])
+  //     chaiExpect(testResult.success).to.be.null
+  //     //testResult.describeResultsSummary.total.should.equal(1)
+  //     //testResult.describeResultsSummary.passes.should.equal(1)
+  //     //testResult.describeResultsSummary.itsTotal.should.equal(1)
+  //     //testResult.describeResultsSummary.itsPasses.should.equal(1)
+  // })
+  // mochaIt('should return sensible results from a test file with describes without any its/tests', function() {
+  //     //const config = applyConfigDefaults({})
+  //     const sampleTestFile = 'unitTesting/sampletests/describesWithoutTests.test.js'
+  //     const sampleTest = loadTestFile(defaultConfig, sampleTestFile)
+  //     const testResult = runTest(defaultConfig, sampleTest)
+  //     //console.log(testResult)
+  //     //console.log(testResult.describeResults[0].itResults)
+  //     //console.log(testResult.describeResults[0].itResultsSummary)
+  //     testResult.should.include.keys([
+  //         'file',
+  //         'success',
+  //         'describeResults',
+  //         'describeResultsSummary'
+  //     ])
+  //     chaiExpect(testResult.success).to.be.null
+  //     testResult.describeResultsSummary.total.should.equal(0)
+  //     testResult.describeResultsSummary.passes.should.equal(0)
+  //     testResult.describeResultsSummary.invalid.should.equal(2)
+  //     testResult.describeResultsSummary.itsTotal.should.equal(0)
+  //     testResult.describeResultsSummary.itsPasses.should.equal(0)
+  // })
+  // mochaIt("should run beforeEachFile tasks (before - can't test)", function() {
+  //     let functionHasRun = false
+  //     global.beforeEachFileFileHasRun = false
+  //     const ourConfig = {
+  //         beforeEachFile: [
+  //             function() {
+  //                 functionHasRun = true
+  //             },
+  //             'unitTesting/runTest/beforeEachFile.js'
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, beforeAfterTest)
+  //     functionHasRun.should.equal(true)
+  //     global.beforeEachFileFileHasRun.should.equal(true)
+  // })
+  // mochaIt("should run afterEachFile tasks (after - can't test)", function() {
+  //     let functionHasRun = false
+  //     global.afterEachFileFileHasRun = false
+  //     const ourConfig = {
+  //         afterEachFile: [
+  //             function() {
+  //                 functionHasRun = true
+  //             },
+  //             'unitTesting/runTest/afterEachFile.js'
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, beforeAfterTest)
+  //     functionHasRun.should.equal(true)
+  //     global.afterEachFileFileHasRun.should.equal(true)
+  // })
+  // mochaIt("should run beforeEachDescribe tasks (before - can't test) each describe block", function() {
+  //     let functionHasRunTimes = 0
+  //     global.beforeEachDescribeFileHasRun = false
+  //     const ourConfig = {
+  //         beforeEachDescribe: [
+  //             function() {
+  //                 functionHasRunTimes++
+  //             },
+  //             'unitTesting/runTest/beforeEachDescribe.js'
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, beforeAfterTest)
+  //     functionHasRunTimes.should.equal(2)
+  //     global.beforeEachDescribeFileHasRun.should.equal(true)
+  // })
+  // mochaIt("should run afterEachDescribe tasks (after - can't test) each describe block", function() {
+  //     let functionHasRunTimes = 0
+  //     global.afterEachDescribeFileHasRun = false
+  //     const ourConfig = {
+  //         afterEachDescribe: [
+  //             function() {
+  //                 functionHasRunTimes++
+  //             },
+  //             'unitTesting/runTest/afterEachDescribe.js'
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, beforeAfterTest)
+  //     functionHasRunTimes.should.equal(2)
+  //     global.afterEachDescribeFileHasRun.should.equal(true)
+  // })
+  // mochaIt("should run beforeEachTest tasks (before - can't test) each test/it block", function() {
+  //     let functionHasRunTimes = 0
+  //     global.beforeEachTestbeforeEachFileFileHasRun = false
+  //     const ourConfig = {
+  //         beforeEachTest: [
+  //             function() {
+  //                 functionHasRunTimes++
+  //             },
+  //             'unitTesting/runTest/beforeEachTest.js'
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, beforeAfterTest)
+  //     functionHasRunTimes.should.equal(3)
+  //     global.beforeEachTestFileHasRun.should.equal(true)
+  // })
+  // mochaIt("should run afterEachTest tasks (after - can't test) each test/it block", function() {
+  //     let functionHasRunTimes = 0
+  //     global.afterEachTestFileFileHasRun = false
+  //     const ourConfig = {
+  //         afterEachTest: [
+  //             function() {
+  //                 functionHasRunTimes++
+  //             },
+  //             'unitTesting/runTest/afterEachTest.js'
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, beforeAfterTest)
+  //     functionHasRunTimes.should.equal(3)
+  //     global.afterEachTestFileHasRun.should.equal(true)
+  // })
+  // // exports provision to test file
+  // // current beforeEachFile exports aren't provided
+  // // perhaps extend sxy-loader to allow this
+  // mochaIt("should pass exported/returned data from beforeEachDescribe tasks", function() {
+  //     const testFile = 'unitTesting/runTest/beforeEachDescribe.test.js'
+  //     const test = loadTestFile(defaultConfig, testFile)
+  //     const ourConfig = {
+  //         beforeEachDescribe: [
+  //             function() {
+  //                 return { functionThing : 'foo' }
+  //             },
+  //             'unitTesting/runTest/beforeEachDescribeExport.js'
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, test)
+  //     global.functionThing.should.equal('foo')
+  //     global.fileThing.should.equal('bar')
+  // })
+  // mochaIt("should pass exported/returned data from beforeEachTest tasks", function() {
+  //     const testFile = 'unitTesting/runTest/beforeEachTest.test.js'
+  //     const test = loadTestFile(defaultConfig, testFile)
+  //     const ourConfig = {
+  //         beforeEachTest: [
+  //             function() {
+  //                 return { functionThing : 'foo' }
+  //             },
+  //             'unitTesting/runTest/beforeEachTestExport.js'
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, test)
+  //     global.functionThing.should.equal('foo')
+  //     global.fileThing.should.equal('bar')
+  // })
+  // // exports pass through
+  // mochaIt("beforeEachFile exports are passed through to afterEachFile", function() {
+  //     // don't try to reload test, fails due to module caching
+  //     //const testFile = 'unitTesting/runTest/beforeAfter.test.js'
+  //     //const test = loadTestFile(defaultConfig, testFile)
+  //     let exports
+  //     const ourConfig = {
+  //         beforeEachFile: [
+  //             function() {
+  //                 return { functionThing : 'foo' }
+  //             },
+  //             'unitTesting/runTest/beforeEachExport.js'
+  //         ],
+  //         afterEachFile: [
+  //             function(theExports) {
+  //                 theExports.should.have.keys(['functionThing', 'fileThing'])
+  //                 exports = theExports
+  //             },
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, beforeAfterTest)
+  //     exports.functionThing.should.equal('foo')
+  //     exports.fileThing.should.equal('bar')
+  // })
+  // mochaIt("beforeEachDescribe exports are passed through to afterEachDescribe", function() {
+  //     // don't try to reload test, fails due to module caching
+  //     //const testFile = 'unitTesting/runTest/beforeAfter.test.js'
+  //     //const test = loadTestFile(defaultConfig, testFile)
+  //     let exports
+  //     const ourConfig = {
+  //         beforeEachDescribe: [
+  //             function() {
+  //                 return { functionThing : 'foo' }
+  //             },
+  //             'unitTesting/runTest/beforeEachExport.js'
+  //         ],
+  //         afterEachDescribe: [
+  //             function(theExports) {
+  //                 exports = theExports
+  //             },
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, beforeAfterTest)
+  //     //console.log('exports', exports)
+  //     exports.functionThing.should.equal('foo')
+  //     exports.fileThing.should.equal('bar')
+  // })
+  // mochaIt("beforeEachTest exports are passed through to afterEachTest", function() {
+  //     // don't try to reload test, fails due to module caching
+  //     //const testFile = 'unitTesting/runTest/beforeAfter.test.js'
+  //     //const test = loadTestFile(defaultConfig, testFile)
+  //     let exports
+  //     const ourConfig = {
+  //         beforeEachTest: [
+  //             function() {
+  //                 return { functionThing : 'foo' }
+  //             },
+  //             'unitTesting/runTest/beforeEachExport.js'
+  //         ],
+  //         afterEachTest: [
+  //             function(theExports) {
+  //                 exports = theExports
+  //             },
+  //         ]
+  //     }
+  //     const config = applyConfigDefaults(ourConfig)
+  //     runTest(config, beforeAfterTest)
+  //     //console.log('exports', exports)
+  //     exports.functionThing.should.equal('foo')
+  //     exports.fileThing.should.equal('bar')
+  // })
+  // mochaIt("we can run code beforeEachTest and afterEachTest from within the test file", function() {
+  //     // don't try to reload test, fails due to module caching
+  //     const testFile = 'unitTesting/runTest/internalBeforeAfterEachTest.test.js'
+  //     const test = loadTestFile(defaultConfig, testFile)
+  //     const config = applyConfigDefaults({})
+  //     global.internalBeforeEachTestRanNTimes = 0
+  //     global.internalAfterEachTestRanNTimes = 0
+  //     runTest(config, test)
+  //     global.internalBeforeAfterEachTest_test1Valid.should.equal(true)
+  //     global.internalBeforeAfterEachTest_test2Valid.should.equal(true)
+  //     global.internalBeforeAfterEachTest_test3Valid.should.equal(true)
+  //     global.internalBeforeEachTestRanNTimes.should.equal(3)
+  //     global.internalAfterEachTestRanNTimes.should.equal(3)
+  // })
+  // mochaIt("we can run code afterDescribe from within descibe in the test file", function() {
+  //     // don't try to reload test, fails due to module caching
+  //     const testFile = 'unitTesting/runTest/internalAfterDescribeTest.test.js'
+  //     const test = loadTestFile(defaultConfig, testFile)
+  //     const config = applyConfigDefaults({})
+  //     global.internalAfterDescribeRanNTimes = 0
+  //     runTest(config, test)
+  //     //global.internalAfterDescribe_test1Valid.should.equal(true)
+  //     //global.internalAfterDescribe_test2Valid.should.equal(true)
+  //     global.internalAfterDescribeRanNTimes.should.equal(2)
+  // })
+});

package/dist/cli/lib/runTasks.js

@@ -0,0 +1,42 @@
+import { join } from 'path';
+import { out, log, debug } from '../../output.js';
+import { addExports } from './addExports.js';
+export async function runTasks(tasks, parcel = undefined) {
+  if (tasks) {
+    if (!(await Array.isArray(tasks))) tasks = [tasks];
+    const exports = {};
+
+    for (const task of tasks) {
+      await debug('task', typeof task, task);
+
+      switch (typeof task) {
+        case 'function':
+          {
+            const result = parcel !== undefined // redundent currently
+            ? await task(parcel) : await task();
+            await addExports(exports, result);
+            break;
+          }
+
+        case 'string':
+          {
+            const result = await import(`file://${await join(await process.cwd(), task)}`); //console.log
+
+            await addExports(exports, result);
+            break;
+          }
+
+        default:
+          {
+            await out(`Error: task entry has an invalid type, expected 'function' or 'string' of an file to import.`);
+            await out(`Received '${typeof task}'.`);
+          }
+      }
+    }
+
+    return exports;
+  } else {
+    await debug('no tasks');
+    return null;
+  }
+}

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

@@ -0,0 +1,30 @@
+import { runTasks } from './runTasks.js';
+import { defaultConfig } from './defaultConfig.js'; // runTasks(config, tasks)
+// config:
+// tasks: function, file location, or array of those
+
+await mochaDescribe('runTasks() function', async function () {
+  await mochaIt('runs tasks (functions and/or files) passed to it', async function () {
+    let functionHasRun = false;
+    global.taskFileHasRun = false;
+    const tasks = [async function () {
+      functionHasRun = true;
+    }, 'unitTesting/runTasks/task.js'];
+    await runTasks(tasks);
+    await functionHasRun.should.equal(true);
+    await global.taskFileHasRun.should.equal(true);
+  });
+  await mochaIt('passes back the properties returned from tasks', async function () {
+    const tasks = [async function () {
+      return {
+        a: 1
+      };
+    }, async function () {
+      return {
+        b: 2
+      };
+    }, 'unitTesting/runTasks/export.js'];
+    const exports = await runTasks(tasks);
+    await exports.should.have.keys(['a', 'b', 'c']);
+  });
+});

package/dist/cli/lib/runTest-old.js

@@ -0,0 +1,159 @@
+/*
+import { createTimeProfiler } from 'sxy-dev-tools'
+import chalk from 'chalk-extensions'
+import { out, log, debug } from '../../output.js'
+import { showTimeProfiling } from '../../config.js'
+
+import { runTasks } from './runTasks.js'
+
+const { timeProfileAsync } = createTimeProfiler(showTimeProfiling)
+
+export function runTest(config, test, customOut = undefined) {
+
+    return timeProfileAsync(`run test ${test.file}`, () => {
+
+        // run before test
+        if (config.beforeEachFile) runTasks(config, config.beforeEachFile)
+
+        // const beforeEachFileExports = (config.beforeEachFile)
+        //     ? runTasks(config, config.beforeEachFile)
+        //     : {}
+
+        let describeCounter = 1
+        const describeRunPromises = []
+
+        for (const describe of test.describes) {
+
+            describeRunPromises.push(
+                promise( runDescribe(config, describe) )
+            )
+
+        }
+
+        const describeResults = Promise.all(describeRunPromises)
+
+        const describeResultsSummary = {
+            total: 0,
+            passes: 0,
+            itsTotal: 0,
+            itsPasses: 0,
+        }
+
+
+        for ( const describeResult of describeResults ) {
+            describeResultsSummary.total += +(describeResult.success !== null)
+            describeResultsSummary.passes += +describeResult.success
+            describeResultsSummary.itsTotal += describeResult.itResultsSummary.total
+            describeResultsSummary.itsPasses += describeResult.itResultsSummary.passes
+        }
+
+        const testResults = {
+            file: test.file,
+            success: (describeResultsSummary.total > 0)
+                ? describeResultsSummary.total === describeResultsSummary.passes
+                : null,
+            describeResults,
+            describeResultsSummary,
+        }
+        
+        // run after test
+        if (config.afterEachFile) runTasks(config, config.afterEachFile)
+
+        return testResults
+
+
+        function runDescribe(config, describe) {
+
+            return timeProfileAsync(`run describe ${describe.thing}`, () => {
+        
+                // run before describe
+                if (config.beforeEachDescribe) runTasks(config, config.beforeEachDescribe)
+
+                // const beforeEachDescribeExports = (config.beforeEachDescribe)
+                //     ? runTasks(config, config.beforeEachDescribe)
+                //     : {}
+
+                const thisDescribeCounter = describeCounter++ // assign THEN increment
+                let itCounter = 1
+                const itResults = []
+
+                for ( const it of describe.its ) {
+                    itResults.push( runIt(config, it) )
+                }
+
+                const itResultsSummary = {
+                    total: 0,
+                    passes: 0,
+                }
+
+                for ( const itResult of itResults ) {
+                    itResultsSummary.total += +(itResult.success !== null)
+                    itResultsSummary.passes += +itResult.success
+                }
+
+                const describeResult = {
+                    counter: thisDescribeCounter,
+                    thing: describe.thing,
+                    success: (itResultsSummary.total > 0)
+                        ? itResultsSummary.passes === itResultsSummary.total
+                        : null,
+                    itResults,
+                    itResultsSummary
+                }
+
+                // run after describe
+                if (config.afterEachDescribe) runTasks(config, config.afterEachDescribe)
+
+                return describeResult
+
+                
+                function runIt(config, it, exports) {
+
+                    return timeProfileAsync(`run it ${it.should}`, () => {
+
+                        // run before test/it
+                        if (config.beforeEachTest) runTasks(config, config.beforeEachTest)
+
+                        const thisItCounter = itCounter++ // assign THEN increment
+            
+                        //// run the it
+                        let success = null
+                        let error
+                        const startTime = (new Date).getTime()
+                        try {
+                            it.test()
+                            success = true
+                        } catch (e) {
+                            success = false
+                            error = e
+                        }
+
+                        const time = (new Date).getTime() - startTime
+
+                        const itResult = {
+                            counter: thisItCounter,
+                            should: it.should,
+                            success,
+                            time,
+                            error
+                        }
+
+                        // run after test/it
+                        if (config.afterEachTest) runTasks(config, config.afterEachTest)
+
+                        return itResult
+                        //testResults.push(testResult)
+                        //testsState.testResults.push(testResult)
+
+                    })
+            
+                }
+        
+            })
+        
+        }
+
+    })
+    
+}
+*/