Fix compatibility with Node 20

[ademdinarevic]

Since we upgraded to node 20.10.0 the method for mocking file creation doesn't work properly

const mockFs = require("mock-fs");

mockFs({
  "/file": {
     VAR: "var_value",
  },
});

[zbigg]

For anyone trying to fix it, it's caused by node20 to use new binding method: readFileUtf8 which isn't "mocked" by this module.

It looks like we should just implement open+read+toUtf+close as one function here.

The usage:

https://github.com/nodejs/node/blob/a81788cb27b96579343765eeba07fd2b772829d0/lib/fs.js#L456

Implementation

https://github.com/nodejs/node/blob/a81788cb27b96579343765eeba07fd2b772829d0/src/node_file.cc#L2375

This is very naive and PoC binding that fixes readFileSync(..., 'utf8') for node 20

Binding.prototype.readFileUtf8 = function (
  name,
  flags
) {
    const fd = this.open(name, flags);
    const descriptor = this.getDescriptorById(fd);

    if (!descriptor.isRead()) {
      throw new FSError('EBADF');
    }
    const file = descriptor.getItem();
    if (file instanceof Directory) {
      throw new FSError('EISDIR');
    }
    if (!(file instanceof File)) {
      // deleted or not a regular file
      throw new FSError('EBADF');
    }
    const content = file.getContent();
    return content.toString('utf8');
};

[canhassancode]

Facing the exact same issue, it was working completely fine then randomly broke. Below is an example of the setup:

beforeAll(() => {
  mockFs.restore();
});

afterEach(() => {
  mockFs.restore();
});

it('mock test', () => {
  mockFs({
    './profiles': {
      test: {
        'TEST_PROFILE_1.json': JSON.stringify(testProfile1),
        'TEST_PROFILE_2.json': JSON.stringify(testProfile2),
      },
...
    },
  });
});

Getting the error: ENOENT: no such file or directory, open 'profiles/test/TEST_PROFILE_2.json'

[crfrolik]

For those like me who came here in a panic because their tests started failing, I had success (and minimal effort) replacing mock-fs with memfs.

[PedroS11]

For those like me who came here in a panic because their tests started failing, I had success (and minimal effort) replacing mock-fs with memfs.

Do you mind post some examples please? I'm trying to use memfs but I'm struggling with it. I found an basic example with jest however, i'm using chai so nothing is working

For reference, this is the basic example of memfs using jest: https://medium.com/nerd-for-tech/testing-in-node-js-easy-way-to-mock-filesystem-883b9f822ea4

or https://dev.to/julienp/node-js-testing-using-a-virtual-filesystem-as-a-mock-2jln

[JBloss1517]

@PedroS11 I also decided to switch using memfs. For me, it was mostly a matter of switching mockFS({. . .}) with vol.fromNestedJSON({. . .}) and changing mockFS.restore() to vol.reset()

So for example (I am using vitest in this but jest should be pretty close as well)

Using mock-fs

const mockFS = require("mock-fs");
import { afterEach, beforeEach, describe, expect, test } from "vitest";

describe("some test", () => {
  beforeEach(() => {
    mockFS({
      Projects: {
        "Projects - 23": {
          "Test Client": {
            "Projects 1": {
              "Sub folder": {},
            },
          },
        },
        "Projects - 24": {},
      },
    });
  });

  afterEach(() => {
    mockFS.restore();
  });

  test("project folder creation", () => {
    const projectFolderPath = path.join(
      "Projects",
      "Projects - 23",
      "Test Client",
      "Projects 2",
    );
    const result = _createProjectFolder(projectFolderPath, projectTemplatePath);
    expect(result).toEqual({ path: projectFolderPath, error: null });
  });
});

Using memfs

import { fs, vol } from "memfs";
import { afterEach, beforeEach, describe, expect, test } from "vitest";

describe("some test", () => {
  beforeEach(() => {
    vol.fromNestedJSON({   // <-- Changed this from mockFS
      Projects: {
        "Projects - 23": {
          "Test Client": {
            "Projects 1": {
              "Sub folder": {},
            },
          },
        },
        "Projects - 24": {},
      },
    });
  });

  afterEach(() => {
    vol.reset(); // <-- changed this from mockFS.restore();
  });

  test("project folder creation", () => {
    const projectFolderPath = path.join(
      "Projects",
      "Projects - 23",
      "Test Client",
      "Projects 2",
    );
    const result = _createProjectFolder(projectFolderPath, projectTemplatePath);
    expect(result).toEqual({ path: projectFolderPath, error: null });
  });
});

I hope that helps!

[PedroS11]

@PedroS11 I also decided to switch using memfs. For me, it was mostly a matter of switching mockFS({. . .}) with vol.fromNestedJSON({. . .}) and changing mockFS.restore() to vol.reset()

So for example (I am using vitest in this but jest should be pretty close as well)

Using mock-fs

const mockFS = require("mock-fs");
import { afterEach, beforeEach, describe, expect, test } from "vitest";

describe("some test", () => {
  beforeEach(() => {
    mockFS({
      Projects: {
        "Projects - 23": {
          "Test Client": {
            "Projects 1": {
              "Sub folder": {},
            },
          },
        },
        "Projects - 24": {},
      },
    });
  });

  afterEach(() => {
    mockFS.restore();
  });

  test("project folder creation", () => {
    const projectFolderPath = path.join(
      "Projects",
      "Projects - 23",
      "Test Client",
      "Projects 2",
    );
    const result = _createProjectFolder(projectFolderPath, projectTemplatePath);
    expect(result).toEqual({ path: projectFolderPath, error: null });
  });
});

Using memfs

import { fs, vol } from "memfs";
import { afterEach, beforeEach, describe, expect, test } from "vitest";

describe("some test", () => {
  beforeEach(() => {
    vol.fromNestedJSON({   // <-- Changed this from mockFS
      Projects: {
        "Projects - 23": {
          "Test Client": {
            "Projects 1": {
              "Sub folder": {},
            },
          },
        },
        "Projects - 24": {},
      },
    });
  });

  afterEach(() => {
    vol.reset(); // <-- changed this from mockFS.restore();
  });

  test("project folder creation", () => {
    const projectFolderPath = path.join(
      "Projects",
      "Projects - 23",
      "Test Client",
      "Projects 2",
    );
    const result = _createProjectFolder(projectFolderPath, projectTemplatePath);
    expect(result).toEqual({ path: projectFolderPath, error: null });
  });
});

I hope that helps!

Thank you for this snippet @JBloss1517 !! in the following weeks, I'll try to migrate too and I'll see how it works. I'll leave my progress here when I start so it helps everyone with this struggle

[dennismeister93]

hi @tschaub, are there any plans to work on this?

[tschaub]

@dennismeister93 - I would be happy to review a pull request, but don't have plans to spend time on a fix myself.

[dicolasi]

struggling with the same problem here.

[MichaelSitter]

I was having issues with my Jest tests still using the built-in fs instead of the memfs implementation. This worked to mock out fs & fs/promises:

import { fs, vol } from 'memfs'
// import needs to match what you used in your code
jest.mock('fs', () => fs)
jest.mock('fs/promises', () => fs.promises)

// test code