08-27-周三_17-09-29

node_modules/dnode/test/_id.js

@@ -0,0 +1,13 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('_id', function (t) {
+    t.plan(1);
+    
+    var server = dnode({ _id : 1337 });
+    var client = dnode();
+    client.on('remote', function (remote, conn) {
+        t.equal(remote._id, 1337);
+    });
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/args.js

@@ -0,0 +1,55 @@
+var test = require('tape');
+
+var parseArgs = require('../lib/parse_args');
+
+function argv () { return arguments }
+
+test('args', function (t) {
+    t.deepEqual(
+        parseArgs(argv('moo.com', 555)),
+        { host : 'moo.com', port : 555 }
+    );
+    
+    t.deepEqual(
+        parseArgs(argv('7777')),
+        { port : 7777 }
+    );
+    
+    t.deepEqual(
+        parseArgs(argv({
+            host : 'moosy.moo.com',
+            port : 5050
+        })),
+        { host : 'moosy.moo.com', port : 5050 }
+    );
+    
+    t.deepEqual(
+        parseArgs(argv('meow.cats.com', { port : '1234' })),
+        { host : 'meow.cats.com', port : 1234 }
+    );
+    
+    t.deepEqual(
+        typeof parseArgs(argv('789')).port,
+        'number'
+    );
+    
+    t.deepEqual(
+        parseArgs(argv(
+            { host : 'woof.dogs.com' }, { port : 4050 }
+        )),
+        { host : 'woof.dogs.com', port : 4050 }
+    );
+    
+    t.deepEqual(
+        parseArgs(argv(
+            undefined,
+            { host : 'woof.dogs.com' },
+            undefined,
+            { port : 4050 },
+            undefined
+        )),
+        { host : 'woof.dogs.com', port : 4050 }
+    );
+    
+    t.end();
+});

node_modules/dnode/test/bidirectional.js

@@ -0,0 +1,30 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('bidirectional', function (t) {
+    t.plan(3);
+    
+    var server = dnode(function (client) {
+        this.timesX = function (n,f) {
+            t.equal(n, 3, "timesX's n == 3");
+            
+            client.x(function (x) {
+                t.equal(x, 20, 'client.x == 20');
+                f(n * x);
+            });
+        }; 
+    });
+    
+    var client = dnode({
+        x : function (f) { f(20) }
+    });
+    client.on('remote', function (remote) {
+        remote.timesX(3, function (res) {
+            t.equal(res, 60, 'result of 20 * 3 == 60');
+            client.end();
+            server.end();
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/broadcast.js

@@ -0,0 +1,69 @@
+var dnode = require('../');
+var EventEmitter = require('events').EventEmitter;
+var test = require('tape');
+
+test('broadcast', function (t) {
+    t.plan(3);
+    
+    var em = new EventEmitter;
+    var server = function () {
+        return dnode(function (client, conn) {
+            conn.on('ready', function () {
+                em.on('message', client.message);
+            });
+            
+            conn.on('end', function () {
+                em.removeListener('message', client.message);
+            });
+            
+            this.message = function (msg) {
+                em.emit('message', client.name + ' says: ' + msg);
+            };
+        });
+    };
+    
+    var recv = { 0 : [], 1 : [], 2 : [] };
+    
+    var client0 = dnode({
+        name : '#0',
+        message : function (msg) { recv[0].push(msg) }
+    });
+    client0.on('remote', function (remote) {
+        setTimeout(function () {
+            remote.message('hello!');
+        }, 25);
+    });
+    client0.pipe(server()).pipe(client0);
+    
+    var client1 = dnode({
+        name : '#1',
+        message : function (msg) { recv[1].push(msg) }
+    });
+    client1.on('remote', function (remote) {
+        setTimeout(function () {
+            remote.message('hey');
+        }, 50);
+    });
+    client1.pipe(server()).pipe(client1);
+    
+    var client2 = dnode({
+        name : '#2',
+        message : function (msg) { recv[2].push(msg) }
+    });
+    client2.on('remote', function (remote) {
+        setTimeout(function () {
+            remote.message('wowsy');
+        }, 75);
+    });
+    client2.pipe(server()).pipe(client2);
+    
+    setTimeout(function () {
+        t.deepEqual(
+            recv[0],
+            [ '#0 says: hello!', '#1 says: hey', '#2 says: wowsy' ],
+            "#0 didn't get the right messages"
+        );
+        t.deepEqual(recv[0], recv[1], "#1 didn't get the messages");
+        t.deepEqual(recv[0], recv[2], "#2 didn't get the messages");
+    }, 150);
+});

node_modules/dnode/test/circular.js

@@ -0,0 +1,33 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('circular refs', function (t) {
+    t.plan(7);
+    
+    var server = dnode({
+        sendObj : function (ref, f) {
+            t.equal(ref.a, 1);
+            t.equal(ref.b, 2);
+            t.deepEqual(ref.c, ref);
+            
+            ref.d = ref.c;
+            
+            f(ref);
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        var obj = { a : 1, b : 2 };
+        obj.c = obj;
+        
+        remote.sendObj(obj, function (ref) {
+            t.equal(ref.a, 1);
+            t.equal(ref.b, 2);
+            t.deepEqual(ref.c, ref);
+            t.deepEqual(ref.d, ref);
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/double.js

@@ -0,0 +1,38 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('double', function (t) {
+    t.plan(4);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = dnode({
+        z : function (f, g, h) {
+            f(10, function (x) {
+                g(10, function (y) {
+                    h(x,y)
+                })
+            })
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        remote.z(
+            function (x,f) { f(x * 2) },
+            function (x,f) { f(x / 2) },
+            function (x,y) {
+                t.equal(x, 20, 'double, not equal');
+                t.equal(y, 5, 'double, not equal');
+            }
+        );
+        
+        function plusTen(n,f) { f(n + 10) }
+        
+        remote.z(plusTen, plusTen, function (x,y) {
+            t.equal(x, 20, 'double, equal');
+            t.equal(y, 20, 'double, equal');
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/emit.js

@@ -0,0 +1,61 @@
+var test = require('tape');
+var EventEmitter = require('events').EventEmitter;
+var dnode = require('../');
+
+test('emit events', function (t) {
+    t.plan(1);
+    
+    var subs = [];
+    function publish (name) {
+        var args = [].slice.call(arguments, 1);
+        for (var i = 0; i < subs.length; i++) {
+            subs[i].emit(name, args);
+        }
+    }
+    
+    var server = function () {
+        return dnode(function (remote, conn) {
+            this.subscribe = function (emit) {
+                subs.push({ emit : emit, id : conn.id });
+                
+                conn.on('end', function () {
+                    for (var i = 0; i < subs.length; i++) {
+                        if (subs.id === conn.id) {
+                            subs.splice(i, 1);
+                            break;
+                        }
+                    }
+                });
+            };
+        });
+    };
+    
+    setTimeout(function () {
+        var times = 0;
+        var iv = setInterval(function () {
+            if (++times === 5) {
+                t.deepEqual(xs, ys);
+                return clearInterval(iv);
+            }
+            else publish('data', Math.floor(Math.random() * 100));
+        }, 20);
+    }, 20);
+    
+    var xs = [];
+    var x = dnode();
+    x.on('remote', function (remote) {
+        var em = new EventEmitter;
+        em.on('data', function (n) { xs.push(n) });
+        remote.subscribe(function () { return em.emit.apply(em, arguments) });
+    });
+    x.pipe(server()).pipe(x);
+    
+    var ys = [];
+    var y = dnode();
+    y.on('remote', function (remote) {
+        var em = new EventEmitter;
+        em.on('data', function (n) { ys.push(n) });
+        remote.subscribe(function () { return em.emit.apply(em, arguments) });
+    });
+    y.pipe(server()).pipe(y);
+});

node_modules/dnode/test/middleware.js

@@ -0,0 +1,51 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('middleware', function (t) {
+    t.plan(5);
+    
+    var tf = setTimeout(function () {
+        t.fail('never finished');
+    }, 1000);
+    
+    var tr = setTimeout(function () {
+        t.fail('never ready');
+    }, 1000);
+    
+    var tc = setTimeout(function () {
+        t.fail('connection not ready');
+    }, 1000);
+    
+    var server = dnode(function (client, conn) {
+        var self = this;
+        t.ok(!conn.zing);
+        t.ok(!client.moo);
+        
+        conn.on('remote', function () {
+            clearTimeout(tr);
+            t.ok(conn.zing);
+            t.ok(self.moo);
+        });
+        
+        this.baz = 42;
+    });
+    
+    server.on('local', function (client, conn) {
+        conn.zing = true;
+    });
+    
+    server.on('local', function (client, conn) {
+        client.moo = true;
+        conn.on('remote', function () {
+            clearTimeout(tc);
+        });
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote, conn) {
+        clearTimeout(tf);
+        t.ok(remote.baz);
+    });
+    
+    server.pipe(client).pipe(server);
+});

node_modules/dnode/test/nested.js

@@ -0,0 +1,48 @@
+var dnode = require('../');
+var test = require('tape');
+var EventEmitter = require('events').EventEmitter;
+
+test('nested', function (t) {
+    t.plan(4);
+    
+    var server1 = function () {
+        return dnode({
+            timesTen : function (n,reply) { reply(n * 10) }
+        });
+    };
+    
+    var server2 = function () {
+        return dnode({
+            timesTwenty : function (n,reply) { reply(n * 20) }
+        });
+    };
+    
+    var moo = new EventEmitter;
+    
+    var client1 = dnode();
+    client1.on('remote', function (remote1, conn1) {
+        var client2 = dnode();
+        client2.on('remote', function (remote2, conn2) {
+            moo.on('hi', function (x) {
+                remote1.timesTen(x, function (res) {
+                    t.equal(res, 5000, 'emitted value times ten');
+                    remote2.timesTwenty(res, function (res2) {
+                        t.equal(res2, 100000, 'result times twenty');
+                    });
+                });
+            });
+            remote2.timesTwenty(5, function (n) {
+                t.equal(n, 100);
+                remote1.timesTen(0.1, function (n) {
+                    t.equal(n, 1);
+                });
+            });
+        });
+        client2.pipe(server2()).pipe(client2);
+    });
+    client1.pipe(server1()).pipe(client1);
+    
+    setTimeout(function() {
+        moo.emit('hi', 500);
+    }, 200);
+});

node_modules/dnode/test/null.js

@@ -0,0 +1,34 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('null', function (t) {
+    t.plan(5);
+    
+    var server = dnode({
+        empty : null,
+        timesTen : function (n, reply) {
+            t.equal(n, 50);
+            reply(n * 10);
+        },
+        moo : function (reply) { reply(100) },
+        sTimesTen : function (n, cb) {
+            t.equal(n, 5);
+            cb(n * 10, null);
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        remote.moo(function (x) {
+            t.equal(x, 100, 'remote moo == 100');
+        });
+        remote.sTimesTen(5, function (m) {
+            t.equal(m, 50, '5 * 10 == 50');
+            remote.timesTen(m, function (n) {
+                t.equal(n, 500, '50 * 10 == 500');
+            });
+        });
+    });
+    
+    server.pipe(client).pipe(server);
+});

node_modules/dnode/test/obj.js

@@ -0,0 +1,29 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('object ref tests', function (t) {
+    t.plan(8);
+    var obj = { a : 1, b : 2, f : function (n,g) { g(n * 20) } };
+    
+    var server = dnode({
+        getObject : function (f) { f(obj) }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote, conn) {
+        remote.getObject(function (rObj) {
+            t.equal(rObj.a, 1);
+            t.equal(rObj.b, 2);
+            t.equal(typeof rObj.f, 'function');
+            rObj.a += 100; rObj.b += 100;
+            t.equal(obj.a, 1);
+            t.equal(obj.b, 2);
+            t.notEqual(obj.f, rObj.g);
+            t.equal(typeof obj.f, 'function');
+            rObj.f(13, function (res) {
+                t.equal(res, 260);
+            });
+        });
+    });
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/refs.js

@@ -0,0 +1,19 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('refs', function (t) {
+    t.plan(2);
+    
+    var server = dnode({
+        a : 1,
+        b : 2
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        t.equal(remote.a, 1);
+        t.equal(remote.b, 2);
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/self-referential.js

@@ -0,0 +1,34 @@
+var dnode = require('../')
+var test = require('tape');
+
+test('self-referential', function (t) {
+    t.plan(7);
+    
+    var server = dnode({
+        timesTen : function (n,reply) {
+            t.equal(n.number, 5);
+            reply(n.number * 10);
+        },
+        print : function (n,reply) {
+            t.strictEqual(n[0],1);
+            t.strictEqual(n[1],2);
+            t.strictEqual(n[2],3);
+            t.strictEqual(n[3],n);
+            reply(n);
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        var args = [1,2,3]
+        args.push(args)
+        
+        remote.print(args, function (m) {
+            t.same(m.slice(0,3), args.slice(0,3));
+            t.equal(m, m[3]);
+            t.equal(args, args[3]);
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/server/null.js

@@ -0,0 +1,40 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('null', function (t) {
+    t.plan(7);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = dnode({
+        empty : null,
+        timesTen : function (n, reply) {
+            t.equal(n, 50);
+            reply(n * 10);
+        },
+        moo : function (reply) { reply(100) },
+        sTimesTen : function (n, cb) {
+            t.equal(n, 5);
+            cb(n * 10, null);
+        },
+    }).listen(port.toString()); // test for stringified ports too why not
+    
+    server.on('listening', function () {
+        dnode.connect(port, function (remote, conn) {
+            t.ok(conn.id);
+            t.equal(conn.stream.remoteAddress, '127.0.0.1');
+            
+            remote.moo(function (x) {
+                t.equal(x, 100, 'remote moo == 100');
+            });
+            remote.sTimesTen(5, function (m) {
+                t.equal(m, 50, '5 * 10 == 50');
+                remote.timesTen(m, function (n) {
+                    t.equal(n, 500, '50 * 10 == 500');
+                    conn.end();
+                    server.close();
+                    t.end();
+                });
+            });
+        });
+    });
+});

node_modules/dnode/test/server/port0.js

@@ -0,0 +1,15 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('port0', function (t) {
+    t.plan(2);
+    var port = 0;
+
+    var server = dnode().listen(port);
+
+    server.on('listening', function () {
+      t.ok(server.address().port !== port);
+      t.ok(server.address().port > 0);
+      server.close();
+    });
+});

node_modules/dnode/test/server/stream.js

@@ -0,0 +1,33 @@
+var dnode = require('../../');
+var net = require('net');
+var test = require('tape');
+
+test('stream', function (t) {
+    t.plan(2);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = net.createServer(function (stream) {
+        var d = dnode({
+            meow : function f (g) { g('cats') }
+        });
+        d.on('remote', function (remote) {
+            t.equal(remote.x, 5);
+        });
+        stream.pipe(d).pipe(stream);
+    });
+    server.listen(port);
+    
+    server.on('listening', function () {
+        var d = dnode({ x : 5 });
+        d.on('remote', function (remote) {
+            remote.meow(function (cats) {
+                t.equal(cats, 'cats');
+                server.close();
+                d.end();
+            });
+        });
+        
+        var stream = net.connect(port);
+        d.pipe(stream).pipe(d);
+    });
+});

node_modules/dnode/test/server/tcp.js

@@ -0,0 +1,35 @@
+var dnode = require('../../')
+var test = require('tape');
+var util = require('util');
+
+test('simple', function (t) {
+    t.plan(3);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = dnode({
+        timesTen : function (n,reply) {
+            t.equal(n.number, 5);
+            reply(n.number * 10);
+        },
+        print : function (n,reply) {
+            reply(util.inspect(n));
+        },
+    }).listen(port);
+    
+    server.on('listening', function () {
+        dnode.connect(port, function (remote, conn) {
+            t.equal(conn.stream.remoteAddress, '127.0.0.1');
+            var args = {
+                number : 5,
+                func : function () {},
+            };
+            
+            remote.timesTen(args, function (m) {
+                t.equal(m, 50, '5 * 10 == 50');
+                conn.end();
+                server.close();
+                t.end();
+            });
+        });
+    });
+});

node_modules/dnode/test/server/unicode.js

@@ -0,0 +1,26 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('unicode', function (t) {
+    t.plan(2);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = dnode({
+        unicodes : function (reply) {
+            reply('☔☔☔☁☼☁❄');
+        }
+    }).listen(port);
+    
+    server.on('listening', function () {
+        dnode.connect(port, function (remote, conn) {
+            t.equal(conn.stream.remoteAddress, '127.0.0.1');
+            remote.unicodes(function (str) {
+                t.equal(str, '☔☔☔☁☼☁❄', 'remote unicodes == ☔☔☔☁☼☁❄');
+                
+                conn.end();
+                server.close();
+                t.end();
+            });
+        });
+    });
+});

node_modules/dnode/test/server/unix.js

@@ -0,0 +1,23 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('unix', function (t) {
+    t.plan(1);
+    
+    var sfile = '/tmp/unix_socket_' + Math.floor(
+        Math.random() * Math.pow(2, 32)
+    ).toString(16);
+    
+    var server = dnode({ f : function (cb) { cb(1337) } }).listen(sfile);
+    
+    server.on('listening', function () {
+        dnode.connect(sfile, function (remote, conn) {
+            remote.f(function (x) {
+                t.equal(x, 1337);
+                server.close();
+                conn.end();
+                t.end();
+            });
+        });
+    });
+});

node_modules/dnode/test/server/zero.js

@@ -0,0 +1,38 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('listen on port 0', function (t) {
+    t.plan(7);
+    
+    var server = dnode({
+        timesTen : function (n,reply) {
+            t.equal(n, 50);
+            reply(n * 10);
+        },
+        moo : function (reply) { reply(100) },
+        sTimesTen : function (n, cb) {
+            t.equal(n, 5);
+            cb(n * 10);
+        },
+    }).listen(0);
+    
+    server.on('listening', function () {
+        dnode.connect(server.address().port, function (remote, conn) {
+            t.ok(conn.id);
+            t.equal(conn.stream.remoteAddress, '127.0.0.1');
+            
+            remote.moo(function (x) {
+                t.equal(x, 100, 'remote moo == 100');
+            });
+            remote.sTimesTen(5, function (m) {
+                t.equal(m, 50, '5 * 10 == 50');
+                remote.timesTen(m, function (n) {
+                    t.equal(n, 500, '50 * 10 == 500');
+                    conn.end();
+                    server.close();
+                    t.end();
+                });
+            });
+        });
+    });
+});

node_modules/dnode/test/simple.js

@@ -0,0 +1,39 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('simple server and client', function (t) {
+    t.plan(5);
+    
+    var server = dnode({
+        timesTen : function (n,reply) {
+            t.equal(n, 50);
+            reply(n * 10);
+        },
+        moo : function (reply) { reply(100) },
+        sTimesTen : function (n, cb) {
+            t.equal(n, 5);
+            cb(n * 10);
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        remote.moo(function (x) {
+            t.equal(x, 100, 'remote moo == 100');
+        });
+        remote.sTimesTen(5, function (m) {
+            t.equal(m, 50, '5 * 10 == 50');
+            remote.timesTen(m, function (n) {
+                t.equal(n, 500, '50 * 10 == 500');
+            });
+        });
+    });
+    
+    server.on('end', function () {
+        console.log('server END');
+    });
+    client.on('end', function () {
+        console.log('client END');
+    });
+    server.pipe(client).pipe(server);
+});

node_modules/dnode/test/stream.js

@@ -0,0 +1,22 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('stream', function (t) {
+    t.plan(2);
+    
+    var server = dnode({
+        meow : function f (g) { g('cats') }
+    });
+    server.on('remote', function (remote) {
+        t.equal(remote.x, 5);
+    });
+    
+    var client = dnode({ x : 5 });
+    client.on('remote', function (remote) {
+        remote.meow(function (cats) {
+            t.equal(cats, 'cats');
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});