"use strict";
/*jslint nomen: true, plusplus: true, vars: true */
var assert = require('assert');
var mocha = require('mocha'), describe = mocha.describe, it = mocha.it, after = mocha.after;
var virtualBaton = require('../../../examples/libraries/virtualBaton.js');
describe('temp', function () {
var messageCount = 0, testStart = Date.now();
function makeMessager(nodes, me, mode) { // shim for High Fidelity Message system
function noopSend(channel, string, source) {
}
function hasChannel(node, channel) {
return -1 !== node.subscribed.indexOf(channel);
}
function sendSync(channel, message, nodes, skip) {
nodes.forEach(function (node) {
if (!hasChannel(node, channel) || (node === skip)) {
return;
}
node.sender(channel, message, me.name);
});
}
nodes.forEach(function (node) {
node.sender = node.sender || noopSend;
node.subscribed = node.subscribed || [];
});
return {
subscriberCount: function () {
var c = 0;
nodes.forEach(function (n) {
if (n.subscribed.length) {
c++;
}
});
return c;
},
subscribe: function (channel) {
me.subscribed.push(channel);
},
unsubscribe: function (channel) {
me.subscribed.splice(me.subscribed.indexOf(channel), 1);
},
sendMessage: function (channel, message) {
if ((mode === 'immediate2Me') && hasChannel(me, channel)) {
me.sender(channel, message, me.name);
}
if (mode === 'immediate') {
sendSync(channel, message, nodes, null);
} else {
process.nextTick(function () {
sendSync(channel, message, nodes, (mode === 'immediate2Me') ? me : null);
});
}
},
messageReceived: {
connect: function (f) {
me.sender = function (c, m, i) {
messageCount++; f(c, m, i);
};
},
disconnect: function () {
me.sender = noopSend;
}
}
};
}
var debug = {}; //{flow: true, send: false, receive: false};
function makeBaton(testKey, nodes, node, debug, mode, optimize) {
debug = debug || {};
var baton = virtualBaton({
batonName: testKey,
debugSend: debug.send,
debugReceive: debug.receive,
debugFlow: debug.flow,
useOptimizations: optimize,
connectionTest: function (id) {
return baton.validId(id);
},
globals: {
Messages: makeMessager(nodes, node, mode),
MyAvatar: {sessionUUID: node.name},
Script: {
setTimeout: setTimeout,
clearTimeout: clearTimeout,
setInterval: setInterval,
clearInterval: clearInterval
},
AvatarList: {
getAvatar: function (id) {
return {sessionUUID: id};
}
},
Entities: {getEntityProperties: function () {
}},
print: console.log
}
});
return baton;
}
function noRelease(batonName) {
assert.ok(!batonName, "should not release");
}
function defineABunch(mode, optimize) {
function makeKey(prefix) {
return prefix + mode + (optimize ? '-opt' : '');
}
var testKeys = makeKey('single-');
it(testKeys, function (done) {
var nodes = [{name: 'a'}];
var a = makeBaton(testKeys, nodes, nodes[0], debug, mode).claim(function (key) {
console.log('claimed a');
assert.equal(testKeys, key);
a.unload();
done();
}, noRelease);
});
var testKeydp = makeKey('dual-parallel-');
it(testKeydp, function (done) {
this.timeout(10000);
var nodes = [{name: 'ap'}, {name: 'bp'}];
var a = makeBaton(testKeydp, nodes, nodes[0], debug, mode, optimize),
b = makeBaton(testKeydp, nodes, nodes[1], debug, mode, optimize);
function accepted(key) { // Under some circumstances of network timing, either a or b can win.
console.log('claimed ap');
assert.equal(testKeydp, key);
done();
}
a.claim(accepted, noRelease);
b.claim(accepted, noRelease);
});
var testKeyds = makeKey('dual-serial-');
it(testKeyds, function (done) {
var nodes = [{name: 'as'}, {name: 'bs'}],
gotA = false,
gotB = false;
makeBaton(testKeyds, nodes, nodes[0], debug, mode, optimize).claim(function (key) {
console.log('claimed as', key);
assert.ok(!gotA, "should not get A after B");
gotA = true;
done();
}, noRelease);
setTimeout(function () {
makeBaton(testKeyds, nodes, nodes[1], debug, mode, optimize).claim(function (key) {
console.log('claimed bs', key);
assert.ok(!gotB, "should not get B after A");
gotB = true;
done();
}, noRelease);
}, 500);
});
var testKeydsl = makeKey('dual-serial-long-');
it(testKeydsl, function (done) {
this.timeout(5000);
var nodes = [{name: 'al'}, {name: 'bl'}],
gotA = false,
gotB = false,
releaseA = false;
makeBaton(testKeydsl, nodes, nodes[0], debug, mode, optimize).claim(function (key) {
console.log('claimed al', key);
assert.ok(!gotB, "should not get A after B");
gotA = true;
if (!gotB) {
done();
}
}, function () {
assert.ok(gotA, "Should claim it first");
releaseA = true;
if (gotB) {
done();
}
});
setTimeout(function () {
makeBaton(testKeydsl, nodes, nodes[1], debug, mode, optimize).claim(function (key) {
console.log('claimed bl', key);
gotB = true;
if (releaseA) {
done();
}
}, noRelease);
}, 3000);
});
var testKeydsr = makeKey('dual-serial-with-release-');
it(testKeydsr, function (done) {
this.timeout(5000);
var nodes = [{name: 'asr'}, {name: 'bsr'}],
gotClaimA = false,
gotReleaseA = false,
a = makeBaton(testKeydsr, nodes, nodes[0], debug, mode, optimize),
b = makeBaton(testKeydsr, nodes, nodes[1], debug, mode, optimize);
a.claim(function (key) {
console.log('claimed asr');
assert.equal(testKeydsr, key);
gotClaimA = true;
b.claim(function (key) {
console.log('claimed bsr');
assert.equal(testKeydsr, key);
assert.ok(gotReleaseA);
done();
}, noRelease);
a.release();
}, function (key) {
console.log('released asr');
assert.equal(testKeydsr, key);
assert.ok(gotClaimA);
gotReleaseA = true;
});
});
var testKeydpr = makeKey('dual-parallel-with-release-');
it(testKeydpr, function (done) {
this.timeout(5000);
var nodes = [{name: 'ar'}, {name: 'br'}];
var a = makeBaton(testKeydpr, nodes, nodes[0], debug, mode, optimize),
b = makeBaton(testKeydpr, nodes, nodes[1], debug, mode, optimize),
gotClaimA = false,
gotReleaseA = false,
gotClaimB = false;
a.claim(function (key) {
console.log('claimed ar');
assert.equal(testKeydpr, key);
gotClaimA = true;
assert.ok(!gotClaimB, "if b claimed, should not get a");
a.release();
}, function (key) {
console.log('released ar');
assert.equal(testKeydpr, key);
assert.ok(gotClaimA);
gotReleaseA = true;
});
b.claim(function (key) {
console.log('claimed br', gotClaimA ? 'with' : 'without', 'ar first');
assert.equal(testKeydpr, key);
gotClaimB = true;
assert.ok(!gotClaimA || gotReleaseA);
done();
}, noRelease);
});
}
function defineAllModeTests(optimize) {
defineABunch('delayed', optimize);
defineABunch('immediate2Me', optimize);
defineABunch('immediate', optimize);
}
defineAllModeTests(true);
defineAllModeTests(false);
after(function () {
console.log(messageCount, 'messages sent over', (Date.now() - testStart), 'ms.');
});
});