Latest Code

node_modules/strong-store-cluster/test/concurrent-inc.js

@@ -0,0 +1,17 @@
+
+var helper = require('./helper/cluster-helper');
+
+suite('concurrent increment', function() {
+  test('master only', function(cb) {
+    helper.run('do-concurrent-inc', true, 0, 4, cb);
+  });
+
+  test('four workers', function(cb) {
+    helper.run('do-concurrent-inc', false, 4, 4, cb);
+  });
+
+  test('master and four workers', function(cb) {
+    helper.run('do-concurrent-inc', true, 4, 4, cb);
+  });
+});
+

node_modules/strong-store-cluster/test/get-set-del.js

@@ -0,0 +1,12 @@
+
+var helper = require('./helper/cluster-helper');
+
+suite('get-set-del', function() {
+  test('master', function(cb) {
+    helper.run('do-get-set-del', true, 0, 1, cb);
+  });
+
+  test('worker', function(cb) {
+    helper.run('do-get-set-del', false, 1, 1, cb);
+  });
+});

node_modules/strong-store-cluster/test/helper/cluster-helper.js

@@ -0,0 +1,83 @@
+
+
+var assert = require('assert'),
+    cluster = require('cluster');
+
+
+if (!process.env.CLUSTER_TEST) {
+  // We're require()'d by the test harness. Export a function that start
+  // the test.
+
+  exports.run = function(filename, inMaster, workers, concurrency, cb) {
+    assert(filename);
+    assert(inMaster || workers);
+    assert(concurrency > 0);
+
+    var env = {};
+    for (var key in process.env)
+      env[key] = process.env[key];
+
+    env.CLUSTER_TEST = require.resolve('./' + filename);
+    env.CLUSTER_TEST_IN_MASTER = inMaster;
+    env.CLUSTER_TEST_WORKERS = workers;
+    env.CLUSTER_TEST_CONCURRENCY = concurrency;
+
+    var cp = require('child_process').fork(module.filename,
+                                           {env: env, stdio: 'inherit'});
+
+    cp.on('exit', function(exitCode, termSig) {
+      assert(exitCode === 0);
+      assert(!termSig);
+
+      cb();
+    });
+  };
+
+} else {
+  // We're being spawned as a standalone process. Execute the test and/or spawn
+  // cluster workers that do.
+
+  var filename = process.env.CLUSTER_TEST,
+      inMaster = !!+process.env.CLUSTER_TEST_IN_MASTER,
+      workers = ~~ + process.env.CLUSTER_TEST_WORKERS,
+      concurrency = ~~ + process.env.CLUSTER_TEST_CONCURRENCY;
+
+  var test = require(filename);
+
+  // Both the master and the worker have .setup() always called once.
+  test.setup && test.setup();
+
+  var waiting = 0;
+
+  // If we're the master process, spawn a number of workers.
+  if (cluster.isMaster && workers) {
+    for (var i = 0; i < workers; i++)
+      var worker = cluster.fork();
+
+    waiting += workers;
+
+    cluster.on('exit', function(worker, exitCode, termSig) {
+      assert(exitCode === 0);
+      assert(!termSig);
+
+      done();
+    });
+  }
+
+  // If we're either a worker, or the master is supposed to run the tests,
+  // run the test cases.
+  if (cluster.isWorker || inMaster) {
+    waiting += concurrency;
+
+    for (var i = 0; i < concurrency; i++)
+      test.run(done);
+  }
+}
+
+
+function done() {
+  assert(--waiting >= 0);
+  if (waiting === 0)
+    return test.teardown && test.teardown();
+}
+

node_modules/strong-store-cluster/test/helper/do-concurrent-inc.js

@@ -0,0 +1,51 @@
+
+exports.run = run;
+exports.teardown = teardown;
+
+
+var ROUNDS = 100;
+assert = require('assert'),
+cluster = require('cluster'),
+store = require('../..');
+
+
+function run(cb) {
+  var left = ROUNDS,
+      coll = store.collection('counter');
+
+  increment();
+
+  function increment() {
+    coll.acquire('counter', function(err, lock, val) {
+      assert(!err);
+
+      if (!val)
+        val = 1;
+      else
+        val++;
+
+      lock.set(val);
+      lock.release();
+
+      if (--left > 0)
+        increment();
+      else
+        cb();
+    });
+  }
+}
+
+
+function teardown() {
+  if (cluster.isWorker)
+    process._channel.unref();
+
+  if (cluster.isMaster) {
+    store.collection('counter').get('counter', function(err, value) {
+      assert(value % ROUNDS === 0);
+      assert(value >= ROUNDS);
+    });
+  }
+}
+
+

node_modules/strong-store-cluster/test/helper/do-get-set-del.js

@@ -0,0 +1,60 @@
+
+exports.run = run;
+exports.teardown = teardown;
+
+
+var assert = require('assert'),
+    cluster = require('cluster'),
+    store = require('../..');
+
+
+function run(cb) {
+  var testsRun = 0;
+
+  testWith('test1', 'key1', 'zulis', onDone);
+  testWith('test2', 'quux', 'stoll', onDone);
+  testWith('test2', 'key1', 'urals', onDone);
+  testWith('test2', 'key2', 'quipp', onDone);
+
+  function onDone() {
+    if (++testsRun === 4)
+      cb();
+  }
+}
+
+
+function testWith(collectionName, key, testValue, cb) {
+  var coll = store.collection(collectionName);
+
+  coll.get(key, function(err, value) {
+    assert(!err);
+    assert(value === undefined);
+
+    coll.set(key, testValue, function(err) {
+      assert(!err);
+
+      coll.get(key, function(err, value) {
+        assert(!err);
+        assert(value === testValue);
+
+        coll.del(key, function(err) {
+          assert(!err);
+
+          coll.get(key, function(err, value) {
+            assert(!err);
+            assert(value === undefined);
+
+            cb();
+          });
+        });
+      });
+    });
+  });
+}
+
+
+
+function teardown() {
+  if (cluster.isWorker)
+    process._channel.unref();
+}

node_modules/strong-store-cluster/test/helper/do-lock-get-set-del.js

@@ -0,0 +1,80 @@
+
+exports.run = run;
+exports.teardown = teardown;
+
+
+var assert = require('assert'),
+    cluster = require('cluster'),
+    store = require('../..');
+
+
+function run(cb) {
+  var testsRun = 0;
+
+  testWith('test1', 'key1', {foo: 'zulis'}, onDone);
+  testWith('test2', 'quux', ['stoll'], onDone);
+  testWith('test2', 'key1', 'urals', onDone);
+  testWith('test2', 'key2', 42, onDone);
+
+  function onDone() {
+    if (++testsRun === 4)
+      cb();
+  }
+}
+
+
+function testWith(collectionName, key, testValue, cb) {
+  var coll = store.collection(collectionName);
+
+  coll.set(key, testValue, function(err, value) {
+    assert(!err);
+
+    coll.acquire(key, function(err, lock, value) {
+      assert(!err);
+
+      assert.deepEqual(testValue, value);
+      assert.deepEqual(testValue, lock.get());
+
+      // Non-primitive values should be deep-cloned.
+      if (typeof testValue === 'object') {
+        assert(testValue !== value);
+        assert(testValue !== lock.get());
+      }
+
+      lock.set('other');
+      assert('other' === lock.get());
+
+      lock.release(function(err) {
+        assert(!err);
+      });
+
+      coll.acquire(key, function(err, lock, value) {
+        assert(!err);
+
+        assert('other' === value);
+        assert('other' === lock.get());
+
+        lock.del();
+        assert(undefined === lock.get());
+
+        lock.release(function(err) {
+          assert(!err);
+        });
+
+        coll.get(key, function(err, value) {
+          assert(!err);
+          assert(undefined === value);
+
+          // That was it!
+          cb();
+        });
+      });
+    });
+  });
+}
+
+
+function teardown() {
+  if (cluster.isWorker)
+    process._channel.unref();
+}

node_modules/strong-store-cluster/test/lock-get-set-del.js

@@ -0,0 +1,12 @@
+
+var helper = require('./helper/cluster-helper');
+
+suite('lock-get-set-del', function() {
+  test('master', function(cb) {
+    helper.run('do-lock-get-set-del', true, 0, 1, cb);
+  });
+
+  test('worker', function(cb) {
+    helper.run('do-lock-get-set-del', false, 1, 1, cb);
+  });
+});