@zenfs/core 1.3.6 → 1.4.0

package/scripts/test.js

@@ -1,16 +1,20 @@
 #!/usr/bin/env node
 
 import { execSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, mkdirSync, rmSync, globSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseArgs } from 'node:util';
 
 const { values: options, positionals } = parseArgs({
 	options: {
 		help: { short: 'h', type: 'boolean', default: false },
-		verbose: { type: 'boolean', default: false },
-		test: { type: 'string' },
-		forceExit: { short: 'f', type: 'boolean', default: false },
+		verbose: { short: 'w', type: 'boolean', default: false },
+		quiet: { short: 'q', type: 'boolean', default: false },
+		test: { short: 't', type: 'string' },
+		force: { short: 'f', type: 'boolean', default: false },
+		auto: { short: 'a', type: 'boolean', default: false },
+		build: { short: 'b', type: 'boolean', default: false },
+		common: { short: 'c', type: 'boolean', default: false },
 	},
 	allowPositionals: true,
 });
@@ -18,32 +22,89 @@ const { values: options, positionals } = parseArgs({
 if (options.help) {
 	console.log(`zenfs-test [...options] <...paths> 
 
-paths: The setup files to run tests on
+Paths: The setup files to run tests on
 
-options:
-	--help, -h		Outputs this help message
-	--verbose		Output verbose messages
-	--test			Which test to run
-	--forceExit		Whether to use --test-force-exit
-	`);
+Options:
+    --help, -h          Outputs this help message
+    --verbose,-w        Output verbose messages
+    --quiet, -q         Don't output normal messages
+    --test,-t <glob>    Which test(s) to run
+    --force, -f     Whether to use --test-force-exit
+    --auto, -a          Automatically detect setup files
+	--build, -b         Run the npm build script prior to running tests
+    --common, -c        Also run tests not specific to any backend
+`);
 	process.exit();
 }
 
-if (options.verbose) console.debug('Forcing tests to exit (--test-force-exit)');
+if (options.quiet && options.verbose) {
+	console.error('ERROR: Can not specify --verbose and --quiet');
+	process.exit(1);
+}
+
+options.verbose && options.force && console.debug('Forcing tests to exit (--test-force-exit)');
+
+if (options.build) {
+	!options.quiet && console.log('Building...');
+	try {
+		execSync('npm run build');
+	} catch {
+		console.warn('Build failed, continuing without it.');
+	}
+}
 
 if (!existsSync(join(import.meta.dirname, '../dist'))) {
-	console.log('ERROR: Missing build. If you are using an installed package, please submit a bug report.');
+	console.error('ERROR: Missing build. If you are using an installed package, please submit a bug report.');
 	process.exit(1);
 }
 
+if (options.auto) {
+	let sum = 0;
+
+	for (const pattern of ['**/tests/setup/*.ts', '**/tests/setup-*.ts']) {
+		const files = await globSync(pattern);
+		sum += files.length;
+		positionals.push(...files);
+	}
+
+	!options.quiet && console.log(`Auto-detected ${sum} test setup files`);
+}
+
+const coverage = join(import.meta.dirname, '../.coverage');
+if (existsSync(coverage)) rmSync(coverage, { recursive: true });
+mkdirSync(coverage);
+process.env.NODE_V8_COVERAGE = coverage;
+
+if (options.common) {
+	!options.quiet && console.log('Running common tests...');
+	try {
+		execSync("tsx --test --experimental-test-coverage 'tests/**/!(fs)/*.test.ts'", {
+			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
+		});
+	} catch {
+		console.error('Common tests failed');
+	}
+}
+
 const testsGlob = join(import.meta.dirname, `../tests/fs/${options.test || '*'}.test.ts`);
 
 for (const setupFile of positionals) {
-	if (options.verbose) console.debug('Running tests for:', setupFile);
-	process.env.SETUP = setupFile;
 	if (!existsSync(setupFile)) {
-		console.log('ERROR: Skipping non-existent file:', setupFile);
+		!options.quiet && console.warn('Skipping tests for non-existent setup file:', setupFile);
 		continue;
 	}
-	execSync(['tsx --test --experimental-test-coverage', options.forceExit ? '--test-force-exit' : '', testsGlob, process.env.CMD].join(' '), { stdio: 'inherit' });
+
+	!options.quiet && console.debug('Running tests using setup:', setupFile);
+	process.env.SETUP = setupFile;
+
+	try {
+		execSync(['tsx --test --experimental-test-coverage', options.force ? '--test-force-exit' : '', testsGlob, process.env.CMD].join(' '), {
+			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
+		});
+	} catch {
+		!options.quiet && console.error('Tests failed:', setupFile);
+	}
 }
+
+execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
+rmSync('.coverage', { recursive: true });

package/tests/assignment.ts

@@ -7,7 +7,7 @@
 	Notes on omissions and exclusions:
 	- __promisify__ is omitted as it is metadata
 	- native is omitted as zenfs isn't native
-	- ReadStream and WriteStream are excluded since they are polfilled from another module
+	- ReadStream and WriteStream are excluded since they are polyfilled from another module
 */
 
 import { fs as zen } from '../src/index.js';

package/tests/common/context.test.ts

@@ -0,0 +1,19 @@
+import { suite, test } from 'node:test';
+import assert from 'node:assert';
+import { bindContext } from '../../dist/context.js';
+import * as fs from '../../dist/emulation/index.js';
+
+fs.mkdirSync('/new_root');
+const c_fs = bindContext('/new_root');
+
+suite('Context', () => {
+	test('create a file', () => {
+		c_fs.writeFileSync('/example.txt', 'not in real root!');
+		assert.deepEqual(fs.readdirSync('/'), ['new_root']);
+		assert.deepEqual(fs.readdirSync('/new_root'), ['example.txt']);
+	});
+
+	test('break-out fails', () => {
+		assert.deepEqual(c_fs.readdirSync('/../../'), ['example.txt']);
+	});
+});

package/tests/{devices.test.ts → common/devices.test.ts}

@@ -1,8 +1,8 @@
 import { suite, test } from 'node:test';
 import assert from 'node:assert';
-import { configure } from '../src/config.js';
-import * as fs from '../src/emulation/index.js';
-import { S_IFCHR, S_IFMT } from '../src/emulation/constants.js';
+import { configure } from '../../dist/config.js';
+import * as fs from '../../dist/emulation/index.js';
+import { S_IFCHR, S_IFMT } from '../../dist/emulation/constants.js';
 
 await configure({
 	addDevices: true,

package/tests/{handle.test.ts → common/handle.test.ts}

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import { constants, type FileHandle, open } from '../src/emulation/promises.js';
+import { constants, type FileHandle, open } from '../../dist/emulation/promises.js';
 
 const content = 'The cake is a lie',
 	appended = '\nAnother lie';

package/tests/common/mounts.test.ts

@@ -0,0 +1,36 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { configure } from '../../dist/config.js';
+import * as fs from '../../dist/emulation/index.js';
+import { InMemory } from '../../dist/index.js';
+
+suite('Mounts', () => {
+	test('Mount in nested directory', async () => {
+		await configure({
+			mounts: {
+				'/nested/dir': InMemory,
+			},
+		});
+
+		assert.deepStrictEqual(fs.readdirSync('/'), ['nested']);
+		assert.deepStrictEqual(fs.readdirSync('/nested'), ['dir']);
+
+		// cleanup
+		fs.umount('/nested/dir');
+		fs.rmSync('/nested', { recursive: true, force: true });
+	});
+
+	test('Race conditions', async () => {
+		await configure({
+			mounts: {
+				one: InMemory,
+				two: InMemory,
+				three: InMemory,
+				four: InMemory,
+			},
+		});
+
+		assert.equal(fs.mounts.size, 5); // 4 + default `/` mount
+		assert.equal(fs.readdirSync('/').length, 4);
+	});
+});

package/tests/{mutex.test.ts → common/mutex.test.ts}

@@ -1,7 +1,7 @@
 import { wait } from 'utilium';
-import { Mutexed } from '../src/mixins/mutexed.js';
-import { StoreFS } from '../src/backends/store/fs.js';
-import { InMemoryStore } from '../src/backends/memory.js';
+import { Mutexed } from '../../dist/mixins/mutexed.js';
+import { StoreFS } from '../../dist/backends/store/fs.js';
+import { InMemoryStore } from '../../dist/backends/memory.js';
 import { suite, test } from 'node:test';
 import assert from 'node:assert';
 

package/tests/common/path.test.ts

@@ -0,0 +1,34 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { basename, dirname, extname, join, normalize, resolve } from '../../dist/emulation/path.js';
+
+suite('Path emulation', () => {
+	test('resolve', () => {
+		assert.equal(resolve('somepath'), '/somepath');
+		assert.equal(resolve('/another', 'path'), '/another/path');
+	});
+
+	test('join', () => {
+		assert.equal(join('/path', 'to', 'file.txt'), '/path/to/file.txt');
+		assert.equal(join('/path/', 'to', '/file.txt'), '/path/to/file.txt');
+	});
+
+	test('normalize', () => {
+		assert.equal(normalize('/path/to/../file.txt'), '/path/file.txt');
+		assert.equal(normalize('/path/to/./file.txt'), '/path/to/file.txt');
+	});
+
+	test('basename', () => {
+		assert.equal(basename('/path/to/file.txt'), 'file.txt');
+		assert.equal(basename('/path/to/file.txt', '.txt'), 'file');
+	});
+
+	test('dirname', () => {
+		assert.equal(dirname('/path/to/file.txt'), '/path/to');
+	});
+
+	test('extname', () => {
+		assert.equal(extname('/path/to/file.txt'), '.txt');
+		assert.equal(extname('/path/to/file'), '');
+	});
+});

package/tests/common.ts

@@ -1,11 +1,12 @@
 import { join, resolve } from 'node:path';
-import { fs } from '../dist/index.js';
+import { fs as defaultFS } from '../dist/index.js';
+export type * from '../dist/emulation/index.js';
 
 const setupPath = resolve(process.env.SETUP || join(import.meta.dirname, 'setup/memory.ts'));
 
-await import(setupPath).catch(error => {
+const setup = await import(setupPath).catch(error => {
 	console.log('Failed to import test setup:');
 	throw error;
 });
 
-export { fs };
+export const fs = (setup.fs || defaultFS) as typeof defaultFS;

package/tests/fs/dir.test.ts

@@ -1,6 +1,6 @@
 import assert, { rejects } from 'node:assert';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { fs, type Dirent } from '../common.js';
 
 const testFile = 'test-file.txt';
 fs.writeFileSync(testFile, 'Sample content');
@@ -59,7 +59,7 @@ suite('Dirent', () => {
 
 suite('Dir', () => {
 	test('read()', async () => {
-		const dir = new fs.Dir(testDirPath);
+		const dir = fs.opendirSync(testDirPath);
 
 		const dirent1 = await dir.read();
 		assert(dirent1 instanceof fs.Dirent);
@@ -76,7 +76,7 @@ suite('Dir', () => {
 	});
 
 	test('readSync()', () => {
-		const dir = new fs.Dir(testDirPath);
+		const dir = fs.opendirSync(testDirPath);
 
 		const dirent1 = dir.readSync();
 		assert(dirent1 instanceof fs.Dirent);
@@ -93,20 +93,20 @@ suite('Dir', () => {
 	});
 
 	test('close()', async () => {
-		const dir = new fs.Dir(testDirPath);
+		const dir = fs.opendirSync(testDirPath);
 		await dir.close();
 		rejects(dir.read(), 'Can not use closed Dir');
 	});
 
 	test('closeSync()', () => {
-		const dir = new fs.Dir(testDirPath);
+		const dir = fs.opendirSync(testDirPath);
 		dir.closeSync();
 		assert.throws(() => dir.readSync(), 'Can not use closed Dir');
 	});
 
 	test('asynchronous iteration', async () => {
-		const dir = new fs.Dir(testDirPath);
-		const dirents: fs.Dirent[] = [];
+		const dir = fs.opendirSync(testDirPath);
+		const dirents: Dirent[] = [];
 
 		for await (const dirent of dir) {
 			dirents.push(dirent);
@@ -119,26 +119,26 @@ suite('Dir', () => {
 	});
 
 	test('read after directory is closed', async () => {
-		const dir = new fs.Dir(testDirPath);
+		const dir = fs.opendirSync(testDirPath);
 		await dir.close();
 		await assert.rejects(dir.read(), 'Can not use closed Dir');
 	});
 
 	test('readSync after directory is closed', () => {
-		const dir = new fs.Dir(testDirPath);
+		const dir = fs.opendirSync(testDirPath);
 		dir.closeSync();
 		assert.throws(() => dir.readSync(), 'Can not use closed Dir');
 	});
 
 	test('close multiple times', async () => {
-		const dir = new fs.Dir(testDirPath);
+		const dir = fs.opendirSync(testDirPath);
 		await dir.close();
 		await dir.close(); // Should not throw an error
 		assert(dir['closed']);
 	});
 
 	test('closeSync multiple times', () => {
-		const dir = new fs.Dir(testDirPath);
+		const dir = fs.opendirSync(testDirPath);
 		dir.closeSync();
 		dir.closeSync(); // Should not throw an error
 		assert(dir['closed']);

package/tests/fs/directory.test.ts

@@ -40,27 +40,27 @@ suite('Directories', () => {
 	});
 
 	test('mkdir, recursive', async () => {
-		assert((await fs.promises.mkdir('/recursiveP/A/B', { recursive: true, mode: 0o755 })) == '/recursiveP');
-		assert((await fs.promises.mkdir('/recursiveP/A/B/C/D', { recursive: true, mode: 0o777 })) == '/recursiveP/A/B/C');
-		assert((await fs.promises.mkdir('/recursiveP/A/B/C/D', { recursive: true, mode: 0o700 })) == undefined);
+		assert.equal(await fs.promises.mkdir('/recursiveP/A/B', { recursive: true, mode: 0o755 }), '/recursiveP');
+		assert.equal(await fs.promises.mkdir('/recursiveP/A/B/C/D', { recursive: true, mode: 0o777 }), '/recursiveP/A/B/C');
+		assert.equal(await fs.promises.mkdir('/recursiveP/A/B/C/D', { recursive: true, mode: 0o700 }), undefined);
 
-		assert((await fs.promises.stat('/recursiveP')).mode == (fs.constants.S_IFDIR | 0o755));
-		assert((await fs.promises.stat('/recursiveP/A')).mode == (fs.constants.S_IFDIR | 0o755));
-		assert((await fs.promises.stat('/recursiveP/A/B')).mode == (fs.constants.S_IFDIR | 0o755));
-		assert((await fs.promises.stat('/recursiveP/A/B/C')).mode == (fs.constants.S_IFDIR | 0o777));
-		assert((await fs.promises.stat('/recursiveP/A/B/C/D')).mode == (fs.constants.S_IFDIR | 0o777));
+		assert.equal((await fs.promises.stat('/recursiveP')).mode, fs.constants.S_IFDIR | 0o755);
+		assert.equal((await fs.promises.stat('/recursiveP/A')).mode, fs.constants.S_IFDIR | 0o755);
+		assert.equal((await fs.promises.stat('/recursiveP/A/B')).mode, fs.constants.S_IFDIR | 0o755);
+		assert.equal((await fs.promises.stat('/recursiveP/A/B/C')).mode, fs.constants.S_IFDIR | 0o777);
+		assert.equal((await fs.promises.stat('/recursiveP/A/B/C/D')).mode, fs.constants.S_IFDIR | 0o777);
 	});
 
 	test('mkdirSync, recursive', () => {
-		assert(fs.mkdirSync('/recursiveS/A/B', { recursive: true, mode: 0o755 }) === '/recursiveS');
-		assert(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o777 }) === '/recursiveS/A/B/C');
-		assert(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o700 }) === undefined);
-
-		assert(fs.statSync('/recursiveS').mode == (fs.constants.S_IFDIR | 0o755));
-		assert(fs.statSync('/recursiveS/A').mode == (fs.constants.S_IFDIR | 0o755));
-		assert(fs.statSync('/recursiveS/A/B').mode == (fs.constants.S_IFDIR | 0o755));
-		assert(fs.statSync('/recursiveS/A/B/C').mode == (fs.constants.S_IFDIR | 0o777));
-		assert(fs.statSync('/recursiveS/A/B/C/D').mode == (fs.constants.S_IFDIR | 0o777));
+		assert.equal(fs.mkdirSync('/recursiveS/A/B', { recursive: true, mode: 0o755 }), '/recursiveS');
+		assert.equal(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o777 }), '/recursiveS/A/B/C');
+		assert.equal(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o700 }), undefined);
+
+		assert.equal(fs.statSync('/recursiveS').mode, fs.constants.S_IFDIR | 0o755);
+		assert.equal(fs.statSync('/recursiveS/A').mode, fs.constants.S_IFDIR | 0o755);
+		assert.equal(fs.statSync('/recursiveS/A/B').mode, fs.constants.S_IFDIR | 0o755);
+		assert.equal(fs.statSync('/recursiveS/A/B/C').mode, fs.constants.S_IFDIR | 0o777);
+		assert.equal(fs.statSync('/recursiveS/A/B/C/D').mode, fs.constants.S_IFDIR | 0o777);
 	});
 
 	test('readdirSync without permission', () => {

package/tests/fs/errors.test.ts

@@ -1,23 +1,10 @@
 import assert from 'node:assert';
-import { suite, test } from 'node:test';
-import { ErrnoError } from '../../dist/error.js';
+import test, { suite } from 'node:test';
+import type { ErrnoError } from '../../dist/error.js';
 import { fs } from '../common.js';
 
 const existingFile = '/exit.js';
 
-async function expectError(fn: (...args: any[]) => unknown, path: string, ...args: any[]) {
-	let error: ErrnoError | undefined;
-	try {
-		await fn(path, ...args);
-	} catch (err: any) {
-		assert(err instanceof ErrnoError);
-		error = err;
-	}
-	assert(error);
-	assert.equal(error.path, path);
-	assert(error.message.includes(path));
-}
-
 suite('Error messages', () => {
 	const path = '/non-existent';
 
@@ -26,28 +13,31 @@ suite('Error messages', () => {
 		assert.equal(error.bufferSize(), 4 + JSON.stringify(error.toJSON()).length);
 	});
 
-	test('stat', () => expectError(fs.promises.stat, path));
-	test('mkdir', () => expectError(fs.promises.mkdir, existingFile, 0o666));
-	test('rmdir', () => expectError(fs.promises.rmdir, path));
-	test('rmdir', () => expectError(fs.promises.rmdir, existingFile));
-	test('rename', () => expectError(fs.promises.rename, path, 'foo'));
-	test('open', () => expectError(fs.promises.open, path, 'r'));
-	test('readdir', () => expectError(fs.promises.readdir, path));
-	test('unlink', () => expectError(fs.promises.unlink, path));
-	test('link', () => expectError(fs.promises.link, path, 'foo'));
-	test('chmod', () => expectError(fs.promises.chmod, path, 0o666));
-	test('lstat', () => expectError(fs.promises.lstat, path));
-	test('readlink', () => expectError(fs.promises.readlink, path));
-	test('statSync', () => expectError(fs.statSync, path));
-	test('mkdirSync', () => expectError(fs.mkdirSync, existingFile, 0o666));
-	test('rmdirSync', () => expectError(fs.rmdirSync, path));
-	test('rmdirSync', () => expectError(fs.rmdirSync, existingFile));
-	test('renameSync', () => expectError(fs.renameSync, path, 'foo'));
-	test('openSync', () => expectError(fs.openSync, path, 'r'));
-	test('readdirSync', () => expectError(fs.readdirSync, path));
-	test('unlinkSync', () => expectError(fs.unlinkSync, path));
-	test('linkSync', () => expectError(fs.linkSync, path, 'foo'));
-	test('chmodSync', () => expectError(fs.chmodSync, path, 0o666));
-	test('lstatSync', () => expectError(fs.lstatSync, path));
-	test('readlinkSync', () => expectError(fs.readlinkSync, path));
+	const missing = { path, message: new RegExp(path) };
+	const existing = { path: existingFile, message: new RegExp(existingFile) };
+
+	test('stat', () => assert.rejects(() => fs.promises.stat(path), missing));
+	test('mkdir', () => assert.rejects(() => fs.promises.mkdir(existingFile, 0o666), existing));
+	test('rmdir', () => assert.rejects(() => fs.promises.rmdir(path), missing));
+	test('rmdir', () => assert.rejects(() => fs.promises.rmdir(existingFile), existing));
+	test('rename', () => assert.rejects(() => fs.promises.rename(path, 'foo'), missing));
+	test('open', () => assert.rejects(() => fs.promises.open(path, 'r'), missing));
+	test('readdir', () => assert.rejects(() => fs.promises.readdir(path), missing));
+	test('unlink', () => assert.rejects(() => fs.promises.unlink(path), missing));
+	test('link', () => assert.rejects(() => fs.promises.link(path, 'foo'), missing));
+	test('chmod', () => assert.rejects(() => fs.promises.chmod(path, 0o666), missing));
+	test('lstat', () => assert.rejects(() => fs.promises.lstat(path), missing));
+	test('readlink', () => assert.rejects(() => fs.promises.readlink(path), missing));
+	test('statSync', () => assert.throws(() => fs.statSync(path), missing));
+	test('mkdirSync', () => assert.throws(() => fs.mkdirSync(existingFile, 0o666), existing));
+	test('rmdirSync', () => assert.throws(() => fs.rmdirSync(path), missing));
+	test('rmdirSync', () => assert.throws(() => fs.rmdirSync(existingFile), existing));
+	test('renameSync', () => assert.throws(() => fs.renameSync(path, 'foo'), missing));
+	test('openSync', () => assert.throws(() => fs.openSync(path, 'r'), missing));
+	test('readdirSync', () => assert.throws(() => fs.readdirSync(path), missing));
+	test('unlinkSync', () => assert.throws(() => fs.unlinkSync(path), missing));
+	test('linkSync', () => assert.throws(() => fs.linkSync(path, 'foo'), missing));
+	test('chmodSync', () => assert.throws(() => fs.chmodSync(path, 0o666), missing));
+	test('lstatSync', () => assert.throws(() => fs.lstatSync(path), missing));
+	test('readlinkSync', () => assert.throws(() => fs.readlinkSync(path), missing));
 });

package/tests/fs/watch.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { fs, type Stats } from '../common.js';
 
 const testDir = '/test-watch-dir';
 const testFile = `${testDir}/test.txt`;
@@ -33,7 +33,7 @@ suite('Watch Features', () => {
 	});
 
 	test('fs.watchFile should detect changes to a file', async () => {
-		const listener = (curr: fs.Stats, prev: fs.Stats) => {
+		const listener = (curr: Stats, prev: Stats) => {
 			assert(curr.mtimeMs != prev.mtimeMs);
 			fs.unwatchFile(testFile, listener);
 		};

package/tests/setup/context.ts

@@ -0,0 +1,9 @@
+import { bindContext } from '../../dist/context.js';
+import { fs as _fs } from '../../dist/index.js';
+import { copy, data } from '../setup.js';
+
+_fs.mkdirSync('/new_root');
+
+export const fs = bindContext('/new_root');
+
+copy(data, fs);

package/tests/setup/cow+fetch.ts

@@ -3,7 +3,7 @@ import { readFileSync } from 'node:fs';
 import { createServer } from 'node:http';
 import { join } from 'node:path';
 import { configureSingle, Fetch, InMemory, Overlay } from '../../dist/index.js';
-import { data, tmp } from './common.js';
+import { data, tmp } from '../setup.js';
 
 const port = 26514,
 	index = tmp + '/index.json';

package/tests/setup/memory.ts

@@ -1,3 +1,3 @@
-import { copy, data } from './common.js';
+import { copy, data } from '../setup.js';
 
 copy(data);

package/tests/{setup/common.ts → setup.ts}

@@ -1,16 +1,17 @@
 import { join, relative } from 'node:path';
 import { statSync, readFileSync, readdirSync, existsSync, mkdirSync } from 'node:fs';
-import { fs } from '../../dist/index.js';
+import { fs as _fs } from '../dist/index.js';
+import type { BoundContext } from '../dist/context.js';
 
-export const data = join(import.meta.dirname, '../data');
+export const data = join(import.meta.dirname, 'data');
 
-export const tmp = join(import.meta.dirname, '../tmp');
+export const tmp = join(import.meta.dirname, 'tmp');
 
 if (!existsSync(tmp)) {
 	mkdirSync(tmp);
 }
 
-export function copy(_path: string) {
+export function copy(_path: string, fs: typeof _fs | BoundContext = _fs) {
 	const path = relative(data, _path) || '/';
 	const stats = statSync(_path);
 
@@ -23,6 +24,6 @@ export function copy(_path: string) {
 		fs.mkdirSync(path);
 	}
 	for (const file of readdirSync(_path)) {
-		copy(join(_path, file));
+		copy(join(_path, file), fs);
 	}
 }