risei 2.0.1 → 3.1.0

package/system/TestDef.js

@@ -4,6 +4,8 @@ import TypeAnalyzer from "./TypeAnalyzer.js";
 import NameAnalyzer from "./NameAnalyzer.js";
 import TypeIdentifier from "./TypeIdentifier.js";
 import Types from "./Types.js";
+import CallTypes from "./CallTypes.js";
+import TotalDisplayer from "./TotalDisplayer.js";
 
 /* Defines what is found in a test definition, typically as 
    a nonce object rather than an instance of this class. */
@@ -13,6 +15,7 @@ export default class TestDef {
 
     static staticName = "static";
     static throwName = "throw";
+    static polyName = "poly";
     static constructorName = "constructor";
     static nonceLocalCallableName = "nonce";
 
@@ -56,13 +59,12 @@ export default class TestDef {
     target;
     
     actual;
-    thrown;
+    thrown;   // Throw in inner scope (tested code).
+    trouble;  // Throw in outer scope (test system or .do / .undo / .from).
     
     // endregion Fields
 
-    // region Properties
-
-    // region Test definition, short names
+    // region Definition properties 
 
     /* These short names make JSON-like definitions easier. */
 
@@ -154,9 +156,9 @@ export default class TestDef {
         this.counteract = value;
     }
 
-    // endregion Test definition, short names
+    // endregion Definition properties
 
-    // region Def state
+    // region State properties
 
     get isRunnable() /* passed */ {
         let isRunnable
@@ -182,19 +184,28 @@ export default class TestDef {
 
         return is || stated;
     }
-    
+
     get isThrowTest() /* passed */ {
         let is = this.andStringContains(TestDef.throwName);
         return is;
     }
 
+    get isMonoCallTest() /* passed */ {
+        return !this.isPolyCallTest;
+    }
+
+    get isPolyCallTest() /* passed */ {
+        let is = this.andStringContains(TestDef.polyName);
+        return is;
+    }
+
     get isConstructorTest() /* passed */ {
         let plainTarget = NameAnalyzer.plainNameOf(this.of);
         return plainTarget === TestDef.constructorName;
     }
 
     get isMethodTest() /* passed */ {
-        return !this.isPropertyTest;
+        return !this.isPropertyTest && !this.isConstructorTest;
     }
 
     get isPropertyTest() /* passed */ {
@@ -207,6 +218,22 @@ export default class TestDef {
         return isPropertyTest;
     }
 
+    get callType() /* passed */ {
+        let type;
+
+        if (this.isMethodTest) {
+            type = this.isMonoCallTest ? CallTypes.methodMono : CallTypes.methodPoly;
+        } 
+        else if (this.isPropertyTest) {
+            type = this.isMonoCallTest ? CallTypes.propMono : CallTypes.propPoly;
+        } 
+        else if (this.isConstructorTest) {
+            type = this.isMonoCallTest ? CallTypes.conMono : CallTypes.conPoly;
+        }
+
+        return type;
+    }
+
     get isRetrievalTest() /* passed */ {
         // Falsy code elements never are a retrieval.
         if (!this.from) {
@@ -252,20 +279,34 @@ export default class TestDef {
     get runName() /* passed */ {
         let plain = NameAnalyzer.plainNameOf(this.of);
 
-        if (this.isMethodTest) {
+        if (!this.isPropertyTest) {
             return `${ plain }()`;
         }
-
-        if (this.isPropertyTest) {
+        else {
             return `.${ plain }`;
         }
     }
 
-    // endregion Def state
+    get anyUnsoughtThrow() /* passed */ {
+        // Prop is true when throw is sought.
+        if (this.isThrowTest) {
+            return;
+        }
 
-    // endregion Properties
+        return this.thrown;
+    }
 
-    // region Def state methods
+    get doesHaveUnsoughtThrow() /* passed */ {
+        return this.anyUnsoughtThrow !== undefined;
+    }
+
+    get doesHaveTrouble() /* passed */ {
+        return this.trouble !== undefined;
+    }
+
+    // endregion State properties
+
+    // region State methods
 
     /* Needed externally, and dependency 
        of all .and-based properties. */
@@ -277,12 +318,11 @@ export default class TestDef {
         return doesContain;
     }
 
-    // endregion Def state methods
+    // endregion State methods
 
     // region Initing, including constructor()
 
-    /* Constructor can't use parameter names like `for`: 
-       when not .-prefixed, they are purely keywords. */
+    /* Long names used, since some short names, like `for`, are parsed as keywords. */
     constructor(nature, type, spoofed, initors, method, inputs, output, source, factors, enact, counteract) /* ok */ {
         this.nature = nature;           // .for 
         this.type = type;               // .on 
@@ -416,4 +456,22 @@ export default class TestDef {
 
     // endregion Initing, including constructor()
 
+    toString() /* verified */ {
+        let displayer = new TotalDisplayer();
+
+        let text = `TestDef{ for:${ displayer.display(this.for) }, `
+           + `on:${ displayer.display(this.on) }, `
+           + `with:${ displayer.display(this.with) }, `
+           + `of:${ displayer.display(this.of) }, `
+           + `plus:${ displayer.display(this.plus) }, `
+           + `in:${ displayer.display(this.in) }, `
+           + `out:${ displayer.display(this.out) }, `
+           + `from:${ displayer.display(this.from) }, `
+           + `and:${ displayer.display(this.and) }, `
+           + `do:${ displayer.display(this.do) }, `
+           + `undo:${ displayer.display(this.undo) } }`
+
+        return text;
+    }
+
 }

package/system/TestFinder.js

@@ -1,14 +1,14 @@
 /**/
 
-/* TestFinder is an ATestFinder that finds tests in the places identified in package.json. */
+/* TestFinder retrieves test sources based on .risei.tests in package.json. */
 
-import ATestFinder from "./ATestFinder.js";
 import ATestSource from "./ATestSource.js";
+import Choices from "./Choices.js";
 import fs from "node:fs";
 import path from "node:path";
 import { minimatch } from "minimatch";
 
-export default class TestFinder extends ATestFinder {
+export default class TestFinder  {
     // region Definitions
 
     static NO_SUCH_FILE = "ENOENT";
@@ -21,20 +21,37 @@ export default class TestFinder extends ATestFinder {
     // endregion Definitions
 
     // region Fields
-    
+
+    #testSources;
+    #thrown = [];
+
     #sought;
     
     // endregion Fields
 
+    // region Properties
+
+    get testSources() {
+        return this.#testSources;
+    }
+
+    set testSources(value) {
+        this.#testSources = value;
+    }
+
+    get thrown() {
+        return this.#thrown;
+    }
+
+    // endregion Properties
+
     constructor() {
-        super();
+        this.#testSources = [];
     }
 
     async findAllTests() {
-        // Paths for test sources are listed in package.json, possibly with globbing.
-        let source = this.sourceBySearch();
-        this.#sought = source.tests;
-        let testPaths = this.pathsFromTargetingSource();
+        this.#sought = this.supplyTestTargeting();
+        let testPaths = this.pathsFromTargeting();
 
         testPaths = this.sortTestPaths(testPaths);
 
@@ -54,28 +71,13 @@ export default class TestFinder extends ATestFinder {
         return tests;
     }
 
-    sourceBySearch() {
-        // App's package.json always found at process.cwd().
-        let packageSite = process.cwd();
-        let pathAndName = path.join(packageSite, TestFinder.METADATA_FILE);
-
-        // Contents of package.json are just a single JSON object.
-        let packageJson = fs.readFileSync(pathAndName, { encoding: "utf8" });
-        packageJson = JSON.parse(packageJson);
-
-        // Can't run or reasonably recover if this is not defined.
-        if (!packageJson.risei) {
-            throw new Error(
-                `For Risei tests to run, this app's package.json must contain `
-                + `a node like this: "risei": { tests: "path-or-glob-here" }.  `
-                + `One glob or path may be used, or an array of them.`);
-        }
-
-        // Only Risei's own metadata is needed.
-        return packageJson.risei;
+    // Spoofing point for self-testing.
+    supplyTestTargeting() {
+        // Value retrieved from package.json.
+        return Choices.testTargeting;
     }
 
-    pathsFromTargetingSource() {
+    pathsFromTargeting() {
         let paths = [];
         let root = process.cwd();
 

package/system/TestFrame.js

@@ -9,12 +9,12 @@ export default class TestFrame {
         // A TestStages is inited for each test.
         this.#stages = new TestStages();
     }
-    
-    run(test) /* passed */ {
+
+    async run(test) /* passed */ {
         // Outer try for fails of groundwork requested.
         try {
             // Spoofing and so on.
-            this.#stages.anyPreTargetingGroundwork(test);
+            await this.#stages.anyPreTargetingGroundwork(test);
             
             // Target may be instance, prototype for constructors, the class 
             // itself for statics, or nonce for properties.  Sets test.target.
@@ -25,17 +25,18 @@ export default class TestFrame {
             // Method under test may be on instance, class, 
             // or nonce for properties.  Sets test.callable.
             let callable = this.#stages.supplyCallableName(test);
-            
+
             // Setting (spoofing) properties and so on.
-            this.#stages.anyPostTargetingGroundwork(test);
-            
+            await this.#stages.anyPostTargetingGroundwork(test);
+
             // Inner try for fails of targeted code only.
             try {
                 // Tests usually look for this.
-                test.actual = target[callable](...test.in);
+                test.actual = await target[callable](...test.in);
             }
             catch (thrown) {
                 // Sometimes tests look for this.
+                // Otherwise, listed in gold bar.
                 test.thrown = thrown;
             }
 
@@ -46,13 +47,21 @@ export default class TestFrame {
             test.didPass = this.#stages.compareResults(test.output, test.actual);
         }
         catch (thrown) {
-            /* Block needed, but no operations. */
+            // Fail of the test system, or of code in .do or .from.
+            test.trouble = thrown;
         }
         finally {
-            // Undoing any groundwork changes made. 
-            this.#stages.anyGroundworkReversal(test);
+            // Always undoing any groundwork changes made.
+            try {
+                await this.#stages.anyGroundworkReversal(test);
+            }
+            catch (thrown) {
+                // Fail of the test system, or of code in .undo; 
+                // only needed when no preceding throw.
+                if (test.trouble === undefined) {
+                    test.trouble = thrown;
+                }
+            }
         }
-        
-        // console.log(`cruft : q, outer try-catch : after`);
     }
 }

package/system/TestGroup.js

@@ -1,25 +1,25 @@
-/**/
-
-export default class TestGroup {
-    // region Private fields
-
-    #group;
-
-    // endregion Private fields
-
-    // region Properties
-
-    get group() {
-        return this.#group;
-    }
-
-    set group(value) {
-        this.#group = value;
-    }
-
-    // endregion Properties
-
-    constructor(group) {
-        this.#group = group;
-    }
-}
+/**/
+
+export default class TestGroup {
+    // region Private fields
+
+    #group;
+
+    // endregion Private fields
+
+    // region Properties
+
+    get group() {
+        return this.#group;
+    }
+
+    set group(value) {
+        this.#group = value;
+    }
+
+    // endregion Properties
+
+    constructor(group) {
+        this.#group = group;
+    }
+}

package/system/TestResult.js

@@ -19,9 +19,19 @@ export default class TestResult {
     #expectedText;
     #actualText;
 
+    #thrown;
+    #trouble;
+
+    #thrownText;
+    #troubleText;
+
+    #wasThrowTest;
+
+    #doesHaveThrow;
+    #doesHaveTrouble;
+
     #didPass;
     #actual;
-    #thrown;
 
     // endregion Fields
 
@@ -91,19 +101,39 @@ export default class TestResult {
         this.#didPass = value;
     }
 
+    get wasThrowTest() {
+        return this.#wasThrowTest;
+    }
+
+    get doesHaveThrow() {
+        return this.#doesHaveThrow;
+    }
+
+    get doesHaveTrouble() {
+        return this.#doesHaveTrouble;
+    }
+
     get anyThrow() {
         return this.#thrown;
     }
 
-    set anyThrow(value) {
-        this.#thrown = value;
+    get anyTrouble() {
+        return this.#trouble;
+    }
+
+    get anyThrowText() {
+        return this.#thrownText;
+    }
+
+    get anyTroubleText() {
+        return this.#troubleText;
     }
 
     // endregion Outcome properties
 
     // region Construction
 
-    constructor(test) {
+    constructor(test) /* ok */ {
         this.#test = test;
         this.#displayer = new TotalDisplayer();
     }
@@ -112,56 +142,76 @@ export default class TestResult {
 
     // region Before run: setNature() and dependencies
 
-    setNature() {
+    setNature() /* passed */ {
         this.#identityText = this.#calculateIdentityText();
         this.#initorsText = this.#calculateInitorsText();
         this.#inputsText = this.#calculateInputsText();
         this.#expectedText = this.#calculateExpectedText();
+        this.#wasThrowTest = this.#test.isThrowTest;
     }
     
-    #calculateIdentityText() {
+    #calculateIdentityText() /* verified */ {
         let text = `${ this.test.for } `;
         return text;
     }
     
-    #calculateInitorsText() {
+    #calculateInitorsText() /* verified */ {
         let text = this.#displayItemRow(this.test.with);
         text = `Initors: ${ text }. `;
         return text;
     }
     
-    #calculateInputsText() {
+    #calculateInputsText() /* verified */ {
         let text = this.#displayItemRow(this.test.in);
         text = `Inputs: ${ text }. `;
         return text;
     }
     
-    #calculateExpectedText() {
+    #calculateExpectedText() /* verified */ {
         let text = this.#displaySingleItem(this.test.out);
         text = `Expected: ${ text }. `;
         return text;
     }
-    
+ 
     // endregion Before run: setNature() and dependencies
     
     // region After run: setResults() and dependencies
 
-    setResults() {
+    setResults() /* passed */ {
         // Direct results.
         this.#didPass = this.test.didPass;
         this.#actual = this.test.actual;
-        this.#thrown = this.test.anyThrow;
         
+        this.#thrown = this.test.thrown;
+        this.#trouble = this.test.trouble;
+
+        this.#doesHaveThrow = this.test.doesHaveUnsoughtThrow;
+        this.#doesHaveTrouble = this.test.doesHaveTrouble;
+
         // Derived displayable results.
         this.#actualText = this.#calculateActualText();
+        this.#thrownText = this.#calculateThrownText("Unsought throw in tested code", this.#thrown);
+        this.#troubleText = this.#calculateThrownText("Throw in framing code", this.#trouble);
     }
 
-    #calculateActualText() {
+    #calculateActualText() /* verified */ {
         let text = this.#displaySingleItem(this.test.actual);
         text = `Actual: ${ text }. `;
         return text;
     }
     
+    #calculateThrownText(scope, thrown) /* verified */ {
+        // No throw to display.
+        if (thrown === undefined) {
+            return;  // Undefined.
+        }
+
+        let text = `${ scope }: ${ this.#test.on.name }: ${ this.#test.runName }: `
+                 + `\"${ this.#test.for }\":  ${ thrown.message }`;
+
+        return text;
+    }
+   
     // endregion After run: setResults() and dependencies
 
     // region Displaying test args

package/system/TestRunner.js

@@ -1,6 +1,6 @@
 /**/
 
-/* Runs tests one by one as an ATestCaller requests them. */
+/* Runs tests one by one as TestCaller or equivalent requests them. */
 
 import TestDef from "./TestDef.js";
 import TestGroup from "./TestGroup.js";
@@ -25,6 +25,10 @@ export default class TestRunner {
     #numberRun;
     #numberPassed;
     #numberFailed;
+
+    #thrown;
+    #trouble;
+
     #allDidPass;
 
     // endregion Private fields
@@ -67,6 +71,14 @@ export default class TestRunner {
         this.#numberFailed = value;
     }
 
+    get thrown() {
+        return this.#thrown;
+    }
+
+    get trouble() {
+        return this.#trouble;
+    }
+
     get allDidPass() {
         return this.#allDidPass;
     }
@@ -86,6 +98,9 @@ export default class TestRunner {
         this.#numberPassed = 0;
         this.#numberFailed = 0;
 
+        this.#thrown = [];
+        this.#trouble = [];
+
         this.#allDidPass = true;
     }
 
@@ -101,9 +116,12 @@ export default class TestRunner {
 
     // Generator for all test results, 
     // including groups and summary.
-    * [Symbol.iterator]() {
+    async * runTests() {
         if (!this.#tests) {
-            throw new Error("No tests available to run.  TestRunner's .tests must be set before an attempt to run is made.");
+            throw new Error(
+                "No tests available to run.  TestRunner's .tests "
+                + "must be set before an attempt to run is made."
+            );
         }
     
         // Converting so that property names can be relied on.
@@ -126,21 +144,24 @@ export default class TestRunner {
 
             // Each new method / prop name should be a group, 
             // and so should the first method for a class.
-            if (test.runName !== methodGroup.group || atFirstClassMethod) {
-                methodGroup.group = test.runName;
+            let runName = test.runName;
+
+            if (runName !== methodGroup.group || atFirstClassMethod) {
+                methodGroup.group = runName;
                 atFirstClassMethod = false;
                 yield methodGroup;
             }
 
-            let result = this.runOneTest(test);
+            let result = await this.#runOneTest(test);
+
             yield result;
         }
 
         // Iterative returning of final results summary.
-        yield this.summarize();
+        yield this.#summarize();
     }
 
-    runOneTest(test) {
+    async #runOneTest(test) {
         // Default outputs.  Never left undefined.
         test.didPass = false;
         test.anyThrow = null;
@@ -151,13 +172,13 @@ export default class TestRunner {
         result.setNature();
 
         // Actually running the test.
-        this.#frame.run(test);
+        await this.#frame.run(test);
 
         // Gathering facts based on the test run.
         result.setResults();
 
         // For later summarizing.
-        this.#retainTestResults(test);
+        this.#retainTestResults(result);
 
         // Results and test back to the caller.
         return result;
@@ -165,22 +186,30 @@ export default class TestRunner {
     
     // region Dependencies of runOneTest()
     
-    #retainTestResults(test) {
+    #retainTestResults(result) {
         this.#numberRun++;
 
-        if (test.didPass) {
+        if (result.doesHaveThrow) {
+            this.#thrown.push(result.anyThrowText);
+        }
+
+        if (result.doesHaveTrouble) {
+            this.#trouble.push(result.anyTroubleText);
+        }
+
+        if (result.didPass) {
             this.#numberPassed++;
         }
         else {
             this.#numberFailed++;
         }
 
-        this.#allDidPass &&= test.didPass;
+        this.#allDidPass &&= result.didPass;
     }
 
     // endregion Dependencies of runOneTest()
 
-    summarize() {
+    #summarize() {
         let summary = `Ran ${ this.#numberRun } test${ this.#numberRun !== 1 ? "s" : "" }.  `
             + `${ this.#allDidPass ? "All tests passed.  " : "" }`
             + `${ this.#numberPassed } passed.  `
@@ -188,9 +217,8 @@ export default class TestRunner {
 
         let anyWereRun = this.#numberRun > 0;
 
-        return new TestSummary(summary, this.#allDidPass, anyWereRun);
+        return new TestSummary(summary, this.#allDidPass, anyWereRun, this.#thrown, this.#trouble);
     }
 
     // endregion Running tests
-
 }