feat: [US-020] - Add missing conformance test coverage from adversarial review

Author: NathanFlurry

packages/core/src/test/block-store-conformance.ts

@@ -162,6 +162,20 @@ export function defineBlockStoreTests(
 					expectErrorCode(err, "ENOENT");
 				}
 			});
+
+			test("readRange with offset exactly at block size returns empty Uint8Array", async () => {
+				const data = makeData(50);
+				await store.write("key", data);
+				const result = await store.readRange("key", 50, 10);
+				expect(result.length).toBe(0);
+			});
+
+			test("readRange with offset=0, length=0 returns empty Uint8Array", async () => {
+				const data = makeData(50);
+				await store.write("key", data);
+				const result = await store.readRange("key", 0, 0);
+				expect(result.length).toBe(0);
+			});
 		});
 
 		// ---------------------------------------------------------------

packages/core/src/test/metadata-store-conformance.ts

@@ -160,6 +160,35 @@ export function defineMetadataStoreTests(
 				const meta = await store.getInode(99999);
 				expect(meta).toBeNull();
 			});
+
+			test("deleteInode cleans up associated chunk mappings and symlink targets", async () => {
+				// Create a file inode with chunk mappings.
+				const fileIno = await store.createInode(fileAttrs());
+				await store.setChunkKey(fileIno, 0, "chunk-0");
+				await store.setChunkKey(fileIno, 1, "chunk-1");
+
+				// Create a symlink inode.
+				const symlinkIno = await store.createInode(symlinkAttrs("/some/target"));
+
+				// Delete the file inode.
+				await store.deleteInode(fileIno);
+				expect(await store.getInode(fileIno)).toBeNull();
+				// Chunk mappings should also be cleaned up.
+				expect(await store.getChunkKey(fileIno, 0)).toBeNull();
+				expect(await store.getChunkKey(fileIno, 1)).toBeNull();
+
+				// Delete the symlink inode.
+				await store.deleteInode(symlinkIno);
+				expect(await store.getInode(symlinkIno)).toBeNull();
+				// readSymlink should fail or return null.
+				try {
+					const target = await store.readSymlink(symlinkIno);
+					// If it doesn't throw, it should return null or undefined.
+					expect(target == null).toBe(true);
+				} catch {
+					// Expected: inode no longer exists.
+				}
+			});
 		});
 
 		// ---------------------------------------------------------------
@@ -409,6 +438,22 @@ export function defineMetadataStoreTests(
 					expectErrorCode(err, "ENOENT");
 				}
 			});
+
+			test("resolvePath with relative symlink targets", async () => {
+				// Create /dir/ containing real.txt and a relative symlink link.txt -> real.txt.
+				const dirIno = await store.createInode(dirAttrs());
+				await store.createDentry(1, "dir", dirIno, "directory");
+
+				const fileIno = await store.createInode(fileAttrs());
+				await store.createDentry(dirIno, "real.txt", fileIno, "file");
+
+				// Relative symlink: target is "real.txt" (no leading /).
+				const linkIno = await store.createInode(symlinkAttrs("real.txt"));
+				await store.createDentry(dirIno, "link.txt", linkIno, "symlink");
+
+				const resolved = await store.resolvePath("/dir/link.txt");
+				expect(resolved).toBe(fileIno);
+			});
 		});
 
 		// ---------------------------------------------------------------
@@ -549,6 +594,17 @@ export function defineMetadataStoreTests(
 				const target = await store.readSymlink(ino);
 				expect(target).toBe("/some/target");
 			});
+
+			test("readSymlink on non-symlink inode throws error", async () => {
+				const fileIno = await store.createInode(fileAttrs());
+				try {
+					await store.readSymlink(fileIno);
+					expect.fail("should have thrown");
+				} catch (err) {
+					// Any error is acceptable: EINVAL, ENOENT, or a generic Error.
+					expect(err).toBeInstanceOf(Error);
+				}
+			});
 		});
 
 		// ---------------------------------------------------------------

packages/core/src/test/vfs-conformance.ts

@@ -999,6 +999,81 @@ export function defineVfsConformanceTests(config: VfsConformanceConfig): void {
 				const text = await fs.readTextFile(path);
 				expect(text).toBe("deep");
 			});
+
+			test.skipIf(!capabilities.pwrite)(
+				"pwrite on nonexistent file throws ENOENT",
+				async () => {
+					const err = await fs
+						.pwrite("/no-such-file.txt", 0, new TextEncoder().encode("x"))
+						.catch((e) => e);
+					expectErrorCode(err, "ENOENT");
+				},
+			);
+
+			test.skipIf(!capabilities.truncate)(
+				"truncate on nonexistent file throws ENOENT",
+				async () => {
+					const err = await fs.truncate("/no-such-file.txt", 0).catch((e) => e);
+					expectErrorCode(err, "ENOENT");
+				},
+			);
+
+			test("stat on root directory '/' returns isDirectory: true", async () => {
+				const s = await fs.stat("/");
+				expect(s.isDirectory).toBe(true);
+			});
+		});
+
+		// ---------------------------------------------------------------
+		// Relative symlink tests (gated)
+		// ---------------------------------------------------------------
+
+		describe.skipIf(!capabilities.symlinks)("relative symlinks", () => {
+			test("relative symlink resolution", async () => {
+				// Create /dir/real.txt, then /dir/link.txt -> real.txt (relative)
+				await fs.writeFile("/dir/real.txt", "real content");
+				await fs.symlink("real.txt", "/dir/link.txt");
+				const text = await fs.readTextFile("/dir/link.txt");
+				expect(text).toBe("real content");
+			});
+
+			test("symlink-to-directory traversal", async () => {
+				// Create /real-dir/file.txt, then /a -> /real-dir
+				// Reading /a/file.txt should resolve to /real-dir/file.txt
+				await fs.writeFile("/real-dir/file.txt", "traversed");
+				await fs.symlink("/real-dir", "/a");
+				const text = await fs.readTextFile("/a/file.txt");
+				expect(text).toBe("traversed");
+			});
+		});
+
+		// ---------------------------------------------------------------
+		// Concurrent rename + readFile (gated on pwrite for concurrency)
+		// ---------------------------------------------------------------
+
+		describe.skipIf(!capabilities.pwrite)("concurrent rename + readFile", () => {
+			test("concurrent rename + readFile does not crash or corrupt", async () => {
+				await fs.writeFile("/conc-rename.txt", "data before rename");
+				// Run rename and readFile concurrently. Neither should crash.
+				// readFile may see the file at old or new path depending on ordering.
+				const results = await Promise.allSettled([
+					fs.rename("/conc-rename.txt", "/conc-renamed.txt"),
+					fs.readFile("/conc-rename.txt"),
+				]);
+				// Rename should succeed.
+				expect(results[0]!.status).toBe("fulfilled");
+				// readFile may succeed (read before rename) or fail with ENOENT (read after rename).
+				if (results[1]!.status === "fulfilled") {
+					const data = (results[1] as PromiseFulfilledResult<Uint8Array>).value;
+					expect(new TextDecoder().decode(data)).toBe("data before rename");
+				} else {
+					const err = (results[1] as PromiseRejectedResult).reason;
+					expectErrorCode(err, "ENOENT");
+				}
+				// The file should exist at the new path.
+				const text = await fs.readTextFile("/conc-renamed.txt");
+				expect(text).toBe("data before rename");
+			});
 		});
 	});
 }