@expressive/mvc 0.53.6 → 0.54.1

package/dist/esm/instruction/set.test.js

@@ -1,527 +0,0 @@
-import { mockPromise, mockWarn } from '../mocks';
-import { Model } from '../model';
-import { set } from './set';
-const warn = mockWarn();
-describe("placeholder", () => {
-    class Test extends Model {
-        constructor() {
-            super(...arguments);
-            this.foobar = set();
-        }
-    }
-    it('will suspend if value is accessed before assign', async () => {
-        const instance = Test.new();
-        const promise = mockPromise();
-        const mockEffect = jest.fn((state) => {
-            promise.resolve(state.foobar);
-        });
-        instance.get(mockEffect);
-        expect(mockEffect).toBeCalledTimes(1);
-        instance.foobar = "foo!";
-        const result = await promise;
-        expect(mockEffect).toBeCalledTimes(2);
-        expect(result).toBe("foo!");
-    });
-    it("will resolve suspense after latest value", async () => {
-        const test = Test.new();
-        const foobar = jest.fn();
-        const effect = jest.fn((state) => {
-            foobar(state.foobar);
-        });
-        test.get(effect);
-        expect(effect).toBeCalledTimes(1);
-        expect(foobar).not.toBeCalled();
-        test.foobar = "foo";
-        test.foobar = "bar";
-        await expect(test).toHaveUpdated("foobar");
-        expect(effect).toBeCalledTimes(2);
-        expect(foobar).not.toBeCalledWith("foo");
-        expect(foobar).toBeCalledWith("bar");
-    });
-    it('will not suspend if value is defined', async () => {
-        const instance = Test.new();
-        instance.foobar = "bar!";
-        const mockEffect = jest.fn((state) => {
-            expect(state.foobar).toBe("bar!");
-        });
-        instance.get(mockEffect);
-        expect(mockEffect).toBeCalledTimes(1);
-    });
-});
-describe("callback", () => {
-    it('will invoke callback on property put', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.test = set(1, value => {
-                    didAssign(value + 1);
-                });
-            }
-        }
-        const state = Subject.new();
-        const didAssign = jest.fn();
-        const didUpdate = jest.fn();
-        expect(didAssign).not.toBeCalled();
-        state.set((key) => {
-            if (key == "test")
-                didUpdate();
-        });
-        state.test = 2;
-        expect(didUpdate).toBeCalledTimes(1);
-        expect(didAssign).toBeCalledWith(3);
-    });
-    it('will invoke return-callback on overwrite', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.test = set(1, () => {
-                    return () => {
-                        callback(true);
-                    };
-                });
-            }
-        }
-        const callback = jest.fn();
-        const state = Subject.new();
-        state.test = 2;
-        await expect(state).toHaveUpdated();
-        expect(callback).not.toBeCalled();
-        state.test = 3;
-        await expect(state).toHaveUpdated();
-        expect(callback).toBeCalledWith(true);
-    });
-    it('will assign a default value', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.test = set("foo", value => {
-                    callback(value);
-                });
-            }
-        }
-        const callback = jest.fn();
-        const state = Subject.new();
-        expect(state.test).toBe("foo");
-        state.test = "bar";
-        await expect(state).toHaveUpdated();
-        expect(callback).toBeCalledWith("bar");
-    });
-    it('will ignore effect promise', () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.property = set(undefined, async () => { });
-            }
-        }
-        const state = Subject.new();
-        expect(() => state.property = "bar").not.toThrow();
-    });
-    it('will not suspend own property access', () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.property = set(undefined, (_, previous) => {
-                    propertyWas = previous;
-                });
-            }
-        }
-        const state = Subject.new();
-        let propertyWas;
-        state.property = "bar";
-        expect(propertyWas).toBe(undefined);
-        state.property = "foo";
-        expect(propertyWas).toBe("bar");
-    });
-    it('will reset nested effects', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.name = "World";
-                this.hello = set("Hello", async (value) => {
-                    this.get(({ name }) => {
-                        effect(`${value} ${name}!`);
-                    });
-                });
-            }
-        }
-        const effect = jest.fn();
-        const state = Subject.new();
-        state.hello = "Hola";
-        await expect(state).toHaveUpdated();
-        expect(effect).toBeCalledWith("Hola World!");
-        state.hello = "Bonjour";
-        await expect(state).toHaveUpdated();
-        expect(effect).toBeCalledWith("Bonjour World!");
-        state.name = "Earth";
-        await expect(state).toHaveUpdated();
-        expect(effect).toBeCalledWith("Bonjour Earth!");
-        expect(effect).not.toBeCalledWith("Hola Earth!");
-    });
-});
-describe("intercept", () => {
-    it('will prevent update if callback returns false', async () => {
-        class Subject extends Model {
-            constructor() {
-                super(...arguments);
-                this.test = set("foo", value => {
-                    callback(value);
-                    return false;
-                });
-            }
-        }
-        const callback = jest.fn();
-        const state = Subject.new();
-        expect(state.test).toBe("foo");
-        state.test = "bar";
-        await expect(state).not.toHaveUpdated();
-        expect(callback).toBeCalledWith("bar");
-        expect(state.test).toBe("foo");
-    });
-    it('will not call prior cleanup if supressed', async () => {
-        const cleanup = jest.fn();
-        const setter = jest.fn(value => {
-            return value === 3 ? false : cleanup;
-        });
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(1, setter);
-            }
-        }
-        const subject = Test.new();
-        subject.value = 2;
-        expect(setter).toBeCalledWith(2, 1);
-        await expect(subject).toHaveUpdated();
-        expect(subject.value).toBe(2);
-        // this update will be supressed by setter
-        subject.value = 3;
-        expect(setter).toBeCalledWith(3, 2);
-        await expect(subject).not.toHaveUpdated();
-        expect(cleanup).not.toBeCalled();
-        subject.value = 4;
-        expect(setter).toBeCalledWith(4, 2);
-        expect(cleanup).toBeCalledTimes(1);
-        expect(cleanup).toBeCalledWith(4);
-    });
-});
-describe("factory", () => {
-    it("will ignore setter if assigned", () => {
-        const getValue = jest.fn(() => "foo");
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(getValue);
-            }
-        }
-        const test = Test.new();
-        test.value = "bar";
-        expect(test).toHaveUpdated();
-        expect(test.value).toBe("bar");
-        expect(getValue).not.toBeCalled();
-    });
-    it("will compute when accessed", () => {
-        const factory = jest.fn(() => "Hello World");
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(factory);
-            }
-        }
-        const test = Test.new();
-        expect(factory).not.toBeCalled();
-        void test.value;
-        expect(factory).toBeCalled();
-    });
-    it("will compute lazily", () => {
-        const factory = jest.fn(async () => "Hello World");
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(factory, false);
-            }
-        }
-        Test.new();
-        expect(factory).not.toBeCalled();
-    });
-    it('will bind factory function to self', async () => {
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                // methods lose implicit this
-                this.value = set(this.method);
-            }
-            async method() {
-                expect(this).toBe(instance);
-            }
-        }
-        const instance = Test.new();
-    });
-    it("will warn and rethrow error from factory", () => {
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.memoized = set(this.failToGetSomething, true);
-            }
-            failToGetSomething() {
-                throw new Error("Foobar");
-            }
-        }
-        const attempt = () => Test.new("ID");
-        expect(attempt).toThrowError("Foobar");
-        expect(warn).toBeCalledWith(`Generating initial value for ID.memoized failed.`);
-    });
-});
-describe("suspense", () => {
-    it("will throw suspense-promise resembling an error", () => {
-        const promise = mockPromise();
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(promise, true);
-            }
-        }
-        const instance = Test.new("ID");
-        expect(() => instance.value).toThrowError(`ID.value is not yet available.`);
-        promise.resolve();
-    });
-    it("will resolve when factory does", async () => {
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(async () => "foobar", true);
-            }
-        }
-        const test = Test.new();
-        expect(() => test.value).toThrow(expect.any(Promise));
-        await expect(test).toUpdate(0);
-        expect(test.value).toBe("foobar");
-    });
-    it("will not suspend where already resolved", async () => {
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.greet = set(async () => "Hello", true);
-                this.name = set(async () => "World", true);
-                this.value = set(() => this.greet + " " + this.name);
-            }
-        }
-        const test = Test.new();
-        try {
-            void test.value;
-        }
-        catch (error) {
-            if (error instanceof Promise)
-                await error;
-            else
-                throw error;
-        }
-        expect(() => test.value).not.toThrow();
-    });
-    it("will suspend if required while still pending", () => {
-        const promise = mockPromise();
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(promise, true);
-            }
-        }
-        const instance = Test.new();
-        expect(() => instance.value).toThrow(expect.any(Promise));
-        promise.resolve();
-    });
-    it("will be undefined if not required", async () => {
-        const promise = mockPromise();
-        const mock = jest.fn();
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(promise);
-            }
-        }
-        const test = Test.new();
-        test.get($ => mock($.value));
-        expect(mock).toBeCalledWith(undefined);
-        promise.resolve("foobar");
-        await expect(test).toUpdate(0);
-        expect(mock).toBeCalledWith("foobar");
-    });
-    it("will suspend another factory", async () => {
-        const greet = mockPromise();
-        const name = mockPromise();
-        const didEvaluate = jest.fn(function () {
-            return this.greet + " " + this.name;
-        });
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.greet = set(greet, true);
-                this.name = set(name, true);
-                this.value = set(didEvaluate, true);
-            }
-        }
-        const test = Test.new();
-        test.get($ => void $.value);
-        greet.resolve("Hello");
-        await expect(test).toUpdate(0);
-        name.resolve("World");
-        await expect(test).toUpdate(0);
-        expect(didEvaluate).toBeCalledTimes(3);
-        expect(test.value).toBe("Hello World");
-    });
-    it("will suspend another factory (async)", async () => {
-        const greet = mockPromise();
-        const name = mockPromise();
-        const didEvaluate = jest.fn(async function () {
-            return this.greet + " " + this.name;
-        });
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.greet = set(() => greet, true);
-                this.name = set(() => name, true);
-                this.value = set(didEvaluate, true);
-            }
-        }
-        const test = Test.new();
-        test.get($ => void $.value);
-        greet.resolve("Hello");
-        await expect(test).toUpdate(0);
-        name.resolve("World");
-        await expect(test).toUpdate(0);
-        expect(didEvaluate).toBeCalledTimes(3);
-        expect(test.value).toBe("Hello World");
-    });
-    it("will nest suspense", async () => {
-        const promise = mockPromise();
-        const didUpdate = mockPromise();
-        class Child extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(promise, true);
-            }
-        }
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.child = new Child();
-                this.childValue = set(() => {
-                    return this.child.value + " world!";
-                }, true);
-            }
-        }
-        const test = Test.new();
-        const effect = jest.fn((state) => {
-            didUpdate.resolve(state.childValue);
-        });
-        test.get(effect);
-        expect(effect).toBeCalledTimes(1);
-        expect(effect).not.toHaveReturned();
-        promise.resolve("hello");
-        await expect(didUpdate).resolves.toBe("hello world!");
-        expect(effect).toBeCalledTimes(2);
-    });
-    it("will return undefined on nested suspense", async () => {
-        const promise = mockPromise();
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.asyncValue = set(() => promise, true);
-                this.value = set(() => `Hello ${this.asyncValue}`);
-            }
-        }
-        const test = Test.new();
-        expect(test.value).toBeUndefined();
-        promise.resolve("World");
-        await expect(test).toUpdate();
-        expect(test.value).toBe("Hello World");
-    });
-    it("will squash repeating suspense", async () => {
-        let pending = mockPromise();
-        let suspend = true;
-        const compute = jest.fn(() => {
-            if (suspend)
-                throw pending;
-            return `OK I'm unblocked.`;
-        });
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.message = set(compute, true);
-            }
-        }
-        const test = Test.new();
-        const didEvaluate = mockPromise();
-        const effect = jest.fn((state) => {
-            didEvaluate.resolve(state.message);
-        });
-        test.get(effect);
-        expect(effect).toBeCalled();
-        expect(effect).not.toHaveReturned();
-        expect(compute).toBeCalledTimes(1);
-        pending.resolve();
-        pending = mockPromise();
-        // TODO: why does this not work when `.set(0)` is used?
-        await test.set();
-        // expect eval to run again because promise resolved.
-        expect(compute).toBeCalledTimes(2);
-        suspend = false;
-        pending.resolve();
-        await didEvaluate;
-        expect(test.message).toBe("OK I'm unblocked.");
-        expect(compute).toBeCalledTimes(3);
-        expect(effect).toBeCalledTimes(2);
-        expect(effect).toHaveReturnedTimes(1);
-    });
-    it("will squash multiple dependancies", async () => {
-        const promise = mockPromise();
-        const promise2 = mockPromise();
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.a = set(promise, true);
-                this.b = set(promise2, true);
-                this.sum = set(this.getSum);
-            }
-            getSum() {
-                const { a, b } = this;
-                return `Answer is ${a + b}.`;
-            }
-        }
-        const test = Test.new();
-        const effect = jest.fn((state) => void state.sum);
-        test.get(effect);
-        expect(effect).toBeCalled();
-        promise.resolve(10);
-        await expect(test).toUpdate();
-        expect(effect).toBeCalledTimes(1);
-        promise2.resolve(20);
-        await expect(test).toUpdate();
-        expect(test.sum).toBe("Answer is 30.");
-        expect(effect).toBeCalledTimes(2);
-    });
-    it('will refresh and throw if async rejects', async () => {
-        const promise = mockPromise();
-        class Test extends Model {
-            constructor() {
-                super(...arguments);
-                this.value = set(promise, true);
-            }
-        }
-        const instance = Test.new();
-        let didThrow;
-        instance.get(state => {
-            try {
-                void state.value;
-            }
-            catch (err) {
-                didThrow = err;
-                if (err instanceof Promise)
-                    throw err;
-            }
-        });
-        expect(didThrow).toBeInstanceOf(Promise);
-        promise.reject("oh no");
-        await new Promise(res => setTimeout(res, 10));
-        expect(didThrow).toBe("oh no");
-    });
-});