@zenfs/core 1.2.9 → 1.3.0

package/tests/fs/stat.test.ts

@@ -1,5 +1,6 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
+import { credentials } from '../../dist/credentials.js';
 import { Stats } from '../../dist/stats.js';
 import { fs } from '../common.js';
 
@@ -34,6 +35,47 @@ suite('Stats', () => {
 		fs.close(fd);
 	});
 
+	test('hasAccess for non-root access', () => {
+		const newFile = 'new.txt';
+
+		fs.writeFileSync(newFile, 'hello', {
+			mode: 0o640, // allow group access
+		});
+
+		const prevCredentials = {
+			...credentials,
+		};
+		const uid = 33;
+		const nonRootCredentials = {
+			uid,
+			gid: uid,
+			euid: uid,
+			egid: uid,
+			suid: uid,
+			sgid: uid,
+		};
+
+		fs.chownSync(newFile, 0, nonRootCredentials.gid); // creating with root-user so that non-root user can access
+
+		Object.assign(credentials, nonRootCredentials);
+		const stat = fs.statSync(newFile);
+
+		assert.equal(stat.gid, nonRootCredentials.gid);
+		assert.equal(stat.uid, 0);
+		assert.equal(stat.hasAccess(fs.constants.R_OK), true);
+		assert.equal(stat.hasAccess(fs.constants.W_OK), false);
+		assert.equal(stat.hasAccess(fs.constants.X_OK), false);
+		// changing group
+
+		Object.assign(credentials, { ...nonRootCredentials, gid: 44 });
+
+		assert.equal(stat.hasAccess(fs.constants.R_OK), false);
+		assert.equal(stat.hasAccess(fs.constants.W_OK), false);
+		assert.equal(stat.hasAccess(fs.constants.X_OK), false);
+
+		Object.assign(credentials, prevCredentials);
+	});
+
 	test('stat file', async () => {
 		const stats = await fs.promises.stat(existing_file);
 		assert(!stats.isDirectory());

package/tests/fs/times.test.ts

@@ -2,46 +2,46 @@ import assert from 'node:assert';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
 import { ErrnoError } from '../../dist/error.js';
-import { _toUnixTimestamp } from '../../dist/utils.js';
+import type { StatsLike } from '../../dist/stats.js';
 import { fs } from '../common.js';
 
-suite('times', () => {
-	const path = 'x.txt';
+const path = 'x.txt';
 
-	function expect_assert(resource: string | number, atime: Date | number, mtime: Date | number) {
-		const stats = typeof resource == 'string' ? fs.statSync(resource) : fs.fstatSync(resource);
-		// check up to single-second precision since sub-second precision is OS and fs dependent
-		assert(_toUnixTimestamp(atime) == _toUnixTimestamp(stats.atime));
-		assert(_toUnixTimestamp(mtime) == _toUnixTimestamp(stats.mtime));
-	}
+/**
+ * Gets unix timestamps from stats
+ *
+ * @internal
+ */
+export function unixTimestamps(stats: StatsLike<number>): Record<'atime' | 'mtime', number> {
+	return {
+		atime: Math.floor(stats.atimeMs),
+		mtime: Math.floor(stats.mtimeMs),
+	};
+}
 
+suite('times', () => {
 	async function runTest(atime: Date | number, mtime: Date | number): Promise<void> {
+		const times = {
+			atime: typeof atime == 'number' ? Math.floor(atime) : atime.getTime(),
+			mtime: typeof mtime == 'number' ? Math.floor(mtime) : mtime.getTime(),
+		};
+
 		await fs.promises.utimes(path, atime, mtime);
-		expect_assert(path, atime, mtime);
+
+		assert.deepStrictEqual(unixTimestamps(await fs.promises.stat(path)), times);
 
 		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
 			assert.strictEqual(error.code, 'ENOENT');
 		});
 
-		// don't close this fd
-		const handle = await fs.promises.open(path, 'r');
+		await using handle = await fs.promises.open(path, 'r');
 
 		await handle.utimes(atime, mtime);
-		expect_assert(handle.fd, atime, mtime);
+		assert.deepStrictEqual(unixTimestamps(await handle.stat()), times);
 
 		fs.utimesSync(path, atime, mtime);
-		expect_assert(path, atime, mtime);
-
-		// some systems don't have futimes
-		// if there's an error, it be ENOSYS
-		try {
-			fs.futimesSync(handle.fd, atime, mtime);
-			expect_assert(handle.fd, atime, mtime);
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.strictEqual(error.code, 'ENOSYS');
-		}
+		assert.deepStrictEqual(unixTimestamps(fs.statSync(path)), times);
 
 		try {
 			fs.utimesSync('foobarbaz', atime, mtime);
@@ -59,11 +59,11 @@ suite('times', () => {
 	}
 
 	test('utimes works', async () => {
-		await runTest(new Date('1982/09/10 13:37:00'), new Date('1982/09/10 13:37:00'));
-		await runTest(new Date(), new Date());
-		await runTest(123456.789, 123456.789);
+		await test('new Date(...)', () => runTest(new Date('1982/09/10 13:37:00'), new Date('1982/09/10 13:37:00')));
+		await test('new Date()', () => runTest(new Date(), new Date()));
+		await test('number', () => runTest(123456.789, 123456.789));
 		const stats = fs.statSync(path);
-		await runTest(stats.atime, stats.mtime);
+		await test('from stats', () => runTest(stats.atime, stats.mtime));
 	});
 
 	test('read changes atime', async () => {

package/tests/setup/cow+fetch.ts

@@ -33,11 +33,13 @@ server
 	.listen(port)
 	.unref();
 
+const baseUrl = 'http://localhost:' + port;
+
 await configureSingle({
 	backend: Overlay,
 	readable: Fetch.create({
-		baseUrl: `http://localhost:${port}/`,
-		index: '.index.json',
+		baseUrl,
+		index: baseUrl + '/.index.json',
 	}),
 	writable: InMemory.create({ name: 'cow' }),
 });