Get compound states working!

Author: royalicing

src/index.test.ts

@@ -1,11 +1,14 @@
-import { always, call, cond, entry, exit, on, start } from "./index";
+import { always, compound, cond, entry, exit, on, start } from "./index";
 
 const fetch = jest.fn();
 beforeEach(fetch.mockClear);
 
 const finishedLoading = jest.fn();
 beforeEach(finishedLoading.mockClear);
 
+const succeeded = jest.fn();
+beforeEach(succeeded.mockClear);
+
 describe("Machine with entry and exit actions", () => {
   const someURL = new URL("https://example.org/");
   function fetchData() {
@@ -22,7 +25,9 @@ describe("Machine with entry and exit actions", () => {
       yield on("SUCCESS", success);
       yield on("FAILURE", failure);
     }
-    function* success() {}
+    function* success() {
+      yield entry(succeeded);
+    }
     function* failure() {
       yield on("RETRY", loading);
     }
@@ -63,11 +68,13 @@ describe("Machine with entry and exit actions", () => {
       expect(finishedLoading).toHaveBeenCalledTimes(1);
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("success");
+      expect(succeeded).toHaveBeenCalledTimes(1);
 
       const transitionResult2 = loader.next("FETCH");
-      expect(transitionResult2.actions).toEqual([]);
+      // expect(transitionResult2.actions).toEqual([]);
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("success");
+      expect(succeeded).toHaveBeenCalledTimes(1);
 
       await loader.resolved;
     });
@@ -79,7 +86,7 @@ describe("Machine with entry and exit actions", () => {
     });
 
     test("sending events", async () => {
-      const loader = start(Loader, [{ url: someURL }]);
+      const loader = start(Loader);
       expect(loader.value).toEqual("idle");
 
       const transitionResult = loader.next("FETCH");
@@ -116,9 +123,7 @@ describe("Machine with entry and exit actions", () => {
   });
 });
 
-describe("Form Field Machine with entry and exit actions", () => {
-  // const validate = jest.fn();
-  // beforeEach(validate.mockClear);
+describe("Form Field Machine with always()", () => {
   const isValid = jest.fn();
   beforeEach(isValid.mockClear);
 
@@ -127,20 +132,12 @@ describe("Form Field Machine with entry and exit actions", () => {
       yield on("CHANGE", editing);
     }
     function* editing() {
-      // yield exit(validate);
       yield on("CHANGE", editing);
       yield on("BLUR", validating);
     }
     function* validating() {
       yield always(cond(isValid, valid));
       yield always(invalid);
-
-      // yield on(null, cond(isValid, valid));
-      // yield on(null, invalid);
-
-      // yield always([cond(isValid, valid), invalid]);
-      // return [cond(isValid, valid), invalid];
-      // return conds([[isValid, valid], [true, invalid]]);
     }
     function* invalid() {
       yield on("CHANGE", editing);
@@ -152,11 +149,6 @@ describe("Form Field Machine with entry and exit actions", () => {
     return initial;
   }
 
-  test("creating", () => {
-    const formField = start(FormField);
-    expect(formField).toBeDefined();
-  });
-
   describe("when is valid", () => {
     beforeEach(() => {
       isValid.mockReturnValue(true);
@@ -173,11 +165,11 @@ describe("Form Field Machine with entry and exit actions", () => {
 
       formField.next("CHANGE");
       expect(formField.value).toEqual("editing");
-      expect(formField.changeCount).toEqual(2);
+      expect(formField.changeCount).toEqual(1);
 
       formField.next("BLUR");
       expect(formField.value).toEqual("valid");
-      expect(formField.changeCount).toEqual(4);
+      expect(formField.changeCount).toEqual(3);
     });
   });
 
@@ -197,106 +189,79 @@ describe("Form Field Machine with entry and exit actions", () => {
 
       formField.next("CHANGE");
       expect(formField.value).toEqual("editing");
-      expect(formField.changeCount).toEqual(2);
+      expect(formField.changeCount).toEqual(1);
 
       formField.next("BLUR");
       expect(formField.value).toEqual("invalid");
-      expect(formField.changeCount).toEqual(4);
+      expect(formField.changeCount).toEqual(3);
     });
   });
 });
 
-describe("Machine with call", () => {
-  function Loader({ url }: { url: URL }) {
-    function* idle() {
-      yield on("FETCH", loading);
-    }
-    function* loading() {
-      yield call(fetch, [url.toString()]);
-      yield on("SUCCESS", success);
-      yield on("FAILURE", failure);
+describe("Hierarchical Traffic Lights Machine", () => {
+  // const validate = jest.fn();
+  // beforeEach(validate.mockClear);
+  const isValid = jest.fn();
+  beforeEach(isValid.mockClear);
+
+  function PedestrianFactory() {
+    function* walk() {
+      yield on("PED_COUNTDOWN", wait);
     }
-    function* success() {}
-    function* failure() {
-      yield on("RETRY", loading);
+    function* wait() {
+      yield on("PED_COUNTDOWN", stop);
     }
+    function* stop() {}
+    function* blinking() {}
 
-    return idle;
+    return { walk, blinking };
   }
+  function* TrafficLights() {
+    const { walk, blinking } = PedestrianFactory();
 
-  const someURL = new URL("https://example.org/");
-
-  test("creating", () => {
-    const loader = start(Loader, [{ url: someURL }]);
-    expect(loader).toBeDefined();
-  });
-
-  describe("when fetch succeeds", () => {
-    beforeEach(() => {
-      fetch.mockResolvedValue(42);
-    });
-
-    test("sending events", async () => {
-      const loader = start(Loader, [{ url: someURL }]);
-      expect(loader.value).toEqual("idle");
-      await expect(loader.resolved).resolves.toEqual([]);
-
-      loader.next("NOOP");
-      expect(loader.value).toEqual("idle");
-      expect(loader.changeCount).toEqual(0);
-      await expect(loader.resolved).resolves.toEqual([]);
-
-      loader.next("FETCH");
-      expect(loader.value).toEqual("loading");
-      expect(loader.changeCount).toEqual(1);
-
-      expect(fetch).toHaveBeenCalledWith("https://example.org/");
-
-      await expect(loader.resolved).resolves.toEqual([42]);
-      expect(loader.changeCount).toEqual(2);
-      expect(loader.value).toEqual("success");
-
-      loader.next("FETCH");
-      expect(loader.changeCount).toEqual(2);
-
-      await loader.resolved;
-    });
-  });
-
-  describe("when fetch fails", () => {
-    beforeEach(() => {
-      fetch.mockRejectedValueOnce(new Error("Failed!")).mockResolvedValue(42);
-    });
-
-    test("sending events", async () => {
-      const loader = start(Loader, [{ url: someURL }]);
-      expect(loader.value).toEqual("idle");
-
-      loader.next("FETCH");
-      expect(loader.value).toEqual("loading");
-      expect(loader.changeCount).toEqual(1);
-
-      expect(fetch).toHaveBeenCalledTimes(1);
-      expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
-
-      await expect(loader.resolved).rejects.toEqual(new Error("Failed!"));
-      expect(loader.changeCount).toEqual(2);
-      expect(loader.value).toEqual("failure");
+    function* green() {
+      yield on("TIMER", yellow);
+    }
+    function* yellow() {
+      yield on("TIMER", red);
+    }
+    function* red() {
+      yield on("TIMER", green);
 
-      loader.next("FETCH");
-      expect(fetch).toHaveBeenCalledTimes(1);
-      expect(loader.changeCount).toEqual(2);
+      return walk;
+    }
 
-      loader.next("RETRY");
-      expect(loader.value).toEqual("loading");
-      expect(loader.changeCount).toEqual(3);
+    yield on("POWER_OUTAGE", compound(red, blinking));
+    yield on("POWER_RESTORED", compound(red));
 
-      expect(fetch).toHaveBeenCalledTimes(2);
-      expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
+    return green;
+  }
 
-      await expect(loader.resolved).resolves.toEqual([42]);
-      expect(loader.changeCount).toEqual(4);
-      expect(loader.value).toEqual("success");
-    });
+  test("sending events", () => {
+    const machine = start(TrafficLights);
+    expect(machine).toBeDefined();
+    expect(machine.value).toEqual("green");
+
+    machine.next("TIMER");
+    expect(machine.value).toEqual("yellow");
+    expect(machine.changeCount).toEqual(1);
+
+    machine.next("TIMER");
+    // expect(machine.value).toEqual("red");
+    // expect(machine.value).toEqual(["red", "walk"]);
+    expect(machine.value).toEqual({ "red": "walk" });
+    expect(machine.changeCount).toEqual(3);
+
+    machine.next("TIMER");
+    expect(machine.value).toEqual("green");
+    expect(machine.changeCount).toEqual(4);
+    
+    machine.next("POWER_RESTORED");
+    expect(machine.value).toEqual({ "red": "walk" });
+    expect(machine.changeCount).toEqual(6);
+    
+    machine.next("POWER_OUTAGE");
+    expect(machine.value).toEqual({ "red": "blinking" });
+    expect(machine.changeCount).toEqual(7);
   });
 });