use program to test program

Author: frawa

samples/src/Samples/Program.test.tsx

@@ -2,6 +2,7 @@ import { mount, ReactWrapper } from 'enzyme';
 import { extendJest, Cmd, Sub, Task, Program, ProgramProps } from "react-tea-cup";
 import React, { ReactNode } from 'react';
 import { Dispatcher } from 'tea-cup-core';
+import { view } from './Counter';
 // import 'jest-enzyme';
 
 extendJest(expect);
@@ -36,6 +37,20 @@ describe('Test Program', () => {
             expect(wrapper.find('.count')).toHaveText('6')
         })
     })
+
+    it('alternative', () => {
+        const props: ProgramProps<number, string> = {
+            init: init1,
+            view: view1,
+            update: update1,
+            subscriptions: () => Sub.none<string>()
+        }
+        return updateUntilIdle(props).then(([model, wrapper]) => {
+            expect(model).toEqual(6)
+            // expect(wrapper).toHaveHTML('')
+            expect(wrapper.find('.count')).toHaveText('6')
+        })
+    })
 })
 
 function mountWhenIdle<Model, Msg>(props: ProgramProps<Model, Msg>) {
@@ -44,6 +59,88 @@ function mountWhenIdle<Model, Msg>(props: ProgramProps<Model, Msg>) {
     return testable.mountWhenIdle()
 }
 
+type WrapperType<Model, Msg> = ReactWrapper<Program<Model, Msg>, ProgramProps<Model, Msg>, never>
+type ResolveType<Model, Msg> = (idle: [Model, WrapperType<Model, Msg>]) => void;
+
+function updateUntilIdle<Model, Msg>(props: ProgramProps<Model, Msg>): Promise<[Model, WrapperType<Model, Msg>]> {
+    return new Promise(resolve => {
+        mount(<Program {...testableProps(resolve, props)} />)
+    })
+}
+
+function testableProps<Model, Msg>(resolve: ResolveType<Model, Msg>, props: ProgramProps<Model, Msg>) {
+    const props2: ProgramProps<TestableModel<Model, Msg>, Msg> = {
+        init: initTestable(resolve, props.init),
+        view: viewTestable(props.view),
+        update: updateTestable((props.update)),
+        subscriptions: suscriptionsTestable(props)
+    }
+    return props2
+}
+
+type TestableModel<Model, Msg> = {
+    readonly resolve: ResolveType<Model, Msg>;
+    readonly cmds: Cmd<Msg>[];
+    readonly model: Model;
+}
+
+function initTestable<Model, Msg>(resolve: ResolveType<Model, Msg>, init: ProgramProps<Model, Msg>['init']): ProgramProps<TestableModel<Model, Msg>, Msg>['init'] {
+    const mac = init();
+    return () => [{
+        resolve,
+        cmds: [mac[1]],
+        model: mac[0]
+    }, Cmd.none()];
+}
+
+function viewTestable<Model, Msg>(view: ProgramProps<Model, Msg>['view']): ProgramProps<TestableModel<Model, Msg>, Msg>['view'] {
+    return (dispatch: Dispatcher<Msg>, model: TestableModel<Model, Msg>) => view(dispatch, model.model);
+}
+
+function updateTestable<Model, Msg>(update: ProgramProps<Model, Msg>['update']): ProgramProps<TestableModel<Model, Msg>, Msg>['update'] {
+    return (msg: Msg, model: TestableModel<Model, Msg>) => {
+        const [model1, cmd1] = update(msg, model.model);
+        const cmds = [cmd1].filter(cmd => cmd.constructor.name !== 'CmdNone')
+        return [{
+            ...model,
+            cmds,
+            model: model1,
+        }, Cmd.none()];
+    }
+}
+
+function suscriptionsTestable<Model, Msg>(props: ProgramProps<Model, Msg>): ProgramProps<TestableModel<Model, Msg>, Msg>['subscriptions'] {
+    return (model: TestableModel<Model, Msg>) => {
+        const subs = props.subscriptions(model.model);
+        if (model.cmds.length === 0) {
+            const wrapper: WrapperType<Model, Msg> = mount(<Program
+                init={() => [model.model, Cmd.none()]}
+                update={(msg, model) => [model, Cmd.none()]}
+                view={(d, m) => props.view(d, m)}
+                subscriptions={(d) => Sub.none()}
+            />)
+            model.resolve([model.model, wrapper]);
+            return subs;
+        }
+        return Sub.batch([new TestableSub(model.cmds), subs]);
+    }
+}
+
+class TestableSub<Msg> extends Sub<Msg> {
+    constructor(private readonly cmds: readonly Cmd<Msg>[]) {
+        super();
+    }
+
+    protected onInit(): void {
+        setTimeout(() => {
+            if (this.dispatcher !== undefined) {
+                const d = this.dispatcher.bind(this);
+                this.cmds.map(cmd => cmd.execute(d));
+            }
+        }, 0)
+    }
+}
+
 class Testable<Model, Msg>{
     private resolve?: (idle: [Model, ReactWrapper<Program<Model, Msg>, ProgramProps<Model, Msg>, never>]) => void;
     private cmds: Cmd<Msg>[] = [];