rivetkit 2.0.2 → 2.0.4-rc.1

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

@@ -0,0 +1,294 @@
+import { describe, expect, test, vi } from "vitest";
+import type { ActorError } from "@/client/mod";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runActorDestroyTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor Destroy Tests", () => {
+		test("actor destroy clears state (without connect)", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = "test-destroy-without-connect";
+
+			// Get destroy observer
+			const observer = client.destroyObserver.getOrCreate(["observer"]);
+			await observer.reset();
+
+			// Create actor
+			const destroyActor = client.destroyActor.getOrCreate([actorKey]);
+
+			// Update state and save immediately
+			await destroyActor.setValue(42);
+
+			// Verify state was saved
+			const value = await destroyActor.getValue();
+			expect(value).toBe(42);
+
+			// Get actor ID before destroying
+			const actorId = await destroyActor.resolve();
+
+			// Destroy the actor
+			await destroyActor.destroy();
+
+			// Wait until the observer confirms the actor was destroyed
+			await vi.waitFor(async () => {
+				const wasDestroyed = await observer.wasDestroyed(actorKey);
+				expect(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+			});
+
+			// Wait until the actor is fully cleaned up (getForId returns error)
+			await vi.waitFor(async () => {
+				let actorRunning = false;
+				try {
+					await client.destroyActor.getForId(actorId).getValue();
+					actorRunning = true;
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
+				}
+
+				expect(actorRunning, "actor still running").toBeFalsy();
+			});
+
+			// Verify actor no longer exists via getForId
+			let existsById = false;
+			try {
+				await client.destroyActor.getForId(actorId).getValue();
+				existsById = true;
+			} catch (err) {
+				expect((err as ActorError).group).toBe("actor");
+				expect((err as ActorError).code).toBe("not_found");
+			}
+			expect(
+				existsById,
+				"actor should not exist after destroy",
+			).toBeFalsy();
+
+			// Verify actor no longer exists via get
+			let existsByKey = false;
+			try {
+				await client.destroyActor
+					.get(["test-destroy-without-connect"])
+					.resolve();
+				existsByKey = true;
+			} catch (err) {
+				expect((err as ActorError).group).toBe("actor");
+				expect((err as ActorError).code).toBe("not_found");
+			}
+			expect(
+				existsByKey,
+				"actor should not exist after destroy",
+			).toBeFalsy();
+
+			// Create new actor with same key using getOrCreate
+			const newActor = client.destroyActor.getOrCreate([
+				"test-destroy-without-connect",
+			]);
+
+			// Verify state is fresh (default value, not the old value)
+			const newValue = await newActor.getValue();
+			expect(newValue).toBe(0);
+		});
+
+		test("actor destroy clears state (with connect)", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = "test-destroy-with-connect";
+
+			// Get destroy observer
+			const observer = client.destroyObserver.getOrCreate(["observer"]);
+			await observer.reset();
+
+			// Create actor handle
+			const destroyActorHandle = client.destroyActor.getOrCreate([
+				actorKey,
+			]);
+
+			// Get actor ID before destroying
+			const actorId = await destroyActorHandle.resolve();
+
+			// Create persistent connection
+			const destroyActor = destroyActorHandle.connect();
+
+			// Update state and save immediately
+			await destroyActor.setValue(99);
+
+			// Verify state was saved
+			const value = await destroyActor.getValue();
+			expect(value).toBe(99);
+
+			// Destroy the actor
+			await destroyActor.destroy();
+
+			// Dispose the connection
+			await destroyActor.dispose();
+
+			// Wait until the observer confirms the actor was destroyed
+			await vi.waitFor(async () => {
+				const wasDestroyed = await observer.wasDestroyed(actorKey);
+				expect(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+			});
+
+			// Wait until the actor is fully cleaned up (getForId returns error)
+			await vi.waitFor(async () => {
+				let actorRunning = false;
+				try {
+					await client.destroyActor.getForId(actorId).getValue();
+					actorRunning = true;
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
+				}
+
+				expect(actorRunning, "actor still running").toBeFalsy();
+			});
+
+			// Verify actor no longer exists via getForId
+			let existsById = false;
+			try {
+				await client.destroyActor.getForId(actorId).getValue();
+				existsById = true;
+			} catch (err) {
+				expect((err as ActorError).group).toBe("actor");
+				expect((err as ActorError).code).toBe("not_found");
+			}
+			expect(
+				existsById,
+				"actor should not exist after destroy",
+			).toBeFalsy();
+
+			// Verify actor no longer exists via get
+			let existsByKey = false;
+			try {
+				await client.destroyActor
+					.get(["test-destroy-with-connect"])
+					.resolve();
+				existsByKey = true;
+			} catch (err) {
+				expect((err as ActorError).group).toBe("actor");
+				expect((err as ActorError).code).toBe("not_found");
+			}
+			expect(
+				existsByKey,
+				"actor should not exist after destroy",
+			).toBeFalsy();
+
+			// Create new actor with same key using getOrCreate
+			const newActor = client.destroyActor.getOrCreate([
+				"test-destroy-with-connect",
+			]);
+
+			// Verify state is fresh (default value, not the old value)
+			const newValue = await newActor.getValue();
+			expect(newValue).toBe(0);
+		});
+
+		test("actor destroy allows recreation via getOrCreate with resolve", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = "test-destroy-getorcreate-resolve";
+
+			// Get destroy observer
+			const observer = client.destroyObserver.getOrCreate(["observer"]);
+			await observer.reset();
+
+			// Create actor
+			const destroyActor = client.destroyActor.getOrCreate([actorKey]);
+
+			// Update state and save immediately
+			await destroyActor.setValue(123);
+
+			// Verify state was saved
+			const value = await destroyActor.getValue();
+			expect(value).toBe(123);
+
+			// Get actor ID before destroying
+			const actorId = await destroyActor.resolve();
+
+			// Destroy the actor
+			await destroyActor.destroy();
+
+			// Wait until the observer confirms the actor was destroyed
+			await vi.waitFor(async () => {
+				const wasDestroyed = await observer.wasDestroyed(actorKey);
+				expect(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+			});
+
+			// Wait until the actor is fully cleaned up
+			await vi.waitFor(async () => {
+				let actorRunning = false;
+				try {
+					await client.destroyActor.getForId(actorId).getValue();
+					actorRunning = true;
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
+				}
+
+				expect(actorRunning, "actor still running").toBeFalsy();
+			});
+
+			// Recreate using getOrCreate with resolve
+			const newHandle = client.destroyActor.getOrCreate([actorKey]);
+			const newActorId = await newHandle.resolve();
+
+			// Verify state is fresh (default value, not the old value)
+			const newValue = await newHandle.getValue();
+			expect(newValue).toBe(0);
+		});
+
+		test("actor destroy allows recreation via create", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = "test-destroy-create";
+
+			// Get destroy observer
+			const observer = client.destroyObserver.getOrCreate(["observer"]);
+			await observer.reset();
+
+			// Create actor using create()
+			const initialHandle = await client.destroyActor.create([actorKey]);
+
+			// Update state and save immediately
+			await initialHandle.setValue(456);
+
+			// Verify state was saved
+			const value = await initialHandle.getValue();
+			expect(value).toBe(456);
+
+			// Get actor ID before destroying
+			const actorId = await initialHandle.resolve();
+
+			// Destroy the actor
+			await initialHandle.destroy();
+
+			// Wait until the observer confirms the actor was destroyed
+			await vi.waitFor(async () => {
+				const wasDestroyed = await observer.wasDestroyed(actorKey);
+				expect(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+			});
+
+			// Wait until the actor is fully cleaned up
+			await vi.waitFor(async () => {
+				let actorRunning = false;
+				try {
+					await client.destroyActor.getForId(actorId).getValue();
+					actorRunning = true;
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
+				}
+
+				expect(actorRunning, "actor still running").toBeFalsy();
+			});
+
+			// Recreate using create()
+			const newHandle = await client.destroyActor.create([actorKey]);
+			const newActorId = await newHandle.resolve();
+
+			// Verify state is fresh (default value, not the old value)
+			const newValue = await newHandle.getValue();
+			expect(newValue).toBe(0);
+		});
+	});
+}

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

@@ -0,0 +1,18 @@
+import { describe } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { runActorScheduleTests } from "./actor-schedule";
+import { runActorSleepTests } from "./actor-sleep";
+import { runActorStateTests } from "./actor-state";
+
+export function runActorDriverTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor Driver Tests", () => {
+		// Run state persistence tests
+		runActorStateTests(driverTestConfig);
+
+		// Run scheduled alarms tests
+		runActorScheduleTests(driverTestConfig);
+
+		// Run actor sleep tests
+		runActorSleepTests(driverTestConfig);
+	});
+}

package/src/driver-test-suite/tests/actor-error-handling.ts

@@ -0,0 +1,150 @@
+import { describe, expect, test } from "vitest";
+import {
+	INTERNAL_ERROR_CODE,
+	INTERNAL_ERROR_DESCRIPTION,
+} from "@/actor/errors";
+import { assertUnreachable } from "@/actor/utils";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runActorErrorHandlingTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor Error Handling Tests", () => {
+		describe("UserError Handling", () => {
+			test("should handle simple UserError with message", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Try to call an action that throws a simple UserError
+				const handle = client.errorHandlingActor.getOrCreate();
+
+				try {
+					await handle.throwSimpleError();
+					// If we get here, the test should fail
+					expect(true).toBe(false); // This should not be reached
+				} catch (error: any) {
+					// Verify the error properties
+					expect(error.message).toBe("Simple error message");
+					// Default code is "user_error" when not specified
+					expect(error.code).toBe("user_error");
+					// No metadata by default
+					expect(error.metadata).toBeUndefined();
+				}
+			});
+
+			test("should handle detailed UserError with code and metadata", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Try to call an action that throws a detailed UserError
+				const handle = client.errorHandlingActor.getOrCreate();
+
+				try {
+					await handle.throwDetailedError();
+					// If we get here, the test should fail
+					expect(true).toBe(false); // This should not be reached
+				} catch (error: any) {
+					// Verify the error properties
+					expect(error.message).toBe("Detailed error message");
+					expect(error.code).toBe("detailed_error");
+					expect(error.metadata).toBeDefined();
+					expect(error.metadata.reason).toBe("test");
+					expect(error.metadata.timestamp).toBeDefined();
+				}
+			});
+		});
+
+		describe("Internal Error Handling", () => {
+			test("should convert internal errors to safe format", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Try to call an action that throws an internal error
+				const handle = client.errorHandlingActor.getOrCreate();
+
+				try {
+					await handle.throwInternalError();
+					// If we get here, the test should fail
+					expect(true).toBe(false); // This should not be reached
+				} catch (error: any) {
+					// Verify the error is converted to a safe format
+					expect(error.code).toBe(INTERNAL_ERROR_CODE);
+					// Original error details should not be exposed
+					expect(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
+				}
+			});
+		});
+
+		// TODO: Does not work with fake timers
+		describe.skip("Action Timeout", () => {
+			test("should handle action timeouts with custom duration", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Call an action that should time out
+				const handle = client.errorHandlingActor.getOrCreate();
+
+				// This should throw a timeout error because errorHandlingActor has
+				// a 500ms timeout and this action tries to run for much longer
+				const timeoutPromise = handle.timeoutAction();
+
+				try {
+					await timeoutPromise;
+					// If we get here, the test failed - timeout didn't occur
+					expect(true).toBe(false); // This should not be reached
+				} catch (error: any) {
+					// Verify it's a timeout error
+					expect(error.message).toMatch(/timed out/i);
+				}
+			});
+
+			test("should successfully run actions within timeout", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Call an action with a delay shorter than the timeout
+				const handle = client.errorHandlingActor.getOrCreate();
+
+				// This should succeed because 200ms < 500ms timeout
+				const result = await handle.delayedAction(200);
+				expect(result).toBe("Completed after 200ms");
+			});
+
+			test("should respect different timeouts for different actors", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// The following actors have different timeout settings:
+				// customTimeoutActor: 200ms timeout
+				// standardTimeoutActor: default timeout (much longer)
+
+				// This should fail - 300ms delay with 200ms timeout
+				try {
+					await client.customTimeoutActor.getOrCreate().slowAction();
+					// Should not reach here
+					expect(true).toBe(false);
+				} catch (error: any) {
+					expect(error.message).toMatch(/timed out/i);
+				}
+
+				// This should succeed - 50ms delay with 200ms timeout
+				const quickResult = await client.customTimeoutActor
+					.getOrCreate()
+					.quickAction();
+				expect(quickResult).toBe("Quick action completed");
+			});
+		});
+
+		describe("Error Recovery", () => {
+			test("should continue working after errors", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				const handle = client.errorHandlingActor.getOrCreate();
+
+				// Trigger an error
+				try {
+					await handle.throwSimpleError();
+				} catch (error) {
+					// Ignore error
+				}
+
+				// Actor should still work after error
+				const result = await handle.successfulAction();
+				expect(result).toBe("success");
+			});
+		});
+	});
+}