Merge pull request #49 from vankeisb/feature/program-testing

program testing

Author: vankeisb

samples/src/Samples/ProgramSample.test.tsx

@@ -0,0 +1,38 @@
+import { mount, ReactWrapper } from 'enzyme';
+import { extendJest, Cmd, Sub, Task, Program, ProgramProps, updateUntilIdle } from "react-tea-cup";
+import React, { ReactNode } from 'react';
+import { Dispatcher } from 'tea-cup-core';
+
+extendJest(expect);
+
+const init1: () => [number, Cmd<string>] = () => {
+    return [0, toCmd('go')];
+}
+
+const view1: (dispatch: Dispatcher<string>, model: number) => React.ReactNode = (dispatch: Dispatcher<string>, model: number) => {
+    return (<div className={'count'}>{model}</div>);
+}
+
+const update1: (msg: string, model: number) => [number, Cmd<string>] = (msg: string, model: number) => {
+    return [model + 1, model < 5 ? toCmd('go') : Cmd.none()];
+}
+
+// const toCmd = (msg: string) => Task.perform(Time.in(0), () => msg);
+const toCmd = (msg: string) => Task.perform(Task.succeed(0), () => msg);
+
+describe('Test Program', () => {
+
+    it('expect when program is idle', () => {
+        const props: ProgramProps<number, string> = {
+            init: init1,
+            view: view1,
+            update: update1,
+            subscriptions: () => Sub.none<string>()
+        }
+        return updateUntilIdle(props, mount).then(([model, wrapper]) => {
+            expect(model).toEqual(6)
+            // expect(wrapper).toHaveHTML('')
+            expect(wrapper.find('.count')).toHaveText('6')
+        })
+    })
+})

tea-cup/src/TeaCup/Program.ts

@@ -70,7 +70,7 @@ export class Program<Model, Msg> extends Component<ProgramProps<Model, Msg>, nev
     this.count++;
     const count = this.count;
     const currentModel = this.currentModel;
-    if (currentModel) {
+    if (currentModel !== undefined) {
       const updated = this.props.update(msg, currentModel);
       if (this.props.devTools) {
         this.fireEvent({

tea-cup/src/TeaCup/Testing.ts

@@ -0,0 +1,166 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2019 Rémi Van Keisbelck
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+import { Dispatcher, Cmd, Sub } from 'tea-cup-core';
+import { ReactElement } from 'react';
+import { ProgramProps, Program } from '.';
+import React from 'react';
+
+export function extendJest<M>(expect: jest.Expect) {
+  expect.extend({
+    toHaveDispatchedMsg(received: Testing<M>, expected: M) {
+      const pass = this.equals(received.dispatched, expected);
+
+      const message = () =>
+        this.utils.matcherHint('toBe', undefined, undefined) +
+        '\n\n' +
+        `Expected: ${this.utils.printExpected(expected)}\n` +
+        `Received: ${this.utils.printReceived(received.dispatched)}`;
+
+      return { actual: received, message, pass };
+    },
+  });
+}
+
+declare global {
+  namespace jest {
+    interface Matchers<R> {
+      toHaveDispatchedMsg<M>(value: M): CustomMatcherResult;
+    }
+  }
+}
+
+export class Testing<M> {
+  private _dispatched: M | undefined;
+
+  public Testing() { }
+
+  public readonly noop: Dispatcher<M> = () => { };
+
+  public get dispatcher(): Dispatcher<M> {
+    this._dispatched = undefined;
+    return (msg: M) => {
+      this._dispatched = msg;
+    };
+  }
+
+  public get dispatched(): M | undefined {
+    return this._dispatched;
+  }
+
+  public dispatchFrom(cmd: Cmd<M>): Promise<M> {
+    return new Promise<M>((resolve, reject) => {
+      const dispatchedMsg = (msg: M) => {
+        resolve(msg);
+      };
+      cmd.execute(dispatchedMsg);
+    });
+  }
+}
+
+type Trigger<Model, Msg, T> = (node: ReactElement<ProgramProps<Model, Msg>>) => T
+type ResolveType<Model, T> = (idle: [Model, T]) => void;
+
+export function updateUntilIdle<Model, Msg, T>(props: ProgramProps<Model, Msg>, fun: Trigger<Model, Msg, T>): Promise<[Model, T]> {
+  return new Promise(resolve => {
+    fun(<Program {...testableProps(resolve, props, fun)} />)
+  })
+}
+
+function testableProps<Model, Msg, T>(resolve: ResolveType<Model, T>, props: ProgramProps<Model, Msg>, fun: Trigger<Model, Msg, T>) {
+  const tprops: ProgramProps<TestableModel<Model, Msg, T>, Msg> = {
+    init: initTestable(resolve, props.init),
+    view: viewTestable(props.view),
+    update: updateTestable((props.update)),
+    subscriptions: suscriptionsTestable(props, fun)
+  }
+  return tprops
+}
+
+type TestableModel<Model, Msg, T> = {
+  readonly resolve: ResolveType<Model, T>;
+  readonly cmds: Cmd<Msg>[];
+  readonly model: Model;
+}
+
+function initTestable<Model, Msg, T>(resolve: ResolveType<Model, T>, init: ProgramProps<Model, Msg>['init']): ProgramProps<TestableModel<Model, Msg, T>, Msg>['init'] {
+  const mac = init();
+  return () => [{
+    resolve,
+    cmds: [mac[1]],
+    model: mac[0]
+  }, Cmd.none()];
+}
+
+function viewTestable<Model, Msg, T>(view: ProgramProps<Model, Msg>['view']): ProgramProps<TestableModel<Model, Msg, T>, Msg>['view'] {
+  return (dispatch: Dispatcher<Msg>, model: TestableModel<Model, Msg, T>) => view(dispatch, model.model);
+}
+
+function updateTestable<Model, Msg, T>(update: ProgramProps<Model, Msg>['update']): ProgramProps<TestableModel<Model, Msg, T>, Msg>['update'] {
+  return (msg: Msg, model: TestableModel<Model, Msg, T>) => {
+    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, T>(props: ProgramProps<Model, Msg>, fun: Trigger<Model, Msg, T>): ProgramProps<TestableModel<Model, Msg, T>, Msg>['subscriptions'] {
+  return (model: TestableModel<Model, Msg, T>) => {
+    const subs = props.subscriptions(model.model);
+    if (model.cmds.length === 0) {
+      const result = fun(<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, result]);
+      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)
+  }
+}