risei 3.3.2 → 3.3.4

package/README.md

@@ -3,7 +3,7 @@
 
 ## Overview
 
-Risei is a new way to write unit tests that's easier and faster, more dependable, and keeps your tests from standing in the way of redesigns.
+Risei is a new way to write unit tests that's easier, faster, and more readable.   Tests made with Risei aren't a source of errors or a drag on redesigns.
 
 Risei does all this by replacing hand-coded tests with simple declarative syntax.
 
@@ -13,6 +13,8 @@ Risei does all this by replacing hand-coded tests with simple declarative syntax
 
 You can find a longer version of this read-me at [https://deusware.com/risei](https://deusware.com/risei/index.html).   It expands greatly on the information here.
 
+Risei's major features are now complete, but new enhancements or fixes may appear from time to time.   For release notes, see the [version history](https://deusware.com/risei/index.html#version-history).
+
 
 
 ## Examples
@@ -40,36 +42,30 @@ And they have a summary bar at the bottom:
 
 ![https://deusware.com/risei/images/Summary-example.png](https://deusware.com/risei/images/Summary-example.png)
 
-- This bar is red when any tests fail, much as you'd expect.
-
-
-
-## Status
-
-Risei's major features are now complete, but new enhancements or fixes may appear from time to time. \
-The latest release, **3.3.2**, adds `async` capabilities formerly missing from the `.from` feature.
-
-Check out the [full list of changes](#version-history).
+- This bar is red when any tests fail, just as you'd expect.
 
 
 
 ## Features of Risei
 
-- #### Declarative syntax to write tests simply and quickly.      ►   [Writing tests](https://deusware.com/risei/index.html#writing-tests)   (basics below)
-- #### Easy-to-read test definitions and test outputs.    ►  [Test and output examples](https://deusware.com/risei/index.html#examples)   (also above)
-- #### Even less to write by stating reused test properties only once.      ►   [Collapsing forward](https://deusware.com/risei/index.html#collapsing-forward)   (basics below)
-- #### Built-in declarative syntax to fake test-time values from dependencies.      ►   [Spoofing using `.plus`](https://deusware.com/risei/index.html#spoofing)   (basics below)
-- #### Full support for `async` code with no special syntax needed.      ►   [Writing tests](https://deusware.com/risei/index.html#writing-tests)   (basics below)
-- #### Testing properties and methods, static and instance members all the same way.      ►   [Properties and statics](https://deusware.com/risei/index.html#testing-properties-and-static-methods)
-- #### Testing `throw` paths effortlessly.      ►   [Using `.and: "throws"`](https://deusware.com/risei/index.html#using-and-throws)
-- #### Deriving actual values to test from raw outputs or property retrieval.      ►   [Using `.from`](https://deusware.com/risei/index.html#using-from)
-- #### Setting up and tearing down arbitrary test state.      ►   [Using `.do` and `.undo`](https://deusware.com/risei/index.html#using-do-and-undo)
-- #### Testing for `undefined` as output.      ►   [Using `this.undef`](https://deusware.com/risei/index.html#using-undef)
-- #### Running a method repeatedly in one test.      ►   [Using `.and: "poly"`](https://deusware.com/risei/index.html#using-and-poly)
+Click ▼ / ▲ to see sections here, or the ► links to see full explanations on Risei's website.
+
+- #### Easy declarative syntax to write tests simply and quickly.  [▼](#writing-tests)  [► Writing tests](https://deusware.com/risei/index.html#writing-tests)
+- #### Easy-to-read test definitions and outputs.  [▲](#examples)  [► Examples](https://deusware.com/risei/index.html#examples)
+- #### Simple reuse of test properties.  [▼](#property-reuse-with-collapsing-forward)  [► Collapsing forward](https://deusware.com/risei/index.html#collapsing-forward)
+- #### Built-in declarative dependency faking.  [▼](#test-isolation-with-spoofing)  [► Spoofing using `.plus`](https://deusware.com/risei/index.html#spoofing)
+- #### Full support for `async` code without special syntax.  [▼](#writing-tests)  [► Writing tests](https://deusware.com/risei/index.html#writing-tests)
+- #### Consistent syntax for all callable code.  [▼](#writing-tests)  [► Properties and statics](https://deusware.com/risei/index.html#testing-properties-and-static-methods)
+- #### Testing exception / error paths effortlessly.   [► Using `.and: "throws"`](https://deusware.com/risei/index.html#using-and-throws)
+- #### Deriving values to test indirectly.   [► Using `.from`](https://deusware.com/risei/index.html#using-from)
+- #### Setting up and tearing down arbitrary test state.   [► Using `.do` and `.undo`](https://deusware.com/risei/index.html#using-do-and-undo)
+- #### Testing for `undefined` as output.   [► Using `this.undef`](https://deusware.com/risei/index.html#using-undef)
+- #### Running a method repeatedly in one test.   [► Using `.and: "poly"`](https://deusware.com/risei/index.html#using-and-poly)
 
 - And more!   Check out the full [Risei home page](https://deusware.com/risei).
 
 
+
 ## Installation
 
 Install Risei for development time only:
@@ -92,11 +88,13 @@ And add Risei's metadata to `package.json`:
 }
 ```
 
+
 ## Testing Risei Itself
 
 To test Risei itself, you clone it from a parallel [repository](https://gitlab.com/riseimaker/risei-public.git), install its dependencies, and run its self-tests.   See the full explanation [here](https://deusware.com/risei/index.html#self-testing).
 
 
+
 ## Writing Tests
 
 You write tests in `.rt.js` files like this:
@@ -123,11 +121,13 @@ tests = [ ...
 ```
 
 - **Asynchronous / awaitable code can tested with no changes at all to this syntax.**
-  - And you use `async` and `await` normally if you define functions within tests.
-- Use empty arrays for `.in` or `.with` when there are no args to pass.
+  - But you use `async` and `await` if you define functions within tests.
+- **Properties can be tested with no changes at all to this syntax.**
+  - Use empty arrays for `.in` or `.with` when there are no args to pass.
 - You can use [long names](https://deusware.com/risei/index.html#long-names) for properties if you want.
 
 
+
 ## Running Tests
 
 Once you have some tests written, you can run them manually:
@@ -151,7 +151,8 @@ npm test
 ```
 
 
-## Basic collapsing forward example
+
+## Property reuse with collapsing forward
 
 You can state repeated test properties just once, and let them _collapse forward_ across subsequent tests to save time and make tests easier to read.
 
@@ -170,12 +171,13 @@ Risei collapses values together from partial or full test objects until it has a
 { on: SortingClass, with: [ ] },                                     // Change of tested class.  All existing props are wiped out.
 ```
 
+- **To change just one property between tests, restate it along with `just: true`.**
 - There are more options available, and an exclusion for mutated args.
 - Learn all the details [here](https://deusware.com/risei/index.html#collapsing-forward).
 
 
 
-## Basic spoofing example
+## Test isolation with spoofing
 
 You can use declarative _spoofing_ syntax to define what dependencies of your targeted code return for it to use.
 
@@ -218,70 +220,20 @@ If errors are thrown while testing, gold bars listing them appear at the bottom,
 
 
 
-## Version history
-
-- Release **3.3.2** (September, 2025) contains this change:
-  - You can now use asynchronous / awaitable code in `.from` using `async` and `await` normally.
-    - You already could use awaitable code with the normal syntax in `.plus`, `.do`, and `.undo`.
-
-
-- Release **3.3.1** (February, 2025) contains this change:
-  - You can now spoof and otherwise address value properties (formally _data descriptors_) that don't have an initial value, whether they are static or instance class members.
-
-
-- Release **3.3.0** (January, 2025) adds this change to those of other recent releases:
-  - You can now test instance members with the same names as static members using a new `.and` option of `"instance"`.
-
-
-
-<details>
-<summary>
-Older releases
-</summary>
-
-- Release **3.2.1** (January, 2025) contains all the changes from **3.2.0**, **3.1.1**, and **3.1.0**, plus this change:
-  - Risei's mistaken nominal dependency on **npm** has been removed.
-
-
-- Release **3.2.0** (January, 2025) contains all the changes from **3.1.1** and **3.1.0**, plus this change:
-  - Risei's self-dependency for its own self-testing has been moved back to the development-only scope.
-
-
-- Release **3.1.1** (January, 2025) contains these changes:
-  - Extra commas and non-objects in arrays of test objects are disregarded, and no longer cause a throw.
-  - Throws in wider scopes are now listed at the end, like others already found there.
-
-
-- Release **3.1.0** (January, 2025) contains these changes:
-  - Accessor properties (formally _accessor descriptors_) are now compared for test results and displayed in test outputs.
-    - Any accessor properties that throw errors during display are displayed as `(threw)`.
-  - Throws in tested code and in test framing code are now listed at the end, and also displayed amid the tests.
-  - `File` objects now have a succinct custom display in outputs.
-  - **(Breaking change)**&nbsp;  In `constructor` tests, constructed instances are available in `.from` functions only as `actual` / `test.actual`.
-    - **(Breaking change)**&nbsp;  In `constructor` tests, `test.target` is now the `prototype` of the tested class.
-  - Widespread internal reengineering of other kinds.
-
-
-> Older releases are dropped from this list progressively over time.&nbsp;  Using the latest release is recommended.
-
-</details>
-
-
-
 ## Known issues and workarounds
 
 There are the known minor issues:
 
-- If args for a test are mutated by tested code, the mutated args are used when collapsing forward.
-  - The workaround is just to restate those args for each test.
+- Any mutated test args are used in mutated form by later tests when collapsing forward.
+  - To work around this, just restate those args for each test.
 
 
 - Spoofing accessor properties only works when they have both a getter and a setter.
-  - The workaround is to find another way to produce the property values you need.
+  - You can use `.do` and `.undo` to set and reverse other properties.
 
 
-- Predefined JavaScript methods like `toString()` may not be recognized, nor any instance method that has the same name as a static method.
-  - The workaround is to use an `.and` value of `"instance"` for any methods like these that you test.
+- Custom overrides of `toString()` and other built-in methods aren't recognized automatically.&nbsp;  Nor are instance methods with the same names as static methods.
+  - You can use an `.and` value of `"instance"` to ensure these are recognized.
 
 
 
@@ -312,7 +264,7 @@ Risei is published for use under the terms of the MIT license:
 
 <div style="border: solid darkgray 1px; padding: 0.5rem;">
 
-<b>Risei Copyright &copy; 2023&ndash;2025 Ed Fallin</b>
+<b>Risei Copyright &copy; 2023&ndash;2026 Ed Fallin</b>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "risei",
-  "version": "3.3.2",
+  "version": "3.3.4",
   "description": "Risei allows you to write unit tests as simple JavaScript objects, so it's easy and fast, with no drag on redesign.",
   "keywords": [
     "unit test",
@@ -54,6 +54,6 @@
     "fs": "^0.0.1-security",
     "mocha": "^10.0.0",
     "morgan": "~1.9.1",
-    "risei": "^3.3.1"
+    "risei": "^3.3.4"
   }
 }

package/system/ASpoofingFixture.js

@@ -6,36 +6,44 @@ export default class ASpoofingFixture {
     constructor() {
         /* No operations. */
     }
-    
-    /* A spoof might be supplied as a custom function, 
+
+    /* A spoof might be supplied as a custom function,
        but it might just be defined by a return value. */
-    spoofMethod(spoofOutput) {
+    spoofMethod(spoofOutput) /* passed */ {
         // No spoof supplied, so spoof is an empty function.
         if (spoofOutput === undefined) {
             let empty = () => { };
             return empty;
         }
-        
+
         // Spoof is a custom function to use as-is.
         if (spoofOutput instanceof Function) {
             return spoofOutput;
         }
-        
-        // Recursive case: Spoof defines a whole object 
+
+        // Recursive case: Spoof defines a whole object
         // tree to be returned as method output.
-        if (Array.isArray(spoofOutput)) {
-            if (spoofOutput.every(x => SpoofDef.isASpoof(x))) {
-                spoofOutput = SpoofDef.fromNonceTuples(spoofOutput);
-                spoofOutput = this.spoofObjectTree(spoofOutput);
-            }
+        if (this.isSpoofArray(spoofOutput)) {
+            spoofOutput = SpoofDef.fromNonceTuples(spoofOutput);
+            spoofOutput = this.spoofObjectTree(spoofOutput);
         }
-        
+
         // Commonest case: Spoof is a value to be returned.
         let spoof = () => { return spoofOutput; }
         return spoof;
     }
 
-    /* Returns an object with all spoofed methods, 
+    isSpoofArray(subject) /* good */ {
+        if (!Array.isArray(subject)) { return false; }
+
+        // Empty array is assumed to be a spoof return value.
+        if (subject.length === 0) { return false; }
+
+        let is = subject.every(x => SpoofDef.isASpoof(x));
+        return is;
+    }
+
+    /* Returns an object with all spoofed methods,
        possibly with intermediate objects. */
     spoofObjectTree(ofAsPairs) {
         let spoof = {};
@@ -66,7 +74,7 @@ export default class ASpoofingFixture {
                 next = next[name];
             }
 
-            // Final or only name is the leaf method; 
+            // Final or only name is the leaf method;
             // name may mistakenly end with `()`.
             name = names.shift();
             name = name.replace("()", "");
@@ -75,7 +83,7 @@ export default class ASpoofingFixture {
             let method = this.spoofMethod(output);
             next[name] = method;
         }
-        
+
         // And back to caller.
         return spoof;
     }

package/system/SpoofDef.js

@@ -4,255 +4,255 @@ import TypeAnalyzer from "./TypeAnalyzer.js";
 import NameAnalyzer from "./NameAnalyzer.js";
 import TotalDisplayer from "./TotalDisplayer.js";
 
-/* Defines what is found in a spoof definition, typically as 
+/* Defines what is found in a spoof definition, typically as
    a nonce object rather than an instance of this class. */
 
 export default class SpoofDef {
     // region Static fields
 
-    /* Properties can have short or long names. */
-    static #onNames = [ "on", "target" ];
-    static #ofNames = [ "of", "method" ];
-    static #asNames = [ "as", "output" ];
+        /* Properties can have short or long names. */
+        static #onNames = [ "on", "target" ];
+        static #ofNames = [ "of", "method" ];
+        static #asNames = [ "as", "output" ];
 
-    static #longsByShort = new Map([
-        SpoofDef.#onNames,
-        SpoofDef.#ofNames,
-        SpoofDef.#asNames
-    ]);
-    
-    // endregion Static fields
+        static #longsByShort = new Map([
+            SpoofDef.#onNames,
+            SpoofDef.#ofNames,
+            SpoofDef.#asNames
+        ]);
+
+        // endregion Static fields
 
     // region Public fields (long names)
 
-    /* These long names are clearer and match the constructor's parameter 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. */
+        /* 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;
+        target;
+        method;
+        output;
 
-    // endregion Public fields (long names)
+        // endregion Public fields (long names)
 
     // region Properties
 
     // region Spoof definition, short names
 
-    /* These short names make JSON-like definitions easier. */
+        /* These short names make JSON-like definitions easier. */
 
-    get on() { return this.target; }
+        get on() { return this.target; }
 
-    set on(value) { this.target = value; }
+        set on(value) { this.target = value; }
 
-    get of() { return this.method; }
+        get of() { return this.method; }
 
-    set of(value) { this.method = value; }
+        set of(value) { this.method = value; }
 
-    get as() { return this.output; }
+        get as() { return this.output; }
 
-    set as(value) { this.output = value; }
+        set as(value) { this.output = value; }
 
-    // endregion Spoof definition, short names
+        // endregion Spoof definition, short names
 
     // region Def state
 
-    /* Returns true if arg doesn't provide enough to spoof with. */
-    static isNotASpoof(nonce) /* passed */ {
-        return !SpoofDef.isASpoof(nonce);
-    }
-
-    /* Returns true if arg provides enough to spoof with. */
-    static isASpoof(nonce) /* passed */ {
-        /* Any nonce that is null or undefined is not a SpoofDef. */
-        if (nonce === undefined || nonce === null) {
-            return false;
+        /* Returns true if arg doesn't provide enough to spoof with. */
+        static isNotASpoof(nonce) /* passed */ {
+            return !SpoofDef.isASpoof(nonce);
         }
-        
-        let hasAnOf = SpoofDef.#hasEitherName(nonce, SpoofDef.#ofNames);
-        let hasAnAs = SpoofDef.#hasEitherName(nonce, SpoofDef.#asNames);
 
-        /* Any nonce with at least an .of or an .as is a SpoofDef. */
-        return hasAnOf || hasAnAs;
-    }
+        /* Returns true if arg provides enough to spoof with. */
+        static isASpoof(nonce) /* passed */ {
+            /* Any nonce that is null or undefined is not a SpoofDef. */
+            if (nonce === undefined || nonce === null) {
+                return false;
+            }
 
-    get isMethodSpoof() /* passed */ {
-        if (this.target === undefined) {
-            throw new Error("No .on / .target present.  It must be set for .isMethodSpoof to work.");
+            let hasAnOf = SpoofDef.#hasEitherName(nonce, SpoofDef.#ofNames);
+            let hasAnAs = SpoofDef.#hasEitherName(nonce, SpoofDef.#asNames);
+
+            /* Any nonce with at least an .of or an .as is a SpoofDef. */
+            return hasAnOf || hasAnAs;
         }
 
-        let plainName = NameAnalyzer.plainNameOf(this.method);
+        get isMethodSpoof() /* passed */ {
+            if (this.target === undefined) {
+                throw new Error("No .on / .target present.  It must be set for .isMethodSpoof to work.");
+            }
 
-        if (NameAnalyzer.hasPropertySigil(this.method)) {
-            return false;
-        }
+            let plainName = NameAnalyzer.plainNameOf(this.method);
 
-        let isMethod 
-            = NameAnalyzer.hasMethodSigil(this.method) 
-            || TypeAnalyzer.isMethodMember(this.target, plainName);
+            if (NameAnalyzer.hasPropertySigil(this.method)) {
+                return false;
+            }
 
-        return isMethod;
-    }
+            let isMethod
+                = NameAnalyzer.hasMethodSigil(this.method)
+                || TypeAnalyzer.isMethodMember(this.target, plainName);
 
-    get isPropertySpoof() /* passed */ {
-        if (this.target === undefined) {
-            throw new Error("No .on / .target present.  It must be set for .isPropertySpoof to work.");
+            return isMethod;
         }
 
-        let plainName = NameAnalyzer.plainNameOf(this.method);
+        get isPropertySpoof() /* passed */ {
+            if (this.target === undefined) {
+                throw new Error("No .on / .target present.  It must be set for .isPropertySpoof to work.");
+            }
 
-        if (NameAnalyzer.hasMethodSigil(this.method)) {
-            return false;
-        }
+            let plainName = NameAnalyzer.plainNameOf(this.method);
+
+            if (NameAnalyzer.hasMethodSigil(this.method)) {
+                return false;
+            }
 
-        let isProperty 
-            = NameAnalyzer.hasPropertySigil(this.method) 
-            || TypeAnalyzer.isPropertyMember(this.target, plainName);
+            let isProperty
+                = NameAnalyzer.hasPropertySigil(this.method)
+                || TypeAnalyzer.isPropertyMember(this.target, plainName);
 
-        return isProperty;
-    }
+            return isProperty;
+        }
 
-    // endregion Def state
+        // endregion Def state
 
     // endregion Properties
 
     // region Initing, including constructor() and statics
 
-    /* Long names used, just in case. */
-    constructor(target, method, output) /* passed */ {
-        this.target = target;
-        this.method = method;
-        this.output = output;
-    }
-
-    /* Arg 'type' should be test.type if present. */
-    static fromNonceTuples(nonces, type) /* passed */ {
-        // Throughput and output.
-        let full = new SpoofDef();
-        let output = [ ];
-
-        // Looping over all.
-        for (let nonce of nonces) {
-            // Get latest spoof definition/s and retain for output.
-            let latests = SpoofDef.fromNonceTuple(nonce, type);
-            output.push(...latests);
+        /* Long names used, just in case. */
+        constructor(target, method, output) /* passed */ {
+            this.target = target;
+            this.method = method;
+            this.output = output;
         }
 
-        // Back to caller.
-        return output;
-    }
-    
-    /* Arg 'type' should be test.type if present. */
-    static fromNonceTuple(nonce, type) /* passed */ {
-        // No spoof-def to output.
-        if (SpoofDef.isNotASpoof(nonce)) {
-            return [ ];
+        /* Arg 'type' should be test.type if present. */
+        static fromNonceTuples(nonces, type) /* passed */ {
+            // Throughput and output.
+            let full = new SpoofDef();
+            let output = [ ];
+
+            // Looping over all.
+            for (let nonce of nonces) {
+                // Get latest spoof definition/s and retain for output.
+                let latests = SpoofDef.fromNonceTuple(nonce, type);
+                output.push(...latests);
+            }
+
+            // Back to caller.
+            return output;
         }
 
-        let defs = [ ];
+        /* Arg 'type' should be test.type if present. */
+        static fromNonceTuple(nonce, type) /* passed */ {
+            // No spoof-def to output.
+            if (SpoofDef.isNotASpoof(nonce)) {
+                return [ ];
+            }
 
-        // Nonce defines one spoof.
-        if (SpoofDef.#isMonoSpoof(nonce)) {
-            let def = SpoofDef.#fromMonoNonce(nonce, type);
-            defs.push(def);
-        }
+            let defs = [ ];
 
-        // Nonce defines more than one spoof: Recursion.
-        if (SpoofDef.#isPolySpoof(nonce)) {
-            let locals = SpoofDef.#fromPolyNonce(nonce, type);
-            defs.push(...locals);
+            // Nonce defines one spoof.
+            if (SpoofDef.#isMonoSpoof(nonce)) {
+                let def = SpoofDef.#fromMonoNonce(nonce, type);
+                defs.push(def);
+            }
+
+            // Nonce defines more than one spoof: Recursion.
+            if (SpoofDef.#isPolySpoof(nonce)) {
+                let locals = SpoofDef.#fromPolyNonce(nonce, type);
+                defs.push(...locals);
+            }
+
+            return defs;
         }
 
-        return defs;
-    }
+        // region Dependencies of nonce-tuple initing methods
 
-    // region Dependencies of nonce-tuple initing methods
+            static #isMonoSpoof(nonce) /* verified */ {
+                return SpoofDef.#hasEitherName(nonce, SpoofDef.#ofNames);
+            }
 
-    static #isMonoSpoof(nonce) /* verified */ {
-        return SpoofDef.#hasEitherName(nonce, SpoofDef.#ofNames);
-    }
+            static #isPolySpoof(nonce) /* verified */ {
+                return !SpoofDef.#isMonoSpoof(nonce);
+            }
 
-    static #isPolySpoof(nonce) /* verified */ {
-        return !SpoofDef.#isMonoSpoof(nonce);
-    }
+            /* Arg 'type' should be test.type if present. */
+            static #fromMonoNonce(nonce, type) /* verified */ {
+                // Empty, since each prop can
+                // have either of two names.
+                let def = new SpoofDef();
 
-    /* Arg 'type' should be test.type if present. */
-    static #fromMonoNonce(nonce, type) /* verified */ {
-        // Empty, since each prop can 
-        // have either of two names.
-        let def = new SpoofDef();
+                let shortNames = SpoofDef.#longsByShort.keys();
 
-        let shortNames = SpoofDef.#longsByShort.keys();
+                // Traversing name pairs to use whichever one is present;
+                // if neither is present, the property is undefined.
+                for (let shortName of shortNames) {
+                    let longName = SpoofDef.#longsByShort.get(shortName);
 
-        // Traversing name pairs to use whichever one is present; 
-        // if neither is present, the property is undefined.
-        for (let shortName of shortNames) {
-            let longName = SpoofDef.#longsByShort.get(shortName);
+                    def[shortName]
+                        = nonce[shortName] !== undefined
+                        ? nonce[shortName]
+                        : nonce[longName];
+                }
 
-            def[shortName] 
-                = nonce[shortName] !== undefined 
-                ? nonce[shortName] 
-                : nonce[longName];
-        }
+                // Adding test target's type, if no type provided.
+                if (def.target === undefined) {
+                    def.target = type;
+                }
 
-        // Adding test target's type, if no type provided.
-        if (def.target === undefined) {
-            def.target = type;
-        }
+                return def;
+            }
 
-        return def;
-    }
+            /* Arg 'type' should be test.type if present. */
+            static #fromPolyNonce(nonce, type) /* verified */ {
+                let defs = [ ];
 
-    /* Arg 'type' should be test.type if present. */
-    static #fromPolyNonce(nonce, type) /* verified */ {
-        let defs = [ ];
+                // Poly-nonce's .on applies to all its partial spoofs.
+                let on = nonce.on !== undefined ? nonce.on : nonce.target;
 
-        // Poly-nonce's .on applies to all its partial spoofs.
-        let on = nonce.on !== undefined ? nonce.on : nonce.target;
+                // Poly-nonce's .as is an array of partial-spoof nonces.
+                let pairs = nonce.as !== undefined ? nonce.as : nonce.output;
 
-        // Poly-nonce's .as is an array of partial-spoof nonces.
-        let pairs = nonce.as !== undefined ? nonce.as : nonce.output;
+                // Traversing partial-spoof nonces (.of and .as only).
+                for (let pair of pairs) {
+                    // Either name (or neither) may exist on nonce partial.
+                    let of = pair.of !== undefined ? pair.of : pair.method;
+                    let as = pair.as !== undefined ? pair.as : pair.output;
 
-        // Traversing partial-spoof nonces (.of and .as only).
-        for (let pair of pairs) {
-            // Either name (or neither) may exist on nonce partial.
-            let of = pair.of !== undefined ? pair.of : pair.method;
-            let as = pair.as !== undefined ? pair.as : pair.output;
+                    // Only one level of recursion.
+                    let passer = SpoofDef.#fromMonoNonce({ on, of, as }, type);
 
-            // Only one level of recursion.
-            let passer = SpoofDef.#fromMonoNonce({ on, of, as }, type);
+                    defs.push(passer);
+                }
 
-            defs.push(passer);
-        }
+                return defs;
+            }
 
-        return defs;
-    }
+            static #hasEitherName(nonce, names) /* verified */ {
+                let hasEither = false;
 
-    static #hasEitherName(nonce, names) /* verified */ {
-        let hasEither = false;
+                for (let name of names) {
+                    hasEither ||= nonce[name] !== undefined;
+                }
 
-        for (let name of names) {
-            hasEither ||= nonce[name] !== undefined;
-        }
-        
-        return hasEither;
-    }
+                return hasEither;
+            }
 
-    // endregion Dependencies of nonce-tuple initing methods
+            // endregion Dependencies of nonce-tuple initing methods
 
-    // endregion Initing, including constructor() and statics
+        // endregion Initing, including constructor() and statics
 
     // region Overrides and dependencies
 
-    toString() /* passed */ {
-        let displayer = new TotalDisplayer();
+        toString() /* passed */ {
+            let displayer = new TotalDisplayer();
 
-        let text = `SpoofDef{ on:${ displayer.display(this.target) }, `
-            + `of:${ displayer.display(this.method) }, `
-            + `as:${ displayer.display(this.output) } }`;
-        return text;
-    }
+            let text = `SpoofDef{ on:${ displayer.display(this.target) }, `
+                + `of:${ displayer.display(this.method) }, `
+                + `as:${ displayer.display(this.output) } }`;
+            return text;
+        }
 
-    // endregion Overrides and dependencies
+        // endregion Overrides and dependencies
 }

package/system/TestTargets.js

@@ -66,11 +66,11 @@ export default class TestTargets {
     // region Dependencies of targeting / naming methods
 
         supplyPolyMethodNonce(test, callable) /* verified */ {
-            let nonce = (...inputs) => {
+            let nonce = async (...inputs) => {
                 let actuals = [];
 
                 for (let args of inputs) {
-                    let local = test.target[callable](...args);
+                    let local = await test.target[callable](...args);
                     actuals.push(local);
                 }