rivetkit 2.0.42 → 2.1.0-rc.1

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

@@ -1,363 +1,264 @@
-import { describe } from "vitest";
+import { describe, expect, test } from "vitest";
 import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
 
 export function runActorInspectorTests(driverTestConfig: DriverTestConfig) {
-	// TODO: Add back
-	describe.skip("Actor Inspector Tests", () => {
-		// describe("Actor Inspector", () => {
-		// 	test("should handle actor not found", async (c) => {
-		// 		const { endpoint } = await setupDriverTest(c, driverTestConfig);
-		// 		const actorId = "non-existing";
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		const response = await http.ping.$get();
-		// 		expect(response.ok).toBe(false);
-		// 	});
-		// 	test("should respond to ping", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create(["test-ping"]);
-		// 		const actorId = await handle.resolve();
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		const response = await http.ping.$get();
-		// 		expect(response.status).toBe(200);
-		// 		const data = await response.json();
-		// 		expect(data).toEqual({ message: "pong" });
-		// 	});
-		// 	test("should get actor state", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create(["test-state"]);
-		// 		const actorId = await handle.resolve();
-		// 		// Increment the counter to set some state
-		// 		await handle.increment(5);
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		const response = await http.state.$get();
-		// 		expect(response.status).toBe(200);
-		// 		const data = await response.json();
-		// 		expect(data).toEqual({
-		// 			enabled: true,
-		// 			state: expect.objectContaining({
-		// 				count: 5,
-		// 			}),
-		// 		});
-		// 	});
-		// 	test("should update actor state with replace", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create([
-		// 			"test-state-replace",
-		// 		]);
-		// 		const actorId = await handle.resolve();
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		// Replace the entire state
-		// 		const response = await http.state.$patch({
-		// 			json: {
-		// 				replace: { count: 10 },
-		// 			},
-		// 		});
-		// 		expect(response.status).toBe(200);
-		// 		const data = await response.json();
-		// 		expect(data).toEqual({
-		// 			enabled: true,
-		// 			state: { count: 10 },
-		// 		});
-		// 	});
-		// 	test("should update actor state with patch", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create([
-		// 			"test-state-patch",
-		// 		]);
-		// 		const actorId = await handle.resolve();
-		// 		// Set initial state
-		// 		await handle.increment(3);
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		// Patch the state
-		// 		const response = await http.state.$patch({
-		// 			json: {
-		// 				patch: [
-		// 					{
-		// 						op: "replace",
-		// 						path: "/count",
-		// 						value: 7,
-		// 					},
-		// 				],
-		// 			},
-		// 		});
-		// 		expect(response.status).toBe(200);
-		// 		const data = await response.json();
-		// 		expect(data).toEqual({
-		// 			enabled: true,
-		// 			state: expect.objectContaining({
-		// 				count: 7,
-		// 			}),
-		// 		});
-		// 	});
-		// 	test("should get actor connections", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create([
-		// 			"test-connections",
-		// 		]);
-		// 		const actorId = await handle.resolve();
-		// 		handle.connect();
-		// 		await handle.increment(10);
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		const response = await http.connections.$get();
-		// 		expect(response.status).toBe(200);
-		// 		const data = await response.json();
-		// 		expect(data.connections).toEqual(
-		// 			expect.arrayContaining([
-		// 				expect.objectContaining({
-		// 					id: expect.any(String),
-		// 				}),
-		// 			]),
-		// 		);
-		// 	});
-		// 	test("should get actor events", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create(["test-events"]);
-		// 		const actorId = await handle.resolve();
-		// 		handle.connect();
-		// 		await handle.increment(10);
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		const response = await http.events.$get();
-		// 		expect(response.status).toBe(200);
-		// 		const data = await response.json();
-		// 		expect(data.events).toEqual(
-		// 			expect.arrayContaining([
-		// 				expect.objectContaining({
-		// 					type: "broadcast",
-		// 					id: expect.any(String),
-		// 				}),
-		// 			]),
-		// 		);
-		// 	});
-		// 	test("should clear actor events", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create([
-		// 			"test-events-clear",
-		// 		]);
-		// 		const actorId = await handle.resolve();
-		// 		handle.connect();
-		// 		await handle.increment(10);
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		{
-		// 			const response = await http.events.$get();
-		// 			expect(response.status).toBe(200);
-		// 			const data = await response.json();
-		// 			expect(data.events).toEqual(
-		// 				expect.arrayContaining([
-		// 					expect.objectContaining({
-		// 						type: "broadcast",
-		// 						id: expect.any(String),
-		// 					}),
-		// 				]),
-		// 			);
-		// 		}
-		// 		const response = await http.events.clear.$post();
-		// 		expect(response.status).toBe(200);
-		// 	});
-		// 	test("should get actor rpcs", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create(["test-rpcs"]);
-		// 		const actorId = await handle.resolve();
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		const response = await http.rpcs.$get();
-		// 		expect(response.status).toBe(200);
-		// 		const data = await response.json();
-		// 		expect(data).toEqual(
-		// 			expect.objectContaining({
-		// 				rpcs: expect.arrayContaining(["increment", "getCount"]),
-		// 			}),
-		// 		);
-		// 	});
-		// 	// database is not officially supported yet
-		// 	test.skip("should get actor database info", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create(["test-db"]);
-		// 		const actorId = await handle.resolve();
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		const response = await http.db.$get();
-		// 		expect(response.status).toBe(200);
-		// 		const data = await response.json();
-		// 		// Database might be enabled or disabled depending on actor configuration
-		// 		expect(data).toHaveProperty("enabled");
-		// 		expect(typeof data.enabled).toBe("boolean");
-		// 		if (data.enabled) {
-		// 			expect(data).toHaveProperty("db");
-		// 			expect(Array.isArray(data.db)).toBe(true);
-		// 		} else {
-		// 			expect(data.db).toBe(null);
-		// 		}
-		// 	});
-		// 	test.skip("should execute database query when database is enabled", async (c) => {
-		// 		const { client, endpoint } = await setupDriverTest(
-		// 			c,
-		// 			driverTestConfig,
-		// 		);
-		// 		const handle = await client.counter.create(["test-db-query"]);
-		// 		const actorId = await handle.resolve();
-		// 		const http = createActorInspectorClient(
-		// 			`${endpoint}/actors/inspect`,
-		// 			{
-		// 				headers: {
-		// 					Authorization: `Bearer token`,
-		// 					[HEADER_ACTOR_QUERY]: JSON.stringify({
-		// 						getForId: { name: "counter", actorId },
-		// 					} satisfies ActorQuery),
-		// 				},
-		// 			},
-		// 		);
-		// 		// First check if database is enabled
-		// 		const dbInfoResponse = await http.db.$get();
-		// 		const dbInfo = await dbInfoResponse.json();
-		// 		if (dbInfo.enabled) {
-		// 			// Execute a simple query
-		// 			const queryResponse = await http.db.$post({
-		// 				json: {
-		// 					query: "SELECT 1 as test",
-		// 					params: [],
-		// 				},
-		// 			});
-		// 			expect(queryResponse.status).toBe(200);
-		// 			const queryData = await queryResponse.json();
-		// 			expect(queryData).toHaveProperty("result");
-		// 		} else {
-		// 			// If database is not enabled, the POST should return enabled: false
-		// 			const queryResponse = await http.db.$post({
-		// 				json: {
-		// 					query: "SELECT 1 as test",
-		// 					params: [],
-		// 				},
-		// 			});
-		// 			expect(queryResponse.status).toBe(200);
-		// 			const queryData = await queryResponse.json();
-		// 			expect(queryData).toEqual({ enabled: false });
-		// 		}
-		// 	});
-		// });
+	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);
+		});
 	});
 }