vault-link/frontend/local-client-cli/src/node-filesystem.test.ts

import { test } from "node:test";
import * as assert from "node:assert/strict";
import * as fs from "fs/promises";
import * as path from "path";
import * as os from "os";
import { NodeFileSystemOperations } from "./node-filesystem";

test("NodeFileSystemOperations - read and write files", async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vaultlink-test-"));
	const fsOps = new NodeFileSystemOperations(tempDir);

	try {
		const content = new TextEncoder().encode("Hello, world!");
		await fsOps.write("test.txt", content);

		const readContent = await fsOps.read("test.txt");
		assert.equal(new TextDecoder().decode(readContent), "Hello, world!");
	} finally {
		await fs.rm(tempDir, { recursive: true, force: true });
	}
});

test("NodeFileSystemOperations - create nested directories with forward slashes", async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vaultlink-test-"));
	const fsOps = new NodeFileSystemOperations(tempDir);

	try {
		const content = new TextEncoder().encode("Nested file");
		// Always use forward slashes in API
		await fsOps.write("dir1/dir2/test.txt", content);

		const readContent = await fsOps.read("dir1/dir2/test.txt");
		assert.equal(new TextDecoder().decode(readContent), "Nested file");
	} finally {
		await fs.rm(tempDir, { recursive: true, force: true });
	}
});

test("NodeFileSystemOperations - exists with forward slashes", async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vaultlink-test-"));
	const fsOps = new NodeFileSystemOperations(tempDir);

	try {
		assert.equal(await fsOps.exists("test.txt"), false);

		await fsOps.write("test.txt", new TextEncoder().encode("test"));

		assert.equal(await fsOps.exists("test.txt"), true);
	} finally {
		await fs.rm(tempDir, { recursive: true, force: true });
	}
});

test("NodeFileSystemOperations - delete with forward slashes", async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vaultlink-test-"));
	const fsOps = new NodeFileSystemOperations(tempDir);

	try {
		await fsOps.write("test.txt", new TextEncoder().encode("test"));
		assert.equal(await fsOps.exists("test.txt"), true);

		await fsOps.delete("test.txt");
		assert.equal(await fsOps.exists("test.txt"), false);
	} finally {
		await fs.rm(tempDir, { recursive: true, force: true });
	}
});

test("NodeFileSystemOperations - rename with forward slashes", async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vaultlink-test-"));
	const fsOps = new NodeFileSystemOperations(tempDir);

	try {
		const content = new TextEncoder().encode("test content");
		await fsOps.write("old.txt", content);

		await fsOps.rename("old.txt", "new.txt");

		assert.equal(await fsOps.exists("old.txt"), false);
		assert.equal(await fsOps.exists("new.txt"), true);

		const readContent = await fsOps.read("new.txt");
		assert.equal(new TextDecoder().decode(readContent), "test content");
	} finally {
		await fs.rm(tempDir, { recursive: true, force: true });
	}
});

test("NodeFileSystemOperations - rename to nested path with forward slashes", async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vaultlink-test-"));
	const fsOps = new NodeFileSystemOperations(tempDir);

	try {
		const content = new TextEncoder().encode("test content");
		await fsOps.write("old.txt", content);

		await fsOps.rename("old.txt", "dir1/dir2/new.txt");

		assert.equal(await fsOps.exists("old.txt"), false);
		assert.equal(await fsOps.exists("dir1/dir2/new.txt"), true);
	} finally {
		await fs.rm(tempDir, { recursive: true, force: true });
	}
});

test("NodeFileSystemOperations - getFileSize", async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vaultlink-test-"));
	const fsOps = new NodeFileSystemOperations(tempDir);

	try {
		const content = new TextEncoder().encode("Hello!");
		await fsOps.write("test.txt", content);

		const size = await fsOps.getFileSize("test.txt");
		assert.equal(size, content.length);
	} finally {
		await fs.rm(tempDir, { recursive: true, force: true });
	}
});

test("NodeFileSystemOperations - atomicUpdateText", async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vaultlink-test-"));
	const fsOps = new NodeFileSystemOperations(tempDir);

	try {
		await fsOps.write("test.txt", new TextEncoder().encode("Hello"));

		const result = await fsOps.atomicUpdateText("test.txt", (current) => ({
			text: current.text + " World",
			cursors: []
		}));

		assert.equal(result, "Hello World");

		const content = await fsOps.read("test.txt");
		assert.equal(new TextDecoder().decode(content), "Hello World");
	} finally {
		await fs.rm(tempDir, { recursive: true, force: true });
	}
});

test("NodeFileSystemOperations - handles paths with forward slashes on all platforms", async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "vaultlink-test-"));
	const fsOps = new NodeFileSystemOperations(tempDir);

	try {
		// API should always accept forward slashes
		const testPath = "deep/nested/directory/file.txt";
		const content = new TextEncoder().encode("test");

		await fsOps.write(testPath, content);
		assert.equal(await fsOps.exists(testPath), true);

		const readContent = await fsOps.read(testPath);
		assert.equal(new TextDecoder().decode(readContent), "test");

		await fsOps.delete(testPath);
		assert.equal(await fsOps.exists(testPath), false);
	} finally {
		await fs.rm(tempDir, { recursive: true, force: true });
	}
});