risei 3.0.0 → 3.1.1

package/system/SpoofDef.js

@@ -2,6 +2,7 @@
 
 import TypeAnalyzer from "./TypeAnalyzer.js";
 import NameAnalyzer from "./NameAnalyzer.js";
+import TotalDisplayer from "./TotalDisplayer.js";
 
 /* Defines what is found in a spoof definition, typically as 
    a nonce object rather than an instance of this class. */
@@ -130,14 +131,14 @@ export default class SpoofDef {
 
     // region Initing, including constructor() and statics
 
-    /* Constructor can't use param names like `of`, because when not .-prefixed, they are keywords. */
-
+    /* Long names used, just in case. */
     constructor(target, method, output) /* passed */ {
         this.target = target;
         this.method = method;
         this.output = output;
     }
 
+    /* Arg 'type' should be test.type if present. */
     static fromNonceTuples(nonces, type) /* passed */ {
         // Throughput and output.
         let full = new SpoofDef();
@@ -154,82 +155,102 @@ export default class SpoofDef {
         return output;
     }
     
+    /* Arg 'type' should be test.type if present. */
     static fromNonceTuple(nonce, type) /* passed */ {
-        /* No spoof-def to output. */
+        // No spoof-def to output.
         if (SpoofDef.isNotASpoof(nonce)) {
             return [ ];
         }
 
-        // Empty, since properties can be set 
-        // by either of two nonce naming styles.
+        let defs = [ ];
+
+        // Nonce defines one spoof.
+        if (SpoofDef.#isMonoSpoof(nonce)) {
+            let def = SpoofDef.#fromMonoNonce(nonce, type);
+            defs.push(def);
+        }
+
+        // Nonce defines more than one spoof: Recursion.
+        if (SpoofDef.#isPolySpoof(nonce)) {
+            let locals = SpoofDef.#fromPolyNonce(nonce, type);
+            defs.push(...locals);
+        }
+
+        return defs;
+    }
+
+    // region Dependencies of nonce-tuple initing methods
+
+    static #isMonoSpoof(nonce) /* verified */ {
+        return SpoofDef.#hasEitherName(nonce, SpoofDef.#ofNames);
+    }
+
+    static #isPolySpoof(nonce) /* verified */ {
+        return !SpoofDef.#isMonoSpoof(nonce);
+    }
+
+    /* Arg 'type' should be test.type if present. */
+    static #fromMonoNonce(nonce, type) /* verified */ {
+        // Empty, since each prop can 
+        // have either of two names.
         let def = new SpoofDef();
 
         let shortNames = SpoofDef.#longsByShort.keys();
 
-        /* &cruft, maybe refactor to put property-setting loop in its own method, and possibly 
-                   recurse internally using it without inner arrays, for a cleaner algorithm */
-
-        // Traversing matching pairs of names and applying 
-        // whichever one is present as the tuple property;
+        // Traversing name pairs to use whichever one is present; 
         // if neither is present, the property is undefined.
         for (let shortName of shortNames) {
             let longName = SpoofDef.#longsByShort.get(shortName);
-            def[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
+
+            def[shortName] 
+                = nonce[shortName] !== undefined 
+                ? nonce[shortName] 
+                : nonce[longName];
+        }
+
+        // Adding test target's type, if no type provided.
+        if (def.target === undefined) {
+            def.target = type;
         }
 
-        // No nested partial spoof-defs 
-        // (mono-spoof) is most likely.
-        let defs = [ def ];
+        return def;
+    }
 
-        // Recursion to handle nested partial spoof-defs (poly-spoofs).
-        if (def.method === undefined && Array.isArray(def.output)) {
-            let locals = [ ];
+    /* Arg 'type' should be test.type if present. */
+    static #fromPolyNonce(nonce, type) /* verified */ {
+        let defs = [ ];
 
-            for (let ofAsPair of def.output) {
-                let localOf = ofAsPair.of !== undefined ? ofAsPair.of : ofAsPair.method;
-                let localAs = ofAsPair.as !== undefined ? ofAsPair.as : ofAsPair.output;
+        // Poly-nonce's .on applies to all its partial spoofs.
+        let on = nonce.on !== undefined ? nonce.on : nonce.target;
 
-                let passer = SpoofDef.fromNonceTuple({ on: def.target, of: localOf, as: localAs });
-                locals.push(passer[0]);
-            }
+        // Poly-nonce's .as is an array of partial-spoof nonces.
+        let pairs = nonce.as !== undefined ? nonce.as : nonce.output;
 
-            // Replace default spoof 
-            // with real poly-spoofs.
-            defs = locals;
-        }
+        // Traversing partial-spoof nonces (.of and .as only).
+        for (let pair of pairs) {
+            // Either name (or neither) may exist on nonce partial.
+            let of = pair.of !== undefined ? pair.of : pair.method;
+            let as = pair.as !== undefined ? pair.as : pair.output;
 
-        // All defs need a type / target class.
-        SpoofDef.#setAnyMissingTypes(defs, type);
+            // Only one level of recursion.
+            let passer = SpoofDef.#fromMonoNonce({ on, of, as }, type);
+
+            defs.push(passer);
+        }
 
-        // Back to caller.
         return defs;
     }
 
-    // region Dependencies of nonce-tuple initing methods
-
     static #hasEitherName(nonce, names) /* verified */ {
         let hasEither = false;
 
         for (let name of names) {
-            hasEither ||= SpoofDef.#hasName(nonce, name);
+            hasEither ||= nonce[name] !== undefined;
         }
         
         return hasEither;
     }
 
-    static #hasName(nonce, name) /* verified */ {
-        return nonce[name] !== undefined;
-    }
-
-    static #setAnyMissingTypes(defs, type) /* verified */ {
-        // Adding test target's type, if no type provided.
-        for (let def of defs) {
-            if (def.target === undefined) {
-                def.target = type;
-            }
-        }
-    }
-
     // endregion Dependencies of nonce-tuple initing methods
 
     // endregion Initing, including constructor() and statics
@@ -237,19 +258,13 @@ export default class SpoofDef {
     // region Overrides and dependencies
 
     toString() /* passed */ {
-        let text = `SpoofDefinition:{ target:${ this.#asRawOrString(this.target) }, `
-            + `method:${ this.#asRawOrString(this.method) }, `
-            + `output:${ this.#asRawOrString(this.output) } }`;
+        let displayer = new TotalDisplayer();
+
+        let text = `SpoofDef{ on:${ displayer.display(this.target) }, `
+            + `of:${ displayer.display(this.method) }, `
+            + `as:${ displayer.display(this.output) } }`;
         return text;
     }
-    
-    #asRawOrString(value) /* verified */ {
-        if (typeof value === "string") {
-            return `"${ value }"`;
-        }
-        
-        return value;
-    }
-    
+
     // endregion Overrides and dependencies
 }

package/system/TerminalReporter.js

@@ -1,8 +1,8 @@
 /**/
 
-/* TerminalReporter is an ATestReporter that sends each result to the terminal / console for display. */
+/* TerminalReporter displays each test result in the terminal / console window. */
 
-import ATestReporter from "./ATestReporter.js";
+import Moment from "./Moment.js";
 import TestGroup from "./TestGroup.js";
 import ClassTestGroup from "./ClassTestGroup.js";
 import MethodTestGroup from "./MethodTestGroup.js";
@@ -11,8 +11,12 @@ import TestSummary from "./TestSummary.js";
 
 import chalk from "chalk";
 
-export default class TerminalReporter extends ATestReporter {
-    // region Private fields
+export default class TerminalReporter {
+    // region Fields
+
+    /* Display styles for the start title and other general needs. */
+    #title = chalk.hex("FFFFFF").bgHex("191970").bold;
+    #fails = chalk.hex("000000").bgHex("FFD700").bold;
 
     /* Foreground-colors using dependency calls and hex. */
     #trueWhite = chalk.hex("FFFFFF");
@@ -31,22 +35,53 @@ export default class TerminalReporter extends ATestReporter {
     #methodGroup = this.#trueWhite.bgHex(this.#aqua).bold;
     #passed = this.#trueBlack.bgHex(this.#paleGreen);
     #failed = this.#trueBlack.bgHex(this.#paleRed);
+    #problems = chalk.hex("000000").bgHex("FFD700").bold;
+
     #passedSummary = this.#trueBlack.bgHex(this.#paleGreen).bold;
     #failedSummary = this.#trueBlack.bgHex(this.#paleRed).bold;
     #summary = chalk.hex("000080").bgHex("FAFAD2").bold;
 
+
     // Count of characters used for indent 
     // and text to the left of each test.
     #preUsedWidth = 20;
 
-    // endregion PrivateFields
+    // endregion Fields
+
+    reportTitle() {
+        // This moment, ready for use in title.
+        let now = new Date();
+        now = new Moment(now);
+
+        // Top of screen and leading color stripe.
+        console.clear();
+        console.log();
+        console.log(this.#title(this.#wide()));
 
-    // region ATestReporter
+        // Actually reporting title.
+        console.log(this.#title(this.#wide(` Risei tests run on ${ now.asReadable() } local time.`)));
+
+        // Trailing color stripe and blank line.
+        console.log(this.#title(this.#wide()));    
+        console.log();
+    }
+
+    // region Dependencies of reportTitle()
+
+    /* Styling for color stripes. */
+    #wide(text) { 
+        let width = process.stdout.columns;
+        text = text || "";
+
+        return text.padEnd(width, "\u00A0");
+    };
+
+    // endregion Dependencies of reportTitle()
 
     reportNext(result) {
         // The next result introduces a group of tests.
         if (result instanceof TestGroup) {
-            this.reportGroup(result);
+            this.#reportGroup(result);
             return;
         }
 
@@ -58,12 +93,14 @@ export default class TerminalReporter extends ATestReporter {
 
         // The next result is the summary of all tests.
         if (result instanceof TestSummary) {
-            this.reportSummary(result);
+            this.#reportSummary(result);
             return;
         }
     }
 
-    reportGroup(result) {
+    // region Direct dependencies of reportNext(), except summary
+
+    #reportGroup(result) {
         if (result instanceof ClassTestGroup) {
             console.log(this.#classGroup(` ${ result.group }: `));
         }
@@ -73,32 +110,44 @@ export default class TerminalReporter extends ATestReporter {
         }
     }
 
-    // region Private dependencies of reportNext()
-
     #reportTestResult(result) {
+        if (result.doesHaveThrow) {
+            this.#reportThrew(result.anyThrow.stack);
+        }
+
+        if (result.doesHaveTrouble) {
+            this.#reportThrew(result.anyTrouble.stack);
+        }
+
         if (result.didPass) {
-            this.reportPassed(result);
+            this.#reportPassed(result);
         }
 
         if (!result.didPass) {
-            this.reportFailed(result);
+            this.#reportFailed(result);
         }
     }
 
-    // endregion Private dependencies of reportNext()
+    // endregion Direct dependencies of reportNext(), except summary
+
+    // region Direct dependencies of #reportTestResult()
+
+    #reportThrew(threw) {
+        console.log(this.#problems(threw));
+    }
 
-    reportPassed(result) {
+    #reportPassed(result) {
         this.#reportOneTestResult(result, "Passed", this.#passed);
     }
 
-    reportFailed(result) {
+    #reportFailed(result) {
         this.#reportOneTestResult(result, "Failed", this.#failed);
     }
 
-    // region Private dependencies of reportPassed() and reportFailed()
+    // endregion Direct dependencies of #reportTestResult()
+
+    // region Dependencies of #reportPassed() and #reportFailed()
 
-    /* &cruft, changes here / in dependencies 
-       for better splitting to multiple lines */
     #reportOneTestResult(result, net, styler) {
         let { lineOne, lineTwo, lineThree, lineFour } = this.#calculateResultDisplay(result);
 
@@ -166,7 +215,7 @@ export default class TerminalReporter extends ATestReporter {
         return this.#oneLineTactic(identityText, inputsText, expectedText, actualText);
     }
 
-    // region Private dependencies of #calculateResultDisplay()
+    // region Dependencies of #calculateResultDisplay()
 
     #fourLineTactic(identityText, inputsText, expectedText, actualText) {
         // Each line on its own.
@@ -218,13 +267,17 @@ export default class TerminalReporter extends ATestReporter {
         return { lineOne, lineTwo, lineThree, lineFour };
     }
 
-    // endregion Private dependencies of #calculateResultDisplay()
+    // endregion Dependencies of #calculateResultDisplay()
+
+    // endregion Dependencies of #reportPassed() and #reportFailed()
 
-    // endregion Private dependencies of reportPassed() and reportFailed()
+    // region Summary dependency of reportNext()
 
-    reportSummary(summary) {
+    #reportSummary(summary) {
         console.log();
 
+        /* Actual summary. */
+
         if (summary.anyWereRun) {
             if (summary.allDidPass) {
                 console.log(this.#passedSummary(this.#toFullWidth(" Test run succeeded.")));
@@ -235,7 +288,31 @@ export default class TerminalReporter extends ATestReporter {
         }
 
         console.log(this.#summary(this.#toFullWidth(` ${ summary.summary }`)));
-    }
+
+        /* Post-summary reporting of any throws. */
+
+        // Unsought throws in tested code.
+        if (summary.anyThrows.length !== 0) {
+            console.log();
+            console.log(this.#problems(summary.anyThrows.join("\n")));
+        }
+
+        // Throws in code in scope of test frame.
+        if (summary.anyTroubles.length !== 0) {
+            console.log();
+            console.log(this.#problems(summary.anyTroubles.join("\n")));
+        }
+
+        // Throws in code in scope of test runner.
+        if (summary.anyCaught.length !== 0) {
+            console.log();
+            console.log(this.#problems(summary.anyCaught.join("\n")));
+        }
+   }
+
+    // endregion Summary dependency of reportNext()
+
+    // region Dependencies of #reportSummary()
 
     #toFullWidth(text) {
         text = text || "";
@@ -244,6 +321,13 @@ export default class TerminalReporter extends ATestReporter {
         return text.padEnd(width, "\u00A0");
     }
 
-    // endregion ATestReporter
+    // endregion Dependencies of #reportSummary()
 
+    blankLine() {
+        console.log();
+    }
+
+    reportLoadFail(fail) {
+        console.log(this.#fails(this.#wide(` ${ fail }`)));
+    }
 }

package/system/TestDef.js

@@ -4,6 +4,8 @@ import TypeAnalyzer from "./TypeAnalyzer.js";
 import NameAnalyzer from "./NameAnalyzer.js";
 import TypeIdentifier from "./TypeIdentifier.js";
 import Types from "./Types.js";
+import CallTypes from "./CallTypes.js";
+import TotalDisplayer from "./TotalDisplayer.js";
 
 /* Defines what is found in a test definition, typically as 
    a nonce object rather than an instance of this class. */
@@ -57,7 +59,8 @@ export default class TestDef {
     target;
     
     actual;
-    thrown;
+    thrown;   // Throw in inner scope (tested code).
+    trouble;  // Throw in outer scope (test system or .do / .undo / .from).
     
     // endregion Fields
 
@@ -187,6 +190,10 @@ export default class TestDef {
         return is;
     }
 
+    get isMonoCallTest() /* passed */ {
+        return !this.isPolyCallTest;
+    }
+
     get isPolyCallTest() /* passed */ {
         let is = this.andStringContains(TestDef.polyName);
         return is;
@@ -198,7 +205,7 @@ export default class TestDef {
     }
 
     get isMethodTest() /* passed */ {
-        return !this.isPropertyTest;
+        return !this.isPropertyTest && !this.isConstructorTest;
     }
 
     get isPropertyTest() /* passed */ {
@@ -211,6 +218,22 @@ export default class TestDef {
         return isPropertyTest;
     }
 
+    get callType() /* passed */ {
+        let type;
+
+        if (this.isMethodTest) {
+            type = this.isMonoCallTest ? CallTypes.methodMono : CallTypes.methodPoly;
+        } 
+        else if (this.isPropertyTest) {
+            type = this.isMonoCallTest ? CallTypes.propMono : CallTypes.propPoly;
+        } 
+        else if (this.isConstructorTest) {
+            type = this.isMonoCallTest ? CallTypes.conMono : CallTypes.conPoly;
+        }
+
+        return type;
+    }
+
     get isRetrievalTest() /* passed */ {
         // Falsy code elements never are a retrieval.
         if (!this.from) {
@@ -256,7 +279,7 @@ export default class TestDef {
     get runName() /* passed */ {
         let plain = NameAnalyzer.plainNameOf(this.of);
 
-        if (this.isMethodTest) {
+        if (!this.isPropertyTest) {
             return `${ plain }()`;
         }
         else {
@@ -264,6 +287,23 @@ export default class TestDef {
         }
     }
 
+    get anyUnsoughtThrow() /* passed */ {
+        // Prop is true when throw is sought.
+        if (this.isThrowTest) {
+            return;
+        }
+
+        return this.thrown;
+    }
+
+    get doesHaveUnsoughtThrow() /* passed */ {
+        return this.anyUnsoughtThrow !== undefined;
+    }
+
+    get doesHaveTrouble() /* passed */ {
+        return this.trouble !== undefined;
+    }
+
     // endregion State properties
 
     // region State methods
@@ -282,8 +322,7 @@ export default class TestDef {
 
     // region Initing, including constructor()
 
-    /* Constructor can't use parameter names like `for`: 
-       when not .-prefixed, they are purely keywords. */
+    /* Long names used, since some short names, like `for`, are parsed as keywords. */
     constructor(nature, type, spoofed, initors, method, inputs, output, source, factors, enact, counteract) /* ok */ {
         this.nature = nature;           // .for 
         this.type = type;               // .on 
@@ -305,6 +344,11 @@ export default class TestDef {
 
         // Looping over all.
         for (let nonce of nonces) {
+            // No possible test definition to output.
+            if (!TestDef.isANonce(nonce)) {
+                continue;
+            }
+
             // Get latest test definition.
             let latest = TestDef.fromNonceTuple(nonce);
 
@@ -359,6 +403,11 @@ export default class TestDef {
 
     // region Dependencies of nonce-tuple initing methods
 
+    static isANonce(topic) /* passed */ {
+        let type = TypeIdentifier.identify(topic);
+        return type === Types.isObject;
+    }
+
     /* Replaces some or all of the 'full' that gathers test 
        props for reuse when targeting changes significantly 
        in the middle of the collapsing-forward process. */
@@ -417,4 +466,22 @@ export default class TestDef {
 
     // endregion Initing, including constructor()
 
+    toString() /* verified */ {
+        let displayer = new TotalDisplayer();
+
+        let text = `TestDef{ for:${ displayer.display(this.for) }, `
+           + `on:${ displayer.display(this.on) }, `
+           + `with:${ displayer.display(this.with) }, `
+           + `of:${ displayer.display(this.of) }, `
+           + `plus:${ displayer.display(this.plus) }, `
+           + `in:${ displayer.display(this.in) }, `
+           + `out:${ displayer.display(this.out) }, `
+           + `from:${ displayer.display(this.from) }, `
+           + `and:${ displayer.display(this.and) }, `
+           + `do:${ displayer.display(this.do) }, `
+           + `undo:${ displayer.display(this.undo) } }`
+
+        return text;
+    }
+
 }

package/system/TestFinder.js

@@ -1,14 +1,14 @@
 /**/
 
-/* TestFinder is an ATestFinder that finds tests in the places identified in package.json. */
+/* TestFinder retrieves test sources based on .risei.tests in package.json. */
 
-import ATestFinder from "./ATestFinder.js";
 import ATestSource from "./ATestSource.js";
+import Choices from "./Choices.js";
 import fs from "node:fs";
 import path from "node:path";
 import { minimatch } from "minimatch";
 
-export default class TestFinder extends ATestFinder {
+export default class TestFinder  {
     // region Definitions
 
     static NO_SUCH_FILE = "ENOENT";
@@ -21,20 +21,37 @@ export default class TestFinder extends ATestFinder {
     // endregion Definitions
 
     // region Fields
-    
+
+    #testSources;
+    #thrown = [];
+
     #sought;
     
     // endregion Fields
 
+    // region Properties
+
+    get testSources() {
+        return this.#testSources;
+    }
+
+    set testSources(value) {
+        this.#testSources = value;
+    }
+
+    get thrown() {
+        return this.#thrown;
+    }
+
+    // endregion Properties
+
     constructor() {
-        super();
+        this.#testSources = [];
     }
 
     async findAllTests() {
-        // Paths for test sources are listed in package.json, possibly with globbing.
-        let source = this.sourceBySearch();
-        this.#sought = source.tests;
-        let testPaths = this.pathsFromTargetingSource();
+        this.#sought = this.supplyTestTargeting();
+        let testPaths = this.pathsFromTargeting();
 
         testPaths = this.sortTestPaths(testPaths);
 
@@ -54,28 +71,13 @@ export default class TestFinder extends ATestFinder {
         return tests;
     }
 
-    sourceBySearch() {
-        // App's package.json always found at process.cwd().
-        let packageSite = process.cwd();
-        let pathAndName = path.join(packageSite, TestFinder.METADATA_FILE);
-
-        // Contents of package.json are just a single JSON object.
-        let packageJson = fs.readFileSync(pathAndName, { encoding: "utf8" });
-        packageJson = JSON.parse(packageJson);
-
-        // Can't run or reasonably recover if this is not defined.
-        if (!packageJson.risei) {
-            throw new Error(
-                `For Risei tests to run, this app's package.json must contain `
-                + `a node like this: "risei": { tests: "path-or-glob-here" }.  `
-                + `One glob or path may be used, or an array of them.`);
-        }
-
-        // Only Risei's own metadata is needed.
-        return packageJson.risei;
+    // Spoofing point for self-testing.
+    supplyTestTargeting() {
+        // Value retrieved from package.json.
+        return Choices.testTargeting;
     }
 
-    pathsFromTargetingSource() {
+    pathsFromTargeting() {
         let paths = [];
         let root = process.cwd();