test(kernel-node): Add failing orphaned ephemeral exo test

Author: rekmarks

packages/kernel-node-runtime/test/e2e/orphaned-ephemeral-exo.test.ts

@@ -0,0 +1,70 @@
+import { makeSQLKernelDatabase } from '@metamask/kernel-store/sqlite/nodejs';
+import { kunser } from '@metamask/ocap-kernel';
+import type { ClusterConfig } from '@metamask/ocap-kernel';
+import { delay } from '@ocap/repo-tools/test-utils';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, it, expect } from 'vitest';
+
+import { makeTestKernel } from '../helpers/kernel.ts';
+
+const PROVIDER_BUNDLE =
+  'http://localhost:3000/orphaned-ephemeral-provider-vat.bundle';
+const CONSUMER_BUNDLE =
+  'http://localhost:3000/orphaned-ephemeral-consumer-vat.bundle';
+
+const clusterConfig: ClusterConfig = {
+  bootstrap: 'consumer',
+  vats: {
+    provider: {
+      bundleSpec: PROVIDER_BUNDLE,
+      parameters: {},
+    },
+    consumer: {
+      bundleSpec: CONSUMER_BUNDLE,
+      parameters: {},
+    },
+  },
+};
+
+describe('Orphaned ephemeral exo', { timeout: 30_000 }, () => {
+  it('rejects when provider vat restarts', async () => {
+    const tempDir = await mkdtemp(join(tmpdir(), 'ocap-ephemeral-'));
+    const dbFilename = join(tempDir, 'kernel.db');
+    try {
+      const kernel = await makeTestKernel(
+        await makeSQLKernelDatabase({ dbFilename }),
+      );
+      try {
+        const { rootKref, subclusterId } =
+          await kernel.launchSubcluster(clusterConfig);
+        await delay();
+
+        // Works before restart
+        const r1 = await kernel.queueMessage(rootKref, 'useEphemeral', []);
+        expect(kunser(r1)).toBe(999);
+
+        // Restart only the provider — the consumer still holds the
+        // ephemeral ref, but the exo behind it no longer exists.
+        const subcluster = kernel.getSubcluster(subclusterId);
+        expect(subcluster).toBeDefined();
+        await kernel.restartVat(subcluster!.vats.provider);
+        await delay();
+
+        // The consumer's E(ephemeral).increment() targets an orphaned vref.
+        // Liveslots in the provider throws "I don't remember allocating",
+        // which terminates the provider and rejects the caller's promise.
+        await expect(
+          kernel.queueMessage(rootKref, 'useEphemeral', []),
+        ).rejects.toMatchObject({
+          body: expect.stringContaining("I don't remember allocating"),
+        });
+      } finally {
+        await kernel.stop();
+      }
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+});

packages/kernel-node-runtime/test/vats/orphaned-ephemeral-consumer-vat.ts

@@ -0,0 +1,22 @@
+import { E } from '@endo/eventual-send';
+import { makeDefaultExo } from '@metamask/kernel-utils/exo';
+
+/**
+ * A consumer vat that obtains an ephemeral exo reference from the provider
+ * during bootstrap and calls it on demand.
+ *
+ * @returns The root object.
+ */
+export function buildRootObject() {
+  let ephemeralRef: unknown;
+
+  return makeDefaultExo('root', {
+    async bootstrap(vats: { provider: unknown }) {
+      ephemeralRef = await E(vats.provider).getEphemeral();
+    },
+
+    async useEphemeral() {
+      return E(ephemeralRef).increment();
+    },
+  });
+}

packages/kernel-node-runtime/test/vats/orphaned-ephemeral-provider-vat.ts

@@ -0,0 +1,21 @@
+import { makeDefaultExo } from '@metamask/kernel-utils/exo';
+
+/**
+ * A provider vat that exposes a single ephemeral (non-durable) exo.
+ * The exo will not survive a vat restart.
+ *
+ * @returns The root object.
+ */
+export function buildRootObject() {
+  const ephemeral = makeDefaultExo('EphemeralCounter', {
+    increment() {
+      return 999;
+    },
+  });
+
+  return makeDefaultExo('root', {
+    getEphemeral() {
+      return ephemeral;
+    },
+  });
+}