risei 1.1.1 → 1.1.2

package/README.md

@@ -507,13 +507,15 @@ One known unexpected result (not quite a bug) exists:
 
 ## What's new in Risei
 
-Release **1.1.1** of Risei (January, 2024) fixes two problems:
+Release **1.1.2** of Risei (January, 2024) fixes two problems:
 - Classes were sometimes displayed in output as their entire definition, instead of just the class name.
 - All `Date` instances were considered equal, regardless of their actual value.
 
 Development of Risei is ongoing, including internal improvements, problem fixes, and additional options for testing.
 
 
+> Do not use release **1.1.1**, because it contains an internal path error.
+
 
 
 ## Who makes Risei

package/index.js

@@ -66,7 +66,7 @@ let wide = (text) => {
 async function runRiseiTests(testFinderPath) {
     // region Converting test-finder from path to class
     
-    testFinderPath = testFinderPath || "./public/javascript/TestFinder.js";
+    testFinderPath = testFinderPath || "./system/TestFinder.js";
     let finderModule = await import(testFinderPath);
     
     let moduleKeys = Object.keys(finderModule);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "risei",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "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",
@@ -32,7 +32,7 @@
   },
   "exports": {
     ".": "./index.js",
-    "./ATestSource": "./public/javascript/ATestSource.js"
+    "./ATestSource": "./system/ATestSource.js"
   },
   "dependencies": {
     "chalk": "^5.0.0",
@@ -44,10 +44,10 @@
     "chalk": "^5.0.0",
     "cookie-parser": "~1.4.4",
     "debug": "~2.6.9",
-    "express": "~4.16.1",
+    "express": "^4.18.2",
     "fs": "^0.0.1-security",
     "mocha": "^10.0.0",
     "morgan": "~1.9.1",
-    "risei": "^1.1.0"
+    "risei": "1.1.2"
   }
 }

package/tests/other-tests/ASpoofingFixture.tests.js

@@ -1,242 +0,0 @@
-/**/
-
-import { ASpoofingFixture } from "../../system/ASpoofingFixture.js";
-import { SpoofTuple } from "../../system/SpoofTuple.js";
-import { TotalComparer } from "../../system/TotalComparer.js";
-import { expect } from "chai";
-
-describe("ASpoofingFixture", () => {
-    /* All the tests here are valid as long as TotalComparer 
-       and any linked objects are passing all their tests. */
-    let comparer = new TotalComparer();
-
-    /* Some cases here are effectively impossible to test directly in self-tests, at least 
-       without complicated workarounds, because of how SpoofTuple is used by Kitten tests. */
-
-    describe("spoofMethod()", () => {
-        describe("Direct tests: Definition of spoofed method is compared.", () => {
-            it("Should return an empty method when not provided an arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = () => { };
-
-                let actual = target.spoofMethod();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return an empty method when not provided undefined as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = () => { };
-
-                let actual = target.spoofMethod(undefined);
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return any whole function supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = () => {
-                    let sum = 6 + 5;
-                    console.log(sum);
-                };
-
-                let actual = target.spoofMethod(expected);
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method naming the parameter when any non-function arg supplied.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = () => { return spoofOutput; };
-
-                let actual = target.spoofMethod(778);
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-        });
-        
-        describe("Indirect tests: Result of calling spoofed method is tested.", () => {
-            it("Should return a simple method returning any value supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = 322;
-
-                let spoofed = target.spoofMethod(322);
-                let actual = spoofed();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method returning any string supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = "A short text.";
-
-                let spoofed = target.spoofMethod("A short text.");
-                let actual = spoofed();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method returning any object supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = { first: "a", second: 2, third: "C" };
-
-                let spoofed = target.spoofMethod({ first: "a", second: 2, third: "C" });
-                let actual = spoofed();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method returning any specialized object supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = new Map([[1, "g"], [2, "k"]]);
-
-                let spoofed = target.spoofMethod(new Map([[1, "g"], [2, "k"]]));
-                let actual = spoofed();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-            
-            it("Should return a simple method returning any deep object supplied as arg", /* good */ () => {
-                let target = new ASpoofingFixture();
-                let arg = { these: { those: { the: { other: () => { return 44; } } } } };
-
-                let spoofed = target.spoofMethod(arg);
-                let actual = spoofed();
-
-                let expected = { these: { those: { the: { other: () => { return 44; } } } } };
-                
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method returning any deep spoofed object defined in the arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-                let arg = [ { of: "these.those.the.other", as: 76 } ];
-
-                let spoofed = target.spoofMethod(arg);
-                let actual = spoofed();
-
-                let expected = { these: { those: { the: { other: () => { return spoofOutput; } } } } };
-
-                let comparison = comparer.compare(actual, expected);
-                expect(comparison).to.be.true;
-            });
-
-        });
-    });
-
-    describe("spoofObjectTree()", () => {
-        it("Should return (object(empty method)) when given one part and no output.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "action" }];
-            
-            let expected = { action: () => { } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-    
-        it("Should return (object(object(empty method))) when given two parts and no output.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "thing.action" }];
-            
-            let expected = { thing: { action: () => { } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(object(empty method)))) when given three parts and no output.", /* good */ () => {
-            let target = new ASpoofingFixture()
-            let arg = [{ of: "outer.inner.action" }];
-            
-            let expected = { outer: { inner: { action: () => { } } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(value-returning method)) when given one part and an output value.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "ten", as: 10 }];
-            
-            let expected = { ten: () => { return spoofOutput; } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(value-returning method))) when given two parts and an output value.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "thing.eleven", as: 11 }];
-            
-            let expected = { thing: { eleven: () => { return spoofOutput; } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(object(value-returning method)))) when given three parts and an output value.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "outer.inner.twelve", as: 12 }];
-            
-            let expected = { outer: { inner: { twelve: () => { return spoofOutput; } } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(string-returning method))) when given two parts and an output string.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "thing.outputText", as: "text-output" }];
-            
-            let expected = { thing: { outputText: () => { return spoofOutput; } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(nonce method))) when given two parts and a nonce method.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "thing.sumIsFourteen", as: () => { return 11 + 3; } }];
-            
-            let expected = { thing: { sumIsFourteen: () => { return 11 + 3; } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-    });
-});

package/tests/other-tests/SpoofClassesFixture.tests.js

@@ -1,130 +0,0 @@
-/**/
-
-import { SpoofClassMethodsFixture } from "../../system/SpoofClassMethodsFixture.js";
-import { Spoofable } from "../target-objects/Spoofable.js";
-import { TotalComparer } from "../../system/TotalComparer.js";
-
-import { expect } from "chai";
-
-describe("SpoofClassMethodsFixture", () => {
-    let comparer = new TotalComparer();
-
-    describe("spoof()", () => {
-        describe("Direct tests: Definition of spoofed method is compared.", () => {
-            it("Should set class method to be empty when given args which define that.", /* good */ () => {
-                let target = new SpoofClassMethodsFixture();
-                let definition = { of: "spoofNumber" };
-                let arg = { on: Spoofable, plus: [ definition ] };
-
-                target.spoof(arg);
-
-                let actual = Spoofable.prototype.spoofNumber;
-
-                target.unspoof();
-
-                let comparison = comparer.compare(actual, () => { });
-                expect(comparison).to.be.true;
-            });
-
-            it("Should set class method to a known nonce function when given that nonce as an arg.", /* good */ () => {
-                let target = new SpoofClassMethodsFixture();
-                let definition = { of: "spoofNumber", as: (a, b) => { return b - a; } };
-                let arg = { on: Spoofable, plus: [ definition ] };
-
-                target.spoof(arg);
-
-                let actual = Spoofable.prototype.spoofNumber;
-
-                target.unspoof();
-
-                let comparison = comparer.compare(actual, (a, b) => { return b - a; });
-                expect(comparison).to.be.true;
-            });
-
-            it("Should set class method to a simple function returning a named parameter when given args which define that.", /* good */ () => {
-                let target = new SpoofClassMethodsFixture();
-                let definition = { of: "spoofNumber" , as: 32 };
-                let arg = { on: Spoofable, plus: [ definition ] };
-
-                target.spoof(arg);
-
-                let actual = Spoofable.prototype.spoofNumber;
-                
-                target.unspoof();
-
-                let comparison = comparer.compare(actual, () => { return spoofOutput; });
-                expect(comparison).to.be.true;
-            });
-        })
-
-        describe("Indirect tests: Result of calling spoofed method is compared.", () => {
-            it("Should set class method to return a known value when given args which define that.", /* good */ () => {
-                let target = new SpoofClassMethodsFixture();
-                let definition = { of: "spoofNumber", as: 17 };
-                let arg = { on: Spoofable, plus: [ definition ] };
-
-                target.spoof(arg);
-
-                let spoofed = Spoofable.prototype.spoofNumber;
-                let actual = spoofed();
-
-                target.unspoof();
-
-                let comparison = comparer.compare(actual, 17);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should set class method to return a known string when given args which define that.", /* good */ () => {
-                let target = new SpoofClassMethodsFixture();
-                let definition = { of: "spoofText", as: "return-text" };
-                let arg = { on: Spoofable, plus: [ definition ] };
-
-                target.spoof(arg);
-
-                let spoofed = Spoofable.prototype.spoofText;
-                let actual = spoofed();
-
-                target.unspoof();
-
-                let comparison = comparer.compare(actual, "return-text");
-                expect(comparison).to.be.true;
-            });
-
-            it("Should set class method to return a known object when given args which define that.", /* good */ () => {
-                let target = new SpoofClassMethodsFixture();
-                let definition = { of: "spoofText", as: { first: "one", second: "two" } };
-                let arg = { on: Spoofable, plus: [ definition ] };
-
-                target.spoof(arg);
-
-                let spoofed = Spoofable.prototype.spoofText;
-                let actual = spoofed();
-
-                target.unspoof();
-
-                let comparison = comparer.compare(actual, { first: "one", second: "two" });
-                expect(comparison).to.be.true;
-            });
-            
-            it("Should set class method to return a deep spoofed object when given args which define that.", /* good */ () => {
-                let target = new SpoofClassMethodsFixture();
-                let definition = { of: "spoofNumber", as: [ { of: "these.those.the.other", as: 76 } ] };
-                let arg = { on: Spoofable, plus: [ definition ] };
-
-                target.spoof(arg);
-
-                let spoofed = Spoofable.prototype.spoofNumber;
-                let actual = spoofed();
-
-                target.unspoof();
-
-                let expected = { these: { those: { the: { other: () => { return spoofOutput; } } } } };
-
-                let comparison = comparer.compare(actual, expected);
-                expect(comparison).to.be.true;
-
-            });
-        });
-    });
-});
-

package/tests/other-tests/SpoofObjectsFixture.tests.js

@@ -1,95 +0,0 @@
-/**/
-
-import { SpoofObjectMethodsFixture } from "../../system/SpoofObjectMethodsFixture.js";
-import { TotalComparer } from "../../system/TotalComparer.js";
-
-import { expect } from "chai";
-
-describe("SpoofObjectMethodsFixture", () => {
-    let comparer = new TotalComparer();
-
-    describe("Direct tests: Definition of spoofed method is compared.", () => {
-        it("Should set an empty method property when given args which define that.", /* good */ () => {
-            let target = new SpoofObjectMethodsFixture();
-            let definition = { of: "spoofNumber" };
-            let arg = { with: [ definition ], in: [ ] };
-
-            target.spoof(arg);
-
-            let actual = arg.with[0];
-            
-            let comparison = comparer.compare(actual, { spoofNumber: () => { } });
-            expect(comparison).to.be.true;
-        });
-
-        it("Should set a method to a known nonce function when given that nonce as an arg.", /* good */ () => {
-            let target = new SpoofObjectMethodsFixture();
-            let definition = { of: "spoofNumber", as: (a, b) => { return b - a; } };
-            let arg = { with: [ definition ], in: [ ] };
-
-            target.spoof(arg);
-
-            let actual = arg.with[0];
-            
-            let comparison = comparer.compare(actual, { spoofNumber: (a, b) => { return b - a; } });
-            expect(comparison).to.be.true;
-        });
-
-        it("Should set class method to a simple function returning a named parameter when given args which define that.", /* good */ () => {
-            let target = new SpoofObjectMethodsFixture();
-            let definition = { of: "spoofNumber" , as: 32 };
-            let arg = { with: [ definition ], in: [ ] };
-
-            target.spoof(arg);
-
-            let actual = arg.with[0];
-
-            let comparison = comparer.compare(actual, { spoofNumber: () => { return spoofOutput; } });
-            expect(comparison).to.be.true;
-        });
-    })
-
-    describe("Indirect tests: Result of calling spoofed method is compared.", () => {
-        it("Should set a method to return a known value when given args which define that.", /* good */ () => {
-            let target = new SpoofObjectMethodsFixture();
-            let definition = { of: "spoofNumber", as: 17 };
-            let arg = { with: [ definition ], in: [] };
-
-            target.spoof(arg);
-
-            let spoofed = arg.with[0];
-            let actual = spoofed.spoofNumber();
-            
-            let comparison = comparer.compare(actual, 17);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should set a method to return a known string when given args which define that.", /* good */ () => {
-            let target = new SpoofObjectMethodsFixture();
-            let definition = { of: "spoofText", as: "return-text" };
-            let arg = { with: [ definition ], in: [] };
-
-            target.spoof(arg);
-
-            let spoofed = arg.with[0];
-            let actual = spoofed.spoofText();
-
-            let comparison = comparer.compare(actual, "return-text");
-            expect(comparison).to.be.true;
-        });
-
-        it("Should set a method to return a known object when given args which define that.", /* good */ () => {
-            let target = new SpoofObjectMethodsFixture();
-            let definition = { of: "spoofText", as: { first: "one", second: "two" } };
-            let arg = { with: [ definition ], in: [] };
-
-            target.spoof(arg);
-
-            let spoofed = arg.with[0];
-            let actual = spoofed.spoofText();
-
-            let comparison = comparer.compare(actual, { first: "one", second: "two" });
-            expect(comparison).to.be.true;
-        });
-    });
-});

package/tests/other-tests/SpoofTuple.tests.js

@@ -1,93 +0,0 @@
-/**/
-
-import { SpoofTuple } from "../../system/SpoofTuple.js";
-import { expect } from "chai";
-
-describe("SpoofTuple", () => {
-    /* Some cases here are effectively impossible to test directly in self-tests, at least 
-       without complicated workarounds, because of how SpoofTuple is used by Kitten tests. */
-
-    describe("isNotASpoof()", () => {
-        it("Should return true when arg is undefined.", /* good */ () => {
-            let nonce = undefined;
-            
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.true;
-        });
-        
-        it("Should return true when arg is null.", /* good */ () => {
-            let nonce = null;
-            
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.true;
-        });
-        
-        it("Should return true when arg is a string.", /* good */ () => {
-            let nonce = "text";
-            
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.true;
-        });
-        
-        it("Should return true when arg is a value, such as a number.", /* good */ () => {
-            let nonce = 37;
-            
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.true;
-        });
-        
-        it("Should return true when arg is a predefined JavaScript Object, such as a Map.", /* good */ () => {
-            let nonce = new Map();
-            
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.true;
-        });
-    
-        it("Should return true when arg contains SpoofTuple properties but also .not.", /* good */ () => {
-            let nonce = { on: "on-arg", of: "of-arg", as: "as-arg", not: true };
-            
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.true;
-        });
-        
-        it("Should return true when arg contains SpoofTuple properties but also .skip.", /* good */ () => {
-            let nonce = { on: "on-arg", of: "of-arg", as: "as-arg", skip: true };
-            
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.true;
-        });
-        
-        it("Should return true when arg doesn't contain any SpoofTuple properties.", /* good */ () => {
-            let nonce = { notOn: true, notOf: "true", notAs: "not-as" };
-            
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.true;
-        });
-        
-        it("Should return false when arg contains any short-named " +
-           "SpoofTuple property, but neither .not nor .skip.", /* good */ () => {
-            let nonce = { on: "some-class" };
-
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.false;
-        });
-
-        it("Should return false when arg contains any long-named " +
-           "SpoofTuple property, but neither .not nor .skip.", /* good */ () => {
-            let nonce = { method: "some-method" };
-
-            let actual = SpoofTuple.isNotASpoof(nonce);
-            
-            expect(actual).to.be.false;
-        });
-    });
-});