risei 1.3.4 → 2.0.0

package/trial-tests/TopicTests.outward-rt.js

@@ -0,0 +1,313 @@
+/**/
+
+/* Lists tuples defining tests of Counter and other model code, 
+   possibly along with any fixtures needed for those tests. */
+
+import ATestSource from "../system/ATestSource.js";  // Path must match class used in TestFinder.
+
+import Counter from "../test-target-objects/Counter.js";
+import Sorter from "../test-target-objects/Sorter.js";
+import Searcher from "../test-target-objects/Searcher.js";
+import DomTarget from "../test-target-objects/DomTarget.js";
+import StaticTarget from "../test-target-objects/StaticTarget.js";
+import StateTarget from "../test-target-objects/StateTarget.js";
+
+export default class TopicTests extends ATestSource {
+    // region Local test fixtures
+
+    getIntervalValues(interval, count, doPermute, doWrap) {
+        let values = [];
+
+        for (let of = 0; of < count; of++) {
+            let value = interval * of;
+            values.push(value);
+        }
+
+        if (doPermute) {
+            /* Permuting order by pairing each value with a random value, 
+               sorting on the random values, then dropping those again. */
+
+            let pairings = [];
+
+            for (let at = 0; at < values.length; at++) {
+                pairings.push({ value: values[at], order: Math.random() });
+            }
+
+            pairings.sort((a, b) => a.order - b.order);
+            values = pairings.map(x => x.value);
+        }
+
+        if (doWrap) {
+            return [ values ];
+        }
+
+        return values;
+    }
+
+    // endregion Local test fixtures
+
+    // region Tests
+
+    tests = [
+        /* Counter . howMany() */
+        { on: Counter, with: [], of: "howMany" },
+
+        {
+            for: "Returns the right number for a repeated single character.", /* good */
+            in: [ "a b c a b c", "a" ], out: 2
+        },
+        {
+            for: "Returns the right number for a repeated string.", /* good */
+            in: [ "more text with more words", "more" ], out: 2
+        },
+        {
+            for: "Returns one for a target once at the start.", /* good */
+            in: [ "a b c d e f", "a" ], out: 1
+        },
+        {
+            for: "Returns one for a target once in the middle.", /* good */
+            in: [ "x b c a b c", "a" ], out: 1
+        },
+        {
+            for: "Returns one for a target once at the end.", /* good */
+            in: [ "a b x a b c", "c" ], out: 1
+        },
+
+        /* Trying out .type-restatement syntax. */
+        { on: Counter, with: [], of: "howMany" },
+
+        {
+            for: "Returns one for a multi-character target present once.", /* good */
+            in: [ "some text with words", "text" ], out: 1
+        },
+        {
+            for: "When target is not present in subject, returns zero.", /* good */
+            in: [ "a b c a b c", "x" ], out: 0
+        },
+
+        /* Trying out .method-restatement syntax. */
+        { of: "howMany" },
+
+        {
+            for: "When subject is empty, returns zero.", /* good */
+            in: [ "", "a" ], out: 0
+        },
+        {
+            for: "When target is empty, returns zero.", /* good */
+            in: [ "something", "" ], out: 0
+        },
+        {
+            for: "When both args are empty, returns zero.", /* good */
+            in: [ "", "" ], out: 0
+        },
+        {
+            for: "When only subject is provided, returns zero.", /* good */
+            in: [ "something" ], out: 0
+        },
+        {
+            for: "When no arguments are provided, returns zero.", /* good */
+            in: [], out: 0
+        },
+        {
+            for: "When subject is null, returns zero.", /* good */
+            in: [ null, "a" ], out: 0
+        },
+        {
+            for: "When target is null, returns zero.", /* good */
+            in: [ "something", null ], out: 0
+        },
+        {
+            for: "When both args are null, returns zero.", /* good */
+            in: [ null, null ], out: 0
+        },
+
+        /* Sorter */
+        { on: Sorter, with: [] },
+
+        /* .countSort() */
+        {
+            for: "When given an unsorted array, returns the values sorted.", /* good */
+            of: "countSort",
+            in: [ [ 3, 2, 6, 4, 1, 5 ] ], out: [ 1, 2, 3, 4, 5, 6 ]
+        },
+        {
+            for: "When given a sorted array, returns the same sort order.", /* good */
+            in: [ [ 2, 4, 6, 8, 9, 10 ] ], out: [ 2, 4, 6, 8, 9, 10 ]
+        },
+
+        /* .mergeSort() */
+        {
+            for: "When given an unsorted array, returns the values sorted.", /* good */
+            of: "mergeSort",
+            in: [ [ 3, 2, 6, 4, 1, 5 ] ], out: [ 1, 2, 3, 4, 5, 6 ]
+        },
+        {
+            for: "Sorts correctly when all stages are divisible by two.", /* good */
+            in: [ [ 3, 2, 6, 4, 1, 5, 8, 7 ] ],
+            out: [ 1, 2, 3, 4, 5, 6, 7, 8 ]
+        },
+
+        {
+            for: "Sorts interval values correctly.",
+            of: "mergeSort",
+            in: this.getIntervalValues(3, 10, true, true), out: this.getIntervalValues(3, 10, false, false)
+        },
+
+        { on: Searcher, with: [], of: "findLinear" },
+
+        {
+            for: "When sought is present in subject, returns true.", /* good */
+            in: [ 3, [ 6, 2, 8, 1, 4, 4, 3, 7, 2, 9, 11 ] ], out: true
+        },
+        {
+            for: "When sought is not present, returns false.", /* good */
+            in: [ 10, [ 6, 2, 8, 1, 4, 4, 3, 7, 2, 9, 11 ] ], out: false
+        },
+        {
+            for: "When no subject is provided, returns false.", /* good */
+            in: [ 7 ], out: false
+        },
+        {
+            for: "When no sought is provided, returns false.", /* good */
+            in: [ undefined, [ 3, 8, 10 ] ], out: false
+        },
+        {
+            for: "When no args are provided, returns false.", /* good */
+            in: [], out: false
+        },
+
+        { on: DomTarget, with: [ "spoof-id" ] },
+
+        {
+            for: "When an instance is inited, `id` arg is set as .id.", /* good */
+            of: "constructor",
+            plus: [ { of: "domNodeFrom" } ],
+            in: [ "arg-id" ],
+            out: "arg-id",
+            from: "id"
+        },
+        {
+            for: "When an instance is inited, return value from domNodeFrom() is set as .node.", /* good */
+            of: "constructor",
+            plus: [ { of: "domNodeFrom", as: "returned-node" } ],
+            in: [ "arg-node" ],
+            out: "returned-node",
+            from: "node"
+        },
+        {
+            for: "When changeDomItem() is called, its arg is the new .id.", /* good */
+            of: "changeDomItem",
+            plus: [ { of: "domNodeFrom" } ],
+            in: [ "new-id" ],
+            out: "new-id",
+            from: "id"
+        },
+        {
+            for: "When changeDomItem() is called, domNodeFrom() changes .node based on the arg.", /* good */
+            of: "changeDomItem",
+            plus: [ { of: "domNodeFrom", as: (arg) => { return arg; } } ],
+            in: [ "new-node" ],
+            out: "new-node",
+            from: "node"
+        },
+
+        /* Tests of inline tuple-based spoofing for static methods, using StaticTarget. */
+
+        { on: StaticTarget, with: [] },
+
+        { for: "When a call is made to a static method with .and set, " +
+               "that method is invoked to return the right result.", /* good */
+          of: "multiplyThenDivide",
+          and: "static",
+          in: [ 3, 4, 2 ],
+          out: 6 /* (3 *4) ÷2 */  },
+        { for: "When .and is set and .from is an arrow function, a value " +
+               "retrieved after a static method call is the right result.", /* good */
+          of: "setStaticProperty",
+          and: "static",
+          in: [ "static-was-set" ],
+          out: "static-was-set",
+          from: (target, test) => { return test.on.staticProperty; } 
+        },
+        { for: "When .and is not set and .from is an arrow function, a value " +
+               "retrieved after a static method call is the right result.", /* good */
+          of: "setStaticProperty",
+          and: [ ],
+          in: [ "was-set-to-static" ],
+          out: "was-set-to-static",
+          from: (target, test) => { return test.on.staticProperty; } 
+        },
+        { for: "When .and is set and .from is a static property name, a value " +
+               "retrieved after a static method call is the right result.", /* good */
+          of: "setStaticProperty",
+          and: "static",
+          in: [ "static-was-set" ],
+          out: "static-was-set",
+          from: "staticProperty" 
+        },
+        { for: "When .and is not set and .from is a static property name, a value " +
+               "retrieved after a static method call is the right result.", /* good */
+          of: "setStaticProperty",
+          and: [ ],
+          in: [ "was-set-to-static" ],
+          out: "was-set-to-static",
+          from: "staticProperty" 
+        },
+
+
+        /* Tests of inline tuple-based spoofing, using CompositionModel. */
+
+        { on: StateTarget, with: [] },
+
+        { for: "When instance is constructed, .numberState is 1.", /* good */
+          of: "constructor",
+          from: "numberState",
+          in: [ ], out: 1 },
+        { for: "When instance is constructed, .textState is \"1\".", /* good */
+          of: "constructor",
+          from: "textState",
+          in: [ ], out: "1" },
+        { for: "When number is set, .numberState property has the chosen value.", /* good */
+          of: "setNumberState",
+          from: "numberState",
+          in: [ 77 ], out: 77 },
+        { for: "When text is set, .textState has the chosen value.", /* good */
+          of: "setTextState",
+          from: "textState",
+          in: [ "This is some text." ], out: "This is some text." },
+
+        { of: "changeNumberAndTextState" },
+
+        { for: "When text and number are changed, .numberState matches the number arg.", /* good */
+          from: "numberState",
+          in: [ 2, "a phrase" ], out: 2 },
+        { for: "When a change is made with property test.from before a test with .from of [], property is used.", /* good */
+          from: "textState",
+          in: [ 2, "a phrase" ], out: "a phrase" },
+        { for: "When a change is made and test.from is [], not a retrieval, the return value is used.", /* good */
+          from: [ ],
+          in: [ 2, "a phrase" ], out: { number: 2, text: "a phrase" } },
+        { for: "When a change is made with property test.from before a test with .from of { }, property is used.", /* good */
+          from: "numberState",
+          in: [ 2, "a phrase" ], out: 2 },
+        { for: "When a change is made and test.from is { }, not a retrieval, the return value is used.", /* good */
+          from: { },
+          in: [ 2, "a phrase" ], out: { number: 2, text: "a phrase" } },
+        { for: "When a change is made with property test.from before a test with .from of false, property is used.", /* good */
+          from: "textState",
+          in: [ 2, "a phrase" ], out: "a phrase" },
+        { for: "When a change is made and test.from is false, not a retrieval, the return value is used.", /* good */
+          from: false,
+          in: [ 2, "a phrase" ], out: { number: 2, text: "a phrase" } },
+        { for: "When a change is made with property test.from before a test with .from of \"\", property is used.", /* good */
+          from: "numberState",
+          in: [ 2, "a phrase" ], out: 2 },
+        { for: "When a change is made and test.from is \"\", not a retrieval, the return value is used.", /* good */
+          from: "",
+          in: [ 2, "a phrase" ], out: { number: 2, text: "a phrase" } }
+
+    ];
+
+    // endregion Tests
+
+}

package/xternal-tests/ASpoofingFixture.tests.js

@@ -0,0 +1,242 @@
+/**/
+
+import ASpoofingFixture from "../system/ASpoofingFixture.js";
+import SpoofDef from "../system/SpoofDef.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 SpoofDef is used by Risei 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/xternal-tests/MethodSpoofer.tests.js

@@ -0,0 +1,130 @@
+/**/
+
+import MethodSpoofer from "../system/MethodSpoofer.js";
+import Spoofable from "../test-target-objects/Spoofable.js";
+import TotalComparer from "../system/TotalComparer.js";
+
+import { expect } from "chai";
+
+describe("MethodSpoofer", () => {
+    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 MethodSpoofer();
+                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 MethodSpoofer();
+                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 MethodSpoofer();
+                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 MethodSpoofer();
+                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 MethodSpoofer();
+                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 MethodSpoofer();
+                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 MethodSpoofer();
+                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;
+
+            });
+        });
+    });
+});
+