flow like the river

BACK_BACK/node_modules/@parcel/workers/test/.babelrc

@@ -0,0 +1,9 @@
+{
+  "presets": [["@babel/preset-env", {
+    "targets": {
+      "node": "current"
+    }
+  }]],
+  "plugins": ["@babel/plugin-transform-runtime"],
+  "ignore": ["integration"]
+}

BACK_BACK/node_modules/@parcel/workers/test/.eslintrc.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../../../.eslintrc.json",
+  "env": {
+    "mocha": true
+  }
+}

BACK_BACK/node_modules/@parcel/workers/test/integration/workerfarm/echo.js

@@ -0,0 +1,10 @@
+function run(data) {
+  return data;
+}
+
+function init() {
+  // do nothing
+}
+
+exports.run = run;
+exports.init = init;

BACK_BACK/node_modules/@parcel/workers/test/integration/workerfarm/init.js

@@ -0,0 +1,12 @@
+let options = {};
+
+function run() {
+  return options;
+}
+
+function init(opt) {
+  options = opt;
+}
+
+exports.run = run;
+exports.init = init;

BACK_BACK/node_modules/@parcel/workers/test/integration/workerfarm/ipc-pid.js

@@ -0,0 +1,25 @@
+const WorkerFarm = require(`../../../${
+  parseInt(process.versions.node, 10) < 8 ? 'lib' : 'src'
+}/WorkerFarm`);
+
+function run() {
+  let result = [process.pid];
+  return new Promise((resolve, reject) => {
+    WorkerFarm.callMaster({
+      location: require.resolve('./master-process-id.js'),
+      args: []
+    })
+      .then(pid => {
+        result.push(pid);
+        resolve(result);
+      })
+      .catch(reject);
+  });
+}
+
+function init() {
+  // Do nothing
+}
+
+exports.run = run;
+exports.init = init;

BACK_BACK/node_modules/@parcel/workers/test/integration/workerfarm/ipc.js

@@ -0,0 +1,17 @@
+const WorkerFarm = require(`../../../${
+  parseInt(process.versions.node, 10) < 8 ? 'lib' : 'src'
+}/WorkerFarm`);
+
+function run(a, b) {
+  return WorkerFarm.callMaster({
+    location: require.resolve('./master-sum.js'),
+    args: [a, b]
+  });
+}
+
+function init() {
+  // Do nothing
+}
+
+exports.run = run;
+exports.init = init;

BACK_BACK/node_modules/@parcel/workers/test/integration/workerfarm/master-process-id.js

@@ -0,0 +1,3 @@
+module.exports = function() {
+  return process.pid;
+};

BACK_BACK/node_modules/@parcel/workers/test/integration/workerfarm/master-sum.js

@@ -0,0 +1,3 @@
+module.exports = function(a, b) {
+  return a + b;
+};

BACK_BACK/node_modules/@parcel/workers/test/integration/workerfarm/ping.js

@@ -0,0 +1,10 @@
+function run() {
+  return 'pong';
+}
+
+function init() {
+  // do nothing
+}
+
+exports.run = run;
+exports.init = init;

BACK_BACK/node_modules/@parcel/workers/test/mocha.opts

@@ -0,0 +1,3 @@
+--require @parcel/babel-register
+--exit
+--timeout 20s

BACK_BACK/node_modules/@parcel/workers/test/workerfarm.js

@@ -0,0 +1,178 @@
+const assert = require('assert');
+const WorkerFarm = require('../index');
+
+describe('WorkerFarm', () => {
+  it('Should start up workers', async () => {
+    let workerfarm = new WorkerFarm(
+      {},
+      {
+        warmWorkers: false,
+        useLocalWorker: false,
+        workerPath: require.resolve('./integration/workerfarm/ping.js')
+      }
+    );
+
+    assert.equal(await workerfarm.run(), 'pong');
+
+    await workerfarm.end();
+  });
+
+  it('Should handle 1000 requests without any issue', async () => {
+    let workerfarm = new WorkerFarm(
+      {},
+      {
+        warmWorkers: false,
+        useLocalWorker: false,
+        workerPath: require.resolve('./integration/workerfarm/echo.js')
+      }
+    );
+
+    let promises = [];
+    for (let i = 0; i < 1000; i++) {
+      promises.push(workerfarm.run(i));
+    }
+    await Promise.all(promises);
+
+    await workerfarm.end();
+  });
+
+  it('Should consistently initialise workers, even after 100 re-inits', async () => {
+    let options = {
+      key: 0
+    };
+
+    let workerfarm = new WorkerFarm(options, {
+      warmWorkers: false,
+      useLocalWorker: false,
+      workerPath: require.resolve('./integration/workerfarm/init.js')
+    });
+
+    for (let i = 0; i < 100; i++) {
+      options.key = i;
+      workerfarm.init(options);
+
+      for (let i = 0; i < workerfarm.workers.size; i++) {
+        assert.equal((await workerfarm.run()).key, options.key);
+      }
+      assert.equal(workerfarm.shouldUseRemoteWorkers(), true);
+    }
+
+    await workerfarm.end();
+  });
+
+  it('Should warm up workers', async () => {
+    let workerfarm = new WorkerFarm(
+      {},
+      {
+        warmWorkers: true,
+        useLocalWorker: true,
+        workerPath: require.resolve('./integration/workerfarm/echo.js')
+      }
+    );
+
+    for (let i = 0; i < 100; i++) {
+      assert.equal(await workerfarm.run(i), i);
+    }
+
+    await new Promise(resolve => workerfarm.once('warmedup', resolve));
+
+    assert(workerfarm.workers.size > 0, 'Should have spawned workers.');
+    assert(
+      workerfarm.warmWorkers >= workerfarm.workers.size,
+      'Should have warmed up workers.'
+    );
+
+    await workerfarm.end();
+  });
+
+  it('Should use the local worker', async () => {
+    let workerfarm = new WorkerFarm(
+      {},
+      {
+        warmWorkers: true,
+        useLocalWorker: true,
+        workerPath: require.resolve('./integration/workerfarm/echo.js')
+      }
+    );
+
+    assert.equal(await workerfarm.run('hello world'), 'hello world');
+    assert.equal(workerfarm.shouldUseRemoteWorkers(), false);
+
+    await workerfarm.end();
+  });
+
+  it('Should be able to use bi-directional communication', async () => {
+    let workerfarm = new WorkerFarm(
+      {},
+      {
+        warmWorkers: false,
+        useLocalWorker: false,
+        workerPath: require.resolve('./integration/workerfarm/ipc.js')
+      }
+    );
+
+    assert.equal(await workerfarm.run(1, 2), 3);
+
+    await workerfarm.end();
+  });
+
+  it('Should be able to handle 1000 bi-directional calls', async () => {
+    let workerfarm = new WorkerFarm(
+      {},
+      {
+        warmWorkers: false,
+        useLocalWorker: false,
+        workerPath: require.resolve('./integration/workerfarm/ipc.js')
+      }
+    );
+
+    for (let i = 0; i < 1000; i++) {
+      assert.equal(await workerfarm.run(1 + i, 2), 3 + i);
+    }
+
+    await workerfarm.end();
+  });
+
+  it('Bi-directional call should return masters pid', async () => {
+    let workerfarm = new WorkerFarm(
+      {},
+      {
+        warmWorkers: false,
+        useLocalWorker: false,
+        workerPath: require.resolve('./integration/workerfarm/ipc-pid.js')
+      }
+    );
+
+    let result = await workerfarm.run();
+    assert.equal(result.length, 2);
+    assert.equal(result[1], process.pid);
+    assert.notEqual(result[0], process.pid);
+
+    await workerfarm.end();
+  });
+
+  it('Should handle 10 big concurrent requests without any issue', async () => {
+    // This emulates the node.js ipc bug for win32
+    let workerfarm = new WorkerFarm(
+      {},
+      {
+        warmWorkers: false,
+        useLocalWorker: false,
+        workerPath: require.resolve('./integration/workerfarm/echo.js')
+      }
+    );
+
+    let bigData = [];
+    for (let i = 0; i < 10000; i++) {
+      bigData.push('This is some big data');
+    }
+
+    let promises = [];
+    for (let i = 0; i < 10; i++) {
+      promises.push(workerfarm.run(bigData));
+    }
+    await Promise.all(promises);
+
+    await workerfarm.end();
+  });
+});