testing retireImports and dropImports

Author: sirtimid

packages/kernel-test/src/garbage-collection.test.ts

@@ -6,7 +6,12 @@ import { makeSQLKernelDatabase } from '@ocap/store/sqlite/nodejs';
 import { waitUntilQuiescent } from '@ocap/utils';
 import { expect, beforeEach, afterEach, describe, it } from 'vitest';
 
-import { getBundleSpec, makeKernel, runTestVats } from './utils.ts';
+import {
+  getBundleSpec,
+  makeKernel,
+  parseReplyBody,
+  runTestVats,
+} from './utils.ts';
 
 /**
  * Make a test subcluster with vats for GC testing
@@ -103,7 +108,7 @@ describe('Garbage Collection E2E Tests', () => {
       [],
     );
     await waitUntilQuiescent();
-    expect(useResult.body).toContain(objectId);
+    expect(parseReplyBody(useResult.body)).toBe(objectId);
   });
 
   it('should trigger GC syscalls through bringOutYourDead', async () => {
@@ -114,88 +119,91 @@ describe('Garbage Collection E2E Tests', () => {
       'createObject',
       [objectId],
     );
-    const objectRef = createObjectData.slots[0] as KRef;
+    const createObjectRef = createObjectData.slots[0] as KRef;
 
     // Store initial reference count information
-    const initialRefCounts = kernelStore.getObjectRefCount(objectRef);
+    const initialRefCounts = kernelStore.getObjectRefCount(createObjectRef);
+    console.log('Initial ref counts:', createObjectRef, initialRefCounts);
     expect(initialRefCounts.reachable).toBe(1);
     expect(initialRefCounts.recognizable).toBe(1);
 
     // 2. Store the reference in the importer vat
+    const objectRef = kunser(createObjectData);
     await kernel.queueMessageFromKernel(importerKRef, 'storeImport', [
       objectRef,
       objectId,
     ]);
     await waitUntilQuiescent();
 
+    // Get reference counts after storing in importer
+    const afterStoreRefCounts = kernelStore.getObjectRefCount(createObjectRef);
+    console.log('After store ref counts:', objectRef, afterStoreRefCounts);
+
     // 3. Verify object is tracked in both vats
     const importerHasObject = await kernel.queueMessageFromKernel(
       importerKRef,
       'listImportedObjects',
       [],
     );
     console.log('$$$ importerHasObject', importerHasObject);
-    expect(importerHasObject.body).toContain(objectId);
+    expect(parseReplyBody(importerHasObject.body)).toContain(objectId);
 
     const exporterHasObject = await kernel.queueMessageFromKernel(
       exporterKRef,
       'isObjectPresent',
       [objectId],
     );
     console.log('$$$ exporterHasObject', exporterHasObject);
-    expect(exporterHasObject.body).toBe('#true');
+    expect(parseReplyBody(exporterHasObject.body)).toBe(true);
 
     // 4. Make a weak reference to the object in the importer vat
     // This should eventually trigger dropImports when GC runs
     await kernel.queueMessageFromKernel(importerKRef, 'makeWeak', [objectId]);
     await waitUntilQuiescent();
 
-    // 5. Schedule reap to trigger bringOutYourDead on next crank
-    kernelStore.scheduleReap(exporterVatId);
+    console.log('$$$ kernelStore.getGCActions(1)', kernelStore.getGCActions());
+
+    // // 5. Schedule reap to trigger bringOutYourDead on next crank
+    kernel.reapAllVats();
 
-    // 6. Run a crank to allow bringOutYourDead to be processed
+    // // 6. Run a crank to allow bringOutYourDead to be processed
     await kernel.queueMessageFromKernel(exporterKRef, 'noop', []);
     await waitUntilQuiescent(100);
 
-    // Check reference counts after dropImports (should be decreased reachable but same recognizable)
-    const afterWeakRefCounts = kernelStore.getObjectRefCount(objectRef);
-    expect(afterWeakRefCounts.reachable).toBeLessThan(
-      initialRefCounts.reachable,
-    );
-    expect(afterWeakRefCounts.recognizable).toBe(initialRefCounts.recognizable);
+    console.log('$$$ kernelStore.getGCActions(2)', kernelStore.getGCActions());
+
+    // // Check reference counts after dropImports
+    const afterWeakRefCounts = kernelStore.getObjectRefCount(createObjectRef);
+    console.log('After weak ref counts:', afterWeakRefCounts);
+    expect(afterWeakRefCounts.reachable).toBe(0);
+    expect(afterWeakRefCounts.recognizable).toBe(1);
 
     // 7. Now completely forget the import in the importer vat
     // This should trigger retireImports when GC runs
-    await kernel.queueMessageFromKernel(importerKRef, 'forgetImport', [
-      objectId,
-    ]);
+    await kernel.queueMessageFromKernel(importerKRef, 'forgetImport', []);
     await waitUntilQuiescent();
 
     // 8. Schedule another reap
-    kernelStore.scheduleReap(importerVatId);
+    kernel.reapAllVats();
 
     // 9. Run a crank to allow bringOutYourDead to be processed
     await kernel.queueMessageFromKernel(importerKRef, 'noop', []);
     await waitUntilQuiescent(100);
 
     // Check reference counts after retireImports (both should be decreased)
-    const afterForgetRefCounts = kernelStore.getObjectRefCount(objectRef);
-    expect(afterForgetRefCounts.reachable).toBeLessThan(
-      initialRefCounts.reachable,
-    );
-    expect(afterForgetRefCounts.recognizable).toBeLessThan(
-      initialRefCounts.recognizable,
-    );
+    const afterForgetRefCounts = kernelStore.getObjectRefCount(createObjectRef);
+    expect(afterForgetRefCounts.reachable).toBe(0);
+    expect(afterForgetRefCounts.recognizable).toBe(0);
 
-    // 10. Now forget the object in the exporter vat
-    // This should trigger retireExports when GC runs
+    // // 10. Now forget the object in the exporter vat
+    // // This should trigger retireExports when GC runs
     await kernel.queueMessageFromKernel(exporterKRef, 'forgetObject', [
       objectId,
     ]);
     await waitUntilQuiescent();
 
     // 11. Schedule a final reap
-    kernelStore.scheduleReap(exporterVatId);
+    kernel.reapAllVats();
 
     // 12. Run multiple cranks to ensure GC completes
     for (let i = 0; i < 3; i++) {
@@ -210,77 +218,79 @@ describe('Garbage Collection E2E Tests', () => {
       [objectId],
     );
     console.log('$$$ exporterFinalCheck', exporterFinalCheck);
-    expect(exporterFinalCheck.body).toBe('#false');
+    expect(parseReplyBody(exporterFinalCheck.body)).toBe(false);
 
     // Check if reference still exists in the kernel store at all
-    const refExists = kernelStore.kernelRefExists(objectRef);
-    expect(refExists).toBe(false);
-
-    // 13. Test abandonExports by creating a new object and forcing its removal
-    const abandonObjectId = 'abandon-test';
-    const abandonObjData = await kernel.queueMessageFromKernel(
-      exporterKRef,
-      'createObject',
-      [abandonObjectId],
-    );
-    console.log('$$$ abandonObjData', abandonObjData);
-    const abandonObjRef = abandonObjData.slots[0] as KRef;
-
-    // Store in importer to make it reachable from both vats
-    await kernel.queueMessageFromKernel(importerKRef, 'storeImport', [
-      abandonObjRef,
-      abandonObjectId,
-    ]);
-    await waitUntilQuiescent();
-
-    // Verify it's reachable from both vats
-    const abandonRefCounts = kernelStore.getObjectRefCount(abandonObjRef);
-    expect(abandonRefCounts.reachable).toBe(1);
-
-    // Force remove in exporter (this simulates abandonExports)
-    await kernel.queueMessageFromKernel(exporterKRef, 'forgetObject', [
-      abandonObjectId,
-    ]);
-    await waitUntilQuiescent();
-
-    // Schedule reap to trigger abandonExports
-    kernelStore.scheduleReap(exporterVatId);
-
-    // Run multiple cranks to ensure GC completes
-    for (let i = 0; i < 3; i++) {
-      await kernel.queueMessageFromKernel(exporterKRef, 'noop', []);
-      await waitUntilQuiescent(50);
-    }
-
-    // Verify object is gone from exporter
-    const exporterAbandonCheck = await kernel.queueMessageFromKernel(
-      exporterKRef,
-      'isObjectPresent',
-      [abandonObjectId],
-    );
-    console.log('$$$ exporterAbandonCheck', exporterAbandonCheck);
-    expect(exporterAbandonCheck.body).toBe('#false');
-
-    // But it should still be in the importer's list
-    const importerAbandonCheck = await kernel.queueMessageFromKernel(
-      importerKRef,
-      'listImportedObjects',
-      [],
-    );
-    console.log('$$$ importerAbandonCheck', importerAbandonCheck);
-    expect(importerAbandonCheck.body).toContain(abandonObjectId);
-
-    // However, using the object should now fail
-    try {
-      await kernel.queueMessageFromKernel(importerKRef, 'useImport', [
-        abandonObjectId,
-      ]);
-      // Should not reach here
-      expect(false).toBe(true);
-    } catch (error) {
-      // We expect an error
-      // eslint-disable-next-line vitest/no-conditional-expect
-      expect(error).toBeDefined();
-    }
+    // const refExists = kernelStore.kernelRefExists(createObjectRef);
+    // expect(refExists).toBe(false);
+
+    // // 13. Test abandonExports by creating a new object and forcing its removal
+    // const abandonObjectId = 'abandon-test';
+    // const abandonObjData = await kernel.queueMessageFromKernel(
+    //   exporterKRef,
+    //   'createObject',
+    //   [abandonObjectId],
+    // );
+    // console.log('$$$ abandonObjData', abandonObjData);
+    // const abandonObjRef = abandonObjData.slots[0] as KRef;
+
+    // // Store in importer to make it reachable from both vats
+    // await kernel.queueMessageFromKernel(importerKRef, 'storeImport', [
+    //   abandonObjRef,
+    //   abandonObjectId,
+    // ]);
+    // await waitUntilQuiescent();
+
+    // // Verify it's reachable from both vats
+    // const abandonRefCounts = kernelStore.getObjectRefCount(abandonObjRef);
+    // expect(abandonRefCounts.reachable).toBe(1);
+
+    // // Force remove in exporter (this simulates abandonExports)
+    // await kernel.queueMessageFromKernel(exporterKRef, 'forgetObject', [
+    //   abandonObjectId,
+    // ]);
+    // await waitUntilQuiescent();
+
+    // // Schedule reap to trigger abandonExports
+    // kernelStore.scheduleReap(exporterVatId);
+
+    // // Run multiple cranks to ensure GC completes
+    // for (let i = 0; i < 3; i++) {
+    //   await kernel.queueMessageFromKernel(exporterKRef, 'noop', []);
+    //   await waitUntilQuiescent(50);
+    // }
+
+    // // Verify object is gone from exporter
+    // const exporterAbandonCheck = await kernel.queueMessageFromKernel(
+    //   exporterKRef,
+    //   'isObjectPresent',
+    //   [abandonObjectId],
+    // );
+    // console.log('$$$ exporterAbandonCheck', exporterAbandonCheck);
+    // expect(parseReplyBody(exporterAbandonCheck.body)).toBe(false);
+
+    // // But it should still be in the importer's list
+    // const importerAbandonCheck = await kernel.queueMessageFromKernel(
+    //   importerKRef,
+    //   'listImportedObjects',
+    //   [],
+    // );
+    // console.log('$$$ importerAbandonCheck', importerAbandonCheck);
+    // expect(parseReplyBody(importerAbandonCheck.body)).toContain(
+    //   abandonObjectId,
+    // );
+
+    // // However, using the object should now fail
+    // try {
+    //   await kernel.queueMessageFromKernel(importerKRef, 'useImport', [
+    //     abandonObjectId,
+    //   ]);
+    //   // Should not reach here
+    //   expect(false).toBe(true);
+    // } catch (error) {
+    //   // We expect an error
+    //   // eslint-disable-next-line vitest/no-conditional-expect
+    //   expect(error).toBeDefined();
+    // }
   });
 });

packages/kernel-test/src/utils.ts

@@ -135,3 +135,18 @@ export function extractVatLogs(buffer: string): string[] {
     .map((line: string) => line.slice(4));
   return sortLogs(result);
 }
+
+/**
+ * Parse a message body into a JSON object.
+ *
+ * @param body - The message body to parse.
+ *
+ * @returns The parsed JSON object, or the original body if parsing fails.
+ */
+export function parseReplyBody(body: string): unknown {
+  try {
+    return JSON.parse(body.slice(1));
+  } catch {
+    return body;
+  }
+}

packages/kernel-test/src/vats/exporter-vat.js

@@ -60,8 +60,25 @@ export function buildRootObject(_vatPowers, parameters, _baggage) {
       return obj;
     },
 
-    getExportedObjectCount() {
-      return exportedObjects.size;
+    // Check if an object exists in our maps
+    isObjectPresent(objId) {
+      return exportedObjects.has(objId);
+    },
+
+    // Remove an object from our tracking, allowing it to be GC'd
+    forgetObject(objId) {
+      if (exportedObjects.has(objId)) {
+        tlog(`Forgetting object ${objId}`);
+        exportedObjects.delete(objId);
+        return true;
+      }
+      tlog(`Cannot forget nonexistent object: ${objId}`);
+      return false;
+    },
+
+    // No-op to help trigger crank cycles
+    noop() {
+      return 'noop';
     },
 
     // Create a weak reference to an object
@@ -111,26 +128,5 @@ export function buildRootObject(_vatPowers, parameters, _baggage) {
         return { status: 'error', message: String(error) };
       }
     },
-
-    // Check if an object exists in our maps
-    isObjectPresent(objId) {
-      return exportedObjects.has(objId);
-    },
-
-    // Remove an object from our tracking, allowing it to be GC'd
-    forgetObject(objId) {
-      if (exportedObjects.has(objId)) {
-        tlog(`Forgetting object ${objId}`);
-        exportedObjects.delete(objId);
-        return true;
-      }
-      tlog(`Cannot forget nonexistent object: ${objId}`);
-      return false;
-    },
-
-    // No-op to help trigger crank cycles
-    noop() {
-      return 'noop';
-    },
   });
 }