@atlaspack/core 2.12.1-dev.3450 → 2.12.1-dev.3466

package/test/requests/WriteBundleRequest.test.js

@@ -1,132 +0,0 @@
-// @flow strict-local
-
-import {replaceStream} from '../../src/requests/WriteBundleRequest';
-import {Writable, pipeline} from 'stream';
-import {replaceHashReferences} from '@atlaspack/rust';
-import assert from 'assert';
-import {blobToStream} from '@atlaspack/utils';
-
-class BufferWritable extends Writable {
-  buffers: Buffer[];
-
-  constructor() {
-    super();
-    this.buffers = [];
-  }
-
-  getBuffer(): Buffer {
-    return Buffer.concat(this.buffers);
-  }
-
-  _write(chunk: string | Buffer, encoding: string, callback) {
-    let buffer =
-      typeof chunk === 'string'
-        ? // $FlowFixMe
-          Buffer.from(chunk, encoding)
-        : chunk;
-    this.buffers.push(buffer);
-    callback();
-  }
-}
-
-function generateSampleInput(
-  hashReferences: Map<string, string>,
-  inputSize: number,
-): Buffe {
-  let output = '';
-
-  while (output.length < inputSize) {
-    if (Math.random() < 0.1) {
-      output += 'HASH_REF_1234567890123456';
-    } else {
-      for (let i = 0; i < 16; i++) {
-        output += String.fromCharCode(97 + Math.floor(Math.random() * 26));
-      }
-    }
-  }
-
-  return Buffer.from(output);
-}
-
-async function javascriptReplaceHashReferences(
-  buffer: Buffer,
-  hashReferences: Map<string, string>,
-): Promise<Buffer> {
-  const writable = new BufferWritable();
-  const transform = replaceStream(hashReferences);
-
-  await new Promise((resolve, reject) => {
-    pipeline(blobToStream(buffer), transform, writable, err => {
-      if (err) reject(err);
-      else resolve(null);
-    });
-  });
-
-  const output = writable.getBuffer();
-  return output;
-}
-
-describe('replaceStream', () => {
-  const hashReferences = new Map([
-    ['HASH_REF_1234567890123456', 'HASH_REF_replacedwithstri'],
-  ]);
-  const buffer = Buffer.from(
-    'Hello HASH_REF_1234567890123456 more stuff here HASH_REF_1234567890123456',
-  );
-  const expectedOutput =
-    'Hello HASH_REF_replacedwithstri more stuff here HASH_REF_replacedwithstri';
-
-  it('javascript - replaces hash references in buffers', async () => {
-    const output = await javascriptReplaceHashReferences(
-      buffer,
-      hashReferences,
-    );
-    const outputString = output.toString();
-    assert.equal(outputString, expectedOutput);
-  });
-
-  it('rust - replaces hash references in buffers', () => {
-    const output = replaceHashReferences(
-      buffer,
-      Object.fromEntries(hashReferences.entries()),
-    );
-
-    const outputString = output.toString();
-    assert.equal(outputString, expectedOutput);
-  });
-
-  let currentInputSize = 1024 * 1024; // Start at 1MB and grow to 40MB
-  const inputSizes = [];
-  while (currentInputSize < 40 * 1024 * 1024) {
-    inputSizes.push(currentInputSize);
-    currentInputSize *= 2;
-  }
-
-  inputSizes.forEach(inputSize => {
-    describe('input size ' + inputSize / 1024 / 1024 + 'MB', () => {
-      const buffer = generateSampleInput(hashReferences, inputSize);
-      const expectedOutput = buffer
-        .toString()
-        .replace(/HASH_REF_1234567890123456/g, 'HASH_REF_replacedwithstri');
-
-      it('javascript - works on huge buffer', async () => {
-        const output = await javascriptReplaceHashReferences(
-          buffer,
-          hashReferences,
-        );
-        const outputString = output.toString();
-        assert.equal(outputString, expectedOutput);
-      });
-
-      it('rust - works on huge buffer', () => {
-        const output = replaceHashReferences(
-          buffer,
-          Object.fromEntries(hashReferences.entries()),
-        );
-
-        const outputString = output.toString();
-        assert.equal(outputString, expectedOutput);
-      });
-    });
-  });
-});

package/test/serializer.test.js

@@ -1,302 +0,0 @@
-// @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);
-    });
-  });
-});