risei 1.3.4 → 2.0.0

package/system/TypeAnalyzer.js

@@ -1,19 +1,28 @@
 /**/
 
+import TypeIdentifier from "./TypeIdentifier.js";
+import Types from "./Types.js";
+
 /* Used to analyze classes / members of classes being tested. */
 
-export class TypeAnalyzer {
+export default class TypeAnalyzer {
     // region Definitions
 
     static constructorName = "constructor";
-    static getName = "get";
-    static setName = "set";
+    static accessorOfPrivate = "Cannot read private member";
 
     // endregion Definitions
 
+    /* Returns true if member is defined for 
+       instances.  Returns false otherwise. */
+    static isInstanceMember(type, name) {
+        /* Reusing logic instead of repeating it. */
+        return !TypeAnalyzer.isStaticMember(type, name);
+    }
+
     /* Returns true if member is static (value or accessor 
        property, or method).  Returns false otherwise. */
-    static memberIsStatic(type, name) /* passed */ {
+    static isStaticMember(type, name) /* passed */ {
         // Constructor of class type, available with `in`, 
         // is not the constructor normally being sought, 
         // which instead is treated as instance-hosted.
@@ -35,88 +44,41 @@ export class TypeAnalyzer {
 
     /* Returns true if instance or static member is a method.
        Returns false if member is any kind of property. */
-    static memberIsMethod(type, name) /* passed */ {
-        return !TypeAnalyzer.memberIsProperty(type, name);
-    }
+    static isMethodMember(type, name) /* passed */ {
+        /* A method is always defined either on a type or 
+           its prototype, even if declared on a superclass. */
 
-    /* Returns true if instance or static member is a property 
-       (value or accessor).  Returns false if member is a method. */
-    static memberIsProperty(type, name) /* passed */ {
-        // Constructor is never a property and is irregular, 
-        // so other type-analysis code can't handle it.
-        if (name === TypeAnalyzer.constructorName) {
-            return false;
-        }
+        try {
+            let anyInstanceType = TypeIdentifier.identify(type.prototype[name]);
+            let anyStaticType = TypeIdentifier.identify(type[name]);
 
-        // Static methods and properties (value or accessor) are on type.
-        if (name in type) {
-            return TypeAnalyzer.#staticMemberIsProperty(type, name);
-        }
-        
-        // Methods and accessor properties are on prototype.
-        if (name in type.prototype) {
-            return TypeAnalyzer.#instanceMemberIsProperty(type.prototype, name);
-        }
+            /* Excludes class "functions", which are not methods. */
+            let isInstanceMethod = anyInstanceType === Types.isFunction;
+            let isStaticMethod = anyStaticType === Types.isFunction;
 
-        // Instance value properties are not on type or prototype.
-        return true;
-    }
-    
-    // region Dependencies of memberIsProperty()
-    
-    /* Algorithm specialized with function check for static members. */
-    static #staticMemberIsProperty(type, name) {
-        let descriptor = Object.getOwnPropertyDescriptor(type, name);
-        
-        // If on type and has accessors, it's a static accessor property.
-        if (TypeAnalyzer.#doesHaveAccessorProps(descriptor)) {
-            return true;
+            /* Returns net method-ness; if not found at all, a property 
+               is assumed (true as long as the member exists at all.) */
+            return isInstanceMethod || isStaticMethod;
         }
-        
-        // If on type and has non-Function .value, it's a static value property.
-        if (TypeAnalyzer.#doesNotHaveFunctionValue(descriptor)) {
-            return true;
+        catch (thrown) {
+            /* If private fields are used behind public accessor properties, 
+               there's a characteristic message which shows it's not a method.  
+               It may be a property returning a function, but not a method. */
+            if (thrown.message.startsWith(TypeAnalyzer.accessorOfPrivate)) {
+                return false;
+            }
+
+            /* Other throws are unpredictable and mean there's a problem. */
+            throw thrown;
         }
 
-        // If on type but not a static property, it's a static method.
-        return false;
+        /* Probably never reached.  No previous throw, but some unknown problem. */
+        throw new Error("Unable to determine method vs. property state.");
     }
 
-    /* Algorithm specialized for instance members, no function check. */
-    static #instanceMemberIsProperty(prototype, name) {
-        let descriptor = Object.getOwnPropertyDescriptor(prototype, name);
-        
-        // If on prototype and has accessors, it's an accessor property.
-        if (TypeAnalyzer.#doesHaveAccessorProps(descriptor)) {
-            return true;
-        }
-        
-        // If on prototype but not an accessor property, it's a method.
-        return false;
-    }
-    
-    // region Internally reused dependencies of other memberIsProperty() dependencies
-    
-    static #doesHaveAccessorProps(descriptor) /* verified */ {
-        // Accessor properties have one or both of these in descriptor.
-        if (TypeAnalyzer.getName in descriptor || TypeAnalyzer.setName in descriptor) {
-            return true;
-        }
-        
-        return false;
-    }
-    
-    static #doesNotHaveFunctionValue(descriptor) /* verified */ {
-        // Simple inverter of other method for readability.
-        return !TypeAnalyzer.#doesHaveFunctionValue(descriptor);
-    }
-    
-    static #doesHaveFunctionValue(descriptor) /* verified */ {
-        // If no member, .value of undefined.
-        return descriptor.value instanceof Function;
+    /* Returns true if instance or static member is a property 
+       (value or accessor).  Returns false if member is a method. */
+    static isPropertyMember(type, name) /* passed */ {
+        return !TypeAnalyzer.isMethodMember(type, name);
     }
-
-    // endregion Internally reused dependencies of other memberIsProperty() dependencies
-
-    // endregion Dependencies of memberIsProperty()
 }

package/system/TypeIdentifier.js

@@ -1,9 +1,10 @@
 /**/
 
-import { Types } from "./Types.js";
+import Types from "./Types.js";
+import ATestSource from "./ATestSource.js";
 
-export class TypeIdentifier {
-    identify(value) /* passed */ {
+export default class TypeIdentifier {
+    static identify(value) /* passed */ {
         // Basis for most top branching.
         let rawType = typeof value;
 
@@ -26,13 +27,17 @@ export class TypeIdentifier {
                 return Types.isDate;
             }
             
+            if (value instanceof Error) {
+                return Types.isError;
+            }
+            
             if (value === null) {
                 return Types.isNull;
             }
             
             return Types.isObject;
         }
-        
+
         // Functions and classes are both "function" to Javascript.
         if (rawType === "function") {
             // Functions can be anonymous.
@@ -53,17 +58,22 @@ export class TypeIdentifier {
             // Function but not class is a named function.
             return Types.isFunction;
         }
-    
+
         // Strings may be handled specially.
         if (typeof value === "string") {
             return Types.isString;
         }
-        
-        // Undefined is different from the rest.
+
+        // Undefined is different from most.
         if (value === undefined) {
             return Types.isUndefined;
         }
-        
+
+        // Undef Symbol is different from most.
+        if (value === ATestSource.undefSymbol) {
+            return Types.isUndefSymbol;
+        }
+
         // Non-string values all handled the same.
         return Types.isValue;
     }

package/system/Types.js

@@ -1,6 +1,6 @@
 /**/
 
-export class Types {
+export default class Types {
     /* This class is essentially an enum. */
     
     static isValue = "value";
@@ -12,6 +12,8 @@ export class Types {
     static isFunction = "function";
     static isClass = "class";
     static isDate = "date";
+    static isError = "error";
     static isUndefined = "undefined";
+    static isUndefSymbol = "undefsym";
     static isNull = "null";
 }

package/test-target-objects/ConditionalThrowTarget.js

@@ -0,0 +1,11 @@
+/**/
+
+export default class ConditionalThrowTarget {
+    returnArgOrThrow(arg) {
+        if (arg === undefined) {
+            throw new Error("No arg provided.");
+        }
+        
+        return arg;
+    }
+}

package/test-target-objects/Counter.js

@@ -0,0 +1,46 @@
+/**/
+
+export default class Counter {
+    constructor() {
+        /* No operations. */
+    }
+
+    howMany(subject, target) /* passed */ {
+        // Bad-call edge case.
+        if (arguments.length < 2) {
+            return 0;
+        }
+
+        // Bad-arg edge cases.
+        if (this.#isEdgeCase(subject, target)) {
+            return 0;
+        }
+
+        // Initial values and ops reducer.
+        let at = 0;
+        let count = 0;
+        let span = target.length;
+
+        // Tracking found site and jumping past it each time the target is found.
+        while ((at = subject.indexOf(target, at)) !== -1) {
+            count++;
+            at += span;
+        }
+
+        // Back to caller.
+        return count;
+    }
+
+    #isEdgeCase(subject, target) /* verified */ {
+        if (subject === null || target === null) {
+            return true;
+        }
+
+        if (target === "") {
+            return true;
+        }
+
+        return false;
+    }
+
+}

package/test-target-objects/DomTarget.js

@@ -0,0 +1,37 @@
+/**/
+
+export default class DomTarget {
+    // region Private fields
+
+    #id;
+    #node;
+    
+    // endregion Private fields
+    
+    // region Properties
+    
+    get id() {
+        return this.#id;
+    }
+    
+    get node() {
+        return this.#node;
+    }
+
+    // endregion Properties
+
+    constructor(id) {
+        this.#id = id;
+        this.#node = this.domNodeFrom(id);
+    }
+    
+    domNodeFrom(id) {
+        let node = document.getElementById(id);
+        return node;
+    }
+    
+    changeDomItem(id) {
+        this.#id = id;
+        this.#node = this.domNodeFrom(id);
+    }
+}

package/test-target-objects/InterSpoofer.js

@@ -0,0 +1,230 @@
+/**/
+
+import MethodSpoofer from "../system/MethodSpoofer.js";
+import PropertySpoofer from "../system/PropertySpoofer.js";
+import PropertiesTarget from "./PropertiesTarget.js";
+
+/* &cruft, maybe drop this after direct testing of groundwork 
+           and reversing it is possible with .do / .undo */
+export default class InterSpoofer {
+    // region Components
+
+    #methodSpoofer = new MethodSpoofer();
+    #propSpoofer = new PropertySpoofer();
+
+    // endregion Components
+
+    // region Gathered names of all spoofables
+
+    static staticProps = [ "staticBaseValueProp", "staticBaseAccessorProp", "staticValueProp", "staticAccessorProp" ];
+    static staticMethods = [ "staticBaseMethod", "staticMethod" ];
+    static props = [ "instanceBaseValueProp", "instanceBaseAccessorProp", "valueProp", "accessorProp" ];
+    static methods = [ "instanceBaseMethod", "instanceMethod" ];
+
+    static allMethods = [ InterSpoofer.staticMethods, InterSpoofer.methods ];
+    static allNames = [ InterSpoofer.staticProps, InterSpoofer.staticMethods, InterSpoofer.props, InterSpoofer.methods ];
+
+    // endregion Gathered names of all spoofables
+
+    // region Gathered original method defs and values
+
+    static #origDefs = InterSpoofer.#bundleDefs(
+        PropertiesTarget, new PropertiesTarget(), ...InterSpoofer.allMethods
+    );
+
+    static #origValues = InterSpoofer.#bundleValues(
+        PropertiesTarget, new PropertiesTarget(), ...InterSpoofer.allNames
+    );
+
+    // endregion Gathered original method defs and values
+
+    // region Methods to test spoofers
+
+    /* If these methods all pass, then the spoofers work 
+       together without breaking each other's changes. */
+
+    spoofMethodsThenProps(test) /* passed */ {
+        this.#methodSpoofer.spoof(test);
+        this.#propSpoofer.spoof(test);
+
+        let type = test.type;
+        let target = test.target;
+
+        let values = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.reverseAllSpoofs(type, target);
+
+        return values;
+    }
+    
+    spoofPropsThenMethods(test) /* passed */ {
+        this.#propSpoofer.spoof(test);
+        this.#methodSpoofer.spoof(test);
+
+        let type = test.type;
+        let target = test.target;
+
+        let values = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.reverseAllSpoofs(type, target);
+
+        return values;
+    }
+
+    spoofAndUnspoofMethodsThenProps(test) /* passed */ {
+        this.#methodSpoofer.spoof(test);
+        this.#propSpoofer.spoof(test);
+
+        let type = test.type;
+        let target = test.target;
+
+        let before = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.#methodSpoofer.unspoof(test);
+        this.#propSpoofer.unspoof(test);
+
+        let after = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.reverseAllSpoofs(type, target);
+
+        return { before, after };
+    }
+
+    spoofAndUnspoofPropsThenMethods(test) /* passed */ {
+        this.#propSpoofer.spoof(test);
+        this.#methodSpoofer.spoof(test);
+
+        let type = test.type;
+        let target = test.target;
+
+        let before = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.#propSpoofer.unspoof(test);
+        this.#methodSpoofer.unspoof(test);
+
+        let after = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.reverseAllSpoofs(type, target);
+
+        return { before, after };
+    }
+
+    spoofMethodsFirstAndUnspoofThemLast(test) /* passed */ {
+        this.#methodSpoofer.spoof(test);
+        this.#propSpoofer.spoof(test);
+
+        let type = test.type;
+        let target = test.target;
+
+        let before = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.#propSpoofer.unspoof(test);
+        this.#methodSpoofer.unspoof(test);
+
+        let after = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.reverseAllSpoofs(type, target);
+
+        return { before, after };
+    }
+
+    spoofPropsFirstAndUnspoofThemLast(test) /* passed */ {
+        this.#propSpoofer.spoof(test);
+        this.#methodSpoofer.spoof(test);
+
+        let type = test.type;
+        let target = test.target;
+
+        let before = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.#methodSpoofer.unspoof(test);
+        this.#propSpoofer.unspoof(test);
+
+        let after = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+
+        this.reverseAllSpoofs(type, target);
+
+        return { before, after };
+    }
+
+    // endregion Methods to test spoofers
+
+    /* To ensure topic class isolated between tests. */
+    reverseAllSpoofs(type, target) /* verified */ {
+        /* Setting known properties and methods of target type 
+           back to their stored original definitions / values. */
+
+        for (let name of InterSpoofer.staticProps) {
+            type[name] = InterSpoofer.#origValues[name];
+        }
+
+        for (let name of InterSpoofer.staticMethods) {
+            type[name] = InterSpoofer.#origDefs[name];
+        }
+
+        /* Plain instance properties shouldn't need to be reversed. */
+
+        for (let name of InterSpoofer.methods) {
+            type.prototype[name] = InterSpoofer.#origDefs[name];
+        }
+
+        for (let name of InterSpoofer.props) {
+            target[name] = InterSpoofer.#origValues[name];
+        }
+
+        let reversed = InterSpoofer.#bundleValues(type, target, ...InterSpoofer.allNames);
+    }
+
+    // region Internals
+
+    static #bundleDefs(type, target, staticMethods, methods) /* verified */ {
+        /* All callables asked for are stored as copies for restoring. */
+
+        let output = { };
+
+        for (let name of staticMethods) {
+            output[name] = InterSpoofer.#copyMethod(type[name]);
+        }
+
+        for (let name of methods) {
+            output[name] = InterSpoofer.#copyMethod(target[name]);
+        }
+
+        return output;
+    }
+
+    static #bundleValues(type, target, staticProps, staticMethods, props, methods) /* verified */ {
+        /* Everything asked for is dropped into an object, either 
+           property values or return values of calling methods. */
+
+        let output = { };
+
+        for (let name of staticProps) {
+            output[name] = type[name];
+        }
+
+        for (let name of staticMethods) {
+            output[name] = type[name]();
+        }
+
+        for (let name of props) {
+            output[name] = target[name];
+        }
+
+        for (let name of methods) {
+            output[name] = target[name]();
+        }
+
+        return output;
+    }
+
+    static #copyMethod(method) /* verified */ {
+        let passer = [ method ];
+        passer = [ ...passer ];
+        let copy = passer[0];
+
+        return copy;
+    }
+
+    // endregion Internals
+}

package/test-target-objects/MixedContents.js

@@ -0,0 +1,33 @@
+/**/
+
+export default class MixedContents {
+    first = 1;
+    second = "2";
+    third = { three: 3 };
+    
+    static fourth = 4;
+    static fifth = "5";
+    
+    getInstanceValueOf(name) {
+        return this[name];
+    }
+    
+    getInstanceProduct() {
+        let a = this.first;
+        let b = Number(this.second);
+        let c = this.third.three;
+
+        return a * b * c;
+    }
+    
+    static getStaticValueOf(name) {
+        return MixedContents[name];
+    }
+    
+    static getStaticProduct() {
+        let a = MixedContents.fourth;
+        let b = Number(MixedContents.fifth);
+
+        return a * b;
+    }
+}

package/test-target-objects/MutationTarget.js

@@ -0,0 +1,37 @@
+/**/
+
+export default class MutationTarget {
+    #map;
+    #array;
+
+    constructor(map, array) {
+        this.#map = map;
+        this.#array = array;
+    }
+
+    mutateInitors() {
+        // Map mutation allows for consecutive mutations.
+        let rawKey = this.#map.size + 1;
+        this.#map.set(rawKey.toString(), "C");
+        this.#array.shift();
+        
+        return { map: this.#map, array: this.#array };
+    }
+
+    mutateArgs(array, tuple) {
+        array.push(10);
+        tuple.changes += 10;
+        
+        return { array, tuple };
+    }
+    
+    replaceArg(array, index, replacement) {
+        // The previous element is added at the end for comparison.
+        array.push(array[index].toString());
+
+        // The new element is set at the original index.
+        array[index] = replacement;
+
+        return array;
+    }
+}

package/test-target-objects/ObjectComposer.js

@@ -0,0 +1,34 @@
+/**/
+
+export default class ObjectComposer {
+    constructor() {
+        /* No operations. */
+    }
+    
+    /* Target of spoofing. */
+    supplySomeObject() {
+        throw new Error("supplyObjectA() must be spoofed in tests.");
+    }
+    
+    enact(chain, method) {
+        // Invoke the method to be spoofed.
+        let target = this.supplySomeObject();
+        
+        // Traverse the spoofed return 
+        // value's object tree.
+        for (let link of chain) {
+            target = target[link];
+        }
+        
+        // Invoke the method at chain end for its return value.
+        let output = target[method]();
+        return output;
+    }
+    
+    doubleEnact(chainOne, methodOne, chainTwo, methodTwo) {
+        let outputOne = this.enact(chainOne, methodOne);
+        let outputTwo = this.enact(chainTwo, methodTwo);
+        
+        return [ outputOne, outputTwo ];
+    }
+}

package/test-target-objects/PolySpoofableInner.js

@@ -0,0 +1,29 @@
+/**/
+
+export default class PolySpoofableInner {
+    constructor() {
+        /* No operations. */
+    }
+    
+    /* Spoofing target. */
+    addOrTimes(numbers) {
+        let a = numbers.supplyA();
+        let b = numbers.supplyB();
+        
+        return a + b;
+    }
+    
+    /* Spoofing target. */
+    minusOrOver(numbers) {
+        let a = numbers.supplyA();
+        let b = numbers.supplyB();
+    
+        return a - b;
+    }
+
+    /* Spoofing target.  Nested object. */
+    numberHost = { 
+        supplyC: () => { return 15; }, 
+        supplyD: () => { return 18; } 
+    }
+}