rivetkit 2.0.2 → 2.0.4

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);
+		});
+	});
+}

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

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest, waitFor } from "../utils";
+
+export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
+	describe.skipIf(driverTestConfig.skip?.schedule)(
+		"Actor Schedule Tests",
+		() => {
+			describe("Scheduled Alarms", () => {
+				test("executes c.schedule.at() with specific timestamp", async (c) => {
+					const { client } = await setupDriverTest(c, driverTestConfig);
+
+					// Create instance
+					const scheduled = client.scheduled.getOrCreate();
+
+					// Schedule a task to run in 100ms using timestamp
+					const timestamp = Date.now() + 100;
+					await scheduled.scheduleTaskAt(timestamp);
+
+					// Wait for longer than the scheduled time
+					await waitFor(driverTestConfig, 200);
+
+					// Verify the scheduled task ran
+					const lastRun = await scheduled.getLastRun();
+					const scheduledCount = await scheduled.getScheduledCount();
+
+					expect(lastRun).toBeGreaterThan(0);
+					expect(scheduledCount).toBe(1);
+				});
+
+				test("executes c.schedule.after() with delay", async (c) => {
+					const { client } = await setupDriverTest(c, driverTestConfig);
+
+					// Create instance
+					const scheduled = client.scheduled.getOrCreate();
+
+					// Schedule a task to run in 100ms using delay
+					await scheduled.scheduleTaskAfter(100);
+
+					// Wait for longer than the scheduled time
+					await waitFor(driverTestConfig, 200);
+
+					// Verify the scheduled task ran
+					const lastRun = await scheduled.getLastRun();
+					const scheduledCount = await scheduled.getScheduledCount();
+
+					expect(lastRun).toBeGreaterThan(0);
+					expect(scheduledCount).toBe(1);
+				});
+
+				test("scheduled tasks persist across actor restarts", async (c) => {
+					const { client } = await setupDriverTest(c, driverTestConfig);
+
+					// Create instance and schedule
+					const scheduled = client.scheduled.getOrCreate();
+					await scheduled.scheduleTaskAfter(200);
+
+					// Wait a little so the schedule is stored but hasn't triggered yet
+					await waitFor(driverTestConfig, 100);
+
+					// Get a new reference to simulate actor restart
+					const newInstance = client.scheduled.getOrCreate();
+
+					// Verify the schedule still exists but hasn't run yet
+					const initialCount = await newInstance.getScheduledCount();
+					expect(initialCount).toBe(0);
+
+					// Wait for the scheduled task to execute
+					await waitFor(driverTestConfig, 200);
+
+					// Verify the scheduled task ran after "restart"
+					const scheduledCount = await newInstance.getScheduledCount();
+					expect(scheduledCount).toBe(1);
+				});
+
+				test("multiple scheduled tasks execute in order", async (c) => {
+					const { client } = await setupDriverTest(c, driverTestConfig);
+
+					// Create instance
+					const scheduled = client.scheduled.getOrCreate();
+
+					// Reset history to start fresh
+					await scheduled.clearHistory();
+
+					// Schedule multiple tasks with different delays
+					await scheduled.scheduleTaskAfterWithId("first", 100);
+					await scheduled.scheduleTaskAfterWithId("second", 300);
+					await scheduled.scheduleTaskAfterWithId("third", 500);
+
+					// Wait for first task only
+					await waitFor(driverTestConfig, 200);
+					const history1 = await scheduled.getTaskHistory();
+					expect(history1).toEqual(["first"]);
+
+					// Wait for second task
+					await waitFor(driverTestConfig, 200);
+					const history2 = await scheduled.getTaskHistory();
+					expect(history2).toEqual(["first", "second"]);
+
+					// Wait for third task
+					await waitFor(driverTestConfig, 200);
+					const history3 = await scheduled.getTaskHistory();
+					expect(history3).toEqual(["first", "second", "third"]);
+				});
+			});
+		},
+	);
+}

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

@@ -0,0 +1,413 @@
+import { describe, expect, test } from "vitest";
+import { SLEEP_TIMEOUT } from "../../../fixtures/driver-test-suite/sleep";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest, waitFor } from "../utils";
+
+// TODO: These tests are broken with fake timers because `_sleep` requires
+// background async promises that have a race condition with calling
+// `getCounts`
+//
+// To fix this, we need to imeplment some event system to be able to check for
+// when an actor has slept. OR we can expose an HTTP endpoint on the manager
+// for `.test` that checks if na actor is sleeping that we can poll.
+export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
+	describe.skipIf(driverTestConfig.skip?.sleep)("Actor Sleep Tests", () => {
+		test("actor sleep persists state", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Create actor
+			const sleepActor = client.sleep.getOrCreate();
+
+			// Verify initial sleep count
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Trigger sleep
+			await sleepActor.triggerSleep();
+
+			// HACK: Wait for sleep to finish in background
+			await waitFor(driverTestConfig, 100);
+
+			// Get sleep count after restore
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(1);
+				expect(startCount).toBe(2);
+			}
+		});
+
+		test("actor sleep persists state with connect", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Create actor with persistent connection
+			const sleepActor = client.sleep.getOrCreate().connect();
+
+			// Verify initial sleep count
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Trigger sleep
+			await sleepActor.triggerSleep();
+
+			// Disconnect to allow reconnection
+			await sleepActor.dispose();
+
+			// HACK: Wait for sleep to finish in background
+			await waitFor(driverTestConfig, 100);
+
+			// Reconnect to get sleep count after restore
+			const sleepActor2 = client.sleep.getOrCreate();
+			{
+				const { startCount, sleepCount } = await sleepActor2.getCounts();
+				expect(sleepCount).toBe(1);
+				expect(startCount).toBe(2);
+			}
+		});
+
+		test("actor automatically sleeps after timeout", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Create actor
+			const sleepActor = client.sleep.getOrCreate();
+
+			// Verify initial sleep count
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Wait for sleep
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Get sleep count after restore
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(1);
+				expect(startCount).toBe(2);
+			}
+		});
+
+		test("actor automatically sleeps after timeout with connect", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Create actor with persistent connection
+			const sleepActor = client.sleep.getOrCreate().connect();
+
+			// Verify initial sleep count
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Disconnect to allow actor to sleep
+			await sleepActor.dispose();
+
+			// Wait for sleep
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Reconnect to get sleep count after restore
+			const sleepActor2 = client.sleep.getOrCreate();
+			{
+				const { startCount, sleepCount } = await sleepActor2.getCounts();
+				expect(sleepCount).toBe(1);
+				expect(startCount).toBe(2);
+			}
+		});
+
+		test("rpc calls keep actor awake", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Create actor
+			const sleepActor = client.sleep.getOrCreate();
+
+			// Verify initial state
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Wait almost until sleep timeout, then make RPC call
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
+
+			// RPC call should reset the sleep timer
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0); // Haven't slept yet
+				expect(startCount).toBe(1); // Still the same instance
+			}
+
+			// Wait another partial timeout period - actor should still be awake
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
+
+			// Actor should still be awake
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0); // Still haven't slept
+				expect(startCount).toBe(1); // Still the same instance
+			}
+
+			// Now wait for full timeout without any RPC calls
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Actor should have slept and restarted
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(1); // Slept once
+				expect(startCount).toBe(2); // New instance after sleep
+			}
+		});
+
+		test("alarms keep actor awake", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Create actor
+			const sleepActor = client.sleep.getOrCreate();
+
+			// Verify initial state
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Set an alarm to keep the actor awake
+			await sleepActor.setAlarm(SLEEP_TIMEOUT - 100);
+
+			// Wait until after SLEEPT_IMEOUT to validate the actor did not sleep
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Actor should not have slept
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+		});
+
+		test("alarms wake actors", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Create actor
+			const sleepActor = client.sleep.getOrCreate();
+
+			// Verify initial state
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Set an alarm to keep the actor awake
+			await sleepActor.setAlarm(SLEEP_TIMEOUT + 100);
+
+			// Wait until after SLEEPT_IMEOUT to validate the actor did not sleep
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 200);
+
+			// Actor should not have slept
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(1);
+				expect(startCount).toBe(2);
+			}
+		});
+
+		test("long running rpcs keep actor awake", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Create actor
+			const sleepActor = client.sleepWithLongRpc.getOrCreate().connect();
+
+			// Verify initial state
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Start a long-running RPC that takes longer than the sleep timeout
+			const waitPromise = new Promise((resolve) =>
+				sleepActor.once("waiting", resolve),
+			);
+			const longRunningPromise = sleepActor.longRunningRpc();
+			await waitPromise;
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await sleepActor.finishLongRunningRpc();
+			await longRunningPromise;
+
+			// Actor should still be the same instance (didn't sleep during RPC)
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0); // Hasn't slept
+				expect(startCount).toBe(1); // Same instance
+			}
+			await sleepActor.dispose();
+
+			// Now wait for the sleep timeout
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Actor should have slept after the timeout
+			const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
+			{
+				const { startCount, sleepCount } = await sleepActor2.getCounts();
+				expect(sleepCount).toBe(1); // Slept once
+				expect(startCount).toBe(2); // New instance after sleep
+			}
+		});
+
+		test("active raw websockets keep actor awake", async (c) => {
+			const { client, endpoint: baseUrl } = await setupDriverTest(
+				c,
+				driverTestConfig,
+			);
+
+			// Create actor
+			const sleepActor = client.sleepWithRawWebSocket.getOrCreate();
+
+			// Verify initial state
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Connect WebSocket
+			const ws = await sleepActor.websocket();
+
+			await new Promise<void>((resolve, reject) => {
+				ws.onopen = () => resolve();
+				ws.onerror = reject;
+			});
+
+			// Wait for connection message
+			await new Promise<void>((resolve) => {
+				ws.onmessage = (event) => {
+					const data = JSON.parse(event.data);
+					if (data.type === "connected") {
+						resolve();
+					}
+				};
+			});
+
+			// Wait longer than sleep timeout while keeping WebSocket connected
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Send a message to check if actor is still alive
+			ws.send(JSON.stringify({ type: "getCounts" }));
+
+			const counts = await new Promise<any>((resolve) => {
+				ws.onmessage = (event) => {
+					const data = JSON.parse(event.data);
+					if (data.type === "counts") {
+						resolve(data);
+					}
+				};
+			});
+
+			// Actor should still be the same instance (didn't sleep while WebSocket connected)
+			expect(counts.sleepCount).toBe(0);
+			expect(counts.startCount).toBe(1);
+
+			// Close WebSocket
+			ws.close();
+			await new Promise((resolve) => setTimeout(resolve, 100));
+
+			// Wait for sleep timeout after WebSocket closed
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Actor should have slept after WebSocket closed
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(1); // Slept once
+				expect(startCount).toBe(2); // New instance after sleep
+			}
+		});
+
+		test("active raw fetch requests keep actor awake", async (c) => {
+			const { client, endpoint: baseUrl } = await setupDriverTest(
+				c,
+				driverTestConfig,
+			);
+
+			// Create actor
+			const sleepActor = client.sleepWithRawHttp.getOrCreate();
+
+			// Verify initial state
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Start a long-running fetch request
+			const fetchDuration = SLEEP_TIMEOUT + 100;
+			const fetchPromise = sleepActor.fetch(
+				`long-request?duration=${fetchDuration}`,
+			);
+
+			// Wait for the fetch to complete
+			const response = await fetchPromise;
+			const result = (await response.json()) as { completed: boolean };
+			expect(result.completed).toBe(true);
+			{
+				const { startCount, sleepCount, requestCount } =
+					await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+				expect(requestCount).toBe(1);
+			}
+
+			// Wait for sleep timeout
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Actor should have slept after timeout
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(1); // Slept once
+				expect(startCount).toBe(2); // New instance after sleep
+			}
+		});
+
+		test("noSleep option disables sleeping", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Create actor with noSleep option
+			const sleepActor = client.sleepWithNoSleepOption.getOrCreate();
+
+			// Verify initial state
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0);
+				expect(startCount).toBe(1);
+			}
+
+			// Wait longer than sleep timeout
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Actor should NOT have slept due to noSleep option
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0); // Never slept
+				expect(startCount).toBe(1); // Still the same instance
+			}
+
+			// Wait even longer to be sure
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+
+			// Actor should still not have slept
+			{
+				const { startCount, sleepCount } = await sleepActor.getCounts();
+				expect(sleepCount).toBe(0); // Never slept
+				expect(startCount).toBe(1); // Still the same instance
+			}
+		});
+	});
+}

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

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runActorStateTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor State Tests", () => {
+		describe("State Persistence", () => {
+			test("persists state between actor instances", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create instance and increment
+				const counterInstance = client.counter.getOrCreate();
+				const initialCount = await counterInstance.increment(5);
+				expect(initialCount).toBe(5);
+
+				// Get a fresh reference to the same actor and verify state persisted
+				const sameInstance = client.counter.getOrCreate();
+				const persistedCount = await sameInstance.increment(3);
+				expect(persistedCount).toBe(8);
+			});
+
+			test("restores state after actor disconnect/reconnect", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create actor and set initial state
+				const counterInstance = client.counter.getOrCreate();
+				await counterInstance.increment(5);
+
+				// Reconnect to the same actor
+				const reconnectedInstance = client.counter.getOrCreate();
+				const persistedCount = await reconnectedInstance.increment(0);
+				expect(persistedCount).toBe(5);
+			});
+
+			test("maintains separate state for different actors", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+
+				// Create first counter with specific key
+				const counterA = client.counter.getOrCreate(["counter-a"]);
+				await counterA.increment(5);
+
+				// Create second counter with different key
+				const counterB = client.counter.getOrCreate(["counter-b"]);
+				await counterB.increment(10);
+
+				// Verify state is separate
+				const countA = await counterA.increment(0);
+				const countB = await counterB.increment(0);
+				expect(countA).toBe(5);
+				expect(countB).toBe(10);
+			});
+		});
+	});
+}