risei 1.0.4 → 1.1.1

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

@@ -0,0 +1,242 @@
+/**/
+
+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

@@ -0,0 +1,130 @@
+/**/
+
+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

@@ -0,0 +1,95 @@
+/**/
+
+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

@@ -0,0 +1,93 @@
+/**/
+
+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;
+        });
+    });
+});