The best way to control Claude Code, Codex and more from any computer or phone

main
ts 151 lines 5.63 KB
Raw
1 import * as Stripe from "@alchemy.run/stripe";
2 import { isMissingStripeResource } from "@alchemy.run/stripe/missing";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import { GetWebhookEndpoint } from "@distilled.cloud/stripe/stripe";
6 import * as Provider from "alchemy/Provider";
7 import * as Effect from "effect/Effect";
8 import * as Redacted from "effect/Redacted";
9 import { MinimumLogLevel } from "effect/References";
10 import * as Schedule from "effect/Schedule";
11
12 const { test } = Test.make({ providers: Stripe.providers() });
13
14 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
15
16 const TEST_URL = "https://example.com/alchemy-stripe-webhook";
17 const UPDATED_URL = "https://example.com/alchemy-stripe-webhook/updated";
18
19 const waitUntilGone = (id: string) =>
20 GetWebhookEndpoint({ webhook_endpoint: id }).pipe(
21 Effect.as("found" as const),
22 Effect.catchIf(isMissingStripeResource, () => Effect.succeed("gone" as const)),
23 Effect.repeat({
24 schedule: Schedule.spaced("1 second"),
25 until: (status) => status === "gone",
26 times: 10,
27 }),
28 );
29
30 const expectSecret = (secret: Redacted.Redacted<string> | undefined) => {
31 expect(secret).toBeDefined();
32 expect(Redacted.isRedacted(secret)).toEqual(true);
33 expect(Redacted.value(secret!).length).toBeGreaterThan(0);
34 };
35
36 test.provider(
37 "create, update, and delete a webhook endpoint",
38 (stack) =>
39 Effect.gen(function* () {
40 yield* stack.destroy();
41
42 const created = yield* stack.deploy(
43 Effect.gen(function* () {
44 return yield* Stripe.WebhookEndpoint("ChargesWebhook", {
45 url: TEST_URL,
46 enabledEvents: ["charge.succeeded"],
47 description: "Alchemy charge webhook",
48 metadata: { purpose: "charges" },
49 });
50 }),
51 );
52
53 expect(created.id).toMatch(/^we_/);
54 expect(created.url).toEqual(TEST_URL);
55 expect(created.enabledEvents).toEqual(["charge.succeeded"]);
56 expect(created.description).toEqual("Alchemy charge webhook");
57 expect(created.status).toEqual("enabled");
58 expect(created.connect).toEqual(false);
59 expect(created.metadata).toMatchObject({ purpose: "charges" });
60 expect(created.created).toEqual(expect.any(Number));
61 expect(created.livemode).toEqual(false);
62 expectSecret(created.secret);
63
64 const fetched = yield* GetWebhookEndpoint({
65 webhook_endpoint: created.id,
66 });
67 expect(fetched.id).toEqual(created.id);
68 expect(fetched.url).toEqual(TEST_URL);
69 expect(fetched.enabled_events).toEqual(["charge.succeeded"]);
70 expect(fetched.description).toEqual("Alchemy charge webhook");
71 expect(fetched.status).toEqual("enabled");
72 expect(fetched.metadata?.purpose).toEqual("charges");
73 expect(fetched.metadata?.[Stripe.alchemyMetadataKeys.stack]).toBeDefined();
74 expect(fetched.metadata?.[Stripe.alchemyMetadataKeys.stage]).toBeDefined();
75 expect(fetched.metadata?.[Stripe.alchemyMetadataKeys.id]).toBeDefined();
76
77 const updated = yield* stack.deploy(
78 Effect.gen(function* () {
79 return yield* Stripe.WebhookEndpoint("ChargesWebhook", {
80 url: UPDATED_URL,
81 enabledEvents: ["charge.succeeded", "charge.failed"],
82 description: "Alchemy charge webhook updated",
83 disabled: true,
84 metadata: { purpose: "charges", env: "test" },
85 });
86 }),
87 );
88
89 expect(updated.id).toEqual(created.id);
90 expect(updated.url).toEqual(UPDATED_URL);
91 expect(updated.enabledEvents).toEqual(["charge.succeeded", "charge.failed"]);
92 expect(updated.description).toEqual("Alchemy charge webhook updated");
93 expect(updated.status).toEqual("disabled");
94 expect(updated.metadata).toEqual({ purpose: "charges", env: "test" });
95 expectSecret(updated.secret);
96
97 const refetched = yield* GetWebhookEndpoint({
98 webhook_endpoint: updated.id,
99 });
100 expect(refetched.url).toEqual(UPDATED_URL);
101 expect(refetched.enabled_events).toEqual(["charge.succeeded", "charge.failed"]);
102 expect(refetched.description).toEqual("Alchemy charge webhook updated");
103 expect(refetched.status).toEqual("disabled");
104 expect(refetched.metadata?.purpose).toEqual("charges");
105 expect(refetched.metadata?.env).toEqual("test");
106 expect(refetched.metadata?.[Stripe.alchemyMetadataKeys.id]).toBeDefined();
107
108 yield* stack.destroy();
109
110 const gone = yield* waitUntilGone(created.id);
111 expect(gone).toEqual("gone");
112 }).pipe(logLevel),
113 {
114 tags: ["provider:stripe", "provider:stripe:webhookendpoint", "live"],
115 timeout: 120_000,
116 },
117 );
118
119 test.provider(
120 "list enumerates the deployed webhook endpoint",
121 (stack) =>
122 Effect.gen(function* () {
123 yield* stack.destroy();
124
125 const deployed = yield* stack.deploy(
126 Effect.gen(function* () {
127 return yield* Stripe.WebhookEndpoint("ListWebhook", {
128 url: TEST_URL,
129 enabledEvents: ["charge.succeeded"],
130 metadata: { kind: "list" },
131 });
132 }),
133 );
134
135 const provider = yield* Provider.findProvider(Stripe.WebhookEndpoint);
136 const all = yield* provider.list();
137 const found = all.find((endpoint) => endpoint.id === deployed.id);
138 expect(found).toBeDefined();
139 expect(found?.url).toEqual(TEST_URL);
140 expect(found?.metadata).toMatchObject({ kind: "list" });
141
142 yield* stack.destroy();
143
144 const gone = yield* waitUntilGone(deployed.id);
145 expect(gone).toEqual("gone");
146 }).pipe(logLevel),
147 {
148 tags: ["provider:stripe", "provider:stripe:webhookendpoint", "live"],
149 timeout: 120_000,
150 },
151 );