risei 1.3.4 → 2.0.0

package/Read-me redux.md

@@ -0,0 +1,581 @@
+
+# Risei Read-Me
+
+## 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 does all this by replacing coded tests with simple declarative syntax.
+
+- Risei works with object-oriented JavaScript in modules.
+
+- Risei works with TypeScript after just a few tweaks.
+
+
+
+## Examples
+
+Here are two example tests, in which `SortModel.countSort()` is being tested using the inputs from `.in` and the expected output from `.out`: 
+
+![https://deusware.com/risei/images/Syntax-example.png](https://deusware.com/risei/images/Syntax-example.png)
+
+
+Here are the example test results for those two tests:
+
+![https://deusware.com/risei/images/Output-example.png](https://deusware.com/risei/images/Output-example.png)
+
+- Outputs are always listed, even on passing tests, which makes code usage much clearer.
+- Any failing tests appear in light red.
+- Your latest tests always sort to the bottom so it's easy to find their results.
+
+
+Test runs have a title bar so the starting point is easy to find:
+
+![https://deusware.com/risei/images/Title-example.png](https://deusware.com/risei/images/Title-example.png)
+
+
+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 is under active development and new enhancements appear often.   The latest release, **2.0.0**, has many [major improvements](#version-history), including broader capabilities and simpler syntax, and a few minor breaking changes.
+
+Check out the [list of the changes](#version-history).
+
+
+
+## Installation
+
+Install Risei for development time only:
+
+```bash
+npm install --save-dev risei
+```
+
+Ensure that `package.json` specifies ECMAScript modules:
+
+```json
+"type": "module"
+```
+
+And add Risei's metadata to `package.json`:
+
+```json
+"risei": {
+  "tests": "**.rt.js"
+}
+```
+
+
+
+## Running Tests
+
+Once you have some tests written, you can run them manually:
+
+```bash
+node ./node_modules/risei/index.js
+```
+
+Or write a script in `package.json` that does the same:
+
+```json
+"scripts": {
+  "test": "node ./node_modules/risei/index.js"
+}
+```
+
+And then run that script:
+
+```bash
+npm test
+```
+
+
+
+## Writing Tests
+
+You write tests in `.rt.js` files like this:
+
+```javascript
+import ATestSource from "risei/ATestSource";
+import ClassToTest from "ClassToTest.js";
+
+export class SomeTests extends ATestSource {
+    tests = [ ... ];
+}
+```
+
+Write individual tests as plain JavaScript objects with Risei's simple syntax:
+
+```javascript
+tests = [ ...
+    { on: ContainerClass, with: [ "a", "b", "c" ],    // Target class and constructor args.
+      of: "doesContain",                              // Target method name.
+      for: "When the arg is present, returns true.",  // Description of test.
+      in: [ "c" ],                                    // Inputs to method.
+      out: true },                                    // Expected output.
+... ];
+```
+
+- To run, a test must have `.on`, `.with`, `.of`, `.for`, `.in`, and `.out` defined.
+- When there are no constructor or method args, you can use empty arrays for `.in` or `.with`.
+- Some of these properties' names are harmlessly the same as JS keywords.   [Long names](#property-long-names) exist if you want to use them instead.
+
+
+
+## Collapsing forward for lighter tests
+
+You can write more tests with less syntax by stating test properties once and letting them _collapse forward_ across subsequent tests.
+
+Risei collapses values together until it has a full test to run, as seen in this typical example:
+
+
+```javascript
+{ on: ContainerClass, with: [ "a", "b", "c" ] },                     // Following tests are of this class.
+
+{ of: "doesContain" },                                               // Following tests are of this method.
+{ for: "Returns true when arg present.", in: [ "c" ], out: true },   // First test: now Risei has enough to run on.
+{ for: "Returns false when arg absent.", in: [ "d" ], out: false },  // Next test: same method, different test case.
+
+{ of: "countOf" },                                                   // Change of tested method.  Method-related props are wiped out.
+...
+
+{ on: SortingClass, with: [ ] },                                     // Change of tested class.  All existing props are wiped out.
+```
+
+Every property collapses forward until it is set to something else or wiped out with a target shift:
+
+- Changing `.on` (the target class) wipes out all other test properties.
+- Changing `.of` (the target method) wipes out all except `.on`, `.with`, and `.plus` (described [later](#spoofing-for-test-isolation-using-plus)).
+- To drop any optional property starting with the current test, you can set it to an empty array `[]`.
+
+
+### Preventing extra tests using `.just`:
+
+You may want to pre-set a property for an upcoming group of tests, even when fully defined tests already exist.   However, this creates an accidental extra test (which often fails), because Risei always collapses old and new values together to make a new fully defined test.
+
+It's easy to avoid this problem with the `.just` property:
+
+```javascript
+{ on: ContainerClass, with: [ "a", "b", "c", ] },  // A section of tests using these values.
+{ ... },
+{ ... },
+
+{ just: true, with: [ "t", "u", "v" ] },           // Changing .with without creating an extra test.
+{ ... },                                           // Tests using the new .with start here.
+{ ... },
+```
+
+- The value of `.just` doesn't have to be `true`, or any value in particular.   The property just has to be defined.
+
+
+### Avoiding mutable-arg problems by restating them:
+
+Collapsing forward reuses test property contents directly.   Tests are isolated unless your code mutates its arguments.   If so, the mutated values are used, throwing off test results.
+
+To prevent this problem, simply restate mutable args in each test to keep them independent.
+
+
+
+## Testing properties and static methods
+
+To test properties of instances, or to test static methods and properties, you use exactly the same syntax you would for instance methods, and Risei figures out the rest:
+
+```javascript
+tests = [
+    { on: VariegatedClass, with: [ ] },
+    { of: "instanceMethod", for: "Returns true.", in: [ ], out: true },  // Typical use: instance method.
+    { of: "staticMethod", for: "Returns false.", in: [ ], out: false },  // Static method: same syntax.  Empty .with needed.
+    { of: "instanceProperty", for: "Returns 47.", in: [ ], out: 47 },    // Instance prop: same.  Empty .in needed.
+    { of: "staticProperty", for: "Returns 98.", in: [ ], out: 98 }       // Static prop: same.  Empty .in needed.
+];
+```
+
+- When testing statics or properties, tests still need a `.with` and `.in`.   You can set them to empty arrays `[]` if needed.
+
+Although Risei figures out what it needs to, you can explicitly state these factors if you want, and Risei will treat them as you specify:
+
+```javascript
+{ of: "instanceMethod()", ... },                            // Trailing parens specify method.
+{ of: ".someProperty", ... }, { of: "someProperty:", ... }  // Leading dot or trailing colon specify property.
+{ of: "something", and: "static", ... },                    // You add an .and of "static" for statics.
+```
+
+- This syntax can be used in `.of`, `.plus`, and `.from` (all covered later).
+- When a property is tested directly, it is listed in test output as `.name`.
+
+
+
+## Spoofing for test isolation using `.plus`
+
+To make code dependencies return what your tests need, just _spoof_ what you want using a `.plus` test property:
+
+```javascript
+{ 
+  on: TestedClass,
+  ...
+  plus: [ 
+      { on: Dependency, of: "someMethod", as: 10 },  // Dependency.someMethod() returns 10 in this test.
+      { of: "testedClassMethod", as: 11 }            // TestedClass.testedClassMethod returns 11 in this test.
+    ],
+  ... 
+}
+```
+
+- It's just like _fakes_, _mocks_, or _test doubles_ in other test systems, but easier to write and read.
+
+There are many options available for spoofing, all laid out together in this example:
+
+```javascript
+{ on: CombinerClass, 
+  ...
+  plus: [ 
+    /* Mono-spoofing. */
+    { on: ClassA, of: "someMethod", as: 10 },    // Spoof this ClassA method to return 10.
+    { on: ClassB, of: "someMethod" },            // Spoof this ClassB method not to return (or do) anything.
+
+    { of: "firstMethod", as: [ 7, 8, 9, 10 ] },  // Spoof a method on the tested class (CombinerClass).
+    { of: "secondMethod" },                      // Spoof a method on the tested class not to do anything.
+
+    { on: ClassC,                                // Spoof this ClassC method to be this nonce code using a runtime arg.
+      of: "someMethod",
+      as: (arg) => { return { color: arg }; } }, 
+
+    /* Poly-spoofing. */
+    { on: ClassD, as: [                          // Spoof two methods on ClassD at the same time.
+        { of: "firstMethod", as: 11 }, 
+        { of: "secondMethod", as: 12 } 
+      ] },
+    { as: [                                      // Spoof two methods on the tested class at the same time.
+        { of: "firstMethod", as: 11 }, 
+        { of: "secondMethod", as: 12 } 
+      ] },
+  ],
+  ...
+}
+```
+
+- These individual types of spoofing can be mixed however needed.
+- You can spoof multiple class methods at the same time with either mono- or poly-spoofing syntax.
+- A spoof nonce function can use args provided to it, but not `this` of the tested instance.
+- You can spoof properties only for the class under test.
+
+
+## Special test conditions
+
+### Testing throws with `.and`:
+
+You can test for a value thrown in code by adding an `.and` property of `"throw"` or `"throws"`:
+
+```javascript
+{ 
+  on: TestedClass, of: "throwsWhenNoArgsGiven", and: "throws", 
+  for: "When not given any args, throws an Error stating \"Argless.\".",
+  in: [ ], out: new Error("Argless.") 
+}
+```
+
+- The `.and` property is an extension point for special test conditions.
+
+
+### Testing for `undefined` actuals with `this.undef`:
+
+You can test for an `undefined` value by setting `.out` to `this.undef` (or `ATestSource.undefSymbol`):
+
+```javascript
+{
+  on: TestedClass, of: "returnsArgGiven", 
+  for: "When the arg is undefined, returns undefined.",
+  in: [ undefined ], out: this.undef 
+}
+```
+
+- You can't use `undefined` itself directly for `.out`, because Risei treats it as a missing prop.
+
+
+
+## Changing actual with `.from`
+
+You can refine the test's actual using the `.from` property, for instance for method side-effects or derivatives of the original actual.
+
+The `.from` can be the name of a property on the target class or its instance created for the test:
+
+```javascript
+{
+  on: TestedClass, of: "makeInstanceReady", 
+  for: "When method is run, the .ready flag is set.", 
+  in: [ ], out: true, 
+  from: "ready"
+}
+```
+
+- Both instance and static props can be retrieved this way.
+- You can't retrieve an instance property for a test of a static method, because no instance is created.
+
+The `.from` can be a nonce function, which must always return a new actual:
+
+```javascript
+{
+  on: TestedClass, of: "initDerivedObject", 
+  for: "When method is run, output's .flag is cleared.",
+  in: [ ], out: false,
+  from: (target, test) => { return test.actual.flag; }
+}
+```
+
+- The `test` parameter is the assemblage of test properties you've provided, plus the test's actual value as `.actual`.
+- The `target` parameter is the instance created for the test, or the tested class itself for statics.
+
+
+
+## Changing external state with `.do.early`, `.do.late`, and `.undo`
+
+If test state you need can't be created declaratively, you can set it up and then tear it down using `.do` and `.undo`.   The `.do` property has two stages, `.early` and `.late`.
+
+You set these properties to nonce functions:
+
+```javascript
+{
+  on: TestedClass, for: "When the file to read is not text, returns first ten bytes as hex.",
+  do: { 
+    early: () => { writeRandomTestFile(); },              // Steps before any test target instance is created.
+    late: (test) => { test.out = readTestFileHex(10); }   // Steps after any instance is created, here altering a test property.
+  },
+  undo: { () => { eraseRandomTestFile(); },               // Steps after everything else in the test.
+  in: [ ... ], out: 0x00,                                 // .out is replaced with varying data in .undo.
+}
+```
+
+- You're better off using Risei's declarative syntax whenever it can do what you need.
+- You don't need to include both `do.early` and `do.late` if you only need one, which is normally the case.
+- You can use the `test` parameter to alter the test itself if needed, though this is rare.
+  - If you do, it's best not to change any added at runtime by Risei.
+
+
+
+## Using TypeScript with Risei
+
+To test TypeScript code with Risei, you make sure the code is transpiled before the tests are run, and you point Risei to the transpiled `.js` files.
+
+
+### In `tsconfig.json`:
+
+You set up the transpiler to output files to a separate directory with these two settings:
+
+```json
+{
+  "outDir": "dist/out-tsc",
+  "noEmit": false
+}
+```
+
+- Any folder can be `outDir`, but it's best to avoid `dist`, which can interfere with frameworks' build steps.
+
+
+### In `package.json`:
+
+In the `test` script, add transpilation before the test run, and file deletion after it, each one conditional on the previous:
+
+```json
+"scripts": {
+  "test": "tsc && node ./node_modules/risei/index.js && rm -r ./dist/out-tsc"
+}
+```
+
+- Using `tsc` or an equivalent produces individually testable JavaScript files.
+- Deleting 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 test files:
+
+All `import` statements have to point to the JavaScript (`.js`) files in the `outDir` path or its subfolders:
+
+```javascript
+import { TestedClass } from "../../dist/out-tsc/SubPath/TestedClass.js";
+```
+
+- Output files may be in a folder tree parallel to the TypeScript originals (Angular), or may all be in the `outDir` folder itself (React).
+
+
+
+## Troubleshooting
+
+### When a gold bar appears and some tests disappear:
+
+When problems cause test files not to load, you see a gold bar listing the syntax errors at fault:
+
+![https://deusware.com/risei/images/Gold-bar-example.png](https://deusware.com/risei/images/Gold-bar-example.png)
+
+- Test files without syntax errors are still loaded and run, so you also see a lower total number of tests.
+
+Here are the most common problems:
+
+|  Error condition  |  Probable cause  |
+|-------------------|------------------|
+|  Gold bar text `"Test loading failed for...  SyntaxError: Unexpected token ':'"`  |  Missing comma in your tests in the named file, either between tests or between test props  |
+|  Gold bar text `"Test loading failed for...  SyntaxError: Unexpected token '.'"`  |  Stating the test list as `this.tests = []` instead of `tests = []` in the file named  |
+|  Other `... Unexpected token ...` errors in gold bar  |  Some other syntax error in the file named, most likely a missing or extra delimiter  |
+|  Many test files failing all at once  |  Syntax error in the code targeted in those test files, or a dependency of it  |
+
+
+## When the listed tests or their results are unexpected:
+
+|  Error condition  |  Probable cause  |
+|-------------------|------------------|
+|  Unexpected extra, failing test/s  |  An object intended only to change test properties lacks a `.just` / `.only`  |
+|  Unexpected actual values, or unexpected passes / fails in test runs  |  Test properties from previous tests not replaced or reset with `[]` <br>&mdash; or &mdash;<br> Mutated args for tested code not restated in following tests to isolate them  |
+| Tests written not appearing in runs  |  Not all properties needed to run tests stated before or in those tests  |
+
+
+
+## Property long names
+
+Test properties have longer names that you can use interchangeably with their short names.
+
+<details>
+<summary>
+Test definition names
+</summary>
+
+| Short Name | Long Name |
+|------------|-----------| 
+| `on` | `type` | 
+| `with` | `initors` |
+| `of` | `method` |
+| `for` | `nature` |
+| `in` | `inputs` |
+| `out` | `output` |
+| `plus` | `spoofed` |
+| `from` | `source` |
+| `and` | `factors` |
+| `do` | `enact` |
+| `undo` | `counteract` |
+| `just` | `only` |
+
+- There are no long names for the `.early` and `.late` properties of `.do` / `.enact`.
+
+</details>
+
+<br>
+
+<details>
+<summary>
+Spoof definition names
+</summary>
+
+| Short Name | Long Name |
+|------|------|
+| `on` | `target` |
+| `of` | `method` |
+| `as` | `output` |
+
+</details>
+
+
+
+## Version history
+
+- Release **2.0.0** (August, 2024) contains all of these changes:
+  - Risei now can determine automatically if tested methods are static.
+  - You can now directly test properties just like methods.
+    - Risei can also determine automatically if these are static.
+    - Directly tested properties appear in the output in the form `.name`.
+  - You can now spoof properties on the targeted class instance, and static properties on the target class itself.
+  - You can now perform arbitrary operations, if needed, with the two-part `.do` property and one-part `.undo` property.
+  - You can now change test properties without accidentally creating a new test using `.just`.
+  - You can now directly test for `undefined` in `.out` using `this.undef` / `ATestSource.undefSymbol`.
+  - `Error` objects are now compared accurately.
+  - You can now identify member types with sigils (`.` / `:` / `()`) in `.of`, `.plus`, and `.from`, though they aren't necessary.
+  - **(Breaking change)**&nbsp;  The `actual` for throw tests is now the entire thrown object (usually an `Error`), rather than the `Error`'s message text.
+  - **(Breaking change)**&nbsp;  `ATestSource` is now a default export, changing its imports from `import { ATestSource } from` to `import ATestSource from`.
+
+> Risei has been massively re-engineered internally along with these improvements.
+
+
+
+<details>
+<summary>
+Older releases
+</summary>
+
+- Release **1.3.4** (March, 2024) fixed a bug that caused class display problems in some cases.
+
+- Release **1.3.3** (March, 2024) fixed a major bug that prevented tests from running in Windows.
+
+- Release **1.3.2** (February, 2024) only improved this read-me's contents.
+
+- Release **1.3.1** (February, 2024) reversed some changes in 1.3.0 that did not work as hoped.
+
+- Release **1.3.0** (February, 2024) added the loading-error gold bar and fixed a test-sorting bug.
+
+- Release **1.2.0** (January, 2024) changed test sorting to move last-edited tests to the end.
+
+- Release **1.1.2** of Risei (January, 2024) fixed class displays and inaccurate `Date` comparisons.
+
+> The oldest releases are no longer listed here, and old releases are dropped progressively over time.&nbsp;  Using the latest release is recommended.
+
+</details>
+
+
+## Known issues and workarounds
+
+The only issue at present is the use of mutated args when tested code mutates them, when collapsing forward. 
+
+- The workaround is simply to restate the args for each test.
+
+
+## Exclusions from Risei
+
+The following are not supported at present:
+
+- Use of `async` syntax
+- Any code not in classes, even in ESM `export` modules, AKA _loose code_
+- CJS syntax using `require()`
+- Performing step-through debugging of tests and tested code
+- Comparing rare JS object types like `Proxy` or `ArrayBuffer` in test assertions
+- Testing for inequality of values
+
+Some of these may be supported in the future.
+
+- You can save a lot of time by using Risei for most of your code, but another framework for whatever it doesn't support.
+
+
+
+## Maker
+
+Risei is written by myself, Ed Fallin.&nbsp;  I'm a longtime software developer who likes to find better ways to do things.
+
+If you find Risei useful, consider spreading the word to other devs, making a donation, suggesting enhancements, or proposing sponsorships.
+
+You can get in touch about Risei at **riseimaker@gmail.com**.
+
+
+
+## License
+
+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;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:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.&nbsp;  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+</div>
+
+
+&nbsp;
+
+

package/index.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "risei",
-  "version": "1.3.4",
-  "description": "Risei is the framework that allows you to write unit tests as simple JavaScript objects, so it's easy and fast, and tests don't serve as a drag on redesigns.",
+  "version": "2.0.0",
+  "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",
     "test",
@@ -19,16 +19,17 @@
   ],
   "author": "Ed Fallin <riseimaker@gmail.com>",
   "license": "MIT",
+  "homepage": "https://deusware.com/risei",
   "type": "module",
   "private": false,
   "scripts": {
     "start": "node ./bin/www",
-    "rself": "clear; node system/Risei.js",
-    "rtest": "clear; node ./node_modules/risei/index.js",
-    "xtest": "clear; mocha **/*.tests.js",
-    "mixedtest": "clear; mocha **/*.tests.js; node ./node_modules/risei/index.js",
-    "alltest": "clear; mocha **/*.tests.js; node ./node_modules/risei/index.js; node system/Risei.js",
-    "test": "clear; node ./node_modules/risei/index.js"
+    "rself": "clear && node system/Risei.js",
+    "rtest": "clear && node ./node_modules/risei/index.js",
+    "xtest": "clear && mocha **/*.tests.js",
+    "mixedtest": "clear && mocha **/*.tests.js; node ./node_modules/risei/index.js",
+    "alltest": "clear && mocha **/*.tests.js; node ./node_modules/risei/index.js; node system/Risei.js",
+    "test": "clear && node ./node_modules/risei/index.js"
   },
   "risei": {
     "tests": "**.rt.js"
@@ -45,12 +46,10 @@
   "devDependencies": {
     "chai": "^4.3.6",
     "chalk": "^5.0.0",
-    "cookie-parser": "~1.4.4",
     "debug": "~2.6.9",
-    "express": "^4.18.2",
     "fs": "^0.0.1-security",
     "mocha": "^10.0.0",
     "morgan": "~1.9.1",
-    "risei": "1.3.3"
+    "risei": "^1.3.4"
   }
 }

package/system/ASpoofingFixture.js

@@ -1,11 +1,10 @@
 /**/
 
-import { ATestFixture } from "./ATestFixture.js";
-import { SpoofDefinition } from "./SpoofDefinition.js";
+import SpoofDef from "./SpoofDef.js";
 
-export class ASpoofingFixture extends ATestFixture {
-    constructor(name, kind) {
-        super(name, kind);
+export default class ASpoofingFixture {
+    constructor() {
+        /* No operations. */
     }
     
     /* A spoof might be supplied as a custom function, 
@@ -25,8 +24,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 => SpoofDefinition.isASpoof(x))) {
-                spoofOutput = SpoofDefinition.fromNonceTuples(spoofOutput);
+            if (spoofOutput.every(x => SpoofDef.isASpoof(x))) {
+                spoofOutput = SpoofDef.fromNonceTuples(spoofOutput);
                 spoofOutput = this.spoofObjectTree(spoofOutput);
             }
         }
@@ -40,7 +39,7 @@ export class ASpoofingFixture extends ATestFixture {
        possibly with intermediate objects. */
     spoofObjectTree(ofAsPairs) {
         let spoof = {};
-    
+
         for (let pair of ofAsPairs) {
             let chain = pair.of;
             let output = pair.as;