@powerhousedao/switchboard 6.2.3-dev.30 → 6.2.3-dev.32

package/test/workflow/webhook-trigger-test.test.ts

@@ -0,0 +1,82 @@
+// Testing a the core webhook trigger over HTTP: the next real delivery to the
+// workflow's endpoint becomes the trigger's test sample, and runs nothing.
+import {
+  actions,
+  reducer,
+  utils,
+  type WorkflowDocument,
+} from "@powerhousedao/workflow/document-models/workflow";
+import type { Action } from "document-model";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import {
+  DEFAULT_WORKFLOW,
+  startWebhookHost,
+  WEBHOOK_TRIGGER,
+  type WebhookHost,
+} from "./harness.js";
+
+const CTX = { headers: {}, db: {}, user: { address: "0xabc" } } as never;
+
+let document: WorkflowDocument;
+let host: WebhookHost;
+
+function apply(...list: Action[]): void {
+  for (const action of list) document = reducer(document, action as never);
+}
+
+beforeAll(async () => {
+  document = utils.createDocument();
+  document.header.id = DEFAULT_WORKFLOW;
+  // A draft, never enabled: nothing is armed but the test's listener.
+  apply(
+    actions.setTrigger({
+      id: "t1",
+      ...WEBHOOK_TRIGGER,
+      config: { scheme: "none", responseStatus: 202 },
+    }),
+  );
+  host = await startWebhookHost({
+    reactorClient: {
+      get: () => Promise.resolve(structuredClone(document)),
+      find: () => Promise.resolve({ results: [] }),
+      execute: (_id: string, _branch: string, list: Action[]) => {
+        apply(...list);
+        return Promise.resolve(document);
+      },
+    },
+  });
+});
+
+afterAll(async () => {
+  host.service.shutdown();
+  await host.stop();
+});
+
+describe("the core webhook trigger test", () => {
+  it("saves the next delivery as the trigger's last test", async () => {
+    const endpoint = await host.service.webhookEndpoint(DEFAULT_WORKFLOW, CTX);
+    const token = endpoint!.url.slice(endpoint!.url.lastIndexOf("/") + 1);
+    // Unarmed: a delivery before the test starts is refused.
+    expect((await host.deliver(token, { body: "{}" })).status).toBe(404);
+
+    const testing = host.service.testTrigger(DEFAULT_WORKFLOW, CTX);
+    let reply: Response | undefined;
+    for (let attempt = 0; attempt < 100 && reply?.status !== 202; attempt++) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      reply = await host.deliver(token, {
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id: "evt_1" }),
+        query: { source: "provider" },
+      });
+    }
+
+    expect(reply?.status).toBe(202);
+    expect(await testing).toMatchObject({
+      method: "POST",
+      queryParams: { source: "provider" },
+      body: { id: "evt_1" },
+    });
+    expect(document.state.global.trigger?.lastTest?.runId).toBeTruthy();
+    expect(host.fired).toEqual([]);
+  });
+});

package/test/workflow/webhook-unsigned.test.ts

@@ -1,4 +1,4 @@
-// The unverified and token halves of core#webhook, over a real socket. Only
+// The unverified and token halves of the core webhook trigger, over a real socket. Only
 // the status code a provider actually receives proves these gates are wired.
 import { afterEach, describe, expect, it } from "vitest";
 import {
@@ -35,7 +35,7 @@ afterEach(async () => {
   host = undefined;
 });
 
-describe("core#webhook over HTTP: unverified", () => {
+describe("the core webhook trigger over HTTP: unverified", () => {
   it("starts one run carrying the request the provider sent", async () => {
     const webhook = await start();
     const { token } = await webhook.arm({ methods: "POST", scheme: "none" });
@@ -74,7 +74,7 @@ describe("core#webhook over HTTP: unverified", () => {
   });
 });
 
-describe("core#webhook over HTTP: method restriction", () => {
+describe("the core webhook trigger over HTTP: method restriction", () => {
   it("refuses every method the author did not allow", async () => {
     // A provider's verification round often probes with GET; the author asked
     // for POST only, so the probe must be refused rather than run anything.
@@ -123,7 +123,7 @@ describe("core#webhook over HTTP: method restriction", () => {
   });
 });
 
-describe("core#webhook over HTTP: token scheme", () => {
+describe("the core webhook trigger over HTTP: token scheme", () => {
   const tokenConfig = { scheme: "token", secretRef: SECRET_REF };
 
   it("accepts a delivery presenting the shared secret", async () => {
@@ -191,7 +191,7 @@ describe("core#webhook over HTTP: token scheme", () => {
   });
 });
 
-describe("core#webhook over HTTP: response modes", () => {
+describe("the core webhook trigger over HTTP: response modes", () => {
   it("answers async before the run has finished", async () => {
     // The point of async mode: the provider's socket is never held for as long
     // as the workflow takes, even for a run that never settles.
@@ -291,7 +291,7 @@ describe("core#webhook over HTTP: response modes", () => {
   });
 });
 
-describe("core#webhook over HTTP: endpoints that are not armed", () => {
+describe("the core webhook trigger over HTTP: endpoints that are not armed", () => {
   it("answers a disarmed endpoint exactly as an unknown one", async () => {
     // The endpoint row outlives disabling so re-enabling keeps the URL, which
     // is why the answer must not betray that the token is a real one.
@@ -311,6 +311,19 @@ describe("core#webhook over HTTP: endpoints that are not armed", () => {
     await expectNoRuns(webhook);
   });
 
+  it("revokes a deleted workflow's token and answers it as unknown", async () => {
+    const webhook = await start();
+    const { token } = await webhook.arm({ scheme: "none" });
+    expect(await webhook.hasToken(token)).toBe(true);
+    await webhook.remove();
+
+    // Revoked off the ingestion path, once the supervisor has released it.
+    await expect.poll(() => webhook.hasToken(token)).toBe(false);
+    const res = await webhook.deliver(token, { ...JSON_BODY, body: "{}" });
+    expect(res.status).toBe(404);
+    await expectNoRuns(webhook);
+  });
+
   it("refuses deliveries to an endpoint whose config does not parse", async () => {
     // A token scheme with no secretRef cannot be honoured; firing anyway would
     // run the workflow with no verification at all.

package/test/workflow-runtime.test.ts

@@ -469,4 +469,18 @@ describe("bindPackagePieces", () => {
     source.emit(new Map());
     expect(registry.entries()).toEqual([]);
   });
+
+  it("gives a piece two packages ship to the first by package name, whatever the load order", () => {
+    const registry = new PieceRegistry();
+    const source = stubSource(
+      new Map([
+        ["@zeta/pack", [entry("@acme/piece-a", "9.0.0")]],
+        ["@alpha/pack", [entry("@acme/piece-a", "1.0.0")]],
+      ]),
+    );
+
+    bindPackagePieces(registry, source);
+
+    expect(registry.versions()).toEqual({ "@acme/piece-a": "1.0.0" });
+  });
 });