pingback test, see #339 and #338 (#340)

jbolda · web-flow · commit c30de63db054 · 2025-10-11T02:04:29.000-05:00
diff --git a/packages/foundation/README.md b/packages/foundation/README.md
@@ -2,6 +2,8 @@
 
 This simulator gives some base level functionality which is likely to be used in every simulator. It is built with the expectation to be extended and meet your needs for any custom simulators as well. If you need assistance in building a simulator for your needs, please reach out to [Frontside for this or any other consulting services](https://frontside.com/).
 
+Use this base with an OpenAPI specification or other API contract enforcement mechanisms to quickly wire up test data that feels real. Implement APIs that feel real _including_ the handling features such as webhooks, WebSockets, GraphQL, and/or Authentication/Authorization. See the other simulators in these repos as additional examples on how you may implement a simulator.
+
 ## Quick Start
 
 Get started with some JSON file, and incrementally build up as needs arise. Start with:
diff --git a/packages/foundation/example/extensiveServer/store.ts b/packages/foundation/example/extensiveServer/store.ts
@@ -62,9 +62,9 @@ const selectors = ({
 };
 
 const tasks = ({ createWebhook }: ExtendSimulationTasks<ExtendedSchema>) => {
-  const webhook = createWebhook("https://example.com/webhook");
+  const webhook = createWebhook("https://example.com");
   const onTest = webhook.create<{ id: string; name: string }>(
-    "webhook:test",
+    "/webhook-endpoint",
     function* (ctx, next) {
       // the following would send off that request
       //  but we don't want to post in tests
diff --git a/packages/foundation/example/pingback/server-one.ts b/packages/foundation/example/pingback/server-one.ts
@@ -12,12 +12,14 @@ export function simulation(): FoundationSimulator<any> {
       schema: ({ slice }: ExtendSimulationSchema) => {
         let slices = {
           boop: slice.num(),
+          bapped: slice.num(),
         };
         return slices;
       },
       tasks: ({ createWebhook }) => {
-        const webhook = createWebhook("http://localhost:3050");
-        const boopTrigger = webhook.create<null>(
+        const webhook = createWebhook("http://localhost:3051");
+        // use webhook.create<TypeOfPayload> if a payload is expected
+        const boopTrigger = webhook.create(
           "/event/boop",
           function* (ctx, next) {
             console.log("firing webhook from 3050 to 3051");
@@ -29,7 +31,7 @@ export function simulation(): FoundationSimulator<any> {
             yield* next();
 
             // this allows you to inspect after the request
-            console.dir({ ctx });
+            console.log({ ctx });
           }
         );
         return { tasks: [webhook.task], actions: { webhook: { boopTrigger } } };
@@ -40,16 +42,24 @@ export function simulation(): FoundationSimulator<any> {
         console.log("received boop increment request on 3050");
         simulationStore.store.dispatch(
           simulationStore.actions.batchUpdater(
-            // @ts-expect-error TODO check on this type rror
             simulationStore.schema.boop.increment()
           )
         );
         res.status(200).json({ status: "ok" });
       });
 
+      router.post("/event/bap", (_req, res) => {
+        console.log("received bap increment request on 3050");
+        simulationStore.store.dispatch(
+          simulationStore.actions.batchUpdater(
+            simulationStore.schema.bapped.increment()
+          )
+        );
+        res.status(200).json({ status: "ok" });
+      });
+
       router.get("/external/boop", (_req, res) => {
         simulationStore.store.dispatch(
-          // @ts-expect-error TODO check on this type rror
           simulationStore.actions.webhook.boopTrigger()
         );
         res.status(200).json({ status: "ok" });
@@ -61,6 +71,13 @@ export function simulation(): FoundationSimulator<any> {
         );
         res.status(200).json({ count });
       });
+
+      router.get("/get/bap", (_req, res) => {
+        const count = simulationStore.schema.bapped.select(
+          simulationStore.store.getState()
+        );
+        res.status(200).json({ count });
+      });
     },
   })();
 }
diff --git a/packages/foundation/example/pingback/server-two.ts b/packages/foundation/example/pingback/server-two.ts
@@ -1,3 +1,4 @@
+import { put, take, takeEvery, type Action } from "starfx";
 import { createFoundationSimulationServer } from "../../src/index.ts";
 import type {
   ExtendSimulationSchema,
@@ -17,7 +18,8 @@ export function simulation(): FoundationSimulator<any> {
       },
       tasks: ({ createWebhook }) => {
         const webhook = createWebhook("http://localhost:3050");
-        const boopTrigger = webhook.create<null>(
+        // use webhook.create<TypeOfPayload> if a payload is expected
+        const boopTrigger = webhook.create(
           "/event/boop",
           function* (ctx, next) {
             console.log("firing webhook from 3051 to 3050");
@@ -28,18 +30,76 @@ export function simulation(): FoundationSimulator<any> {
             // this fires off the actual request
             yield* next();
 
-            console.dir({ ctx });
+            // this allows you to inspect after the request
+            // console.log({ ctx });
           }
         );
-        return { tasks: [webhook.task], actions: { webhook: { boopTrigger } } };
+        const bappedTrigger = webhook.create(
+          "/event/bap",
+          function* (ctx, next) {
+            console.log("firing bapped webhook from 3051 to 3050");
+            ctx.request = ctx.req({
+              body: JSON.stringify(ctx.payload),
+            });
+
+            // this fires off the actual request
+            yield* next();
+
+            // this allows you to inspect after the request
+            // console.dir({ ctx });
+          }
+        );
+        const isBoopEvent = (action: Action) =>
+          action.type === "store" &&
+          !!action?.payload?.patches.find((p: any) => p.path.includes("boop"));
+
+        // using takeEvery is one method of doing of listening for events
+        function* boopWatcherOptionOne() {
+          yield* takeEvery("store", function* (action) {
+            if (isBoopEvent(action)) {
+              // console.dir(
+              //   {
+              //     w: "one",
+              //     m: "saw a boop, triggering bap on 3050",
+              //     action,
+              //   },
+              //   { depth: null }
+              // );
+              // to avoid the double call from the two watchers
+              // skip this one
+              // yield* put(bappedTrigger());
+            }
+          });
+        }
+        // using take and your own iteration loop is another method of doing of listening for events
+        function* boopWatcherOptionTwo() {
+          while (true) {
+            const action = yield* take("*");
+            if (isBoopEvent(action)) {
+              // console.dir(
+              //   {
+              //     w: "two",
+              //     m: "saw a boop, triggering bap on 3050",
+              //     action,
+              //   },
+              //   { depth: null }
+              // );
+              yield* put(bappedTrigger());
+            }
+          }
+        }
+
+        return {
+          tasks: [webhook.task, boopWatcherOptionOne, boopWatcherOptionTwo],
+          actions: { webhook: { boopTrigger, bappedTrigger } },
+        };
       },
     },
     extendRouter(router, simulationStore) {
       router.post("/event/boop", (_req, res) => {
         console.log("received boop increment request on 3051");
         simulationStore.store.dispatch(
           simulationStore.actions.batchUpdater(
-            // @ts-expect-error TODO check on this type rror
             simulationStore.schema.boop.increment()
           )
         );
@@ -48,7 +108,6 @@ export function simulation(): FoundationSimulator<any> {
 
       router.get("/external/boop", (_req, res) => {
         simulationStore.store.dispatch(
-          // @ts-expect-error TODO check on this type rror
           simulationStore.actions.webhook.boopTrigger()
         );
         res.status(200).json({ status: "ok" });
diff --git a/packages/foundation/src/store/index.ts b/packages/foundation/src/store/index.ts
@@ -172,13 +172,13 @@ export function createSimulationStore<
   // where all the thunks get called in the middleware stack
   thunks.use(thunks.routes());
 
-  let batchUpdater = thunks.create<StoreUpdater<AnyState>[]>(
-    "update",
-    function* (ctx, next) {
-      yield* updateStore(ctx.payload);
-      yield* next();
-    }
-  );
+  let batchUpdater = thunks.create<
+    StoreUpdater<AnyState> | StoreUpdater<AnyState>[]
+  >("update", function* (ctx, next) {
+    yield* updateStore(ctx.payload);
+    yield* next();
+  });
+
   let simulationLog = thunks.create<{
     method: string;
     url: string;
diff --git a/packages/foundation/tests/webhook.test.ts b/packages/foundation/tests/webhook.test.ts
@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { simulation as simOne } from "../example/pingback/server-one.ts";
+import { simulation as simTwo } from "../example/pingback/server-two.ts";
+import type { FoundationSimulatorListening } from "../src/index.ts";
+
+const appPortOne = 3050;
+const appPortTwo = 3051;
+const host = "http://localhost";
+const urlOne = `${host}:${appPortOne}`;
+const urlTwo = `${host}:${appPortTwo}`;
+
+const f = (url: string) => fetch(url).then((r) => r.json());
+const p = (url: string) => fetch(url, { method: "POST" }).then((r) => r.json());
+
+console.log = (...args: any) => {
+  // comment out in test to reduce noise
+};
+
+describe("pingback", () => {
+  let serverOne: FoundationSimulatorListening<any>;
+  let serverTwo: FoundationSimulatorListening<any>;
+  beforeAll(async () => {
+    let appOne = simOne();
+    serverOne = await appOne.listen(appPortOne);
+    let appTwo = simTwo();
+    serverTwo = await appTwo.listen(appPortTwo);
+  });
+  afterAll(async () => {
+    await serverOne.ensureClose();
+    await serverTwo.ensureClose();
+  });
+
+  it("sim servers talk back and forth", async () => {
+    // check initial state
+    let r1 = await f(`${urlOne}/get/boop`);
+    expect(r1).toEqual({ count: 0 });
+    let r2 = await f(`${urlTwo}/get/boop`);
+    expect(r2).toEqual({ count: 0 });
+
+    // trigger direct bump on each
+    let r3 = await p(`${urlOne}/event/boop`);
+    expect(r3).toEqual({ status: "ok" });
+    let r4 = await p(`${urlTwo}/event/boop`);
+    expect(r4).toEqual({ status: "ok" });
+
+    // check they both incremented
+    let r5 = await f(`${urlOne}/get/boop`);
+    expect(r5).toEqual({ count: 1 });
+    let r6 = await f(`${urlTwo}/get/boop`);
+    expect(r6).toEqual({ count: 1 });
+
+    // check the webhook listener is gets double incremented
+    let r7 = await f(`${urlOne}/get/bap`);
+    // note that we have two watchers
+    // but only one sends the increment request
+    expect(r7).toEqual({ count: 1 });
+
+    // trigger via external endpoint on one
+    // which will webhook to the other
+    let r8 = await f(`${urlOne}/external/boop`);
+    expect(r8).toEqual({ status: "ok" });
+
+    // check the webhook pinged the other server
+    let r9 = await f(`${urlOne}/get/boop`);
+    expect(r9).toEqual({ count: 1 }); // unchanged
+    let r10 = await f(`${urlTwo}/get/boop`);
+    expect(r10).toEqual({ count: 2 });
+
+    // our watcher has updated the bapped count though
+    let r11 = await f(`${urlOne}/get/bap`);
+    expect(r11).toEqual({ count: 2 }); // ie see r9 vs r11
+  });
+});
