risei 1.2.0 → 1.3.1

package/README.md

@@ -4,7 +4,7 @@
 ## What Risei is
 
 **Risei is a new way to write unit tests that allows you to:**
-* Whip up full test coverage of object-oriented or object-hosted JavaScript in no time.
+* Whip up full test coverage of object-oriented or object-hosted JavaScript and TypeScript in no time.
 * Refactor or replace existing designs without worrying about the cost in past or future test time.
 * Create tests with immediate confidence, because you can't introduce mistakes in test code you write.
 
@@ -41,7 +41,11 @@ Test runs also feature a title bar at the top, as well as a summary bar at the b
 
 ## Using Risei
 
-Risei is under active development.   If you've been here before, check out [what's new in Risei](#whats-new-in-risei) for the latest.   Also see [known bugs and workarounds](#known-bugs-and-workarounds) and [limitations in Risei](#limitations-in-risei).
+Risei is under active development.   If you've been here before, check out [what's new in Risei](#whats-new-in-risei) for the latest.   Also see [known issues and workarounds](#known-issues-and-workarounds) and [limitations in Risei](#limitations-in-risei).
+
+There are a few additional or different steps for [using Typescript with Risei](#using-typescript-with-risei).
+
+
 
 ### Installation
 
@@ -65,6 +69,8 @@ And add Risei's metadata to `package.json`:
 }
 ```
 
+Just a [few extra steps](#using-typescript-with-risei) are required for Risei to work with TypeScript.
+
 
 
 ### Siting tests
@@ -117,13 +123,15 @@ You can save a lot of time by putting repeated test properties into an object on
     { of: "countOf", for: "Returns the number present.", in: [ "b" ], out: 2 }
 ```
 
-This _collapsing forward_ works for just about every test property, but is reset when you change the class in `.on`, when you give the property a new value, or you erase it with an empty array `[ ]`.  
+- This _collapsing forward_ works for just about every test property, but is reset when you change the class in `.on`, when you give the property a new value, or you erase it with an empty array `[ ]`.
+
+- When the tested code mutates the contents of `.with` or `.in`, provide these args as the output of a function or method, because at present, the mutated values are collapsed forward.
 
 
 
 #### Spoof away code dependencies:
 
-When your code has dependencies on other code, just _spoof_ the results of that code to get what your test needs from it, using a `.plus` property on your tests that offers many options:
+When your tests need certain results from code dependencies, just _spoof_ what you want using a `.plus` test property:
 
 ```javascript
         { on: CombinerClass, with: [ ], 
@@ -145,7 +153,9 @@ When your code has dependencies on other code, just _spoof_ the results of that
           in: [ "green" ], out: [ 7, 8, 9, 10, 10, 11, 12, { color: "green" } ] }
 ```
 
-These are basically all varieties of spoofing.   Spoofing collapses forward across tests, but not across the elements within `.plus`. 
+- Spoofing collapses forward across tests, but not across the elements within `.plus`.
+
+- Spoofing is also fully isolated within tests.
 
 
 
@@ -171,15 +181,15 @@ And then run that script:
 npm test
 ```
 
-Risei can be used alongside other test frameworks.   You might run them all from the same test script, or perhaps write unique scripts for each.
+Risei can be used alongside other test frameworks, and even run with them from the same test script if you want.
 
 
 
 ### Learning more about Risei
 
-Be sure to read through the rest of this doc to learn more about Risei's many capabilities, and about where Risei is headed.
+Read through the rest of this doc to learn more about Risei's many capabilities, and about where Risei is headed.
 
-- For instance, learn about using `.and` to test static code or throws.
+- For instance, learn about using `.and` to test static methods or throws.
 - Or learn about using `.from` to test property results or other state.
 - Don't miss out:  Once you've tried the basics, read the rest...!
 
@@ -188,6 +198,11 @@ Be sure to read through the rest of this doc to learn more about Risei's many ca
 
 ## Risei in depth
 
+<details>
+<summary>
+There's plenty more to learn about Risei and how it makes testing easy...
+</summary>
+
 ### Installation
 
 - You can use any file extension you want in Risei's metadata in `package.json`, and Risei will scan those files for tests.
@@ -211,6 +226,7 @@ Be sure to read through the rest of this doc to learn more about Risei's many ca
 - The order and placement of test properties doesn't matter, although the order seen in the examples is probably most readable.
 
 
+
 #### Basic test properties and options for each:
 
 | Name   | Contents                                                                                                  |
@@ -226,25 +242,21 @@ Be sure to read through the rest of this doc to learn more about Risei's many ca
 - The property names were chosen to be easy to remember and type, but longer alternatives are available, covered later.
 
 
-</details>
-
 
 ### Test-property reuse _AKA_ Collapsing forward
 
 - To save time and effort, any property you write is collapsed forward to subsequent tests unless you replace it or erase it with an empty array `[ ]`.
   - Property values are gathered across partial test objects until they add up to a runnable test, which is then run.
   - Changes to properties are combined with previous ones to produce intended new tests.
-    - For a rare and avoidable side-effect of this system, see [Known bugs and workarounds](#known-bugs-and-workarounds).
+    - For a rare and avoidable side-effect of this system, see [known issues and workarounds](#known-issues-and-workarounds).
 
 - Test contents, reused or not, are automatically reset when it makes the most sense:
   - Changing the tested class in `.on` wipes out all prior test properties, so the new class has a fresh start.
   - Changing the tested method in `.of` wipes out only test properties related to methods, to preserve class values you usually want.
 
+- Individual tests remain isolated, except for when args are mutable.
+  - To use the original, un-mutated args for successive tests, just return them from a function or method to set `.with` or `.in`.
 
-- Individual tests remain isolated because class instances, spoofed methods (covered later) and so on are all created anew for each test.
-  - However, input (`.in`) and instantiation (`.with`) arguments that are mutated by tested code are not yet isolated.
-  - They will be fully isolated in a future release.
-  - In the meantime, calling a function to supply them to `.in` or `.with` does isolate them completely.
 
 
 ### Choosing test-only dependency inputs _AKA_ Spoofing
@@ -257,6 +269,7 @@ Be sure to read through the rest of this doc to learn more about Risei's many ca
 - All classes whose members are being spoofed have to be imported.
 
 
+
 #### Spoof-definition properties:
 
 | Name | Necessary or Optional | Contents                                                                                                                                                             |
@@ -342,7 +355,7 @@ To test a value that isn't the exercised code's return value, you use `.out` nor
 
 
 - Getting properties, mutated args, and other non-return values is known as _retrieving_.
-- Retrieving definitions collapse forward across tests unless  replaced with new definitions, or erased by setting `.from` to an empty array `[ ]`.
+- Retrieving definitions collapse forward across tests unless replaced with new definitions, or erased by setting `.from` to an empty array `[ ]`.
 
 
 <details>
@@ -446,9 +459,72 @@ Constructors can be tested with no special test properties or keywords.
 - Any `.with` args are completely ignored for a constructor test.&nbsp;  Only those in the test's `.in` property are used.
   - However, a `.with` must still be provided.&nbsp;  It can simply be an empty array `[ ]`.
 
+</details>
+
+
+
+
+## Using TypeScript with Risei
+
+Testing TypeScript code with Risei basically just means transpiling before running the tests, and being sure to point to its output JS files, not the TS ones.
+
+- Anything beyond those basics is intended to keep JS files separate from TS files and the output of web frameworks' own, complex build processes.
+
+If you follow the general Risei set-up, you can just make the following few modifications for TypeScript applications.
+- These steps have worked with both Angular and React.
+- Variant approaches are also sure to work, depending on the other technical choices in play.
+
+
+
+### In `package.json`:
+
+Add transpilation and deletion operations to the `test` script, with each operation conditional on completion of the preceding one:
+
+```json
+"scripts": {
+  "test": "tsc && node ./node_modules/risei/index.js && rm -r ./dist/out-tsc"
+}
+```
+
+- Generally, you should use `tsc` or another plain transpiler, not web frameworks' complex processes with single output files.
+- Deleting the files at the end prevents interference with web frameworks' bundling.
+- The deletion path must match the `outDir` in `tsconfig.json`.
+
+> You can run Risei manually with the same sequence of operations.
+
+
+
+### In `tsconfig.json`:
+
+You set up the transpiler to output files to a directory with these settings:
+
+```json
+{
+  "outDir": "dist/out-tsc",
+  "noEmit": false
+}
+```
+
+- The `outDir` can be any location.&nbsp;  It's best not to just use `dist`, where adding or deleting files may interfere with web frameworks' build steps.
+- These settings are normally not near each other in the file (as seen here).
+- You can also set the `target` to `es6` or higher, although Risei works fine with ES5.
+
+
+
 
+### In test files:
 
-### Limitations in Risei
+All `import` statements have to point to the `outDir` path or subfolders there, using relative-path syntax:
+
+```javascript
+import { TestedClass } from "../../dist/out-tsc/SubPath/TestedClass.js";
+```
+
+- Output files may be in a folder tree parallel to the originals (Angular), or may all be in the `outDir` folder itself (React).
+
+
+
+## Limitations in Risei
 
 The following are not supported at present:
 - Use of `async` syntax
@@ -468,52 +544,48 @@ Some of these are on the tentative future-development list.&nbsp;  In the meanti
 
 Most problems with using Risei are minor mistakes in syntax, or omissions in test definitions:
 
-| Error condition or text           | Probable cause / fix                                           |
-|-----------------------------------|----------------------------------------------------------------|
-| Sudden drop in the number of tests run                              | An error occurred in a test file; error output at the top of the test run explains why                                                                                                      |
-| `"Test loading failed for...  SyntaxError: Unexpected token ':'"`   | Missing comma in your tests in the named file                                                                                                                                                               |
-| `"Test loading failed for...  SyntaxError: Unexpected token '.'"`   | Using `this.tests = []` instead of `tests = []` in the file named                                                                                                                                           |
-| Other `... Unexpected token ...` errors                             | Some other syntax error in the file named, most likely a missing or extra delimiter                                                                                                                         |
-| Unexpected actual values, or unexpected passes / fails in test runs | Spoofs, retrievals, or special conditions from previous tests not replaced or reset with `[ ]`<br>&mdash; or &mdash;<br>Tested method mutates `.in` or `.with` args: preventable by using a function to supply those args<br>&mdash; or &mdash;<br>Pre-listed test properties produce extra tests: preventable by restating class in `.on` |
-
+| Error condition or text                                             | Probable cause / fix                                                                                                                                                                                                                                                                                                                       |
+|---------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Gold bar appears below the summary, and the number of tests run drops        | A syntax error caused a test file not to load; error output in the gold bar explains why                                                                                                                                                                                                                                        |
+| `"Test loading failed for...  SyntaxError: Unexpected token ':'"`   | Missing comma in your tests in the named file                                                                                                                                                                                                                                                                                              |
+| `"Test loading failed for...  SyntaxError: Unexpected token '.'"`   | Using `this.tests = []` instead of `tests = []` in the file named                                                                                                                                                                                                                                                                          |
+| Other `... Unexpected token ...` errors                             | Some other syntax error in the file named, most likely a missing or extra delimiter                                                                                                                                                                                                                                                        |
+| Unexpected actual values, or unexpected passes / fails in test runs | Spoofs, retrievals, or special conditions from previous tests not replaced or reset with `[ ]` |
+| Unexpected actual values, or unexpected passes / fails in test runs | Pre-listed test properties have produced extra tests; changing properties as part of new tests prevents this |
+| Unexpected actual values, or unexpected passes / fails in test runs | `.with` or `.in` values were mutated by a test and passed to subsequent tests; providing contents of these properties with a function prevents this |
 
 
 
-## Known bugs and workarounds
+## Known issues and workarounds
 
-One known bug exists:
-- When the args stated in `.with` or `.in` are mutated by the method under test (or by anything done within a test), the mutated values are carried forward to other tests.
-- A workaround exists for now: just provide those args using a fixture function when they may be mutated.&nbsp;  The function is called each time, isolating them completely.
+Two issues are known to exist:
 
+- If the contents of `.with` or `.in` are mutated by the code being tested, the mutated values are carried from test to test.
+  - To use the original, un-mutated args for successive tests, just return them from a function or method, and call it to set `.with` or `.in`.
+  - Ways to prevent this are being looked at.
 
- - This problem with test isolation is being fixed in an upcoming release.
 
-
-One known unexpected result (not quite a bug) exists:
-- Because test properties collapse forward to form whole tests, pre-stating new properties for upcoming tests without changing `.on` is treated as a new test like prior ones, with just those properties changed.
-  - Pre-stating properties might be done as a way to make them stand out when reading through the tests.
-
-- This means you see an extra unexpected test that most likely fails, due to the mix of old and new properties.
-
-- A workaround exists: if you pre-state new properties, also restate the class under test in `.on`, which erases all prior test properties.
-  - Restating `.on` doesn't cause the class name to be displayed again in output.
-
-
- - This output is rarely an issue, and may be what is wanted in some cases, but options for preventing it are being considered.
+- Changing one or more properties in objects by themselves in the middle of tests (perhaps to emphasize them) can create extra tests.
+  - The extra tests usually fail, because they have an unintended mix of old and new properties.
+  - In this case, Rs is actually working properly, running prior tests with the new properties swapped in.
+  - To avoid this problem, include changed properties in full tests to run, or restate `.of` along with the changed properties.
+  - This situation is rarely an issue, but ways to optionally prevent it are being considered.
 
 
 
 ## What's new in Risei
 
-- Release **1.2.0** (January, 2024) changes sorting of test files.&nbsp;  Previously they were displayed in the order found.&nbsp;  Now the last-edited file is moved to the bottom, making it easy to see the latest test results.
+- Release **1.3.1** (February, 2024) reverses some changes in 1.3.0 that were intended to fully isolate tests against mutable args, but which caused incomplete or inaccurate object contents in some cases.&nbsp;  Later work may restore full isolation in a different way at some point.
+
+- Release **1.3.0** (February, 2024) moves the display of test-loading error messages to a new gold bar that appears at the bottom of the summary when there are any loading errors.&nbsp;  A sorting error that occurs when no test files exist yet has also been fixed. 
 
+- Release **1.2.0** (January, 2024) changes sorting of test files.&nbsp;  Previously they were displayed in the order found.&nbsp;  Now the order remains the same, except that the last-edited file is moved to the bottom, making it easy to see the latest test results.
 
 - Release **1.1.2** of Risei (January, 2024) fixes two problems:
   - Classes were sometimes displayed in output as their entire definition.&nbsp;  Now just the class name is displayed.
   - All `Date` instances were considered equal, regardless of their actual value.&nbsp;  Now they only are considered equal when they actually are.
 
-
-> Don't use release **1.1.1**, which contains an internal path error.
+- Don't use release **1.1.1**, which contains an internal path error.
 
 
 
@@ -534,7 +606,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 Ed Fallin</b>
+<b>Risei Copyright &copy; 2023&ndash;2024 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/index.js

@@ -1,6 +1,6 @@
 /**/
 
-/* Copyright (c) 2023 Ed Fallin.  Published under the terms of the MIT license. */
+/* Copyright (c) 2023-2024 Ed Fallin.  Published under the terms of the MIT license. */
 
 /* This index.js is the entry point for running Risei tests from 
    other code.  It imports other modules to perform its work.
@@ -47,6 +47,7 @@ export * from "./system/ATestReporter.js";
 
 /* Display styles for the start title and other general needs. */
 const title = chalk.hex("FFFFFF").bgHex("191970").bold;
+const fails = chalk.hex("000000").bgHex("FFD700").bold;
 
 // endregion Named styles
 
@@ -61,7 +62,7 @@ let wide = (text) => {
 
 // endregion Styling for color stripes
 
-// region Key callable, its scriptable call, and its export
+// region Key callable, its scripted call, and its export
 
 async function runRiseiTests(testFinderPath) {
     // region Converting test-finder from path to class
@@ -90,7 +91,7 @@ async function runRiseiTests(testFinderPath) {
     console.log();
     
     // endregion Intro / title
-    
+
     // region Running tests
     
     // Test-system objects and their relationships.
@@ -104,7 +105,19 @@ async function runRiseiTests(testFinderPath) {
     await caller.runAllTests();
     
     // endregion Running tests
-    
+
+    // region Trailing display of test-loading issues
+
+    if (finder.thrown.length !== 0) {
+        let loadFails = finder.thrown;
+
+        for (let fail of loadFails) {
+            console.log(fails(wide(` ${ fail }`)));
+        }
+    }
+
+    // endregion Trailing display of test-loading issues
+
     // region Trailing formatting
     
     console.log();
@@ -118,5 +131,5 @@ await runRiseiTests();
 
 export default runRiseiTests;
 
-// endregion Key callable, its scriptable call, and its export
+// endregion Key callable, its scripted call, and its export
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "risei",
-  "version": "1.2.0",
+  "version": "1.3.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",
@@ -28,8 +28,7 @@
     "test": "clear; node ./node_modules/risei/index.js"
   },
   "risei": {
-    "tests": "**.rt.js",
-    "sort": "normal"
+    "tests": "**.rt.js"
   },
   "exports": {
     ".": "./index.js",
@@ -49,6 +48,6 @@
     "fs": "^0.0.1-security",
     "mocha": "^10.0.0",
     "morgan": "~1.9.1",
-    "risei": "1.1.2"
+    "risei": "1.3.1"
   }
 }

package/system/ASpoofingFixture.js

@@ -1,7 +1,7 @@
 /**/
 
 import { ATestFixture } from "./ATestFixture.js";
-import { SpoofTuple } from "./SpoofTuple.js";
+import { SpoofDefinition } from "./SpoofDefinition.js";
 
 export class ASpoofingFixture extends ATestFixture {
     constructor(name, kind) {
@@ -25,8 +25,8 @@ export class ASpoofingFixture extends ATestFixture {
         // Recursive case: Spoof defines a whole object 
         // tree to be returned as method output.
         if (Array.isArray(spoofOutput)) {
-            if (spoofOutput.every(x => SpoofTuple.isASpoof(x))) {
-                spoofOutput = SpoofTuple.fromNonceTuples(spoofOutput);
+            if (spoofOutput.every(x => SpoofDefinition.isASpoof(x))) {
+                spoofOutput = SpoofDefinition.fromNonceTuples(spoofOutput);
                 spoofOutput = this.spoofObjectTree(spoofOutput);
             }
         }

package/system/ATestFinder.js

@@ -5,7 +5,14 @@
 import { ATestSource } from "./ATestSource.js";
 
 export class ATestFinder {
+    // region Fields
+
     #testSources;
+    #thrown = [];
+
+    // endregion Fields
+
+    // region Properties
 
     get testSources() {
         return this.#testSources;
@@ -15,6 +22,12 @@ export class ATestFinder {
         this.#testSources = value;
     }
 
+    get thrown() {
+        return this.#thrown;
+    }
+
+    // endregion Properties
+
     constructor() {
         this.#testSources = [];
     }

package/system/Risei.js

@@ -1,14 +1,19 @@
 /**/
 
-/* Risei.js is the entry point for running Kitten / Koneko / Risei tests.  
-   It imports other modules to do all of its work. */
+/* Copyright (c) 2023-2024 Ed Fallin.  Published under the terms of the MIT license. */
+
+/* This index.js is the entry point for running Risei tests from 
+   other code.  It imports other modules to perform its work.
+   It also exports modules that should / can be subclassed. */
+
+// region Imports
 
 // region Test-running dependencies
 
 import { TestRunner } from "./TestRunner.js";
-import { ChosenTestFinder } from "./ChosenTestFinder.js";
 import { LocalCaller } from "./LocalCaller.js";
 import { TerminalReporter } from "./TerminalReporter.js";
+import { TestFinder } from "./TestFinder.js";
 
 // endregion Test-running dependencies
 
@@ -19,19 +24,13 @@ import { Moment } from "./Moment.js";
 
 // endregion Display dependencies
 
+// endregion Imports
+
 // region Named styles
 
 /* Display styles for the start title and other general needs. */
-const cal = chalk.hex("0000FF").bgHex("EEEE00").bold;
-const onBlue = chalk.bgBlueBright;
-const onGreen = chalk.bgGreenBright;
-
-const future = chalk.hex("FFFFFF").bgHex("191970").bold;
-
-/* Display styles for tests. */
-const group = chalk.hex("FFFFFF").bgHex("0000CD");
-const passed = chalk.hex("000000").bgHex("90EE90");
-const failed = chalk.hex("000000").bgHex("F08080");
+const title = chalk.hex("FFFFFF").bgHex("191970").bold;
+const fails = chalk.hex("000000").bgHex("FFD700").bold;
 
 // endregion Named styles
 
@@ -46,43 +45,74 @@ let wide = (text) => {
 
 // endregion Styling for color stripes
 
-// region Intro / title
-
-/* To clear the console first, you can include `clear;` in the script 
-   ahead of calling this, or else restore console.clear() here, 
-   although the Risei output may then overwrite some prior output. */
-
-console.log();
-console.log(future(wide()));
-
-let now = new Date();
-now = new Moment(now);
-
-console.log(future(wide(` Risei tests run on ${ now.asReadable() } local time.`)));
-console.log(future(wide()));
-
-console.log();
-
-// endregion Intro / title
-
-// region Running tests
-
-// Test-system objects and their relationships.
-const finder = new ChosenTestFinder();
-const runner = new TestRunner();
-const reporter = new TerminalReporter();
-
-const caller = new LocalCaller(finder, runner, reporter);
-
-// Actually running the tests using this system.
-await caller.runAllTests();
-
-// endregion Running tests
-
-// region Trailing formatting
-
-console.log();
-console.log();
-
-// endregion Trailing formatting
+// region Key callable and its scripted call
+
+async function runRiseiMetaTests(testFinderPath) {
+    // region Converting test-finder from path to class
+    
+    testFinderPath = testFinderPath || "./TestFinder.js";
+    let finderModule = await import(testFinderPath);
+    
+    let moduleKeys = Object.keys(finderModule);
+    let classKey = moduleKeys[0];
+    let finderClass = finderModule[classKey];
+    
+    // endregion Converting test-finder from path to class
+
+    // region Intro / title
+    
+    console.clear();
+    console.log();
+    console.log(title(wide()));
+    
+    let now = new Date();
+    now = new Moment(now);
+    
+    console.log(title(wide(` Risei tests run on ${ now.asReadable() } local time.`)));
+    console.log(title(wide()));
+    
+    console.log();
+    
+    // endregion Intro / title
+    
+    // region Running tests
+    
+    // Test-system objects and their relationships.
+    const finder = new finderClass.prototype.constructor();
+    finder.sourceBySearch = () => { return { tests: "**.outward-rt.js" }; };
+
+    const runner = new TestRunner();
+    const reporter = new TerminalReporter();
+    
+    const caller = new LocalCaller(finder, runner, reporter);
+
+    // Actually running the tests using this system.
+    await caller.runAllTests();
+    
+    // endregion Running tests
+    
+    // region Trailing display of test-loading issues
+
+    if (finder.thrown.length !== 0) {
+        let loadFails = finder.thrown;
+
+        for (let fail of loadFails) {
+            console.log(fails(wide(` ${ fail }`)));
+        }
+    }
+
+    // endregion Trailing display of test-loading issues
+
+    // region Trailing formatting
+    
+    console.log();
+    console.log();
+    
+    // endregion Trailing formatting
+}
+
+/* Runs tests now. */
+await runRiseiMetaTests();
+
+// endregion Key callable and its scripted call
 

package/system/SpoofClassMethodsFixture.js

@@ -1,7 +1,7 @@
 /**/
 
 import { ASpoofingFixture } from "./ASpoofingFixture.js";
-import { SpoofTuple } from "./SpoofTuple.js";
+import { SpoofDefinition } from "./SpoofDefinition.js";
 
 export class SpoofClassMethodsFixture extends ASpoofingFixture {
     /* Algorithm:  Forward method spoof() looks at spoof definitions in .plus and applies them 
@@ -53,10 +53,10 @@ export class SpoofClassMethodsFixture extends ASpoofingFixture {
         }
     
         // Converting to scope object type.
-        let spoofTuples = SpoofTuple.fromNonceTuples(spoofNonces);
+        let spoofDefinitions = SpoofDefinition.fromNonceTuples(spoofNonces);
         
         // Storing spoofing definitions.
-        this.#retainSpoofsByClass(type, spoofTuples);
+        this.#retainSpoofsByClass(type, spoofDefinitions);
         
         // Storing originals for restoring later.
         this.#reserveOriginalsByClass();
@@ -67,9 +67,9 @@ export class SpoofClassMethodsFixture extends ASpoofingFixture {
 
     // region Dependencies of spoof()
 
-    #retainSpoofsByClass(type, spoofTuples) {
+    #retainSpoofsByClass(type, spoofDefinitions) {
         // Map of Maps: by type, then by method.
-        for (let tuple of spoofTuples) {
+        for (let tuple of spoofDefinitions) {
             // If no .target, use `type`. 
             if (!tuple.target) {
                 tuple.target = type;