Connection listener can be undefined.

Author: randunel

examples/client.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const client = require('../lib/abstract_socket')
+const client = require('../lib/abstract_socket.js')
     .connect('\0foo2', () => { //'connect' listener
         console.log('client connected');
     })

examples/server.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('../lib/abstract_socket')
+require('../lib/abstract_socket.js')
     .createServer(client => {
         console.log('client connected');
         client.on('end', () => {

lib/abstract_socket.js

@@ -68,7 +68,9 @@ exports.connect = exports.createConnection = function(name, connectListener) {
     }
 
     const sock = new net.Socket(options);
-    setImmediate(() => connectListener(sock));
+    if ('function' === typeof connectListener) {
+        setImmediate(() => connectListener(sock));
+    }
     return sock;
 };
 

package.json

@@ -4,6 +4,9 @@
         "email": "saghul@gmail.com",
         "url": "http://bettercallsaghul.com"
     },
+    "scripts": {
+        "test": "./node_modules/.bin/mocha --growl --timeout 2000 test/*.test.js"
+    },
     "name": "abstract-socket",
     "version": "1.1.0",
     "description": "Abstract domain socket support for Node / io.js",
@@ -21,6 +24,10 @@
         "bindings": "^1.2.1",
         "nan": "^2.0.9"
     },
+    "devDependencies": {
+        "should": "8.2.x",
+        "mocha": "2.4.x"
+    },
     "os": [
         "linux"
     ]

test/abstract-socket.test.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const spawn = require('child_process').spawn;
+const should = require('should'); // jshint ignore: line
+const abs = require('../lib/abstract_socket.js');
+
+const SOCKET_NAME = '\0test312';
+const SOME_DATA = 'asdqq\n';
+
+describe('server', () => {
+    describe('listening', () => {
+        let server;
+        beforeEach(() => (server = abs.createServer()) && server.listen(SOCKET_NAME));
+        afterEach(() => server.close());
+
+        it('should listen on abstract socket', () => exec('lsof -U')
+            .then(output => output.should.containEql(`@${SOCKET_NAME.slice(1)}`)));
+
+        it('should emit error when socket is busy', done => {
+            const server = abs.createServer();
+            server.listen(SOCKET_NAME);
+            server.on('error', err => {
+                err.syscall.should.equal('listen');
+                done();
+            });
+        });
+    });
+
+    describe('client connections', () => {
+        let server;
+        beforeEach(() => (server = abs.createServer()) && server.listen(SOCKET_NAME));
+        afterEach(() => server.close());
+
+        it('should emit event when client connects', done => {
+            server.on('connection', () => done());
+            abs.connect(SOCKET_NAME);
+        });
+
+        it('should receive client data', done => {
+            server.on('connection', client => {
+                client.on('data', data => {
+                    data.toString().should.equal(SOME_DATA);
+                    done();
+                });
+            });
+            abs.connect(SOCKET_NAME).write(SOME_DATA);
+        });
+    });
+
+    describe('messages', () => {
+        let server;
+        beforeEach(() => (server = abs.createServer()) && server.listen(SOCKET_NAME));
+        afterEach(() => server.close());
+
+        it('should be received from the client', done => {
+            server.on('connection', client => {
+                client.on('data', data => {
+                    data.toString().should.equal(SOME_DATA);
+                    done();
+                });
+            });
+            const client = abs.connect(SOCKET_NAME, () => {
+                client.write(SOME_DATA);
+            });
+        });
+    });
+});
+
+describe('client', () => {
+    describe('should emit error', () => {
+        it('when connecting to a non existent socket', done => {
+            abs.connect('\0non-existent-socket').on('error', () => done());
+        });
+
+        it('when connecting to a non abstract socket', done => {
+            abs.connect('non-abstract-socket').on('error', () => done());
+        });
+    });
+
+    describe('connect callback', () => {
+        let server;
+        beforeEach(() => (server = abs.createServer()) && server.listen(SOCKET_NAME));
+        afterEach(() => server.close());
+
+        it('should be called when connected', done => {
+            abs.connect(SOCKET_NAME, () => done());
+        });
+
+        it('should be called asynchronously', done => {
+            let counter = 0;
+            abs.connect(SOCKET_NAME, () => {
+                counter.should.equal(1);
+                done();
+            });
+            ++counter;
+        });
+    });
+
+    describe('messages', () => {
+        let server;
+        beforeEach(() => (server = abs.createServer()) && server.listen(SOCKET_NAME));
+        afterEach(() => server.close());
+
+        it('should be sent to the server', done => {
+            server.on('connection', client => {
+                client.on('data', data => {
+                    data.toString().should.equal(SOME_DATA);
+                    done();
+                });
+            });
+            const client = abs.connect(SOCKET_NAME, () => {
+                client.write(SOME_DATA);
+            });
+        });
+    });
+});
+
+function exec(cmd, options) {
+    return new Promise((resolve, reject) => {
+        let bin = cmd.split(' ').shift();
+        let params = cmd.split(' ').slice(1);
+        let child = spawn(bin, params, options);
+        let res = new Buffer(0);
+        let err = new Buffer(0);
+
+        child.stdout.on('data', buf => res = Buffer.concat([res, buf], res.length + buf.length));
+        child.stderr.on('data', buf => err = Buffer.concat([err, buf], err.length + buf.length));
+        child.on('close', code => {
+            return setImmediate(() => {
+                // setImmediate is required because there are often still
+                // pending write requests in both stdout and stderr at this point
+                if (code) {
+                    reject(err.toString());
+                } else {
+                    resolve(res.toString());
+                }
+            });
+        });
+        child.on('error', reject);
+    });
+}
+