risei 1.1.0 → 1.1.2

package/index.js

@@ -10,17 +10,17 @@
 
 // region Test-running dependencies
 
-import { TestRunner } from "./public/javascript/TestRunner.js";
-import { LocalCaller } from "./public/javascript/LocalCaller.js";
-import { TerminalReporter } from "./public/javascript/TerminalReporter.js";
-import { TestFinder } from "./public/javascript/TestFinder.js";
+import { TestRunner } from "./system/TestRunner.js";
+import { LocalCaller } from "./system/LocalCaller.js";
+import { TerminalReporter } from "./system/TerminalReporter.js";
+import { TestFinder } from "./system/TestFinder.js";
 
 // endregion Test-running dependencies
 
 // region Display dependencies
 
 import chalk from "chalk";
-import { Moment } from "./public/javascript/Moment.js";
+import { Moment } from "./system/Moment.js";
 
 // endregion Display dependencies
 
@@ -30,14 +30,14 @@ import { Moment } from "./public/javascript/Moment.js";
 
 // region Classes that users typically subclass
 
-export * from "./public/javascript/ATestSource.js";
+export * from "./system/ATestSource.js";
 
 // endregion Classes that users typically subclass
 
 // region Classes that users might subclass for uncommon cases
 
-export * from "./public/javascript/ATestFinder.js";
-export * from "./public/javascript/ATestReporter.js";
+export * from "./system/ATestFinder.js";
+export * from "./system/ATestReporter.js";
 
 // endregion Classes that users might subclass for uncommon cases
 
@@ -66,7 +66,7 @@ let wide = (text) => {
 async function runRiseiTests(testFinderPath) {
     // region Converting test-finder from path to class
     
-    testFinderPath = testFinderPath || "./public/javascript/TestFinder.js";
+    testFinderPath = testFinderPath || "./system/TestFinder.js";
     let finderModule = await import(testFinderPath);
     
     let moduleKeys = Object.keys(finderModule);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "risei",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Risei is the framework that allows you to write unit tests as collections of values in JavaScript objects, so it's easy and fast, and tests don't serve as a drag on redesigns.",
   "keywords": [
     "unit test",
@@ -14,17 +14,17 @@
     "objects",
     "declarative"
   ],
-  "author": "Ed Fallin <riseijsmaker@gmail.com>",
+  "author": "Ed Fallin <riseimaker@gmail.com>",
   "license": "MIT",
   "type": "module",
   "private": false,
   "scripts": {
     "start": "node ./bin/www",
-    "rself": "clear; node ./public/javascript/Risei.js",
+    "rself": "clear; node system/Risei.js",
     "rtest": "clear; node ./node_modules/risei/index.js",
     "xtest": "clear; mocha **/*.tests.js",
     "mixedtest": "clear; mocha **/*.tests.js; node ./node_modules/risei/index.js",
-    "alltest": "clear; mocha **/*.tests.js; node ./node_modules/risei/index.js; node ./public/javascript/Risei.js",
+    "alltest": "clear; mocha **/*.tests.js; node ./node_modules/risei/index.js; node system/Risei.js",
     "test": "clear; node ./node_modules/risei/index.js"
   },
   "risei": {
@@ -32,7 +32,7 @@
   },
   "exports": {
     ".": "./index.js",
-    "./ATestSource": "./public/javascript/ATestSource.js"
+    "./ATestSource": "./system/ATestSource.js"
   },
   "dependencies": {
     "chalk": "^5.0.0",
@@ -44,10 +44,10 @@
     "chalk": "^5.0.0",
     "cookie-parser": "~1.4.4",
     "debug": "~2.6.9",
-    "express": "~4.16.1",
+    "express": "^4.18.2",
     "fs": "^0.0.1-security",
     "mocha": "^10.0.0",
     "morgan": "~1.9.1",
-    "risei": "^1.0.4"
+    "risei": "1.1.2"
   }
 }

package/{public/javascript → system}/ChosenTestFinder.js

@@ -3,8 +3,8 @@
 /* ChosenTestFinder is an ATestFinder that finds tests in the places coded in its constructor. */
 
 import { ATestFinder } from "./ATestFinder.js";
-import { TopicTests } from "./topic-tests/TopicTests.outward-rt.js";
-import { SelfTests } from "./self-tests/SelfTests.outward-rt.js";
+import { TopicTests } from "../tests/topic-tests/TopicTests.outward-rt.js";
+import { SelfTests } from "../tests/self-tests/SelfTests.outward-rt.js";
 
 export class ChosenTestFinder extends ATestFinder {
     constructor() {

package/{public/javascript → system}/SpoofClassMethodsFixture.js

@@ -4,6 +4,11 @@ import { ASpoofingFixture } from "./ASpoofingFixture.js";
 import { SpoofTuple } from "./SpoofTuple.js";
 
 export class SpoofClassMethodsFixture extends ASpoofingFixture {
+    /* Algorithm:  Forward method spoof() looks at spoof definitions in .plus and applies them 
+                   to each class' prototypes after first saving the original member definitions.
+                   Reverse method unspoof() restores each original member definition.
+                   Fundamentally different from what SpoofObjectMethodsFixture does. */
+
     // region Private fields
 
     #spoofsByClass = new Map();
@@ -51,16 +56,18 @@ export class SpoofClassMethodsFixture extends ASpoofingFixture {
         let spoofTuples = SpoofTuple.fromNonceTuples(spoofNonces);
         
         // Storing spoofing definitions.
-        this.#targetThese(type, spoofTuples);
+        this.#retainSpoofsByClass(type, spoofTuples);
         
         // Storing originals for restoring later.
-        this.#reserveOriginalsForSpoofs();
+        this.#reserveOriginalsByClass();
         
         // Actually spoofing.
-        this.#spoofAll();
+        this.#spoofMembersByClass();
     }
 
-    #targetThese(type, spoofTuples) {
+    // region Dependencies of spoof()
+
+    #retainSpoofsByClass(type, spoofTuples) {
         // Map of Maps: by type, then by method.
         for (let tuple of spoofTuples) {
             // If no .target, use `type`. 
@@ -68,13 +75,7 @@ export class SpoofClassMethodsFixture extends ASpoofingFixture {
                 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);
-            }
+            let spoofsByTarget = this.#supplyMemberMap(this.#spoofsByClass, tuple.target);
             
             // A single-method spoof is set for later use.
             if (tuple.method) {
@@ -95,23 +96,20 @@ export class SpoofClassMethodsFixture extends ASpoofingFixture {
         }
     }
     
-    #reserveOriginalsForSpoofs() {
+    #reserveOriginalsByClass() {
         /* 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 each class.
         for (let type of types) {
-            let originalsByTarget = this.#originalsByClass.get(type);
+            let originalsByTarget = this.#supplyMemberMap(this.#originalsByClass, type);
             
-            if (!originalsByTarget) {
-                originalsByTarget = new Map();
-                this.#originalsByClass.set(type, originalsByTarget);
-            }
-
             let spoofsByTarget = this.#spoofsByClass.get(type);
             let names = spoofsByTarget.keys();
             
+            // Saving originals in the Map for later.
             for (let name of names) {
                 let original = type.prototype[name];
                 originalsByTarget.set(name, original);
@@ -119,16 +117,31 @@ export class SpoofClassMethodsFixture extends ASpoofingFixture {
         }
     }
 
-    #spoofAll() {
+    /* Dependency of #retainSpoofsByClass() 
+       and #reserveOriginalsByClass(). */
+    #supplyMemberMap(source, target) {
+        let mapForType = source.get(target);
+        
+        if (!mapForType) {
+            mapForType = new Map();
+            source.set(target, mapForType);
+        }
+        
+        return mapForType;
+    }
+
+    #spoofMembersByClass() {
         /* 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 each class.
         for (let type of types) {
             let spoofsByTarget = this.#spoofsByClass.get(type);
             let names = spoofsByTarget.keys();
             
+            // Actually spoofing, one by one.
             for (let name of names) {
                 let spoofSource = spoofsByTarget.get(name);
                 let spoof = super.spoofMethod(spoofSource);
@@ -137,25 +150,28 @@ export class SpoofClassMethodsFixture extends ASpoofingFixture {
         }
     }
 
+    // endregion Dependencies of spoof()
+
     // Spoofed methods on any targeted classes 
     // are restored to their original forms.
     unspoof() {
         let types = this.#originalsByClass.keys();
         
+        // For each class.
         for (let target of types) {
-            let originalsByTarget = this.#originalsByClass.get(target);
-            
             let prototype = target.prototype;
             
+            let originalsByTarget = this.#originalsByClass.get(target);
             let names = originalsByTarget.keys();
             
+            // Actually restoring, one by one.
             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() {

package/system/SpoofObjectMethodsFixture.js

@@ -0,0 +1,58 @@
+/* */
+
+import { ASpoofingFixture } from "./ASpoofingFixture.js";
+import { SpoofTuple } from "./SpoofTuple.js";
+
+export class SpoofObjectMethodsFixture extends ASpoofingFixture {
+    /* Algorithm:  Forward method spoof() looks at a test's .with and .in, and replaces entire objects 
+                   in each with spoofed object trees, if the originals are spoof definitions.
+                   No reverse unspoofing method is needed, since objects are nonces tossed after tests.
+                   Fundamentally different from much of what SpoofClassMethodsFixture does. */
+
+    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 array of test-aspect elements.
+        for (let topic of topics) {
+            // Replacing whole element with spoof or with unchanged self.
+            for (let at = 0; at < topic.length; at++) {
+                let target = topic[at];
+                topic[at] = this.spoofTarget(target);
+            }
+        }
+    }
+
+    spoofTarget(target) {
+        // Non-spoof targets are returned unchanged.
+        if (SpoofTuple.isNotASpoof(target)) {
+            return target;
+        }
+
+        // Spoof definition targets are converted.
+        let tuple = SpoofTuple.fromNonceTuple(target);
+        let ofAsPairs = this.#supplySpoofPairs(tuple);
+        
+        // Returning object with one or more spoofed members.
+        let spoofedTarget = super.spoofObjectTree(ofAsPairs);
+        return spoofedTarget;
+    }
+
+    #supplySpoofPairs(tuple) {
+        // Single-spoof output.
+        let ofAsPairs = [{ of: tuple.method, as: tuple.output }];
+
+        // Poly-spoof output.
+        if (!tuple.method) {
+            ofAsPairs = tuple.output;
+        }
+        
+        return ofAsPairs;
+    }
+}

package/{public/javascript → system}/SpoofTuple.js

@@ -1,5 +1,7 @@
 /**/
 
+import { TypeAnalyzer } from "./TypeAnalyzer.js";
+
 /* Defines what is found in a spoof-definition tuple (SDT).  Actual SDTs don't need to be instances of this class. */
 
 export class SpoofTuple {
@@ -18,6 +20,12 @@ export class SpoofTuple {
 
     // endregion Static fields
 
+    // region Private fields
+    
+    #typeAnalyzer;
+    
+    // endregion Private fields
+
     // region Public fields (long names)
 
     /* These long names are clearer and match the constructor's parameter names. */
@@ -76,6 +84,10 @@ export class SpoofTuple {
         
         return isSpoofable;
     }
+    
+    isPropertySpoof() /* passed */ {
+        return this.#typeAnalyzer.memberIsProperty(this.method);
+    }
 
     // endregion Tuple state
 
@@ -89,6 +101,8 @@ export class SpoofTuple {
         this.target = target;
         this.method = method;
         this.output = output;
+        
+        this.#typeAnalyzer = new TypeAnalyzer(target);
     }
 
     static fromNonceTuples(nonces) {

package/system/TestFrame.js

@@ -0,0 +1,187 @@
+/**/
+
+import { TestStages } from "./TestStages.js";
+
+export class TestFrame {
+    /* &cruft : when TestStages is ready, use it and its methods here */
+    
+    #stages;
+
+    constructor() {
+        // A TestStages is inited for each test.
+        this.#stages = new TestStages();
+    }
+    
+    testFrame(test) {
+        console.log(`cruft : a`);
+        // Outer try for fails of groundwork requested.
+        try {
+            console.log(`cruft : b`);
+            /* &cruft, maybe simplify explanations here */
+
+            // Certain args must be isolated for collapsing forward, in case tested 
+            // code mutates them.  Sets test.localInitors and test.localInputs.
+            this.#stages.setLocalInitorsAndInputs(test);
+
+            console.log(`cruft : c`);
+
+            // Spoofing, setting static properties, and so on.
+            this.#stages.anyPreTargetingGroundwork(test);
+            
+            console.log(`cruft : d`);
+
+            // Target may be instance, prototype for constructors, the class 
+            // itself for statics, or nonce for properties.  Sets test.target.
+            this.#stages.setLocalTarget(test);
+            
+            console.log(`cruft : e`);
+            
+            // Method under test may be on instance, class, 
+            // or nonce for properties.  Sets test.callable.
+            this.#stages.setLocalCallable(test);
+            
+            console.log(`cruft : f`);
+            
+            // Setting instance properties and so on.
+            this.#stages.anyPostTargetingGroundwork(test);
+            
+            
+            console.log(`cruft : g`);
+            
+            // Inner try for fails of targeted code only.
+            try {
+                console.log(`cruft : h`);
+                
+                console.log(`cruft : test.actual:`, test.actual);
+                console.log(`cruft : test.localTarget:`, test.localTarget);
+                console.log(`cruft : test.localCallable:`, test.localCallable);
+                console.log(`cruft : test.localInputs:`, test.localInputs);
+            
+                // Tests usually look for this.
+                test.actual = test.localTarget[test.localCallable](...test.localInputs);
+                
+                console.log(`cruft : test.actual:`, test.actual);
+                console.log(`cruft : i`);
+            }
+            catch (thrown) {
+                console.log(`cruft : j`);
+                
+                // Sometimes tests look for this.
+                test.thrown = thrown;
+                
+                console.log(`cruft : k`);
+            }
+
+            console.log(`cruft : l`);
+
+            // Sometimes tests look for results elsewhere. 
+            this.#stages.anyModifyActual(test);
+
+            console.log(`cruft : m`);
+
+            /* &cruft, remove test-checking line when all tests pass */
+            // test.didPass = "fails";
+
+            // Actually testing the result.
+            test.didPass = this.#stages.compareResults(test.output, test.actual);
+            
+            console.log(`cruft : n`);
+            
+        }
+        finally {
+            console.log(`cruft : o`);
+        
+            // Undoing any groundwork changes made. 
+            this.#stages.anyGroundworkReversion(test);
+            
+            console.log(`cruft : p`);
+        }
+        
+        console.log(`cruft : q`);
+    }
+
+    // // region Dependencies of test frames
+    //
+    // /* &cruft, remove if / once superseded by code in TestStages */
+    //
+    // #anyOriginalPropertyGetting(target, settables) {
+    //     if (!Array.isArray(settables)) {
+    //         return;
+    //     }
+    //
+    //     let unsettables = [ ];
+    //    
+    //     for (let settable of settables) {
+    //         // Not a setter tuple.
+    //         if (!settable.of) {
+    //             continue;
+    //         }
+    //        
+    //         // Retaining original.
+    //         let original = target[settable.of];
+    //         let unsettable = { of: settable.of, as: original };
+    //         unsettables.push(unsettable);
+    //     }
+    //    
+    //     return unsettables;
+    // }
+    //
+    // #anyPropertySetting(target, settables) {
+    //     // No properties to set.
+    //     if (!Array.isArray(settables)) {
+    //         return;
+    //     }
+    //
+    //     for (let settable of settables) {
+    //         // Not a setter tuple.
+    //         if (!settable.of) {
+    //             continue;
+    //         }
+    //
+    //         // Actually setting property.
+    //         target[settable.of] = settable.as;
+    //     }
+    // }
+    //
+    // #anyPropertyUnsetting(target, unsettables) {
+    //     // Unsetting is the same as setting, 
+    //     // but with tuples of original values.
+    //     return this.#anyPropertySetting(target, unsettables);
+    // }
+    //
+    // // #compare(expected, actual) {
+    // //     return this.#comparer.compare(expected, actual);
+    // // }
+    //
+    // #supplyNonReturnActual(test, target) {
+    //     // When there is a .from that's a string, 
+    //     // the actual is the named target member.
+    //     if (typeof test.from === "string") {
+    //         // Common member host; 
+    //         // undefined if static.
+    //         let host = target;
+    //        
+    //         // When .and defines static.
+    //         if (this.#doesAddressStatics(test)) {
+    //             host = test.on;
+    //         }
+    //    
+    //         return host[test.from];
+    //     }
+    //    
+    //     // When there is a .from that's a function, 
+    //     // the actual is the result of calling it, 
+    //     // given everything that might be needed.
+    //     if (test.from instanceof Function) {
+    //         return test.from(target, test);
+    //     }
+    //
+    //     // When there is any other .from, the actual is the
+    //     // value of the code element provided as .from.
+    //     return test.from;
+    // }
+    //
+    // // endregion Dependencies of test frames
+    //
+
+}

package/{public/javascript → system}/TestFrameChooser.js

@@ -15,14 +15,14 @@ export class TestFrameChooser {
     supplyTestFrame(test) /* passed */ {
         // If `.and` includes "static", a call of a static member 
         // is made, and the actual is its return value.
-        if (this.doesAddressStatics(test)) {
-            if (this.isThrowTest(test)) {
+        if (test.isStaticTest) {
+            if (test.isThrowTest) {
                 return this.frames.testThrowResultAfterStaticCall;
             }
         
             // If .from, a static call is made, then the actual is 
             // retrieved from a named code element or custom code.
-            if (this.isRetrievalTest(test)) {
+            if (test.isRetrievalTest) {
                 return this.frames.testCodeElementAfterStaticCall;
             }
 
@@ -33,17 +33,17 @@ export class TestFrameChooser {
 
         // Constructors are a special case; no second call should 
         // be made, and actual must be retrieved from property.
-        if (test.of === this.constructorName) {
+        if (test.isConstructorTest) {
             return this.frames.testCodeElementAfterConstruction;
         }
         
-        if (this.isThrowTest(test)) {
+        if (test.isThrowTest) {
             return this.frames.testThrowResultAfterCall;
         }
 
         // If .from, a call of the target is made, then the actual 
         // is retrieved from a named code element or custom code.
-        if (this.isRetrievalTest(test)) {
+        if (test.isRetrievalTest) {
             return this.frames.testCodeElementAfterCall;
         }
 
@@ -51,45 +51,4 @@ export class TestFrameChooser {
         // and the actual is its return value.
         return this.frames.testReturnValueOfCall;
     }
-
-    doesAddressStatics(test) /* passed */ {
-        if (typeof test.and === "string") {
-            if (test.and.includes(this.staticName)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-    
-    isThrowTest(test) /* passed */ {
-        if (typeof test.and === "string") {
-            if (test.and.includes(this.throwName)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    isRetrievalTest(test) /* passed */ {
-        // Falsy code elements never are a retrieval.
-        if (!test.from) {
-            return false;
-        }
-        
-        // If a (non-falsy) string, must be a retrieval.
-        if (typeof test.from === "string") {
-            return true;
-        }
-        
-        // If a function, is a retrieval.
-        if (test.from instanceof Function) {
-            return true;
-        }
-        
-        // Anything else is not a retrieval.
-        return false;
-    }
-
 }