rivetkit 2.0.2 → 2.0.4-rc.1

package/src/driver-test-suite/tests/actor-inspector.ts

@@ -0,0 +1,264 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor Inspector HTTP API", () => {
+		test("GET /inspector/state returns actor state", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate(["inspector-state"]);
+
+			// Set some state first
+			await handle.increment(5);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(`${gatewayUrl}/inspector/state`, {
+				headers: { Authorization: "Bearer token" },
+			});
+			expect(response.status).toBe(200);
+			const data = await response.json();
+			expect(data).toEqual({ state: { count: 5 } });
+		});
+
+		test("PATCH /inspector/state updates actor state", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate([
+				"inspector-set-state",
+			]);
+
+			await handle.increment(5);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+
+			// Replace state
+			const patchResponse = await fetch(
+				`${gatewayUrl}/inspector/state`,
+				{
+					method: "PATCH",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: "Bearer token",
+					},
+					body: JSON.stringify({ state: { count: 42 } }),
+				},
+			);
+			expect(patchResponse.status).toBe(200);
+			const patchData = await patchResponse.json();
+			expect(patchData).toEqual({ ok: true });
+
+			// Verify via action
+			const count = await handle.getCount();
+			expect(count).toBe(42);
+		});
+
+		test("GET /inspector/connections returns connections list", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate([
+				"inspector-connections",
+			]);
+
+			// Ensure actor exists
+			await handle.increment(0);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(
+				`${gatewayUrl}/inspector/connections`,
+				{
+					headers: { Authorization: "Bearer token" },
+				},
+			);
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as {
+				connections: unknown[];
+			};
+			expect(data).toHaveProperty("connections");
+			expect(Array.isArray(data.connections)).toBe(true);
+		});
+
+		test("GET /inspector/rpcs returns available actions", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate(["inspector-rpcs"]);
+
+			// Ensure actor exists
+			await handle.increment(0);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(`${gatewayUrl}/inspector/rpcs`, {
+				headers: { Authorization: "Bearer token" },
+			});
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as { rpcs: string[] };
+			expect(data).toHaveProperty("rpcs");
+			expect(data.rpcs).toContain("increment");
+			expect(data.rpcs).toContain("getCount");
+			expect(data.rpcs).toContain("setCount");
+		});
+
+		test("POST /inspector/action/:name executes an action", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate([
+				"inspector-action",
+			]);
+
+			await handle.increment(10);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(
+				`${gatewayUrl}/inspector/action/increment`,
+				{
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: "Bearer token",
+					},
+					body: JSON.stringify({ args: [5] }),
+				},
+			);
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as { output: number };
+			expect(data.output).toBe(15);
+
+			// Verify via normal action
+			const count = await handle.getCount();
+			expect(count).toBe(15);
+		});
+
+		test("GET /inspector/queue returns queue status", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate(["inspector-queue"]);
+
+			// Ensure actor exists
+			await handle.increment(0);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(
+				`${gatewayUrl}/inspector/queue?limit=10`,
+				{
+					headers: { Authorization: "Bearer token" },
+				},
+			);
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as {
+				size: number;
+				maxSize: number;
+				truncated: boolean;
+				messages: unknown[];
+			};
+			expect(data).toHaveProperty("size");
+			expect(data).toHaveProperty("maxSize");
+			expect(data).toHaveProperty("truncated");
+			expect(data).toHaveProperty("messages");
+			expect(typeof data.size).toBe("number");
+			expect(typeof data.maxSize).toBe("number");
+			expect(typeof data.truncated).toBe("boolean");
+			expect(Array.isArray(data.messages)).toBe(true);
+		});
+
+		test("GET /inspector/traces returns trace data", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate([
+				"inspector-traces",
+			]);
+
+			// Perform an action to generate traces
+			await handle.increment(1);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(
+				`${gatewayUrl}/inspector/traces?startMs=0&endMs=${Date.now() + 60000}&limit=100`,
+				{
+					headers: { Authorization: "Bearer token" },
+				},
+			);
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as {
+				otlp: unknown;
+				clamped: boolean;
+			};
+			expect(data).toHaveProperty("otlp");
+			expect(data).toHaveProperty("clamped");
+			expect(typeof data.clamped).toBe("boolean");
+		});
+
+		test("GET /inspector/workflow-history returns workflow status", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate([
+				"inspector-workflow",
+			]);
+
+			// Ensure actor exists
+			await handle.increment(0);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(
+				`${gatewayUrl}/inspector/workflow-history`,
+				{
+					headers: { Authorization: "Bearer token" },
+				},
+			);
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as {
+				history: unknown;
+				isWorkflowEnabled: boolean;
+			};
+			expect(data).toHaveProperty("history");
+			expect(data).toHaveProperty("isWorkflowEnabled");
+			// Counter actor has no workflow, so it should be disabled
+			expect(data.isWorkflowEnabled).toBe(false);
+			expect(data.history).toBeNull();
+		});
+
+		test("GET /inspector/summary returns full actor snapshot", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate([
+				"inspector-summary",
+			]);
+
+			await handle.increment(7);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+			const response = await fetch(
+				`${gatewayUrl}/inspector/summary`,
+				{
+					headers: { Authorization: "Bearer token" },
+				},
+			);
+			expect(response.status).toBe(200);
+			const data = (await response.json()) as {
+				state: { count: number };
+				connections: unknown[];
+				rpcs: string[];
+				queueSize: number;
+				isStateEnabled: boolean;
+				isDatabaseEnabled: boolean;
+				isWorkflowEnabled: boolean;
+				workflowHistory: unknown;
+			};
+			expect(data.state).toEqual({ count: 7 });
+			expect(Array.isArray(data.connections)).toBe(true);
+			expect(data.rpcs).toContain("increment");
+			expect(typeof data.queueSize).toBe("number");
+			expect(data.isStateEnabled).toBe(true);
+			expect(typeof data.isDatabaseEnabled).toBe("boolean");
+			expect(data.isWorkflowEnabled).toBe(false);
+			expect(data.workflowHistory).toBeNull();
+		});
+
+		test("inspector endpoints require auth in non-dev mode", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const handle = client.counter.getOrCreate([
+				"inspector-auth",
+			]);
+
+			await handle.increment(0);
+
+			const gatewayUrl = await handle.getGatewayUrl();
+
+			// Request with wrong token should fail
+			const response = await fetch(`${gatewayUrl}/inspector/state`, {
+				headers: { Authorization: "Bearer wrong-token" },
+			});
+			expect(response.status).toBe(401);
+		});
+	});
+}

package/src/driver-test-suite/tests/actor-kv.ts

@@ -0,0 +1,65 @@
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+import { describe, expect, test, type TestContext } from "vitest";
+
+export function runActorKvTests(driverTestConfig: DriverTestConfig) {
+	type KvTextHandle = {
+		putText: (key: string, value: string) => Promise<unknown>;
+		getText: (key: string) => Promise<string | null>;
+		listText: (prefix: string) => Promise<Array<{ key: string; value: string }>>;
+	};
+
+	type KvArrayBufferHandle = {
+		roundtripArrayBuffer: (key: string, bytes: number[]) => Promise<number[]>;
+	};
+
+		describe("Actor KV Tests", () => {
+			test("supports text encoding and decoding", async (c: TestContext) => {
+				const { client: rawClient } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
+				const client = rawClient as any;
+				const kvHandle =
+					client.kvActor.getOrCreate(["kv-text"]) as unknown as KvTextHandle;
+
+			await kvHandle.putText("greeting", "hello");
+			const value = await kvHandle.getText("greeting");
+			expect(value).toBe("hello");
+
+			await kvHandle.putText("prefix-a", "alpha");
+			await kvHandle.putText("prefix-b", "beta");
+
+			const results = await kvHandle.listText("prefix-");
+			const sorted = results.sort((a, b) => a.key.localeCompare(b.key));
+			expect(sorted).toEqual([
+				{ key: "prefix-a", value: "alpha" },
+				{ key: "prefix-b", value: "beta" },
+			]);
+		});
+
+		test(
+			"supports arrayBuffer encoding and decoding",
+			async (c: TestContext) => {
+				const { client: rawClient } = await setupDriverTest(
+					c,
+					driverTestConfig,
+				);
+				const client = rawClient as any;
+				const kvHandle = client.kvActor.getOrCreate([
+					"kv-array-buffer",
+				]) as unknown as KvArrayBufferHandle;
+
+				const values = await kvHandle.roundtripArrayBuffer("bytes", [
+					4,
+					8,
+					15,
+					16,
+					23,
+					42,
+				]);
+				expect(values).toEqual([4, 8, 15, 16, 23, 42]);
+			},
+			);
+		});
+	}

package/src/driver-test-suite/tests/actor-metadata.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runActorMetadataTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor Metadata Tests", () => {
+		describe("Actor Name", () => {
+			test("should provide access to actor name", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Get the actor name
+				const handle = client.metadataActor.getOrCreate();
+				const actorName = await handle.getActorName();
+
+				// Verify it matches the expected name
+				expect(actorName).toBe("metadataActor");
+			});
+
+			test("should preserve actor name in state during onWake", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Get the stored actor name
+				const handle = client.metadataActor.getOrCreate();
+				const storedName = await handle.getStoredActorName();
+
+				// Verify it was stored correctly
+				expect(storedName).toBe("metadataActor");
+			});
+		});
+
+		describe("Actor Tags", () => {
+			test("should provide access to tags", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create actor and set up test tags
+				const handle = client.metadataActor.getOrCreate();
+				await handle.setupTestTags({
+					env: "test",
+					purpose: "metadata-test",
+				});
+
+				// Get the tags
+				const tags = await handle.getTags();
+
+				// Verify the tags are accessible
+				expect(tags).toHaveProperty("env");
+				expect(tags.env).toBe("test");
+				expect(tags).toHaveProperty("purpose");
+				expect(tags.purpose).toBe("metadata-test");
+			});
+
+			test("should allow accessing individual tags", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create actor and set up test tags
+				const handle = client.metadataActor.getOrCreate();
+				await handle.setupTestTags({
+					category: "test-actor",
+					version: "1.0",
+				});
+
+				// Get individual tags
+				const category = await handle.getTag("category");
+				const version = await handle.getTag("version");
+				const nonexistent = await handle.getTag("nonexistent");
+
+				// Verify the tag values
+				expect(category).toBe("test-actor");
+				expect(version).toBe("1.0");
+				expect(nonexistent).toBeNull();
+			});
+		});
+
+		describe("Metadata Structure", () => {
+			test("should provide complete metadata object", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create actor and set up test metadata
+				const handle = client.metadataActor.getOrCreate();
+				await handle.setupTestTags({ type: "metadata-test" });
+				await handle.setupTestRegion("us-west-1");
+
+				// Get all metadata
+				const metadata = await handle.getMetadata();
+
+				// Verify structure of metadata
+				expect(metadata).toHaveProperty("name");
+				expect(metadata.name).toBe("metadataActor");
+
+				expect(metadata).toHaveProperty("tags");
+				expect(metadata.tags).toHaveProperty("type");
+				expect(metadata.tags.type).toBe("metadata-test");
+
+				// Region should be set to our test value
+				expect(metadata).toHaveProperty("region");
+				expect(metadata.region).toBe("us-west-1");
+			});
+		});
+
+		describe("Region Information", () => {
+			test("should retrieve region information", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create actor and set up test region
+				const handle = client.metadataActor.getOrCreate();
+				await handle.setupTestRegion("eu-central-1");
+
+				// Get the region
+				const region = await handle.getRegion();
+
+				// Verify the region is set correctly
+				expect(region).toBe("eu-central-1");
+			});
+		});
+	});
+}

package/src/driver-test-suite/tests/actor-onstatechange.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "@/driver-test-suite/mod";
+import { setupDriverTest } from "@/driver-test-suite/utils";
+
+export function runActorOnStateChangeTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor onStateChange Tests", () => {
+		test("triggers onStateChange when state is modified", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actor = client.onStateChangeActor.getOrCreate();
+
+			// Modify state - should trigger onChange
+			await actor.setValue(10);
+
+			// Check that onChange was called
+			const changeCount = await actor.getChangeCount();
+			expect(changeCount).toBe(1);
+		});
+
+		test("triggers onChange multiple times for multiple state changes", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actor = client.onStateChangeActor.getOrCreate();
+
+			// Modify state multiple times
+			await actor.incrementMultiple(3);
+
+			// Check that onChange was called for each modification
+			const changeCount = await actor.getChangeCount();
+			expect(changeCount).toBe(3);
+		});
+
+		test("does NOT trigger onChange for read-only actions", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actor = client.onStateChangeActor.getOrCreate();
+
+			// Set initial value
+			await actor.setValue(5);
+
+			// Read value without modifying - should NOT trigger onChange
+			const value = await actor.getValue();
+			expect(value).toBe(5);
+
+			// Check that onChange was NOT called
+			const changeCount = await actor.getChangeCount();
+			expect(changeCount).toBe(1);
+		});
+
+		test("does NOT trigger onChange for computed values", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actor = client.onStateChangeActor.getOrCreate();
+
+			// Set initial value
+			await actor.setValue(3);
+
+			// Check that onChange was called
+			{
+				const changeCount = await actor.getChangeCount();
+				expect(changeCount).toBe(1);
+			}
+
+			// Compute value without modifying state - should NOT trigger onChange
+			const doubled = await actor.getDoubled();
+			expect(doubled).toBe(6);
+
+			// Check that onChange was NOT called
+			{
+				const changeCount = await actor.getChangeCount();
+				expect(changeCount).toBe(1);
+			}
+		});
+
+		test("simple: connect, call action, dispose does NOT trigger onChange", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actor = client.onStateChangeActor.getOrCreate();
+
+			// Connect to the actor
+			const connection = await actor.connect();
+
+			// Call an action that doesn't modify state
+			const value = await connection.getValue();
+			expect(value).toBe(0);
+
+			// Dispose the connection
+			await connection.dispose();
+
+			// Verify that onChange was NOT triggered
+			const changeCount = await actor.getChangeCount();
+			expect(changeCount).toBe(0);
+		});
+	});
+}