rivetkit 2.1.5 → 2.1.6-rc.1

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

@@ -38,28 +38,26 @@ export function runActorRunTests(driverTestConfig: DriverTestConfig) {
 			expect(state2.tickCount).toBeGreaterThan(count1);
 		});
 
-			test("active run handler keeps actor awake past sleep timeout", async (c) => {
-				const { client } = await setupDriverTest(c, driverTestConfig);
+		test("active run handler keeps actor awake past sleep timeout", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
 
-				const actor = client.runWithTicks.getOrCreate([
-					"run-stays-awake",
-				]);
+			const actor = client.runWithTicks.getOrCreate(["run-stays-awake"]);
 
-				// Wait for run to start
-				await waitFor(driverTestConfig, 100);
+			// Wait for run to start
+			await waitFor(driverTestConfig, 100);
 
-				const state1 = await actor.getState();
-				expect(state1.runStarted).toBe(true);
-				const tickCount1 = state1.tickCount;
+			const state1 = await actor.getState();
+			expect(state1.runStarted).toBe(true);
+			const tickCount1 = state1.tickCount;
 
-				// Active run loops should keep the actor awake.
-				await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 300);
+			// Active run loops should keep the actor awake.
+			await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 300);
 
-				const state2 = await actor.getState();
-				expect(state2.runStarted).toBe(true);
-				expect(state2.runExited).toBe(false);
-				expect(state2.tickCount).toBeGreaterThan(tickCount1);
-			});
+			const state2 = await actor.getState();
+			expect(state2.runStarted).toBe(true);
+			expect(state2.runExited).toBe(false);
+			expect(state2.tickCount).toBeGreaterThan(tickCount1);
+		});
 
 		test("actor without run handler works normally", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
@@ -78,8 +76,8 @@ export function runActorRunTests(driverTestConfig: DriverTestConfig) {
 			expect(state2.wakeCount).toBe(2);
 		});
 
-			test("run handler can consume from queue", async (c) => {
-				const { client } = await setupDriverTest(c, driverTestConfig);
+		test("run handler can consume from queue", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
 
 			const actor = client.runWithQueueConsumer.getOrCreate([
 				"queue-consumer",
@@ -107,30 +105,30 @@ export function runActorRunTests(driverTestConfig: DriverTestConfig) {
 				type: "test",
 				value: 2,
 			});
-				expect(state.messagesReceived[2].body).toEqual({
-					type: "test",
-					value: 3,
-				});
+			expect(state.messagesReceived[2].body).toEqual({
+				type: "test",
+				value: 3,
 			});
+		});
 
-			test("queue-waiting run handler can sleep and resume", async (c) => {
-				const { client } = await setupDriverTest(c, driverTestConfig);
+		test("queue-waiting run handler can sleep and resume", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
 
-				const actor = client.runWithQueueConsumer.getOrCreate([
-					"queue-consumer-sleep",
-				]);
+			const actor = client.runWithQueueConsumer.getOrCreate([
+				"queue-consumer-sleep",
+			]);
 
-				await waitFor(driverTestConfig, 100);
-				const state1 = await actor.getState();
-				expect(state1.runStarted).toBe(true);
+			await waitFor(driverTestConfig, 100);
+			const state1 = await actor.getState();
+			expect(state1.runStarted).toBe(true);
 
-				await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 500);
-				const state2 = await actor.getState();
+			await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 500);
+			const state2 = await actor.getState();
 
-				expect(state2.wakeCount).toBeGreaterThan(state1.wakeCount);
-			});
+			expect(state2.wakeCount).toBeGreaterThan(state1.wakeCount);
+		});
 
-		test("run handler that exits early triggers destroy", async (c) => {
+		test("run handler that exits early sleeps instead of destroying", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 
 			const actor = client.runWithEarlyExit.getOrCreate(["early-exit"]);
@@ -141,22 +139,23 @@ export function runActorRunTests(driverTestConfig: DriverTestConfig) {
 			const state1 = await actor.getState();
 			expect(state1.runStarted).toBe(true);
 
-			// Wait for the actor to be destroyed
-			await waitFor(driverTestConfig, 300);
+			// Wait for the run handler to exit and the normal idle sleep timeout.
+			await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 400);
 
-			// After the run handler exits early, the actor should be destroyed.
-			// Depending on the driver, it may be in a destroyed state or recreated.
-			// In the file-system driver test environment, the actor is not automatically
-			// rescheduled, so we just verify the initial behavior worked.
-			// A new getOrCreate should create a fresh actor.
-			const actor2 = client.runWithEarlyExit.getOrCreate([
-				"early-exit-fresh",
-			]);
-			const state2 = await actor2.getState();
+			const state2 = await actor.getState();
 			expect(state2.runStarted).toBe(true);
+			expect(state2.destroyCalled).toBe(false);
+
+			if (driverTestConfig.skip?.sleep) {
+				expect(state2.sleepCount).toBe(0);
+				expect(state2.wakeCount).toBe(1);
+			} else {
+				expect(state2.sleepCount).toBeGreaterThan(0);
+				expect(state2.wakeCount).toBeGreaterThan(1);
+			}
 		});
 
-		test("run handler that throws error triggers destroy", async (c) => {
+		test("run handler that throws error sleeps instead of destroying", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 
 			const actor = client.runWithError.getOrCreate(["run-error"]);
@@ -167,15 +166,20 @@ export function runActorRunTests(driverTestConfig: DriverTestConfig) {
 			const state1 = await actor.getState();
 			expect(state1.runStarted).toBe(true);
 
-			// Wait for the actor to be destroyed
-			await waitFor(driverTestConfig, 300);
+			// Wait for the run handler to throw and the normal idle sleep timeout.
+			await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 400);
 
-			// After the run handler throws, the actor should be destroyed.
-			// Similar to the early exit test, the driver may not automatically reschedule.
-			// A new getOrCreate should create a fresh actor.
-			const actor2 = client.runWithError.getOrCreate(["run-error-fresh"]);
-			const state2 = await actor2.getState();
+			const state2 = await actor.getState();
 			expect(state2.runStarted).toBe(true);
+			expect(state2.destroyCalled).toBe(false);
+
+			if (driverTestConfig.skip?.sleep) {
+				expect(state2.sleepCount).toBe(0);
+				expect(state2.wakeCount).toBe(1);
+			} else {
+				expect(state2.sleepCount).toBeGreaterThan(0);
+				expect(state2.wakeCount).toBeGreaterThan(1);
+			}
 		});
 	});
 }

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

@@ -0,0 +1,78 @@
+// @ts-nocheck
+import { describe, expect, test, vi } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runActorSandboxTests(driverTestConfig: DriverTestConfig) {
+	describe.skipIf(driverTestConfig.skip?.sandbox)("Actor Sandbox Tests", () => {
+		test("supports sandbox actions through the actor runtime", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+			const sandbox = client.dockerSandboxActor.getOrCreate([
+				`sandbox-${crypto.randomUUID()}`,
+			]);
+			const decoder = new TextDecoder();
+
+			const health = await vi.waitFor(
+				async () => {
+					return await sandbox.getHealth();
+				},
+				{
+					timeout: 120_000,
+					interval: 500,
+				},
+			);
+			expect(typeof health.status).toBe("string");
+			const { url } = await sandbox.getSandboxUrl();
+			expect(url).toMatch(/^https?:\/\//);
+
+			await sandbox.mkdirFs({ path: "/root/tmp" });
+			await sandbox.writeFsFile(
+				{ path: "/root/tmp/hello.txt" },
+				"sandbox actor driver test",
+			);
+			expect(
+				decoder.decode(
+					await sandbox.readFsFile({ path: "/root/tmp/hello.txt" }),
+				),
+			).toBe("sandbox actor driver test");
+
+			const stat = await sandbox.statFs({ path: "/root/tmp/hello.txt" });
+			expect(stat.entryType).toBe("file");
+
+				await sandbox.moveFs({
+					from: "/root/tmp/hello.txt",
+					to: "/root/tmp/renamed.txt",
+				});
+				expect(
+					(await sandbox.listFsEntries({ path: "/root/tmp" })).map(
+						(entry: { name: string }) => entry.name,
+					),
+				).toContain("renamed.txt");
+
+			await sandbox.dispose();
+
+			const healthAfterDispose = await vi.waitFor(
+				async () => {
+					return await sandbox.getHealth();
+				},
+				{
+					timeout: 120_000,
+					interval: 500,
+				},
+			);
+			expect(typeof healthAfterDispose.status).toBe("string");
+			expect(
+				decoder.decode(
+					await sandbox.readFsFile({ path: "/root/tmp/renamed.txt" }),
+				),
+			).toBe("sandbox actor driver test");
+
+			await sandbox.deleteFsEntry({ path: "/root/tmp", recursive: true });
+			expect(await sandbox.listFsEntries({ path: "/root" })).not.toEqual(
+				expect.arrayContaining([
+					expect.objectContaining({ name: "tmp" }),
+				]),
+			);
+		}, 180_000);
+	});
+}

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

@@ -81,10 +81,7 @@ export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
 					// Wait for second task
 					await waitFor(driverTestConfig, 500);
 					const history2 = await scheduled.getTaskHistory();
-					expect(history2.slice(0, 2)).toEqual([
-						"first",
-						"second",
-					]);
+					expect(history2.slice(0, 2)).toEqual(["first", "second"]);
 
 					// Wait for third task
 					await waitFor(driverTestConfig, 500);

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

@@ -124,6 +124,40 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 		});
 
+		test("waitUntil can broadcast before sleep disconnect", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const sleepActor =
+				client.sleepWithWaitUntilMessage.getOrCreate().connect();
+			const receivedMessages: Array<{
+				sleepCount: number;
+				startCount: number;
+			}> = [];
+
+			sleepActor.once("sleeping", (message) => {
+				receivedMessages.push(message);
+			});
+
+			await sleepActor.triggerSleep();
+			await waitFor(driverTestConfig, 250);
+
+			expect(receivedMessages).toHaveLength(1);
+			expect(receivedMessages[0]?.startCount).toBe(1);
+
+			await sleepActor.dispose();
+
+			await waitFor(driverTestConfig, 250);
+
+			const sleepActor2 = client.sleepWithWaitUntilMessage.getOrCreate();
+			{
+				const { startCount, sleepCount, waitUntilMessageCount } =
+					await sleepActor2.getCounts();
+				expect(waitUntilMessageCount).toBe(1);
+				expect(sleepCount).toBe(1);
+				expect(startCount).toBe(2);
+			}
+		});
+
 		test("rpc calls keep actor awake", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 
@@ -411,5 +445,82 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 				expect(startCount).toBe(1); // Still the same instance
 			}
 		});
+
+		test("preventSleep blocks auto sleep until cleared", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const sleepActor = client.sleepWithPreventSleep.getOrCreate();
+
+			{
+				const status = await sleepActor.getStatus();
+				expect(status.sleepCount).toBe(0);
+				expect(status.startCount).toBe(1);
+				expect(status.preventSleep).toBe(false);
+				expect(status.preventSleepOnWake).toBe(false);
+			}
+
+			expect(await sleepActor.setPreventSleep(true)).toBe(true);
+
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+
+			{
+				const status = await sleepActor.getStatus();
+				expect(status.sleepCount).toBe(0);
+				expect(status.startCount).toBe(1);
+				expect(status.preventSleep).toBe(true);
+			}
+
+			expect(await sleepActor.setPreventSleep(false)).toBe(false);
+
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+
+			{
+				const status = await sleepActor.getStatus();
+				expect(status.sleepCount).toBe(1);
+				expect(status.startCount).toBe(2);
+				expect(status.preventSleep).toBe(false);
+			}
+		});
+
+		test("preventSleep can be restored during onWake", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const sleepActor = client.sleepWithPreventSleep.getOrCreate();
+
+			expect(await sleepActor.setPreventSleepOnWake(true)).toBe(true);
+
+			await sleepActor.triggerSleep();
+			await waitFor(driverTestConfig, 250);
+
+			{
+				const status = await sleepActor.getStatus();
+				expect(status.sleepCount).toBe(1);
+				expect(status.startCount).toBe(2);
+				expect(status.preventSleep).toBe(true);
+				expect(status.preventSleepOnWake).toBe(true);
+			}
+
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+
+			{
+				const status = await sleepActor.getStatus();
+				expect(status.sleepCount).toBe(1);
+				expect(status.startCount).toBe(2);
+				expect(status.preventSleep).toBe(true);
+			}
+
+			expect(await sleepActor.setPreventSleepOnWake(false)).toBe(false);
+			expect(await sleepActor.setPreventSleep(false)).toBe(false);
+
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+
+			{
+				const status = await sleepActor.getStatus();
+				expect(status.sleepCount).toBe(2);
+				expect(status.startCount).toBe(3);
+				expect(status.preventSleep).toBe(false);
+				expect(status.preventSleepOnWake).toBe(false);
+			}
+		});
 	});
 }