risei 1.3.4 → 2.0.0

package/system/ATestCaller.js

@@ -6,10 +6,10 @@
     and the ATestReporter for out / formatting if needed.
     A = abstract. */
 
-import { TestRunner } from "./TestRunner.js";
-import { ATestReporter } from "./ATestReporter.js";
+import TestRunner from "./TestRunner.js";
+import ATestReporter from "./ATestReporter.js";
 
-export class ATestCaller {
+export default class ATestCaller {
     // region Private fields
 
     #finder;

package/system/ATestFinder.js

@@ -2,9 +2,9 @@
 
 /* Defines operations that test-finding classes should implement.  A = abstract. */
 
-import { ATestSource } from "./ATestSource.js";
+import ATestSource from "./ATestSource.js";
 
-export class ATestFinder {
+export default class ATestFinder {
     // region Fields
 
     #testSources;

package/system/ATestReporter.js

@@ -2,9 +2,10 @@
 
 /* Defines operations that a test reporter must implement.  A = abstract. */
 
+/* &cruft, ? replace with my own code eventually */
 import chalk from "chalk";
 
-export class ATestReporter {
+export default class ATestReporter {
     // Reports whatever was just provided by the TestRunner.
     // Can delegate to the other report-x methods.
     reportNext(result) {

package/system/ATestSource.js

@@ -2,7 +2,11 @@
 
 /* Defines operations that a source of tests must (trivially) implement, basically listing tests and fixtures. */
 
-export class ATestSource {
+export default class ATestSource {
+    /* These support testing for undefined values. */
+    static undefSymbol = Symbol.for("undefined");
+    undef = ATestSource.undefSymbol;
+
     /* Must be implemented by subclasses. */
     tests = [];
 }

package/system/ChosenTestFinder.js

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

package/system/ClassTestGroup.js

@@ -1,8 +1,8 @@
 /**/
 
-import { TestGroup } from "./TestGroup.js";
+import TestGroup from "./TestGroup.js";
 
 /* Identifies a grouping of tests by class.  No specialized workings. */
 
-export class ClassTestGroup extends TestGroup {
+export default class ClassTestGroup extends TestGroup {
 }

package/system/LocalCaller.js

@@ -3,12 +3,12 @@
 /* LocalCaller is an ATestCaller that invokes each available test in turn locally 
    on the server, without HTTP calls from a browser or other external source. */
 
-import { ATestFinder } from "./ATestFinder.js";
-import { ATestCaller } from "./ATestCaller.js";
-import { TerminalReporter } from "./TerminalReporter.js";
-import { TestRunner } from "./TestRunner.js";
+import ATestFinder from "./ATestFinder.js";
+import ATestCaller from "./ATestCaller.js";
+import TerminalReporter from "./TerminalReporter.js";
+import TestRunner from "./TestRunner.js";
 
-export class LocalCaller extends ATestCaller {
+export default class LocalCaller extends ATestCaller {
     async runAllTests() {
         let tests = await this.finder.findAllTests();
         this.runner.useTests(tests); 

package/system/{ClassMethodSpoofer.js → MethodSpoofer.js}

@@ -1,14 +1,15 @@
 /**/
 
-import { ASpoofingFixture } from "./ASpoofingFixture.js";
-import { SpoofDefinition } from "./SpoofDefinition.js";
-import { TypeAnalyzer } from "./TypeAnalyzer.js";
+import ASpoofingFixture from "./ASpoofingFixture.js";
+import SpoofDef from "./SpoofDef.js";
+import TypeAnalyzer from "./TypeAnalyzer.js";
+import NameAnalyzer from "./NameAnalyzer.js";
 
-export class ClassMethodSpoofer extends ASpoofingFixture {
+export default class MethodSpoofer 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 ObjectMethodSpoofer does. */
+                   More complex and purely class based than what PropertySpoofer does. */
 
     // region Private fields
 
@@ -38,12 +39,12 @@ export class ClassMethodSpoofer extends ASpoofingFixture {
     // endregion Properties
 
     constructor() {
-        super("ClassMethodSpoofer", "Construction");
+        super("MethodSpoofer", "Construction");
     }
     
-    /* Spoofs methods of classes as defined in nonce 
-       spoof-tuple definitions in any test.plus. */
-    spoof(test) {
+    // Spoofs methods of classes as defined in nonce 
+    // spoof-tuple definitions in any test.plus.
+    spoof(test) /* passed */ {
         // Localizing.
         let type = test.on;
         let spoofNonces = test.plus;
@@ -52,12 +53,19 @@ export class ClassMethodSpoofer extends ASpoofingFixture {
         if (!Array.isArray(spoofNonces)) {
             return;
         }
-    
+
         // Converting to scope object type.
-        let spoofDefinitions = SpoofDefinition.fromNonceTuples(spoofNonces);
-        
+        let spoofDefs = SpoofDef.fromNonceTuples(spoofNonces, type);
+
+        // Working only with method spoofs.
+        let methodSpoofs = Array.from(spoofDefs)
+            .filter(x => x.isMethodSpoof);
+
+        // Stripping spoofs of any sigils.
+        methodSpoofs.forEach(x => x.method = NameAnalyzer.plainNameOf(x.method));
+
         // Storing spoofing definitions.
-        this.#retainSpoofsByClass(type, spoofDefinitions);
+        this.#retainSpoofsByClass(type, methodSpoofs);
         
         // Storing originals for restoring later.
         this.#reserveOriginalsByClass();
@@ -68,36 +76,20 @@ export class ClassMethodSpoofer extends ASpoofingFixture {
 
     // region Dependencies of spoof()
 
-    #retainSpoofsByClass(type, spoofDefinitions) {
+    #retainSpoofsByClass(type, spoofDefs) /* verified */ {
         // Map of Maps: by type, then by method.
-        for (let tuple of spoofDefinitions) {
-            // If no .target, use `type`. 
-            if (!tuple.target) {
-                tuple.target = type;
-            }
-            
-            let spoofsByTarget = this.#supplyMemberMap(this.#spoofsByClass, tuple.target);
+        for (let def of spoofDefs) {
+            let spoofsByTarget = this.#supplyMemberMap(this.#spoofsByClass, def.target);
             
             // 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);
-                }
-                
+            if (def.method) {
+                spoofsByTarget.set(def.method, def.output);
                 continue;
             }
         }
     }
     
-    #reserveOriginalsByClass() {
+    #reserveOriginalsByClass() /* verified */ {
         /* Any spoofing of multiple methods on each class has already been 
            split up into Map elements, so this code can use those naively. */
     
@@ -112,7 +104,10 @@ export class ClassMethodSpoofer extends ASpoofingFixture {
             
             // Saving originals in the Map for later.
             for (let name of names) {
-                let original = type.prototype[name];
+                let original = TypeAnalyzer.isInstanceMember(type, name)
+                    ? type.prototype[name]
+                    : type[name];
+
                 originalsByTarget.set(name, original);
             }
         }
@@ -120,7 +115,7 @@ export class ClassMethodSpoofer extends ASpoofingFixture {
 
     /* Dependency of #retainSpoofsByClass() 
        and #reserveOriginalsByClass(). */
-    #supplyMemberMap(source, target) {
+    #supplyMemberMap(source, target) /* verified */ {
         let mapForType = source.get(target);
         
         if (!mapForType) {
@@ -131,31 +126,36 @@ export class ClassMethodSpoofer extends ASpoofingFixture {
         return mapForType;
     }
 
-    #spoofMembersByClass() {
+    #spoofMembersByClass() /* verified */ {
         /* 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);
+        for (let target of types) {
+            let spoofsByTarget = this.#spoofsByClass.get(target);
             let names = spoofsByTarget.keys();
 
             // Actually spoofing, one by one.
             for (let name of names) {
                 let spoofSource = spoofsByTarget.get(name);
                 let spoof = super.spoofMethod(spoofSource);
-                type.prototype[name] = spoof;
+
+                // Instance members are on prototype, 
+                // static members on the type itself.
+                TypeAnalyzer.isInstanceMember(target, name) 
+                    ? target.prototype[name] = spoof 
+                    : target[name] = spoof;
             }
         }
     }
 
     // endregion Dependencies of spoof()
 
-    // Spoofed methods on any targeted classes 
-    // are restored to their original forms.
-    unspoof() {
+    // Spoofed methods on any targeted classes are restored to 
+    // their original forms, and spoof definitions are erased.
+    unspoof() /* passed */ {
         let types = this.#originalsByClass.keys();
         
         // For each class.
@@ -168,14 +168,20 @@ export class ClassMethodSpoofer extends ASpoofingFixture {
             // Actually restoring, one by one.
             for (let name of names) {
                 let original = originalsByTarget.get(name);
-                target.prototype[name] = original;
+
+                TypeAnalyzer.isInstanceMember(target, name)
+                    ? target.prototype[name] = original
+                    : target[name] = original;
             }
         }
+
+        // Letting next call of spoof() start from scratch.
+        this.removeDefinitions();
     }
 
-    // Removes definitions, useful if this instance is reused, 
-    // or else they might be applied when they shouldn't be.
-    removeDefinitions() {
+    // Removes definitions, useful since this instance is reused, 
+    // so they won't be used in tests when they shouldn't be.
+    removeDefinitions() /* verified */ {
         this.#spoofsByClass.clear();
         this.#originalsByClass.clear();
     }

package/system/MethodTestGroup.js

@@ -1,8 +1,8 @@
 /**/
 
-import { TestGroup } from "./TestGroup.js";
+import TestGroup from "./TestGroup.js";
 
 /* Identifies a grouping of tests by method.  No specialized workings. */
 
-export class MethodTestGroup extends TestGroup {
+export default class MethodTestGroup extends TestGroup {
 }

package/system/Moment.js

@@ -1,6 +1,6 @@
 /**/
 
-export class Moment {
+export default class Moment {
     #now;
 
     constructor(now) {

package/system/NameAnalyzer.js

@@ -0,0 +1,26 @@
+/**/
+
+export default class NameAnalyzer {
+    // region Definitions
+
+    static dotOperator = ".";
+    static colonOperator = ":";
+    static parensOperator = "()";
+    static operatorsRegExp = /\.|:|\(\)/g;
+
+    // endregion Definitions
+
+    static hasPropertySigil(name) /* passed */ {
+        return name.startsWith(NameAnalyzer.dotOperator) || name.endsWith(NameAnalyzer.colonOperator);
+    }
+
+    static hasMethodSigil(name) /* passed */ {
+        return name.endsWith(NameAnalyzer.parensOperator);
+    }
+
+    static plainNameOf(name) /* passed */ {
+        let plain = name.replaceAll(NameAnalyzer.operatorsRegExp, "");
+        return plain;
+    }
+}
+

package/system/PropertySpoofer.js

@@ -0,0 +1,156 @@
+/**/
+
+import ASpoofingFixture from "./ASpoofingFixture.js";
+import SpoofDef from "./SpoofDef.js";
+import TypeAnalyzer from "./TypeAnalyzer.js";
+import NameAnalyzer from "./NameAnalyzer.js";
+
+export default class PropertySpoofer extends ASpoofingFixture {
+    /* Algorithm:  Forward method spoof() looks at property spoof definitions in .plus 
+                   and first saves the original values on the target object 
+                   (or its type, if a property is static), then applies the spoofed ones.
+                   Reverse method unspoof() restores each original property value.
+                   Works on test target and its class only, unlike MethodSpoofer. */
+
+    // region Private fields
+
+    #target;
+    #type;
+
+    // Spoofed and original property values.
+    #settables = [ ];
+    #unsettables = [ ];
+
+    // endregion Private fields
+
+    // region Properties
+
+    get target() {
+        return this.#target;
+    }
+    
+    set target(value) {
+        this.#target = value;
+    }
+
+    get settables() {
+        return this.#settables;
+    }
+
+    set settables(value) {
+        this.#settables = value;
+    }
+
+    get unsettables() {
+        return this.#unsettables;
+    }
+
+    set unsettables(value) {
+        this.#unsettables = value;
+    }
+
+    // endregion Properties
+
+    constructor() {
+        super("PropertySpoofer", "Construction");
+    }
+    
+    /* Spoofs properties of test.target as defined in any test.plus. */
+    spoof(test) /* passed */ {
+        // Localizing.
+        this.#target = test.target;
+        this.#type = test.type;
+
+        let spoofNonces = test.plus;
+
+        // Spoofing definitions are always in an array.
+        if (!Array.isArray(spoofNonces)) {
+            return;
+        }
+
+        // Converting to scope object type.
+        let spoofDefs = SpoofDef.fromNonceTuples(spoofNonces, this.#type);
+
+        // Working only with property spoofs.
+        let propertySpoofs = Array.from(spoofDefs)
+            .filter(x => x.isPropertySpoof);
+
+        // Stripping spoofs of any sigils.
+        propertySpoofs.forEach(x => x.method = NameAnalyzer.plainNameOf(x.method));
+
+        // Storing new values for setting.
+        this.#settables = propertySpoofs;
+
+        // Storing original values for restoring later.
+        this.#anyOriginalPropertyGetting(this.#target, this.#type, this.#settables);
+
+        // Actually spoofing with new values.
+        this.#anyPropertySetting(this.#target, this.#type, this.#settables);
+    }
+
+    /* Spoofed properties on test.target are restored to their original values.
+       Necessary at the least to remove spoofed values before next test. */
+    unspoof() /* passed */ {
+        // Actually unspoofing.
+        this.#anyPropertyUnsetting(this.#target, this.#type, this.#unsettables);
+
+        // Letting next call of spoof() start from scratch.
+        this.removeValues();
+    }
+
+    // region Dependencies of spoof()
+
+    #anyOriginalPropertyGetting(target, type, settables) /* verified */ {
+        let unsettables = [ ];
+        
+        for (let settable of settables) {
+            let name = settable.of;
+
+            // Retaining original.
+            let original 
+                = TypeAnalyzer.isInstanceMember(type, name) 
+                ? target[name] 
+                : type[name];
+
+            let unsettable = { of: name, as: original };
+            unsettables.push(unsettable);
+        }
+        
+        this.#unsettables = unsettables;
+    }
+
+    // endregion Dependencies of spoof()
+    
+    // region Dependencies of unspoof()
+
+    #anyPropertyUnsetting(target, type, unsettables) /* verified */ {
+        // Unsetting is the same as setting, 
+        // but with tuples of original values.
+        return this.#anyPropertySetting(target, type, unsettables);
+    }
+
+    // Removes spoof values, useful since this instance is reused, 
+    // so they won't be used in tests when they shouldn't be.
+    removeValues() /* verified */ {
+        this.#settables = [ ];
+        this.#unsettables = [ ];
+    }
+
+    // endregion Dependencies of unspoof()
+
+    // region Dependencies of both spoof() and unspoof()
+
+    #anyPropertySetting(target, type, settables) /* verified */ {
+        for (let settable of settables) {
+            let name = settable.of;
+            let output = settable.as;
+
+            // Actually setting property.
+            TypeAnalyzer.isInstanceMember(type, name) 
+                ? target[name] = output 
+                : type[name] = output;
+        }
+    }
+
+    // endregion Dependencies of both spoof() and unspoof()
+}

package/system/Risei.js

@@ -10,17 +10,17 @@
 
 // region Test-running dependencies
 
-import { TestRunner } from "./TestRunner.js";
-import { LocalCaller } from "./LocalCaller.js";
-import { TerminalReporter } from "./TerminalReporter.js";
-import { TestFinder } from "./TestFinder.js";
+import TestRunner from "./TestRunner.js";
+import LocalCaller from "./LocalCaller.js";
+import TerminalReporter from "./TerminalReporter.js";
+import TestFinder from "./TestFinder.js";
 
 // endregion Test-running dependencies
 
 // region Display dependencies
 
 import chalk from "chalk";
-import { Moment } from "./Moment.js";
+import Moment from "./Moment.js";
 
 // endregion Display dependencies