risei 1.0.4 → 1.1.1

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
 

package/package.json

@@ -1,23 +1,36 @@
 {
   "name": "risei",
-  "version": "1.0.4",
-  "description": "RiseiJs 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", "test", "unit testing", "testing", "easy", "fast", "values", "objects", "declarative" ],
-  "author": "Ed Fallin <riseijsmaker@gmail.com>",
+  "version": "1.1.1",
+  "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",
+    "test",
+    "unit testing",
+    "testing",
+    "easy",
+    "fast",
+    "simple",
+    "values",
+    "objects",
+    "declarative"
+  ],
+  "author": "Ed Fallin <riseimaker@gmail.com>",
   "license": "MIT",
   "type": "module",
   "private": false,
   "scripts": {
     "start": "node ./bin/www",
-    "risei": "node ./index.js",
-    "rtest": "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",
-    "test": "clear; mocha **/*.tests.js; node ./public/javascript/Risei.js"
+    "mixedtest": "clear; mocha **/*.tests.js; node ./node_modules/risei/index.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": {
     "tests": "**.rt.js"
   },
-  "exports":{
+  "exports": {
     ".": "./index.js",
     "./ATestSource": "./public/javascript/ATestSource.js"
   },
@@ -34,6 +47,7 @@
     "express": "~4.16.1",
     "fs": "^0.0.1-security",
     "mocha": "^10.0.0",
-    "morgan": "~1.9.1"
+    "morgan": "~1.9.1",
+    "risei": "^1.1.0"
   }
 }

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

@@ -72,7 +72,7 @@ export class ASpoofingFixture extends ATestFixture {
             name = names.shift();
             name = name.replace("()", "");
 
-            // Actually spoofing method.
+            // Actually spoofing, as method only.
             let method = this.spoofMethod(output);
             next[name] = method;
         }

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

@@ -3,15 +3,16 @@
 /* ChosenTestFinder is an ATestFinder that finds tests in the places coded in its constructor. */
 
 import { ATestFinder } from "./ATestFinder.js";
-import { Tests } from "./topic-tests/Tests.rt.js";
-import { SelfTests } from "./self-tests/SelfTests.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() {
         super();
         
-        let testSource = new Tests();
+        let testSource = new TopicTests();
         let selfTestSource = new SelfTests();
+        
         this.testSources = [ testSource, selfTestSource ];
     }
 

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) {
@@ -162,7 +176,6 @@ export class SpoofTuple {
         return true;
     }
     
-    /* &cruft, test or drop */
     static isASpoof(nonce) {
         return !this.isNotASpoof(nonce);
     }