fix: prevent readFile from updating ctime when only accessing files

Co-authored-by: streamich <[email protected]>

Author: Copilot

src/__tests__/node.test.ts

@@ -60,15 +60,15 @@ describe('node.ts', () => {
         node.read(buf, 0, 1, 1);
         expect(buf.equals(Buffer.from([2]))).toBe(true);
       });
-      it('updates the atime and ctime', () => {
+      it('updates the atime but not ctime', () => {
         const node = new Node(1);
         const oldAtime = node.atime;
         const oldCtime = node.ctime;
         node.read(Buffer.alloc(0));
         const newAtime = node.atime;
         const newCtime = node.ctime;
         expect(newAtime).not.toBe(oldAtime);
-        expect(newCtime).not.toBe(oldCtime);
+        expect(newCtime).toBe(oldCtime);
       });
     });
     describe('.chmod(perm)', () => {
@@ -79,7 +79,7 @@ describe('node.ts', () => {
       expect(node.perm).toBe(0o600);
       expect(node.isFile()).toBe(true);
     });
-    describe.each(['uid', 'gid', 'atime', 'mtime', 'perm', 'nlink'])('when %s changes', field => {
+    describe.each(['uid', 'gid', 'mtime', 'perm', 'nlink'])('when %s changes', field => {
       it('updates the property and the ctime', () => {
         const node = new Node(1);
         const oldCtime = node.ctime;
@@ -89,28 +89,38 @@ describe('node.ts', () => {
         expect(node[field]).toBe(1);
       });
     });
+    describe('when atime changes', () => {
+      it('updates the property but NOT the ctime', () => {
+        const node = new Node(1);
+        const oldCtime = node.ctime;
+        node.atime = new Date(1);
+        const newCtime = node.ctime;
+        expect(newCtime).toBe(oldCtime);
+        expect(node.atime).toEqual(new Date(1));
+      });
+    });
     describe('.getString(encoding?)', () => {
-      it('updates the atime and ctime', () => {
+      it('updates the atime but not ctime', () => {
         const node = new Node(1);
         const oldAtime = node.atime;
         const oldCtime = node.ctime;
         node.getString();
         const newAtime = node.atime;
         const newCtime = node.ctime;
         expect(newAtime).not.toBe(oldAtime);
-        expect(newCtime).not.toBe(oldCtime);
+        expect(newCtime).toBe(oldCtime);
       });
     });
     describe('.getBuffer()', () => {
-      it('updates the atime and ctime', () => {
+      it('updates the atime but not ctime', () => {
         const node = new Node(1);
         const oldAtime = node.atime;
         const oldCtime = node.ctime;
         node.getBuffer();
         const newAtime = node.atime;
         const newCtime = node.ctime;
         expect(newAtime).not.toBe(oldAtime);
-        expect(newCtime).not.toBe(oldCtime);
+        expect(newCtime).toBe(oldCtime);
       });
     });
   });

src/core/Node.ts

@@ -68,7 +68,6 @@ export class Node extends EventEmitter {
 
   public set atime(atime: Date) {
     this._atime = atime;
-    this.ctime = new Date();
   }
 
   public get atime(): Date {
@@ -115,7 +114,7 @@ export class Node extends EventEmitter {
 
   getBuffer(): Buffer {
     this.atime = new Date();
-    if (!this.buf) this.setBuffer(bufferAllocUnsafe(0));
+    if (!this.buf) this.buf = bufferAllocUnsafe(0);
     return bufferFrom(this.buf); // Return a copy.
   }
 

src/node/__tests__/volume/readFile-ctime.test.ts

@@ -0,0 +1,78 @@
+import { memfs } from '../../..';
+
+describe('readFile ctime issue', () => {
+  it('should NOT change ctime when readFile is called', async () => {
+    const { fs } = memfs();
+
+    const file = '/test-readfile-ctime.txt';
+
+    // Create the file
+    await fs.promises.writeFile(file, 'test content');
+
+    // Get initial ctime
+    const initialStat = await fs.promises.stat(file);
+    const initialCtime = initialStat.ctimeMs;
+
+    // Wait a bit to ensure any ctime change would be detectable
+    await new Promise(resolve => setTimeout(resolve, 10));
+
+    // Read the file (this should only update atime, not ctime)
+    await fs.promises.readFile(file);
+
+    // Check ctime again
+    const afterReadStat = await fs.promises.stat(file);
+    const afterReadCtime = afterReadStat.ctimeMs;
+
+    // ctime should be unchanged after read
+    expect(afterReadCtime).toBe(initialCtime);
+  });
+
+  it('should change atime when readFile is called', async () => {
+    const { fs } = memfs();
+
+    const file = '/test-readfile-atime.txt';
+
+    // Create the file
+    await fs.promises.writeFile(file, 'test content');
+
+    // Get initial atime
+    const initialStat = await fs.promises.stat(file);
+    const initialAtime = initialStat.atimeMs;
+
+    // Wait a bit to ensure any atime change would be detectable
+    await new Promise(resolve => setTimeout(resolve, 10));
+
+    // Read the file (this should update atime)
+    await fs.promises.readFile(file);
+
+    // Check atime again
+    const afterReadStat = await fs.promises.stat(file);
+    const afterReadAtime = afterReadStat.atimeMs;
+
+    // atime should be updated after read
+    expect(afterReadAtime).toBeGreaterThan(initialAtime);
+  });
+
+  it('should NOT change ctime when readFileSync is called', () => {
+    const { fs } = memfs();
+
+    const file = '/test-readfilesync-ctime.txt';
+
+    // Create the file
+    fs.writeFileSync(file, 'test content');
+
+    // Get initial ctime
+    const initialStat = fs.statSync(file);
+    const initialCtime = initialStat.ctimeMs;
+
+    // Read the file (this should only update atime, not ctime)
+    fs.readFileSync(file);
+
+    // Check ctime again
+    const afterReadStat = fs.statSync(file);
+    const afterReadCtime = afterReadStat.ctimeMs;
+
+    // ctime should be unchanged after read
+    expect(afterReadCtime).toBe(initialCtime);
+  });
+});