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

Annihilate

This commit is contained in:
0loli 2022-03-17 02:08:30 +00:00 committed by GitHub
parent 324346c738
commit 17d798fa22
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 0 additions and 981 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
test/CI.js
View File

@ -1,68 +0,0 @@
//TCP TESTS
import cmd from 'node-cmd';
import {run as TCPClientRun} from './TCP/client.js';
import {run as TCPServerRun} from './TCP/server.js';
import {run as UDPRun} from './UDP/client.js';
import {run as unixClientRun} from './unix/client.js';
function logOutput(name,err, data, stderr){
console.log(`
${name} OUTPUT
`);
console.log(err, data, stderr)
}
cmd.run(
'node ./test/TCP/TCPServer.js',
function(err, data, stderr){
logOutput('TCP SERVER',err, data, stderr)
}
);
cmd.run(
'node ./test/TCP/TCPClient.js',
function(err, data, stderr){
logOutput('TCP CLIENT',err, data, stderr)
}
);
cmd.run(
'node ./test/UDP/UDP4Server.js',
function(err, data, stderr){
logOutput('UDP4',err, data, stderr)
}
);
cmd.run(
'node ./test/UDP/UDP6Server.js',
function(err, data, stderr){
logOutput('UDP6',err, data, stderr)
}
);
cmd.run(
'node ./test/unix/unixServer.js',
function(err, data, stderr){
logOutput('unix/posix',err, data, stderr)
}
);
cmd.run(
'node ./test/unix/unixServerSync.js',
function(err, data, stderr){
logOutput('unix/posix sync',err, data, stderr)
}
);
await TCPClientRun();
await TCPServerRun();
await UDPRun();
await unixClientRun();

45
test/TCP/TCPClient.js
View File

@ -1,45 +0,0 @@
import ipc from '../../node-ipc.js';
import process from 'process';
const dieAfter = 30e3;
function killClientProcess(){
process.exit(0);
}
setTimeout(
killClientProcess,
dieAfter
);
ipc.config.id = 'tcpClient';
ipc.config.retry= 600;
ipc.config.silent=true;
ipc.config.networkPort=8500;
ipc.connectToNet(
'testWorld',
function(){
ipc.of.testWorld.on(
'connect',
function(){
ipc.of.testWorld.emit(
'message',
'hello'
);
}
);
ipc.of.testWorld.on(
'END',
killClientProcess
)
}
);
export {
dieAfter as default,
dieAfter
}

53
test/TCP/TCPServer.js
View File

@ -1,53 +0,0 @@
import ipc from '../../node-ipc.js';
import process from 'process';
const dieAfter = 30e3;
function killServerProcess(){
process.exit(0);
}
setTimeout(
killServerProcess,
dieAfter
);
ipc.config.id = 'tcpServer';
ipc.config.retry= 1500;
ipc.config.networkPort=8300;
ipc.config.silent=true;
ipc.serveNet(
function serverStarted(){
ipc.server.on(
'message',
function gotMessage(data,socket){
console.log('Server recieved message',data);
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'I am TCP server!'
}
);
console.log('server emitted data')
}
);
ipc.server.on(
'END',
killServerProcess
);
console.log('TCP server up');
}
);
ipc.server.start();
export {
killServerProcess as default,
killServerProcess
}

191
test/TCP/client.js
View File

@ -1,191 +0,0 @@
import VanillaTest from 'vanilla-test';
import Is from 'strong-type';
import {IPCModule} from '../../node-ipc.js';
import delay from '../../helpers/delay.js';
async function run(){
const test=new VanillaTest;
const is=new Is;
const cleanup=function(){
test.pass();
test.done();
}
const fail=function(err){
console.trace(err)
test.fail();
}
var transmit_delay = 1000;
try{
test.expects(
'TCP client to connection attempts to be limited by the "maxRetries" parameter.'
);
const ipc=new IPCModule;
ipc.config.id ='testClient';
ipc.config.retry = 60;
ipc.config.maxRetries = 3;
ipc.config.stopRetrying = false;
ipc.config.silent=true;
//set to -1 because there is an error on the first fail
//before retrying
let errorCount=-1;
ipc.connectToNet(
'tcpFakeServer',
8002,
function open(){
}
);
ipc.of.tcpFakeServer.on(
'error',
function gotError(err){
errorCount++;
is.defined(err);
}
);
await delay(ipc.config.retry*ipc.config.maxRetries + transmit_delay);
ipc.config.stopRetrying = true;
ipc.of.tcpFakeServer.emit('END');
ipc.disconnect('tcpFakeServer');
test.compare(errorCount,ipc.config.maxRetries);
}catch(err){
fail(err);
}
cleanup();
try{
test.expects(
'TCP client not to try to reconnect when "stopRetrying" is set to true.'
);
const ipc=new IPCModule;
ipc.config.maxRetries = 3;
ipc.config.stopRetrying = true;
ipc.silent=true;
//set to -1 because there is an error on the first fail
//before retrying
let errorCount=-1;
ipc.connectToNet(
'tcpFakeServer',
8002,
function open(){
}
);
ipc.of.tcpFakeServer.on(
'error',
function gotError(err){
is.defined(err);
errorCount++;
}
);
await delay(ipc.config.retry*ipc.config.maxRetries + transmit_delay);
test.compare(errorCount,0);
test.compare(ipc.of.tcpFakeServer.retriesRemaining,ipc.config.maxRetries);
ipc.disconnect('tcpFakeServer');
}catch(err){
fail(err);
}
cleanup();
try{
test.expects(
'TCP client to connect to server named "tcpServer" and receive a message.'
);
const ipc=new IPCModule;
ipc.config.maxRetries = 3;
ipc.config.stopRetrying = true;
ipc.silent=true;
let data={};
ipc.connectToNet(
'tcpServer',
8300,
function open(){
ipc.of.tcpServer.on(
'connect',
function connected(){
ipc.of.tcpServer.emit(
'message',
{
id : ipc.config.id,
message : 'Hello from testClient.'
}
);
console.log('client sent message');
}
);
ipc.of.tcpServer.on(
'message',
function gotMessage(message){
data=message;
console.log('client got message');
}
);
}
);
ipc.of.tcpServer.on(
'error',
function gotError(err){
fail(err);
}
);
await delay(ipc.config.retry*ipc.config.maxRetries + transmit_delay);
console.log(data)
test.compare(data.id,'tcpServer');
test.compare(data.message,'I am TCP server!');
ipc.of.tcpServer.emit(
'END'
);
ipc.disconnect('tcpServer');
}catch(err){
fail(err);
}
cleanup();
}
export {
run as default,
run
}

77
test/TCP/server.js
View File

@ -1,77 +0,0 @@
import VanillaTest from 'vanilla-test';
import Is from 'strong-type';
import {IPCModule} from '../../node-ipc.js';
import delay from '../../helpers/delay.js';
async function run(){
const test=new VanillaTest;
const is=new Is;
const cleanup=function(){
test.pass();
test.done();
}
const fail=function(err){
console.trace(err)
test.fail();
}
var transmit_delay = 1000;
try{
test.expects(
'Server to detect TCP client connection.'
);
const ipc=new IPCModule;
ipc.config.id ='testWorld';
ipc.config.retry = 1000;
ipc.config.networkPort=8500;
let requiredCount=2;
let requiredCounter=0;
ipc.serveNet(
function serverStarted(){
ipc.server.on(
'connect',
function connected(socket){
requiredCounter++;
ipc.server.on(
'message',
function(data){
requiredCounter++;
}
)
}
);
}
);
ipc.server.start();
await delay(transmit_delay*2);
ipc.server.broadcast('END');
ipc.config.stopRetrying = true;
ipc.server.stop();
test.compare(requiredCount,requiredCounter);
}catch(err){
fail(err);
}
cleanup();
}
export {
run as default,
run
}

47
test/UDP/UDP4Server.js
View File

@ -1,47 +0,0 @@
import ipc from '../../node-ipc.js';
import process from 'process';
const dieAfter = 30e3;
function killServerProcess(){
process.exit(0);
}
setTimeout(
killServerProcess,
dieAfter
);
ipc.config.id = 'udp4Server';
ipc.config.retry= 1500;
ipc.config.silent=true;
ipc.config.networkPort=8095;
ipc.serveNet(
'127.0.0.1',
'udp4',
function serverStarted(){
ipc.server.on(
'message',
function gotMessage(data,socket){
//console.log(data,socket)
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'I am UDP4 server!'
}
);
}
);
ipc.server.on(
'END',
killServerProcess
);
}
);
ipc.server.start();

46
test/UDP/UDP6Server.js
View File

@ -1,46 +0,0 @@
import ipc from '../../node-ipc.js';
import process from 'process';
const dieAfter = 30e3;
function killServerProcess(){
process.exit(0);
}
setTimeout(
killServerProcess,
dieAfter
);
ipc.config.id = 'udp6Server';
ipc.config.retry= 1500;
ipc.config.silent=true;
ipc.config.networkPort=8099;
ipc.serveNet(
'::1',
'udp6',
function serverStarted(){
ipc.server.on(
'message',
function gotMessage(data,socket){
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'I am UDP6 server!'
}
);
}
);
ipc.server.on(
'END',
killServerProcess
);
}
);
ipc.server.start();

165
test/UDP/client.js
View File

@ -1,165 +0,0 @@
import VanillaTest from 'vanilla-test';
import Is from 'strong-type';
import {IPCModule} from '../../node-ipc.js';
import delay from '../../helpers/delay.js';
async function run(){
const test=new VanillaTest;
const is=new Is;
const cleanup=function(){
test.pass();
test.done();
}
const fail=function(err){
console.trace(err)
test.fail();
}
var transmit_delay = 1000;
try{
test.expects(
'UDP4 server to connect to "udpServer" and receive message.'
);
const ipc=new IPCModule;
ipc.config.networkPort=8009;
ipc.config.id ='testClient';
ipc.config.retry = 60;
ipc.config.maxRetries=3;
let serverID='';
let message='';
const expectedServerID='udp4Server';
const expectedMessage='I am UDP4 server!';
const UDPAddr={
address : '127.0.0.1',
port : 8095
}
ipc.serveNet(
UDPAddr.address,
'udp4',
async function serverStarted(){
ipc.server.on(
'message',
function gotMessage(data,socket){
console.log(data,socket)
serverID=data.id;
message=data.message;
ipc.server.emit(
UDPAddr,
'END'
);
}
);
//latency issues when running UDP4 via node-cmd
await delay(transmit_delay);
ipc.server.emit(
UDPAddr,
'message'
);
}
);
ipc.server.start();
await delay(transmit_delay*3);
console.log(serverID,expectedServerID,message,expectedMessage);
test.compare(serverID,expectedServerID);
test.compare(message,expectedMessage);
ipc.server.stop();
}catch(err){
fail(err);
}
cleanup();
try{
test.expects(
'UDP6 server to connect to "udp6Server" and receive message.'
);
const ipc=new IPCModule;
ipc.config.networkPort=8007;
ipc.config.id ='testClient';
ipc.config.retry = 60;
ipc.config.maxRetries=3;
let serverID='';
let message='';
const expectedServerID='udp6Server';
const expectedMessage='I am UDP6 server!';
const UDP6Addr={
address : '::1',
port : 8099
}
ipc.serveNet(
UDP6Addr.address,
'udp6',
async function serverStarted(){
ipc.server.on(
'message',
function gotMessage(data,socket){
serverID=data.id;
message=data.message;
ipc.server.emit(
UDP6Addr,
'END'
);
}
);
//latency issues when running UDP4 via node-cmd
await delay(transmit_delay);
ipc.server.emit(
UDP6Addr,
'message'
);
}
);
ipc.server.start();
await delay(transmit_delay*3);
console.log(serverID,expectedServerID,message,expectedMessage);
test.compare(serverID,expectedServerID);
test.compare(message,expectedMessage);
ipc.server.stop();
}catch(err){
fail(err);
}
cleanup();
}
export {
run as default,
run
}

165
test/unix/client.js
View File

@ -1,165 +0,0 @@
import VanillaTest from 'vanilla-test';
import Is from 'strong-type';
import {IPCModule} from '../../node-ipc.js';
import delay from '../../helpers/delay.js';
async function run(){
const test=new VanillaTest;
const is=new Is;
const cleanup=function(){
test.pass();
test.done();
}
const fail=function(err){
console.trace(err)
test.fail();
}
var transmit_delay = 1000;
try{
test.expects(
'unix client to connect to "unixServer" and receive a message.'
);
const ipc=new IPCModule;
ipc.config.id ='testClient';
ipc.config.retry = 900;
let serverID='';
let serverMessage='';
let expectedServerID='unixServer';
let expectedMessage='I am unix server!';
ipc.connectTo(
'unixServer',
function open(){
ipc.of.unixServer.on(
'connect',
function connected(){
ipc.of.unixServer.on(
'message',
function gotMessage(data){
serverID=data.id
serverMessage=data.message
}
);
ipc.of.unixServer.emit(
'message',
{
id : ipc.config.id,
message : 'Hello from Client.'
}
);
}
);
}
);
await delay(transmit_delay);
ipc.config.stopRetrying=true;
ipc.of.unixServer.emit(
'END'
);
}catch(err){
fail(err);
}
cleanup();
try{
test.expects(
'the unix client to send synchronously when config.sync is set to true'
);
const ipc=new IPCModule;
ipc.config.sync = true;
ipc.config.silent = true;
const messageTotal=5;
let responseCounter = 0;
ipc.connectTo(
'unixServerSync',
'/tmp/app.unixServerSync',
function open(){
ipc.of.unixServerSync.on(
'connect',
function connected(){
for(let i=0; i<messageTotal; i++){
ipc.of.unixServerSync.emit(
'message',
{
id : ipc.config.id,
message : 'Unix Client Request '
}
);
}
ipc.of.unixServerSync.on(
'message',
function gotMessage(data){
if(data.message!=='Response from unix server'){
throw new Error("data.message!=='Response from unix server'");
};
responseCounter++;
}
);
}
);
}
);
await delay(transmit_delay);
ipc.config.stopRetrying=true;
test.compare(responseCounter,messageTotal);
ipc.of.unixServerSync.emit(
'END'
);
}catch(err){
fail(err);
}
cleanup();
// try{
// test.expects(
// ''
// );
// const ipc=new IPCModule;
// }catch(err){
// fail(err);
// }
// cleanup();
}
export {
run as default,
run
}

27
test/unix/unixClient.js
View File

@ -1,27 +0,0 @@
import ipc from '../../node-ipc.js';
import process from 'process';
const dieAfter=30e3;
function killServerProcess(){
process.exit(0);
}
setTimeout(
killServerProcess,
dieAfter
);
ipc.config.id = 'unixClient';
ipc.config.retry= 600;
ipc.config.silent=true;
ipc.connectTo(
'testWorld',
'/tmp/app.testWorld'
);
ipc.connectTo(
'testWorld2',
'/tmp/app.testWorld'
);

42
test/unix/unixServer.js
View File

@ -1,42 +0,0 @@
import ipc from '../../node-ipc.js';
import process from 'process';
const dieAfter=30e3;
function killServerProcess(){
process.exit(0);
}
setTimeout(
killServerProcess,
dieAfter
);
ipc.config.id = 'unixServer';
ipc.config.retry= 1500;
ipc.config.silent=false;
ipc.serve(
function serverStarted(){
ipc.server.on(
'message',
function gotMessage(data,socket){
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'I am unix server!'
}
);
}
);
}
);
ipc.server.on(
'END',
killServerProcess
);
ipc.server.start();

55
test/unix/unixServerSync.js
View File

@ -1,55 +0,0 @@
import ipc from '../../node-ipc.js';
import process from 'process';
const dieAfter=30e3;
function killServerProcess(){
process.exit(0);
}
setTimeout(
killServerProcess,
dieAfter
);
ipc.config.id = 'unixServerSync';
ipc.config.retry= 1500;
ipc.config.silent=true;
ipc.serve(
function serverStarted(){
let ready=false;
ipc.server.on(
'message',
function gotMessage(data,socket){
if(ready){
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'Error, client not wating for server response before sending request.'
}
);
}
ipc.server.emit(
socket,
'message',
{
id : ipc.config.id,
message : 'Response from unix server'
}
);
}
);
}
);
ipc.server.on(
'END',
killServerProcess
)
ipc.server.start();