@atlaspack/fs 2.12.1-canary.3354

package/test/OverlayFS.test.js

@@ -0,0 +1,232 @@
+// @flow
+
+import {OverlayFS} from '../src/OverlayFS';
+import {fsFixture} from '@atlaspack/test-utils/src/fsFixture';
+import {MemoryFS} from '../src/MemoryFS';
+import WorkerFarm from '@atlaspack/workers';
+
+import assert from 'assert';
+import path from 'path';
+
+describe('OverlayFS', () => {
+  let underlayFS;
+  let fs;
+  let workerFarm;
+
+  beforeEach(() => {
+    workerFarm = new WorkerFarm({
+      workerPath: require.resolve('@atlaspack/core/src/worker.js'),
+    });
+    underlayFS = new MemoryFS(workerFarm);
+    fs = new OverlayFS(workerFarm, underlayFS);
+  });
+
+  afterEach(async () => {
+    await workerFarm.end();
+  });
+
+  it('copies on write', async () => {
+    await fsFixture(underlayFS)`
+      foo: foo
+    `;
+
+    assert.equal(fs.readFileSync('foo', 'utf8'), 'foo');
+
+    await fs.writeFile('foo', 'bar');
+
+    assert.equal(fs.readFileSync('foo', 'utf8'), 'bar');
+    assert.equal(underlayFS.readFileSync('foo', 'utf8'), 'foo');
+  });
+
+  it('copies on write with dir', async () => {
+    await fsFixture(underlayFS)`
+      foo/foo: foo
+    `;
+
+    assert.equal(fs.readFileSync('foo/foo', 'utf8'), 'foo');
+
+    await fs.writeFile('foo/bar', 'bar');
+
+    assert.equal(fs.readFileSync('foo/bar', 'utf8'), 'bar');
+    assert(!underlayFS.existsSync('foo/bar'));
+  });
+
+  it('copies on write when copying', async () => {
+    await fsFixture(underlayFS)`
+      foo: foo
+    `;
+
+    assert.equal(fs.readFileSync('foo', 'utf8'), 'foo');
+
+    await fs.copyFile('foo', 'bar');
+    assert.equal(fs.readFileSync('bar', 'utf8'), 'foo');
+    assert(!underlayFS.existsSync('bar'));
+  });
+
+  it('copies on write when copying with dir', async () => {
+    await fsFixture(underlayFS)`
+      foo/foo: foo
+      bar
+    `;
+
+    assert.equal(fs.readFileSync('foo/foo', 'utf8'), 'foo');
+
+    await fs.copyFile('foo/foo', 'bar/bar');
+    assert.equal(fs.readFileSync('bar/bar', 'utf8'), 'foo');
+    assert(!underlayFS.existsSync('bar/bar'));
+  });
+
+  it('writes to memory', async () => {
+    await fs.writeFile('foo', 'foo');
+
+    assert.equal(fs.readFileSync('foo', 'utf8'), 'foo');
+    assert(!underlayFS.existsSync('foo'));
+  });
+
+  it('symlinks in memory', async () => {
+    await fsFixture(underlayFS)`
+      foo: foo
+    `;
+
+    assert(fs.existsSync('foo'));
+
+    await fs.symlink('foo', 'bar');
+
+    assert.equal(fs.readFileSync('bar', 'utf8'), 'foo');
+    assert.equal(underlayFS.readFileSync('foo', 'utf8'), 'foo');
+    assert.equal(fs.realpathSync('bar'), path.resolve('/foo'));
+    assert(!underlayFS.existsSync('bar'));
+  });
+
+  it('tracks deletes', async () => {
+    await fsFixture(underlayFS)`
+      foo: bar
+      baz -> foo`;
+
+    assert(fs.existsSync('foo'));
+    assert.equal(fs.realpathSync('baz'), path.resolve('/foo'));
+    assert(fs._isSymlink('baz'));
+
+    await fs.rimraf('foo');
+
+    assert(!fs.existsSync('foo'));
+    assert(fs._isSymlink('baz'));
+    assert(!fs.existsSync('baz'));
+    assert(underlayFS.existsSync('foo'));
+    assert(underlayFS.existsSync('baz'));
+  });
+
+  it('tracks unlinks', async () => {
+    await fsFixture(underlayFS)`
+      foo: bar
+      baz -> foo`;
+
+    assert(fs.existsSync('baz'));
+    assert.equal(fs.realpathSync('baz'), path.resolve('/foo'));
+    assert(fs._isSymlink('baz'));
+
+    await fs.unlink('baz');
+
+    assert(!fs._isSymlink('baz'));
+    assert(!fs.existsSync('baz'));
+    assert(fs.existsSync('foo'));
+    assert(underlayFS.existsSync('foo'));
+    assert(underlayFS.existsSync('baz'));
+    assert.equal(underlayFS.realpathSync('baz'), path.resolve('/foo'));
+  });
+
+  it('tracks nested deletes', async () => {
+    await fsFixture(underlayFS)`
+      foo/bar: baz
+      foo/bat/baz: qux
+    `;
+
+    assert(fs.existsSync('foo/bar'));
+    assert(fs.existsSync('foo/bat/baz'));
+
+    await fs.rimraf('foo');
+
+    assert(!fs.existsSync('foo/bar'));
+    assert(!fs.existsSync('foo/bat/baz'));
+    assert(underlayFS.existsSync('foo/bar'));
+    assert(underlayFS.existsSync('foo/bat/baz'));
+
+    await fs.mkdirp('foo');
+
+    assert(fs.existsSync('foo'));
+    assert(!fs.existsSync('foo/bar'));
+    assert(!fs.existsSync('foo/baz/bat'));
+
+    await fs.mkdirp('foo/baz');
+    assert(fs.existsSync('foo/baz'));
+    assert(!fs.existsSync('foo/baz/bat'));
+  });
+
+  it('supports changing to a dir that is only on the readable fs', async () => {
+    await fsFixture(underlayFS)`
+      foo/bar: baz
+    `;
+
+    assert.equal(fs.cwd(), path.resolve('/'));
+    fs.chdir('/foo');
+    assert.equal(fs.cwd(), path.resolve('/foo'));
+  });
+
+  it('supports changing to a dir that is only on the writable fs', async () => {
+    await fsFixture(underlayFS)`
+      foo/bar: bar
+    `;
+
+    await fs.mkdirp('/bar');
+    assert(!underlayFS.existsSync('/bar'));
+
+    assert.equal(fs.cwd(), path.resolve('/'));
+    fs.chdir('/bar');
+    assert.equal(fs.cwd(), path.resolve('/bar'));
+  });
+
+  it('supports changing dir relative to cwd', async () => {
+    await fsFixture(underlayFS)`
+      foo/bar: bar
+    `;
+
+    assert.equal(fs.cwd(), path.resolve('/'));
+    fs.chdir('foo');
+    assert.equal(fs.cwd(), path.resolve('/foo'));
+  });
+
+  it('changes dir without changing underlying fs dir', async () => {
+    await fsFixture(underlayFS)`
+      foo/bar: baz
+      foo/bat/baz: qux
+    `;
+
+    assert.equal(fs.cwd(), path.resolve('/'));
+    assert.equal(underlayFS.cwd(), path.resolve('/'));
+
+    fs.chdir('foo');
+
+    assert.equal(fs.cwd(), path.resolve('/foo'));
+    assert.equal(underlayFS.cwd(), path.resolve('/'));
+  });
+
+  it('errors when changing to a dir that does not exist on either fs', async () => {
+    await fsFixture(underlayFS)`
+      foo/bar: bar
+    `;
+
+    assert.throws(() => fs.chdir('/bar'), /ENOENT/);
+  });
+
+  it('errors when changing to a deleted dir', async () => {
+    await fsFixture(underlayFS)`
+      foo/bar: bar
+    `;
+
+    await fs.rimraf('foo');
+    assert(!fs.existsSync('foo'));
+    assert(underlayFS.existsSync('foo'));
+
+    assert.throws(() => fs.chdir('/foo'), /ENOENT/);
+  });
+});