risei 1.0.0

package/public/javascript/SpoofClassMethodsFixture.js

@@ -0,0 +1,165 @@
+/**/
+
+import { ASpoofingFixture } from "./ASpoofingFixture.js";
+import { SpoofTuple } from "./SpoofTuple.js";
+
+export class SpoofClassMethodsFixture extends ASpoofingFixture {
+    // region Private fields
+
+    #spoofsByClass = new Map();
+    #originalsByClass = new Map();
+
+    // endregion Private fields
+
+    // region Properties
+
+    get spoofsByClass() {
+        return this.#spoofsByClass;
+    }
+
+    set spoofsByClass(value) {
+        this.#spoofsByClass = value;
+    }
+
+    get originalsByClass() {
+        return this.#originalsByClass;
+    }
+
+    set originalsByClass(value) {
+        this.#originalsByClass = value;
+    }
+
+    // endregion Properties
+
+    constructor() {
+        super("SpoofClassMethodsFixture", "Construction");
+    }
+    
+    /* Spoofs methods of classes as defined in nonce 
+       spoof-tuple definitions in any test.plus. */
+    spoof(test) {
+        // Localizing.
+        let type = test.on;
+        let spoofNonces = test.plus;
+        
+        // Spoofing definitions are always in an array.
+        if (!Array.isArray(spoofNonces)) {
+            return;
+        }
+    
+        // Converting to scope object type.
+        let spoofTuples = SpoofTuple.fromNonceTuples(spoofNonces);
+        
+        // Storing spoofing definitions.
+        this.#targetThese(type, spoofTuples);
+        
+        // Storing originals for restoring later.
+        this.#reserveOriginalsForSpoofs();
+        
+        // Actually spoofing.
+        this.#spoofAll();
+    }
+
+    #targetThese(type, spoofTuples) {
+        // Map of Maps: by type, then by method.
+        for (let tuple of spoofTuples) {
+            // If no .target, use `type`. 
+            if (!tuple.target) {
+                tuple.target = type;
+            }
+            
+            // Either the existing Map for this type, or a new one if none yet. 
+            let spoofsByTarget = this.#spoofsByClass.get(tuple.target);
+            
+            if (!spoofsByTarget) {
+                spoofsByTarget = new Map();
+                this.#spoofsByClass.set(tuple.target, spoofsByTarget);
+            }
+            
+            // A single-method spoof is set for later use.
+            if (tuple.method) {
+                spoofsByTarget.set(tuple.method, tuple.output);
+                continue;
+            }
+            
+            // Two or more method spoofs are set for later use.
+            if (tuple.output) {
+                let ofAsPairs = tuple.output;
+                
+                for (let pair of ofAsPairs) {
+                    spoofsByTarget.set(pair.of, pair.as);
+                }
+                
+                continue;
+            }
+        }
+    }
+    
+    #reserveOriginalsForSpoofs() {
+        /* Any spoofing of multiple methods on each class has already been 
+           split up into Map elements, so this code can use those naively. */
+    
+        let types = this.#spoofsByClass.keys();
+        
+        for (let type of types) {
+            let originalsByTarget = this.#originalsByClass.get(type);
+            
+            if (!originalsByTarget) {
+                originalsByTarget = new Map();
+                this.#originalsByClass.set(type, originalsByTarget);
+            }
+
+            let spoofsByTarget = this.#spoofsByClass.get(type);
+            let names = spoofsByTarget.keys();
+            
+            for (let name of names) {
+                let original = type.prototype[name];
+                originalsByTarget.set(name, original);
+            }
+        }
+    }
+
+    #spoofAll() {
+        /* Any spoofing of multiple methods on each class has already been 
+           split up into Map elements, so this code can use those naively. */
+
+        let types = this.#spoofsByClass.keys();
+    
+        for (let type of types) {
+            let spoofsByTarget = this.#spoofsByClass.get(type);
+            let names = spoofsByTarget.keys();
+            
+            for (let name of names) {
+                let spoofSource = spoofsByTarget.get(name);
+                let spoof = super.spoofMethod(spoofSource);
+                type.prototype[name] = spoof;
+            }
+        }
+    }
+
+    // Spoofed methods on any targeted classes 
+    // are restored to their original forms.
+    unspoof() {
+        let types = this.#originalsByClass.keys();
+        
+        for (let target of types) {
+            let originalsByTarget = this.#originalsByClass.get(target);
+            
+            let prototype = target.prototype;
+            
+            let names = originalsByTarget.keys();
+            
+            for (let name of names) {
+                let original = originalsByTarget.get(name);
+                target.prototype[name] = original;
+            }
+        }
+    }
+    
+    // Removes definitions, useful if this instance is reused, 
+    // or else they might be applied when they shouldn't be.
+    removeDefinitions() {
+        this.#spoofsByClass.clear();
+        this.#originalsByClass.clear();
+    }
+}

package/public/javascript/SpoofObjectMethodsFixture.js

@@ -0,0 +1,52 @@
+/* */
+
+import { ASpoofingFixture } from "./ASpoofingFixture.js";
+import { SpoofTuple } from "./SpoofTuple.js";
+
+export class SpoofObjectMethodsFixture extends ASpoofingFixture {
+    constructor() {
+        super("SpoofObjectMethodsFixture", "Construction");
+    }
+    
+    /* Spoofs methods of any objects in test.with and test.in 
+       for which nonce spoof-tuple definitions are provided. */
+    spoof(test) {
+        // These array test aspects may contain object-spoof definitions.
+        let topics = [ test.with, test.in ];
+        
+        // Spoofing each element, or leaving it in place if not a spoof.
+        for (let topic of topics) {
+            for (let at = 0; at < topic.length; at++) {
+                let target = topic[at];
+                topic[at] = this.spoofTarget(target);
+            }
+        }
+    }
+
+    spoofTarget(target) {
+        // Non-spoofs are returned unchanged.
+        if (SpoofTuple.isNotASpoof(target)) {
+            return target;
+        }
+
+        // Spoofs are converted to their type.
+        let tuple = SpoofTuple.fromNonceTuple(target);
+        
+        // Actually spoofing.
+        let spoof = this.#supplySpoof(tuple);
+        return spoof;
+    }
+
+    #supplySpoof(target) {
+        // Common case.
+        let ofAsPairs = [{ of: target.method, as: target.output }];
+
+        // Complex case.
+        if (!target.method) {
+            ofAsPairs = target.output;
+        }
+
+        let spoof = super.spoofObjectTree(ofAsPairs);
+        return spoof;
+    }
+}

package/public/javascript/SpoofTuple.js

@@ -0,0 +1,238 @@
+/**/
+
+/* Defines what is found in a spoof-definition tuple (SDT).  Actual SDTs don't need to be instances of this class. */
+
+export class SpoofTuple {
+    // region Static fields
+
+    /* Properties can have short or long names. */
+    static #longsByShort = new Map([
+        [ "on", "target" ],
+        [ "of", "method" ],
+        [ "as", "output" ],
+    ]);
+    
+    /* Objects with either of these property names aren't 
+       converted to SpoofTuples by from-nonce methods. */
+    static skipNames = [ "not", "skip" ];
+
+    // endregion Static fields
+
+    // region Public fields (long names)
+
+    /* These long names are clearer and match the constructor's parameter names. */
+
+    /* The test-definition field names use the longer, possibly clearer forms.  
+       Equivalent short-name and long-name properties use the same fields. */
+
+    target;
+    method;
+    output;
+
+    // endregion Public fields (long names)
+
+    // region Properties
+
+    // region Spoof definition, short names
+
+    /* These short names make JSON-like definitions easier. */
+
+    get on() {
+        return this.target;
+    }
+
+    set on(value) {
+        this.target = value;
+    }
+
+    get of() {
+        return this.method;
+    }
+
+    set of(value) {
+        this.method = value;
+    }
+
+    get as() {
+        return this.output;
+    }
+
+    set as(value) {
+        this.output = value;
+    }
+
+    // endregion Spoof definition, short names
+
+    // region Tuple state
+
+    /* Returns true if instance provides enough to spoof with.
+       A spoof must define at least either a method to spoof, or an output 
+       containing an array of methods to spoof, with optional outputs.
+       See .notASpoof() for a contrasting condition. */
+    isSpoofable() /* passed */ {
+        let isSpoofable 
+            = this.method !== undefined 
+            || this.output !== undefined; 
+        
+        return isSpoofable;
+    }
+
+    // endregion Tuple state
+
+    // endregion Properties
+
+    // region Initing, including constructor()
+
+    /* Constructor can't use param names like `of`, because when not .-prefixed, they are keywords. */
+
+    constructor(target, method, output) /* passed */ {
+        this.target = target;
+        this.method = method;
+        this.output = output;
+    }
+
+    static fromNonceTuples(nonces) {
+        // Throughput and output.
+        let full = new SpoofTuple();
+        let output = [];
+
+        // Looping over all.
+        for (let nonce of nonces) {
+            // Don't convert non-tuples, but output 
+            // them unchanged for the caller.
+            if (SpoofTuple.isNotASpoof(nonce)) {
+                output.push(nonce);
+                continue;
+            }
+        
+            // Get latest spoof definition.
+            let latest = SpoofTuple.fromNonceTuple(nonce);
+
+            // Restarting spoof definitions when desired.
+            full = SpoofTuple.maybeRestartFull(full, latest);
+
+            // Merge any previous 
+            // values into latest.
+            latest.combineWith(full);
+
+            // Make latest the tuple for 
+            // combining with next time.
+            full = latest;
+
+            // Add latest only if it's 
+            // ready to use to spoof.
+            if (latest.isSpoofable) {
+                output.push(latest);
+            }
+        }
+
+        // Back to caller.
+        return output;
+    }
+    
+    /* Returns true if arg should not be used for spoofing.
+       See isSpoofable() for a contrasting condition. */
+    static isNotASpoof(nonce) /* passed */ {
+        /* Any nonce that is null or undefined is not a SpoofTuple. */
+        if (nonce === undefined || nonce === null) {
+            return true;
+        }
+    
+        /* Any nonce with .not or .skip isn't a SpoofTuple, even if it has SpoofTuple properties. */
+        for (let non of SpoofTuple.skipNames) {
+            if (nonce[non] !== undefined) {
+                return true;
+            }
+        }
+        
+        /* Any other nonce with any SpoofTuple properties is a full or partial SpoofTuple. */
+        for (let key of SpoofTuple.#longsByShort.keys()) {
+            let value = SpoofTuple.#longsByShort.get(key);
+        
+            if (nonce[key] !== undefined) {
+                return false;
+            }
+            
+            if (nonce[value] !== undefined) {
+                return false;
+            }
+        }
+    
+        /* Any nonce without SpoofTuple properties is not a spoof. */
+        return true;
+    }
+    
+    /* &cruft, test or drop */
+    static isASpoof(nonce) {
+        return !this.isNotASpoof(nonce);
+    }
+
+    static fromNonceTuple(nonce) /* passed */ {
+        // Empty, since properties can be set 
+        // by either of two nonce naming styles.
+        let tuple = new SpoofTuple();
+
+        let shortNames = SpoofTuple.#longsByShort.keys();
+
+        // Traversing matching pairs of names and applying 
+        // whichever one is present as the tuple property;
+        // if neither is present, the property is undefined.
+        for (let shortName of shortNames) {
+            let longName = SpoofTuple.#longsByShort.get(shortName);
+            tuple[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
+        }
+
+        // Back to caller.
+        return tuple;
+    }
+
+    // region Dependencies of nonce-tuple initing methods
+
+    static maybeRestartFull(full, latest) /* passed */ {
+        // When a (new) spoof target is named, return the new 
+        // SpoofTuple to wipe out all reused spoof values.
+        if (latest.target !== undefined) {
+            full = latest;
+        }
+
+        return full;
+    }
+
+    combineWith(other) {
+        let shortNames = SpoofTuple.#longsByShort.keys();
+
+        for (let shortName of shortNames) {
+            SpoofTuple.combineValues(this, other, shortName);
+        }
+    }
+
+    static combineValues(self, other, name) /* passed */ {
+        // Property may still end up undefined.
+        if (self[name] === undefined) {
+            self[name] = other[name];
+        }
+    }
+
+    // endregion Dependencies of nonce-tuple initing methods
+
+    // endregion Initing, including constructor()
+
+    // region Overrides and dependencies
+
+    toString() /* passed */ {
+        let text = `SpoofTuple:{ target:${ this.#asRawOrString(this.target) }, `
+            + `method:${ this.#asRawOrString(this.method) }, `
+            + `output:${ this.#asRawOrString(this.output) } }`;
+        return text;
+    }
+    
+    #asRawOrString(value) /* verified */ {
+        if (typeof value === "string") {
+            return `"${ value }"`;
+        }
+        
+        return value;
+    }
+    
+    // endregion Overrides and dependencies
+}

package/public/javascript/TerminalReporter.js

@@ -0,0 +1,222 @@
+/**/
+
+/* TerminalReporter is an ATestReporter that sends each result to the terminal / console for display. */
+
+import { ATestReporter } from "./ATestReporter.js";
+import { TestGroup } from "./TestGroup.js";
+import { ClassTestGroup } from "./ClassTestGroup.js";
+import { MethodTestGroup } from "./MethodTestGroup.js";
+import { TestResult } from "./TestResult.js";
+import { TestSummary } from "./TestSummary.js";
+
+import chalk from "chalk";
+
+export class TerminalReporter extends ATestReporter {
+    // region Private fields
+
+    /* Foreground-colors using dependency calls and hex. */
+    #trueWhite = chalk.hex("FFFFFF");
+    #trueBlack = chalk.hex("000000");
+
+    /* Background colors as hex for dependency 
+       calls to use, needed syntactically. */
+    #blue = "0000CD";
+    #aqua = "00BFFF";
+    #paleGreen = "90EE90";
+    #paleRed = "F08080";
+
+    /* Full fore- and background color output styles. */
+
+    #classGroup = this.#trueWhite.bgHex(this.#blue).bold;
+    #methodGroup = this.#trueWhite.bgHex(this.#aqua).bold;
+    #passed = this.#trueBlack.bgHex(this.#paleGreen);
+    #failed = this.#trueBlack.bgHex(this.#paleRed);
+    #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
+
+    // region ATestReporter
+
+    reportNext(result) {
+        // The next result introduces a group of tests.
+        if (result instanceof TestGroup) {
+            this.reportGroup(result);
+            return;
+        }
+
+        // The next result is from one test.
+        if (result instanceof TestResult) {
+            this.#reportTestResult(result);
+            return;
+        }
+
+        // The next result is the summary of all tests.
+        if (result instanceof TestSummary) {
+            this.reportSummary(result);
+            return;
+        }
+    }
+
+    reportGroup(result) {
+        if (result instanceof ClassTestGroup) {
+            console.log(this.#classGroup(` ${ result.group }: `));
+        }
+
+        if (result instanceof MethodTestGroup) {
+            console.log("   " + this.#methodGroup(` ${ result.group }(): `));
+        }
+    }
+
+    // region Private dependencies of reportNext()
+
+    #reportTestResult(result) {
+        if (result.didPass) {
+            this.reportPassed(result);
+        }
+
+        if (!result.didPass) {
+            this.reportFailed(result);
+        }
+    }
+
+    // endregion Private dependencies of reportNext()
+
+    reportPassed(result) {
+        this.#reportOneTestResult(result, "Passed", this.#passed);
+    }
+
+    reportFailed(result) {
+        this.#reportOneTestResult(result, "Failed", this.#failed);
+    }
+
+    // region Private dependencies of reportPassed() and reportFailed()
+
+    /* cruft, changes here */
+    #reportOneTestResult(result, net, styler) {
+        let { lineOne, lineTwo, lineThree } = this.#calculateResultDisplay(result);
+
+        console.log(
+            "\t" + styler(` ${ net }:  ${ lineOne }`)
+        );
+
+        if (lineTwo) {
+            console.log(
+                "\t\t  " + styler(` ${ lineTwo }`)
+            );
+        }
+
+        if (lineThree) {
+            console.log(
+                "\t\t  " + styler(` ${ lineThree }`)
+            );
+        }
+    }
+    
+    /* &cruft, changes here and/or factoring 
+       to lengths and tactics branching */
+    #calculateResultDisplay(result) {
+        /* Getting lengths to determine if output should 
+         * be split to multiple lines to fit the window. */
+
+        let forInputsLength
+            = this.#preUsedWidth
+            + result.identityText.length
+            + result.inputsText.length;
+
+        let allLength
+            = forInputsLength
+            + result.expectedText.length
+            + result.actualText.length;
+
+        /* Splitting as much as is needed. */
+        
+        let identityText = result.identityText;
+        let inputsText = result.inputsText;
+        let expectedText = result.expectedText;
+        let actualText = result.actualText;
+
+        if (forInputsLength >= process.stdout.columns) {
+            return this.#threeLineTactic(identityText, inputsText, expectedText, actualText);
+        }
+
+        if (allLength >= process.stdout.columns) {
+            return this.#twoLineTactic(identityText, inputsText, expectedText, actualText);
+        }
+
+        return this.#oneLineTactic(identityText, inputsText, expectedText, actualText);
+    }
+
+    // region Private dependencies of #calculateResultDisplay()
+
+    #threeLineTactic(identityText, inputsText, expectedText, actualText) {
+        // Each line, with two spaces between phrases on same line.
+        let lineOne = identityText;
+        let lineTwo = inputsText;
+        let lineThree = expectedText + " " + actualText;
+
+        return { lineOne, lineTwo, lineThree };
+    }
+
+    #twoLineTactic(identityText, inputsText, expectedText, actualText) {
+        // Each line, with two spaces between phrases on same line.
+        let lineOne = identityText + " " + inputsText;
+        let lineTwo = expectedText + " " + actualText;
+
+        // Left undefined.
+        let lineThree;
+
+        return { lineOne, lineTwo, lineThree };
+    }
+
+    #oneLineTactic(identityText, inputsText, expectedText, actualText) {
+        // Single line, with two spaces between all phrases.
+        let lineOne
+            = identityText
+            + " "
+            + inputsText
+            + " "
+            + expectedText
+            + " "
+            + actualText;
+
+        // Left undefined.
+        let lineTwo, lineThree;
+
+        return { lineOne, lineTwo, lineThree };
+    }
+
+    // endregion Private dependencies of #calculateResultDisplay()
+
+    // endregion Private dependencies of reportPassed() and reportFailed()
+
+    reportSummary(summary) {
+        console.log();
+
+        if (summary.anyWereRun) {
+            if (summary.allDidPass) {
+                console.log(this.#passedSummary(this.#toFullWidth(" Test run succeeded.")));
+            }
+            else {
+                console.log(this.#failedSummary(this.#toFullWidth(" Test run failed.")));
+            }
+        }
+
+        console.log(this.#summary(this.#toFullWidth(` ${ summary.summary }`)));
+    }
+
+    #toFullWidth(text) {
+        text = text || "";
+        let width = process.stdout.columns;
+
+        return text.padEnd(width, "\u00A0");
+    }
+
+    // endregion ATestReporter
+
+}