@atlaspack/core 2.12.1-canary.3354

package/test/requests/ConfigRequest.test.js

@@ -0,0 +1,254 @@
+// @flow strict-local
+
+import WorkerFarm from '@atlaspack/workers';
+import path from 'path';
+import assert from 'assert';
+import sinon from 'sinon';
+import {MemoryFS} from '@atlaspack/fs';
+import {hashString} from '@atlaspack/rust';
+
+import type {
+  ConfigRequest,
+  ConfigRequestResult,
+} from '../../src/requests/ConfigRequest';
+import type {RunAPI} from '../../src/RequestTracker';
+import {runConfigRequest} from '../../src/requests/ConfigRequest';
+import {toProjectPath} from '../../src/projectPath';
+
+// $FlowFixMe unclear-type forgive me
+const mockCast = (f: any): any => f;
+
+describe('ConfigRequest tests', () => {
+  const projectRoot = 'project_root';
+  const farm = new WorkerFarm({
+    workerPath: require.resolve('../../src/worker.js'),
+    maxConcurrentWorkers: 1,
+  });
+  let fs = new MemoryFS(farm);
+  beforeEach(() => {
+    fs = new MemoryFS(farm);
+  });
+
+  const getMockRunApi = (
+    options: mixed = {projectRoot, inputFS: fs},
+  ): RunAPI<ConfigRequestResult> => {
+    const mockRunApi = {
+      storeResult: sinon.spy(),
+      canSkipSubrequest: sinon.spy(),
+      invalidateOnFileCreate: sinon.spy(),
+      getInvalidSubRequests: sinon.spy(),
+      getInvalidations: sinon.spy(),
+      getPreviousResult: sinon.spy(),
+      getRequestResult: sinon.spy(),
+      getSubRequests: sinon.spy(),
+      invalidateOnBuild: sinon.spy(),
+      invalidateOnConfigKeyChange: sinon.spy(),
+      invalidateOnEnvChange: sinon.spy(),
+      invalidateOnFileDelete: sinon.spy(),
+      invalidateOnFileUpdate: sinon.spy(),
+      invalidateOnOptionChange: sinon.spy(),
+      invalidateOnStartup: sinon.spy(),
+      runRequest: sinon.spy(request => {
+        return request.run({
+          api: mockRunApi,
+          options,
+        });
+      }),
+    };
+    return mockRunApi;
+  };
+
+  const baseRequest: ConfigRequest = {
+    id: 'config_request_test',
+    invalidateOnBuild: false,
+    invalidateOnConfigKeyChange: [],
+    invalidateOnFileCreate: [],
+    invalidateOnEnvChange: new Set(),
+    invalidateOnOptionChange: new Set(),
+    invalidateOnStartup: false,
+    invalidateOnFileChange: new Set(),
+  };
+
+  it('can execute a config request', async () => {
+    const mockRunApi = getMockRunApi();
+    await runConfigRequest(mockRunApi, {
+      ...baseRequest,
+    });
+  });
+
+  it('forwards "invalidateOnFileChange" calls to runAPI', async () => {
+    const mockRunApi = getMockRunApi();
+    await runConfigRequest(mockRunApi, {
+      ...baseRequest,
+      invalidateOnFileChange: new Set([
+        toProjectPath(projectRoot, 'path1'),
+        toProjectPath(projectRoot, 'path2'),
+      ]),
+    });
+
+    assert(
+      mockCast(mockRunApi.invalidateOnFileUpdate).called,
+      'Invalidate was called',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnFileUpdate).calledWith('path1'),
+      'Invalidate was called with path1',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnFileUpdate).calledWith('path2'),
+      'Invalidate was called with path2',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnFileDelete).calledWith('path1'),
+      'Invalidate was called with path1',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnFileDelete).calledWith('path2'),
+      'Invalidate was called with path2',
+    );
+  });
+
+  it('forwards "invalidateOnFileCreate" calls to runAPI', async () => {
+    const mockRunApi = getMockRunApi();
+    await runConfigRequest(mockRunApi, {
+      ...baseRequest,
+      invalidateOnFileCreate: [
+        {filePath: toProjectPath(projectRoot, 'filePath')},
+        {glob: toProjectPath(projectRoot, 'glob')},
+        {
+          fileName: 'package.json',
+          aboveFilePath: toProjectPath(projectRoot, 'fileAbove'),
+        },
+      ],
+    });
+
+    assert(
+      mockCast(mockRunApi.invalidateOnFileCreate).called,
+      'Invalidate was called',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnFileCreate).calledWithMatch({
+        filePath: 'filePath',
+      }),
+      'Invalidate was called for path',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnFileCreate).calledWithMatch({
+        glob: 'glob',
+      }),
+      'Invalidate was called for glob',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnFileCreate).calledWithMatch({
+        fileName: 'package.json',
+        aboveFilePath: 'fileAbove',
+      }),
+      'Invalidate was called for fileAbove',
+    );
+  });
+
+  it('forwards "invalidateOnEnvChange" calls to runAPI', async () => {
+    const mockRunApi = getMockRunApi();
+    await runConfigRequest(mockRunApi, {
+      ...baseRequest,
+      invalidateOnEnvChange: new Set(['env1', 'env2']),
+    });
+
+    assert(
+      mockCast(mockRunApi.invalidateOnEnvChange).called,
+      'Invalidate was called',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnEnvChange).calledWithMatch('env1'),
+      'Invalidate was called for env1',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnEnvChange).calledWithMatch('env2'),
+      'Invalidate was called for env1',
+    );
+  });
+
+  it('forwards "invalidateOnOptionChange" calls to runAPI', async () => {
+    const mockRunApi = getMockRunApi();
+    await runConfigRequest(mockRunApi, {
+      ...baseRequest,
+      invalidateOnOptionChange: new Set(['option1', 'option2']),
+    });
+
+    assert(
+      mockCast(mockRunApi.invalidateOnOptionChange).called,
+      'Invalidate was called',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnOptionChange).calledWithMatch('option1'),
+      'Invalidate was called for option1',
+    );
+    assert(
+      mockCast(mockRunApi.invalidateOnOptionChange).calledWithMatch('option2'),
+      'Invalidate was called for option2',
+    );
+  });
+
+  it('forwards "invalidateOnStartup" calls to runAPI', async () => {
+    const mockRunApi = getMockRunApi();
+    await runConfigRequest(mockRunApi, {
+      ...baseRequest,
+      invalidateOnStartup: true,
+    });
+
+    assert(
+      mockCast(mockRunApi.invalidateOnStartup).called,
+      'Invalidate was called',
+    );
+  });
+
+  it('forwards "invalidateOnBuild" calls to runAPI', async () => {
+    const mockRunApi = getMockRunApi();
+    await runConfigRequest(mockRunApi, {
+      ...baseRequest,
+      invalidateOnBuild: true,
+    });
+
+    assert(
+      mockCast(mockRunApi.invalidateOnBuild).called,
+      'Invalidate was called',
+    );
+  });
+
+  it('forwards "invalidateOnConfigKeyChange" calls to runAPI', async () => {
+    await fs.mkdirp('/project_root');
+    await fs.writeFile(
+      '/project_root/config.json',
+      JSON.stringify({key1: 'value1'}),
+    );
+    sinon.spy(fs, 'readFile');
+    sinon.spy(fs, 'readFileSync');
+    const mockRunApi = getMockRunApi();
+    await runConfigRequest(mockRunApi, {
+      ...baseRequest,
+      invalidateOnConfigKeyChange: [
+        {
+          configKey: 'key1',
+          filePath: toProjectPath(
+            projectRoot,
+            path.join('project_root', 'config.json'),
+          ),
+        },
+      ],
+    });
+
+    const fsCall = mockCast(fs).readFile.getCall(0);
+    assert.deepEqual(
+      fsCall?.args,
+      [path.join('project_root', 'config.json'), 'utf8'],
+      'readFile was called',
+    );
+
+    const call = mockCast(mockRunApi.invalidateOnConfigKeyChange).getCall(0);
+    assert.deepEqual(
+      call.args,
+      ['config.json', 'key1', hashString('"value1"')],
+      'Invalidate was called for key1',
+    );
+  });
+});

package/test/serializer.test.js

@@ -0,0 +1,302 @@
+// @flow
+import {
+  serialize,
+  deserialize,
+  registerSerializableClass,
+  unregisterSerializableClass,
+} from '../src/serializer';
+import assert from 'assert';
+import sinon from 'sinon';
+
+describe('serializer', () => {
+  it('should serialize a basic object', () => {
+    let serialized = serialize({foo: 2, bar: 3});
+    assert(Buffer.isBuffer(serialized));
+    let deserialized = deserialize(serialized);
+    assert.equal(typeof deserialized, 'object');
+    assert.deepEqual(deserialized, {foo: 2, bar: 3});
+  });
+
+  it('should serialize an object with multiple references', () => {
+    let a = {foo: 2};
+    let b = {bar: a, baz: a};
+    let res = deserialize(serialize(b));
+    assert.deepEqual(res, b);
+    assert.equal(res.bar, res.baz);
+  });
+
+  it('should serialize a cyclic object', () => {
+    let a = {foo: 2, bar: {}};
+    a.bar = a;
+    let res = deserialize(serialize(a));
+    assert.deepEqual(res, a);
+    assert.equal(res.bar, res);
+    assert.equal(a.bar, a);
+  });
+
+  it('should serialize a Map', () => {
+    let a = new Map([[2, 3]]);
+    let res = deserialize(serialize(a));
+    assert(res instanceof Map);
+    assert.equal(res.get(2), 3);
+  });
+
+  it('should serialize a Set', () => {
+    let a = new Set([2, 3]);
+    let res = deserialize(serialize(a));
+    assert(res instanceof Set);
+    assert(res.has(2));
+    assert(res.has(3));
+  });
+
+  it('should serialize a class', () => {
+    class Test {
+      x: number;
+      constructor(x: number) {
+        this.x = x;
+      }
+    }
+
+    registerSerializableClass('Test', Test);
+
+    let x = new Test(2);
+    let res = deserialize(serialize(x));
+    assert(res instanceof Test);
+    assert.equal(res.x, x.x);
+
+    unregisterSerializableClass('Test', Test);
+  });
+
+  it('should serialize a class with a custom serialize method', () => {
+    class Test {
+      x: number;
+      constructor(x: number) {
+        this.x = x;
+      }
+
+      serialize() {
+        return {
+          x: this.x,
+          serialized: true,
+        };
+      }
+    }
+
+    registerSerializableClass('Test', Test);
+
+    let x = new Test(2);
+    let res = deserialize(serialize(x));
+    assert(res instanceof Test);
+    assert.equal(res.x, x.x);
+    assert.equal(res.serialized, true);
+
+    unregisterSerializableClass('Test', Test);
+  });
+
+  it('should serialize a class with a custom deserialize method', () => {
+    class Test {
+      x: number;
+      constructor(x: number) {
+        this.x = x;
+      }
+
+      static deserialize(x: any) {
+        return {
+          deserialized: true,
+          value: x,
+        };
+      }
+    }
+
+    registerSerializableClass('Test', Test);
+
+    let x = new Test(2);
+    let res = deserialize(serialize(x));
+    assert(!(res instanceof Test));
+    assert.equal(res.value.x, x.x);
+    assert.equal(res.deserialized, true);
+
+    unregisterSerializableClass('Test', Test);
+  });
+
+  it('should serialize a class recursively', () => {
+    class Foo {
+      x: number;
+      constructor(x: number) {
+        this.x = x;
+      }
+    }
+
+    class Bar {
+      foo: Foo;
+      constructor(foo: Foo) {
+        this.foo = foo;
+      }
+    }
+
+    registerSerializableClass('Foo', Foo);
+    registerSerializableClass('Bar', Bar);
+
+    let x = new Bar(new Foo(2));
+    let res = deserialize(serialize(x));
+    assert(res instanceof Bar);
+    assert(res.foo instanceof Foo);
+    assert.equal(res.foo.x, 2);
+
+    unregisterSerializableClass('Foo', Foo);
+    unregisterSerializableClass('Bar', Bar);
+  });
+
+  it('should serialize a cyclic class', () => {
+    class Foo {
+      x: ?Foo;
+      constructor(x: ?Foo) {
+        this.x = x;
+      }
+    }
+
+    registerSerializableClass('Foo', Foo);
+
+    let x = new Foo();
+    x.x = x;
+
+    let res = deserialize(serialize(x));
+    assert(res instanceof Foo);
+    assert(res.x instanceof Foo);
+    assert.equal(res.x, res);
+
+    assert.equal(x.x, x);
+
+    unregisterSerializableClass('Foo', Foo);
+  });
+
+  it('should copy on write', () => {
+    class Foo {
+      x: number;
+      constructor(x: number) {
+        this.x = x;
+      }
+    }
+
+    registerSerializableClass('Foo', Foo);
+
+    let x = {y: {foo: new Foo(2)}};
+
+    let res = deserialize(serialize(x));
+    assert(res.y.foo instanceof Foo);
+    assert(x.y.foo instanceof Foo);
+
+    unregisterSerializableClass('Foo', Foo);
+  });
+
+  it('should serialize a cyclic class and copy on write', () => {
+    class Foo {
+      x: ?Foo;
+      constructor(x: ?Foo) {
+        this.x = x;
+      }
+    }
+
+    registerSerializableClass('Foo', Foo);
+
+    let x = new Foo();
+    x.x = x;
+    let y = {x: {y: x}};
+
+    let res = deserialize(serialize(y));
+    assert(res.x.y instanceof Foo);
+    assert(res.x.y.x instanceof Foo);
+    assert(y.x.y instanceof Foo);
+    assert(y.x.y.x instanceof Foo);
+    assert.equal(res.x.y.x, res.x.y);
+
+    assert.equal(x.x, x);
+
+    unregisterSerializableClass('Foo', Foo);
+  });
+
+  it('should serialize a class inside a Map', () => {
+    class Test {
+      x: number;
+      constructor(x: number) {
+        this.x = x;
+      }
+    }
+
+    registerSerializableClass('Test', Test);
+
+    let x = new Map([[2, new Test(2)]]);
+    let res = deserialize(serialize(x));
+    assert(res instanceof Map);
+    assert(res.get(2) instanceof Test);
+
+    unregisterSerializableClass('Test', Test);
+  });
+
+  it('should serialize a class inside a Set', () => {
+    class Test {
+      x: number;
+      constructor(x: number) {
+        this.x = x;
+      }
+    }
+
+    registerSerializableClass('Test', Test);
+
+    let x = new Set([new Test(2)]);
+    let res = deserialize(serialize(x));
+    assert(res instanceof Set);
+    assert(res.values().next().value instanceof Test);
+
+    unregisterSerializableClass('Test', Test);
+  });
+
+  describe('raw values', () => {
+    class Outer {
+      inner: Inner;
+
+      constructor(inner) {
+        this.inner = inner;
+      }
+
+      serialize() {
+        return {
+          $$raw: true,
+          inner: this.inner,
+        };
+      }
+    }
+
+    class Inner {
+      x: number;
+
+      constructor(x) {
+        this.x = x;
+      }
+
+      static deserialize = sinon.spy();
+    }
+
+    beforeEach(() => {
+      registerSerializableClass('Outer', Outer);
+      registerSerializableClass('Inner', Inner);
+    });
+
+    afterEach(() => {
+      unregisterSerializableClass('Outer', Outer);
+      unregisterSerializableClass('Inner', Inner);
+    });
+
+    it('should not recursively serialize raw values', () => {
+      let res = deserialize(serialize(new Outer(new Inner(42))));
+      assert(res instanceof Outer);
+      assert(!(res.inner instanceof Inner));
+      assert.equal(res.inner.x, 42);
+    });
+
+    it('should not recursively deserialize raw values', () => {
+      deserialize(serialize(new Outer(new Inner(42))));
+      assert(Inner.deserialize.notCalled);
+    });
+  });
+});

package/test/test-utils.js

@@ -0,0 +1,80 @@
+// @flow strict-local
+
+import type {Environment, AtlaspackOptions, Target} from '../src/types';
+
+import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
+import {FSCache} from '@atlaspack/cache';
+import tempy from 'tempy';
+import path from 'path';
+import {inputFS, outputFS} from '@atlaspack/test-utils';
+import {relativePath} from '@atlaspack/utils';
+import {NodePackageManager} from '@atlaspack/package-manager';
+import {createEnvironment} from '../src/Environment';
+import {toProjectPath} from '../src/projectPath';
+
+let cacheDir = tempy.directory();
+export let cache: FSCache = new FSCache(outputFS, cacheDir);
+cache.ensure();
+
+export const DEFAULT_OPTIONS: AtlaspackOptions = {
+  cacheDir: path.join(__dirname, '.atlaspack-cache'),
+  atlaspackVersion: '',
+  watchDir: __dirname,
+  watchIgnore: undefined,
+  watchBackend: undefined,
+  entries: [],
+  logLevel: 'info',
+  targets: undefined,
+  projectRoot: __dirname,
+  shouldAutoInstall: false,
+  hmrOptions: undefined,
+  shouldContentHash: true,
+  shouldBuildLazily: false,
+  lazyIncludes: [],
+  lazyExcludes: [],
+  shouldBundleIncrementally: true,
+  serveOptions: false,
+  mode: 'development',
+  env: {},
+  shouldDisableCache: false,
+  shouldProfile: false,
+  shouldTrace: false,
+  inputFS,
+  outputFS,
+  cache,
+  shouldPatchConsole: false,
+  packageManager: new NodePackageManager(inputFS, '/'),
+  additionalReporters: [],
+  instanceId: 'test',
+  defaultTargetOptions: {
+    shouldScopeHoist: false,
+    shouldOptimize: false,
+    publicUrl: '/',
+    distDir: undefined,
+    sourceMaps: false,
+  },
+  featureFlags: {
+    ...DEFAULT_FEATURE_FLAGS,
+  },
+};
+
+export const DEFAULT_ENV: Environment = createEnvironment({
+  context: 'browser',
+  engines: {
+    browsers: ['> 1%'],
+  },
+});
+
+export const DEFAULT_TARGETS: Array<Target> = [
+  {
+    name: 'test',
+    distDir: toProjectPath('/', '/dist'),
+    distEntry: 'out.js',
+    env: DEFAULT_ENV,
+    publicUrl: '/',
+  },
+];
+
+export function relative(f: string): string {
+  return relativePath(__dirname, f, false);
+}

package/test/utils.test.js

@@ -0,0 +1,43 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {getPublicId} from '../src/utils';
+
+const id = '0123456789abcdef0123456789abcdef';
+const fullPublicId = '296TIIbB3u904riPYGPJJ';
+
+describe('getPublicId', () => {
+  it('only accepts 32-character hexadecimal strings', () => {
+    assert.throws(() => {
+      getPublicId('abc', () => false);
+    });
+
+    let notHexadecimal = 'abcdefghiklmnopqrstuvwxyz1234567';
+    assert.equal(notHexadecimal.length, 32);
+    assert.throws(() => {
+      getPublicId(notHexadecimal, () => false);
+    });
+  });
+
+  it('if no collisions, returns the first 5 base62 characters of value represented by the input', () => {
+    assert.equal(
+      getPublicId(id, () => false),
+      fullPublicId.slice(0, 5),
+    );
+  });
+
+  it('uses more characters if there is a collision', () => {
+    assert.equal(
+      getPublicId(id, publicId =>
+        [fullPublicId.slice(0, 5), fullPublicId.slice(0, 6)].includes(publicId),
+      ),
+      fullPublicId.slice(0, 7),
+    );
+  });
+
+  it('fails if all characters collide', () => {
+    assert.throws(() => {
+      getPublicId(id, () => true);
+    });
+  });
+});