Troplo/node-ipc
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Wiki Activity

Merge pull request #55 from nileshprasad/master

Browse source 
Test cases for Node IPC. Looking forward to tests for raw buffer.
This commit is contained in:
Brandon Nozaki Miller 2016-01-07 23:10:59 -08:00
commit b60551202b
15 changed files with 982 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
spec/support/jasmine.json Normal file
View file

@ -0,0 +1,16 @@
{
"spec_dir": "spec",
"spec_files": [
"/support/jasmineTest/testFile.js",
"/support/jasmineTest/Unix/unixSocketClient.spec.js",
"/support/jasmineTest/UDP/udpSocketClient.spec.js",
"/support/jasmineTest/TCP/tcpSocketClient.spec.js",
"/support/jasmineTest/Unix/unixSocketServer.spec.js",
"/support/jasmineTest/TCP/tcpSocketServer.spec.js"
]
}

221
spec/support/jasmineTest/TCP/tcpSocketClient.spec.js Normal file
View file

@ -0,0 +1,221 @@
var ipc = require('../../../../node-ipc');
ipc.config.id ='testClient';
ipc.config.retry = 600;
describe('TCP Socket verification of client',
function(){
it(
'Verify retry attempts by TCP client to connect to the server as per the value set in "maxRetries" parameter.',
function(done){
var tcpRetryAttempt = 3; //variable created to count the attempt made by client to connect to the server.
ipc.config.maxRetries = 3;
ipc.config.stopRetrying = false;
ipc.config.silent= false;
ipc.connectToNet(
'tcpFakeServer',
8002,
function(){
ipc.of.tcpFakeServer.on(
'disconnect',
function(){
if(ipc.of.tcpFakeServer.retriesRemaining == 0){
expect(tcpRetryAttempt).toBe(ipc.of.tcpFakeServer.retriesRemaining);
expect(ipc.of.tcpFakeServer.socket.destroyed).toBe(true);
}
else if(ipc.of.tcpFakeServer.retriesRemaining < 0){
expect(tcpRetryAttempt).not.toBeLessThan(0);
expect(ipc.of.tcpFakeServer.retriesRemaining).not.toBeLessThan(0);
ipc.of.tcpFakeServer.on(
'error',
function(err){
console.log('Error is: ', err);
ipc.disconnect('tcpFakeServer');
}
);
}
tcpRetryAttempt--;
}
);
}
);
// Wait time is added to verify the fail case scenario of additional retry attempt by client than expected.
setTimeout(
function(){
ipc.disconnect('tcpFakeServer');
done();
},2500
);
}
);
it(
'Verify TCP client does not connect to the TCPserver when "stopRetrying" value is set to true.',
function(done){
var tcpRetryAttempt = 3; //variable created to count the attempt made by client to connect to the server.
ipc.config.maxRetries = 3;
ipc.config.stopRetrying = true;
ipc.connectToNet(
'tcpFakeServer',
8002,
function(){
ipc.of.tcpFakeServer.on(
'disconnect',
function(){
if(ipc.of.tcpFakeServer.retriesRemaining == 3){
expect(tcpRetryAttempt).toBe(ipc.of.tcpFakeServer.retriesRemaining);
expect(ipc.of.tcpFakeServer.socket.destroyed).toBe(true);
}
else if(ipc.of.tcpFakeServer.retriesRemaining < 3){
expect(tcpRetryAttempt).not.toBeLessThan(3);
expect(ipc.of.tcpFakeServer.retriesRemaining).not.toBeLessThan(3);
ipc.of.tcpFakeServer.on(
'error',
function(err){
console.log('Error is: ', err);
ipc.disconnect('tcpFakeServer');
}
);
}
tcpRetryAttempt--;
}
);
}
);
// Wait time is added to verify the fail case scenario of additional retry attempt by client than expected.
setTimeout(
function(){
ipc.disconnect('tcpFakeServer');
done();
},700
);
}
);
it(
'Verify TCP client connects to server named "tcpServer" and receives message.',
function(done){
ipc.connectToNet(
'tcpServer',
8300,
function(){
ipc.of.tcpServer.on(
'connect',
function(){
ipc.of.tcpServer.emit(
'message',
{
id : ipc.config.id,
message : 'Hello from testClient.'
}
);
ipc.of.tcpServer.on(
'message',
function(data,socket){
expect(data.id).toBe('tcpServer');
expect(data.message).toBe('I am TCP server!');
ipc.disconnect('tcpServer');
done();
}
);
}
);
}
);
}
);
it(
'Verify TCP client queues the requests being sent to the server synchronously until it receives the response from server.',
function(done){
ipc.config.sync = true;
var responseCounter = 0;
ipc.connectToNet(
'tcpServerSync',
8400,
function(){
ipc.of.tcpServerSync.on(
'connect',
function(){
for(var i=0; i<5; i++){
ipc.of.tcpServerSync.emit(
'message',
{
id : ipc.config.id,
message : 'TCP Client Request '+ i
}
);
}
ipc.of.tcpServerSync.on(
'message',
function(data){
if (data.message != null){
responseCounter++;
expect(data.message).toBe('Response from TCP server');
}
if (responseCounter == 5){
expect(responseCounter).toBe(5);
ipc.disconnect('tcpServerSync');
done();
}
}
);
ipc.of.tcpServerSync.on(
'error',
function(err){
console.log('Error is: ', err); done();
ipc.disconnect('tcpServerSync');
}
);
}
);
}
);
}
);
}
);

48
spec/support/jasmineTest/TCP/tcpSocketServer.spec.js Normal file
View file

@ -0,0 +1,48 @@
var ipc = require('../../../../node-ipc');
ipc.config.id ='testWorld';
ipc.config.retry = 1000;
describe('TCP Socket verification of server',
function(){
it(
'Verify TCP server detects only 1 client out of 2 clients and receives message.',
function(done){
var clientCounter =0;
ipc.config.maxConnections=1;
ipc.config.networkPort=8500;
ipc.serveNet(
function(){
ipc.server.on(
'app.message',
function(data,socket){
clientCounter++;
expect(data.id).toBe('tcpClient');
expect(data.message).toBe('I am TCP client.');
}
);
setTimeout(
function(){
expect(clientCounter).toBe(1);
done();
},2000
);
}
);
ipc.server.start();
}
);
}
);

93
spec/support/jasmineTest/UDP/udpSocketClient.spec.js Normal file
View file

@ -0,0 +1,93 @@
var ipc = require('../../../../node-ipc');
ipc.config.id ='testClient';
ipc.config.retry = 600;
describe(
'UDP Socket verification.',
function(){
it(
'Verify UDP server of type udp4 connects to UDP server named "udp4Server" and receives message.',
function(done){
ipc.serveNet(
8001,
'udp4',
function(){
ipc.server.on(
'message',
function(data,socket){
expect(data.id).toBe('udpServer');
expect(data.message).toBe('I am UDP4 server!');
done();
}
);
ipc.server.emit(
{
address : 'localhost',
port : ipc.config.networkPort
},
'message',
{
id : ipc.config.id,
message : 'I am testClient'
}
);
ipc.server.on(
'error',
function(err){
console.log('Error is: ', err);
}
);
}
);
ipc.server.start();
}
);
it(
'Verify UDP server of type udp6 connects to UDP server named "udp6Server" and receives message.',
function(done){
ipc.serveNet(
'::1',
8010,
'udp6',
function(){
ipc.server.on(
'message',
function(data,socket){
expect(data.id).toBe('udp6Server');
expect(data.message).toBe('I am UDP6 server!');
done();
}
);
ipc.server.emit(
{
address : 'localhost',
port : ipc.config.networkPort
},
'message',
{
id : ipc.config.id,
message : 'I am testClient'
}
);
ipc.server.on(
'error',
function(err){
console.log('Error is: ', err);
}
);
}
);
ipc.server.start();
}
);
}
);

225
spec/support/jasmineTest/Unix/unixSocketClient.spec.js Normal file
View file

@ -0,0 +1,225 @@
var ipc = require('../../../../node-ipc');
ipc.config.id ='testClient';
ipc.config.retry = 600;
describe('Test Cases for Unix client: ',
function(){
it(
'Verify retry attempts by Unix client to connect to the Unix server as per the value set in "maxRetries" parameter.',
function(done){
var retryAttempt = 3; //variable created to count the attempt made by client to connect to the server.
ipc.config.maxRetries = 3;
ipc.config.silent= true;
ipc.connectTo(
'fakeworld',
function(){
ipc.of.fakeworld.on(
'disconnect',
function(){
if(ipc.of.fakeworld.retriesRemaining == 0){
expect(retryAttempt).toBe(ipc.of.fakeworld.retriesRemaining);
expect(ipc.of.fakeworld.socket.destroyed).toBe(true);
}
else if(ipc.of.fakeworld.retriesRemaining < 0){
expect(retryAttempt).not.toBeLessThan(0);
expect(ipc.of.fakeworld.retriesRemaining).not.toBeLessThan(0);
ipc.of.fakeworld.on(
'error',
function(err){
console.log('Error is: ', err);
ipc.disconnect('fakeworld');
}
);
}
retryAttempt--;
}
);
}
);
// Wait time is added to verify the fail case scenario of additional retry attempt by client than expected.
setTimeout(
function(){
ipc.disconnect('fakeworld');
done();
},2500
);
}
);
it(
'Verify Unix client does not connect to the unix server when "stopRetrying" value is set to true.',
function(done){
var retryAttempt = 3; //variable created to count the attempt made by client to connect to the server.
ipc.config.maxRetries = 3;
ipc.config.stopRetrying = true;
ipc.connectTo(
'fakeworld',
function(){
ipc.of.fakeworld.on(
'disconnect',
function(){
if(ipc.of.fakeworld.retriesRemaining == 3){
expect(retryAttempt).toBe(ipc.of.fakeworld.retriesRemaining);
expect(ipc.of.fakeworld.socket.destroyed).toBe(true);
}
else if(ipc.of.fakeworld.retriesRemaining < 3){
expect(retryAttempt).not.toBeLessThan(3);
expect(ipc.of.fakeworld.retriesRemaining).not.toBeLessThan(3);
ipc.of.fakeworld.on(
'error',
function(err){
console.log('Error is: ', err);
ipc.disconnect('fakeworld');
}
);
}
retryAttempt--;
}
);
}
);
// Wait time is added to verify the fail case scenario of additional retry attempt by client than expected.
setTimeout(
function(){
ipc.disconnect('fakeworld');
done();
},700
);
}
);
it(
'Verify unix client connects to "unixServer" and receives message.',
function(done){
ipc.connectTo(
'unixServer',
'/tmp/app.unixServer',
function(){
ipc.of.unixServer.on(
'connect',
function(){
ipc.of.unixServer.emit(
'message',
{
id : ipc.config.id,
message : 'Hello from Client.'
}
);
ipc.of.unixServer.on(
'message',
function(data){
expect(data.id).toBe('unixServer');
expect(data.message).toBe('I am unix server!');
ipc.disconnect('unixServer');
done();
}
);
ipc.of.unixServer.on(
'error',
function(err){
console.log('Error is: ', err); done();
ipc.disconnect('unixServer');
}
);
}
);
}
);
}
);
it(
'Verify unix client queues the requests being sent to the server synchronously until it receives the response from server.',
function(done){
ipc.config.sync = true;
var responseCounter = 0;
ipc.connectTo(
'unixServerSync',
'/tmp/app.unixServerSync',
function(){
ipc.of.unixServerSync.on(
'connect',
function(){
for(var i=0; i<5; i++){
ipc.of.unixServerSync.emit(
'message',
{
id : ipc.config.id,
message : 'Unix Client Request '+ i
}
);
}
ipc.of.unixServerSync.on(
'message',
function(data){
if (data.message != null){
responseCounter++;
expect(data.message).toBe('Response from unix server');
}
if (responseCounter == 5){
expect(responseCounter).toBe(5);
ipc.disconnect('unixServerSync');
done();
}
}
);
ipc.of.unixServerSync.on(
'error',
function(err){
console.log('Error is: ', err); done();
ipc.disconnect('unixServerSync');
}
);
}
);
}
);
}
);
// End of test cases for Unix
}
);

47
spec/support/jasmineTest/Unix/unixSocketServer.spec.js Normal file
View file

@ -0,0 +1,47 @@
var ipc = require('../../../../node-ipc');
ipc.config.id ='testWorld';
ipc.config.retry = 1000;
describe('Test Cases for server: ',
function(){
// Unix server verification //
it(
'Verify unix server detects only 1 client out of 2 clients and receives message.',
function(done){
var clientCounter =0;
ipc.config.maxConnections=1;
ipc.config.networkPort='/tmp/app.testWorld';
ipc.serve(
function(){
ipc.server.on(
'message',
function(data,socket){
clientCounter++;
expect(data.id).toBe('unixClient');
expect(data.message).toBe('I am unix client.');
}
);
setTimeout(
function(){
expect(clientCounter).toBe(1);
done();
},2000
);
}
);
ipc.server.start();
}
);
}
);

38
spec/support/jasmineTest/tcpClient.js Normal file
View file

@ -0,0 +1,38 @@
var ipc=require('../../../node-ipc');
ipc.config.id = 'tcpClient';
ipc.config.retry= 600;
ipc.connectToNet(
'tcpClient',
8500,
function(){
ipc.of.tcpClient.on(
'connect',
function(){
ipc.of.tcpClient.emit(
'app.message',
{
id : ipc.config.id,
message : 'I am TCP client.'
}
)
}
);
ipc.of.tcpClient.on(
'disconnect',
function(){
ipc.log('disconnected from world'.notice);
}
);
ipc.of.tcpClient.on(
'app.message',
function(data){
ipc.log('got a message from world : '.debug, data.message);
}
);
}
);

35
spec/support/jasmineTest/tcpServer.js Normal file
View file

@ -0,0 +1,35 @@
var ipc=require('../../../node-ipc');
/***************************************\
*
* You should start both hello and world
* then you will see them communicating.
*
* *************************************/
ipc.config.id = 'tcpServer';
ipc.config.retry= 1500;
ipc.config.networkPort =8300;
ipc.serveNet(
function(){
ipc.server.on(
'message',
function(data,socket){
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'I am TCP server!'
}
);
}
);
}
);
ipc.server.start();

39
spec/support/jasmineTest/tcpServerSync.js Normal file
View file

@ -0,0 +1,39 @@
var ipc=require('../../../node-ipc');
/***************************************\
*
* You should start both hello and world
* then you will see them communicating.
*
* *************************************/
ipc.config.id = 'tcpServerSync';
ipc.config.retry= 1500;
ipc.config.networkPort = 8400;
ipc.serveNet(
function(){
ipc.server.on(
'message',
function(data,socket){
setTimeout(
function(){
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'Response from TCP server'
}
);
},900
);
}
);
}
);
ipc.server.start();

17
spec/support/jasmineTest/testFile.js Normal file
View file

@ -0,0 +1,17 @@
var cmd=require('node-cmd');
cmd.run('node '+ __dirname + '/unixServer.js');
cmd.run('node '+ __dirname + '/unixServerSync.js');
cmd.run('node '+ __dirname + '/udp4Server.js');
cmd.run('node '+ __dirname + '/udp6Server.js');
cmd.run('node '+ __dirname + '/tcpServer.js');
cmd.run('node '+ __dirname + '/tcpServerSync.js');
cmd.run('node '+ __dirname + '/unixClient.js');
cmd.run('node '+ __dirname + '/unixClient.js');
cmd.run('node '+ __dirname + '/tcpClient.js');
cmd.run('node '+ __dirname + '/tcpClient.js');

48
spec/support/jasmineTest/udp4Server.js Normal file
View file

@ -0,0 +1,48 @@
var ipc=require('../../../node-ipc');
/***************************************\
*
* Since there is no client relationship
* with UDP sockets sockets are not kept
* open.
*
* This means the order sockets are opened
* is important.
*
* Start World first. Then you can start
* hello or goodbye in any order you
* choose.
*
***************************************/
ipc.config.id = 'udpServer';
ipc.config.retry= 1500;
ipc.serveNet(
'udp4',
function(){
ipc.server.on(
'message',
function(data,socket){
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'I am UDP4 server!'
}
);
}
);
}
);
ipc.server.start();

47
spec/support/jasmineTest/udp6Server.js Normal file
View file

@ -0,0 +1,47 @@
var ipc=require('../../../node-ipc');
/***************************************\
*
* Since there is no client relationship
* with UDP sockets sockets are not kept
* open.
*
* This means the order sockets are opened
* is important.
*
* Start World first. Then you can start
* hello or goodbye in any order you
* choose.
*
***************************************/
ipc.config.id = 'udp6Server';
ipc.config.retry= 1500;
ipc.serveNet(
'::1',
'udp6',
function(){
ipc.server.on(
'message',
function(data,socket){
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'I am UDP6 server!'
}
);
}
);
}
);
ipc.server.start();

38
spec/support/jasmineTest/unixClient.js Normal file
View file

@ -0,0 +1,38 @@
var ipc=require('../../../node-ipc');
ipc.config.id = 'unixClient';
ipc.config.retry= 600;
ipc.connectTo(
'testWorld',
'/tmp/app.testWorld',
function(){
ipc.of.testWorld.on(
'connect',
function(){
ipc.of.testWorld.emit(
'message',
{
id : ipc.config.id,
message : 'I am unix client.'
}
)
}
);
ipc.of.testWorld.on(
'disconnect',
function(){
ipc.log('disconnected from testWorld'.notice);
}
);
ipc.of.testWorld.on(
'message',
function(data){
ipc.log('got a message from testWorld : '.debug, data);
}
);
}
);

34
spec/support/jasmineTest/unixServer.js Normal file
View file

@ -0,0 +1,34 @@
var ipc=require('../../../node-ipc');
/***************************************\
*
* You should start both hello and world
* then you will see them communicating.
*
* *************************************/
ipc.config.id = 'unixServer';
ipc.config.retry= 1500;
ipc.serve(
function(){
ipc.server.on(
'message',
function(data,socket){
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'I am unix server!'
}
);
}
);
}
);
ipc.server.start();

36
spec/support/jasmineTest/unixServerSync.js Normal file
View file

@ -0,0 +1,36 @@
var ipc=require('../../../node-ipc');
/***************************************\
*
* You should start both hello and world
* then you will see them communicating.
*
* *************************************/
ipc.config.id = 'unixServerSync';
ipc.config.retry= 1500;
ipc.serve(
function(){
ipc.server.on(
'message',
function(data,socket){
setTimeout(
function(){
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'Response from unix server'
}
);
},900
);
}
);
}
);
ipc.server.start();