client.js

function setupTransport() {
	// Dummy transport
	portal.transports.dummy = function() {
		return {
			open: function() {},
			send: function() {},
			close: function() {}
		};
	};

	// The server-side view of the socket handling
	// when using this, the user must use the server.fire and not use the client.fire
	portal.transports.mock = function(client, options) {
		var server;
		
		// Hack for the server-side socket's transport
		if (options.client) {
			server = client;
			client = options.client;
			
			// The server does
			return {
				open: function() {},
				send: function(data) {
					if (client.state() === "opened") {
						client._fire(data);
					}
				},
				close: function() {
					server.fire("close", "aborted");
				}
			};
		}
		
		// The client does 
		return {
			feedback: true,
			open: function() {
				// Forwards control to the user
				client.server = function(opts) {
					if (server) {
						return server;
					}
					
					// A server-side socket
					opts = opts || {};
					server = portal.open("/server~" + client.option("url"), {
						reconnect: false,
						sharing: false,
						transports: ["mock"],
						client: client
					});
					
					return server.on({
						open: function() {
							client.fire("open");
						},
						close: function(reason) {
							// Safe though this is done by the client
							client.fire("close", reason);
						},
						// Incomplete implementation but fine
						heartbeat: function() {
							if (!opts.noHeartbeat) {
								// Only heartbeat event should be sent with some delay
								setTimeout(function() {
									server.send("heartbeat");
								}, 1);
							}
						}
					});
				};
			},
			send: function(data) {
				if (server && server.state() === "opened") {
					server._fire(data);
				}
			},
			close: function() {
				if (server) {
					server.fire("close", "aborted");
				}
			}
		};
	};
}

QUnit.module("portal", {
	setup: function() {
		helper.setup();
		setupTransport();
		portal.defaults.transports = ["dummy"];
	},
	teardown: helper.teardown
});

test("portal.open(url) should opens and returns a socket", function() {
	ok(portal.open("dummy"));
});

test("portal.open(url, options) should opens and returns a socket", function() {
	ok(portal.open("dummy", {}));
});

test("portal.find() should return the first socket", function() {
	var first = portal.open("dummy1"), second = portal.open("dummy2");
	
	strictEqual(first, portal.find());
	notStrictEqual(second, portal.find());
});

test("portal.find(url) should return the socket which is mapped to the given url", function() {
	var socket = portal.open("dummy");
	
	strictEqual(socket, portal.find("dummy"));
	strictEqual(portal.find("absent"), null);
});

test("portal.find(url) should work with both absolute url and relative url", function() {
	var socket = portal.open("dummy");
	strictEqual(socket, portal.find("./dummy"));
	strictEqual(socket, portal.find(portal.support.getAbsoluteURL("dummy")));
});

QUnit.module("socket", {
	setup: function() {
		helper.setup();
		setupTransport();
		portal.defaults.transports = ["dummy"];
	},
	teardown: helper.teardown
});

// Event managing
test("socket.on(event, handler) should add a given event handler for a given event", 2, function() {
	portal.open("dummy").on("event", helper.okTrue).fire("event").fire("event");
});

test("The 'this' of any event handler should refer the socket where the event occurs", 1, function() {
	var socket = portal.open("dummy");
	
	socket.on("event", function() {
		strictEqual(this, socket);
	})
	.fire("event");
});

test("socket.on(handlers) should add a given event handlers from a given map of event type and event handler", 2, function() {
	portal.open("dummy").on({event: helper.okTrue}).fire("event").fire("event");
});

test("socket.off(event, handler) should remove a given event handler for a given event", function() {
	portal.open("dummy").on("event", helper.okFalse).off("event", helper.okFalse).on("event", helper.okTrue).fire("event");
});

test("socket.one(event, handler) should add a given one time event handler for a given event", 1, function() {
	portal.open("dummy").one("event", helper.okTrue).fire("event").fire("event");
});

// Life cycle and event
test("socket.state() should determine the current state of the socket", 1, function() {
	strictEqual(typeof portal.open("dummy").state(), "string");
});

test("socket.state() should be 'preparing' as an initial state", 1, function() {
	strictEqual(portal.open("dummy", {prepare: function() {}}).state(), "preparing");
});

test("connecting event should be fired only once when a connection is tried", 1, function() {
	var output = "",
		out = function(str) {
			return function() {
				output += str;
			};
		};
	
	portal.open("dummy").on("connecting", out("A")).on("connecting", out("B")).fire("connecting");
	strictEqual(output, "AB");
});

test("socket.connecting(fn) should add the given handler for the connecting event", 1, function() {
	var output = "",
		out = function(str) {
			return function() {
				output += str;
			};
		};
	
	portal.open("dummy").connecting(out("A")).connecting(out("B")).fire("connecting");
	strictEqual(output, "AB");
});

test("socket.state() should be 'connecting' on the connecting event", 1, function() {
	portal.open("dummy").connecting(function() {
		strictEqual(this.state(), "connecting");
	});
});

test("connecting event handler should receive no arguments", 1, function() {
	portal.open("dummy").on("connecting", function() {
		strictEqual(arguments.length, 0);
	});
});

test("waiting event should be fired only once when a reconnection has scheduled", 1, function() {
	var output = "",
		out = function(str) {
			return function() {
				output += str;
			};
		};
	
	portal.open("dummy").on("waiting", out("A")).fire("close").on("waiting", out("B")).fire("waiting");
	strictEqual(output, "AB");
});

test("socket.waiting(fn) should add the given handler for the waiting event", 1, function() {
	var output = "",
		out = function(str) {
			return function() {
				output += str;
			};
		};
	
	portal.open("dummy").waiting(out("A")).fire("close").waiting(out("B")).fire("waiting");
	strictEqual(output, "AB");
});

test("socket.state() should be 'waiting' on the waitingevent", 1, function() {
	portal.open("dummy").waiting(function() {
		strictEqual(this.state(), "waiting");
	})
	.fire("waiting");
});

test("waiting event handler should receive the reconnection delay and the total number of reconnection attempts", 2, function() {
	portal.open("dummy").waiting(function(delay, attempts) {
		strictEqual(delay, 500);
		strictEqual(attempts, 1);
	})
	.fire("close");
});

test("open event should be fired only once when a connection is established", 1, function() {
	var output = "",
		out = function(str) {
			return function() {
				output += str;
			};
		};
	
	portal.open("dummy").on("open", out("A")).fire("open").on("open", out("B")).fire("open");
	strictEqual(output, "AB");
});

test("socket.open(fn) should add the given handler for the open event", 1, function() {
	var output = "",
		out = function(str) {
			return function() {
				output += str;
			};
		};
	
	portal.open("dummy").open(out("A")).fire("open").open(out("B")).fire("open");
	strictEqual(output, "AB");
});

test("socket.state() should be 'opened' on the open event", 1, function() {
	portal.open("dummy").open(function() {
		strictEqual(this.state(), "opened");
	})
	.fire("open");
});

test("open event handler should receive no arguments", 1, function() {
	portal.open("dummy").fire("open").on("open", function() {
		strictEqual(arguments.length, 0);
	});
});

test("connecting event should become locked on the open event", 2, function() {
	portal.open("dummy").on("connecting", helper.okTrue).open(helper.okTrue).fire("open").on("connecting", helper.okFalse);
});

test("Accumulated events which are sent before the open event should be sent", function() {
	var received = [],
		client = portal.open("mock", {transports: ["mock"]}).send("event", "v0").send("event", "v1"),
		server = client.server().on("event", function(value) {
			received.push(value);
		}); 
	
	strictEqual(received.length, 0);
	strictEqual(client.state(), "connecting");
	server.fire("open");
	strictEqual(received.length, 2);
	strictEqual(client.state(), "opened");
	client.send("event", "v2");
	strictEqual(received.length, 3);
});

test("message event should be fired multiple times when a message event has been received", 1, function() {
	var output = "",
		out = function(str1) {
			return function() {
				output += str1;
			};
		};
	
	portal.open("dummy").on("message", out("A")).fire("message").on("message", out("B")).fire("message");
	strictEqual(output, "AAB");
});

test("socket.message(fn) should add the given handler for the message event", 1, function() {
	var output = "",
		out = function(str1) {
			return function() {
				output += str1;
			};
		};
	
	portal.open("dummy").message(out("A")).fire("message").message(out("B")).fire("message");
	strictEqual(output, "AAB");
});

test("message event should receive the data", 1, function() {
	var output = "",
		out = function(str1) {
			return function(str2) {
				output += str1 + str2;
			};
		};
	
	portal.open("dummy").message(out("A")).fire("message", "0").message(out("B")).fire("message", "1");
	strictEqual(output, "A0A1B1");
});

test("message event should receive the data and the optional callback for replying", 2, function() {
	portal.open("mock", {transports: ["mock"]}).message(function(data, reply) {
		strictEqual(data, "data");
		ok(portal.support.isFunction(reply));
	})
	.server().fire("open").send("message", "data", function() {});
});

test("callback which is a second argument of message event handler should be able to send a reply to the server", 1, function() {
	portal.open("mock", {transports: ["mock"]}).message(function(data, reply) {
		reply(data);
	})
	.server().fire("open").send("message", "data", function(data) {
		strictEqual(data, "data");
	});
});

test("close event should be fired once when a connection has been closed", 1, function() {
	var output = "",
		out = function(str) {
			return function() {
				output += str;
			};
		};
	
	portal.open("dummy").on("close", out("A")).fire("close").on("close", out("B")).fire("close");
	strictEqual(output, "AB");
});

test("socket.close(fn) should add the given handler for the close event", 1, function() {
	var output = "",
		out = function(str) {
			return function() {
				output += str;
			};
		};
	
	portal.open("dummy").close(out("A")).fire("close").close(out("B")).fire("close");
	strictEqual(output, "AB");
});

test("socket.state() should be 'closed' on the close event", 1, function() {
	portal.open("dummy").close(function() {
		strictEqual(this.state(), "closed");
	})
	.fire("close");
});

test("close event handler should receive the connection close reason", 1, function() {
	portal.open("dummy").fire("close", "").on("close", function(reason) {
		strictEqual(typeof reason, "string");
	});
});

test("close reason should be 'canceled' when preparation fails", 1, function() {
	portal.open("dummy", {
		prepare: function(connect, cancel) {
			cancel();
		}
	})
	.close(function(reason) {
		strictEqual(reason, "canceled");
	});
});

test("close reason should be 'notransport' when there is no available transport", 1, function() {
	portal.transports.spaceship = function() {};
	portal.open("dummy", {transports: ["spaceship"]}).close(function(reason) {
		strictEqual(reason, "notransport");
	});
});

test("close reason should be 'done' when the connection has been closed normally", 1, function() {
	portal.open("dummy").close(function(reason) {
		strictEqual(reason, "done");
	})
	.fire("close", "done");
});

test("close reason should be 'aborted' when the connection has been closed by its close()", 1, function() {
	portal.open("dummy").close(function(reason) {
		strictEqual(reason, "aborted");
	})
	.close();
});

asyncTest("close reason should be 'timeout' when the connection has been timed out", 1, function() {
	portal.open("dummy", {timeout: 10}).close(function(reason) {
		strictEqual(reason, "timeout");
		start();
	});
});

test("close reason should be 'error' when the connection has been closed due to a server error or could not be opened", 1, function() {
	portal.open("dummy").close(function(reason) {
		strictEqual(reason, "error");
	})
	.fire("close", "error");
});

helper.each("connecting open message event".split(" "), function(i, event) {
	test(event + " event should become locked on the close event", 2, function() {
		portal.open("dummy").on(event, helper.okTrue).fire(event).close(helper.okTrue).fire("close").on(event, helper.okFalse).fire(event);
	});
	test(event + " event propagation should be stopped on the close event", 1, function() {
		portal.open("dummy2").on(event, helper.okTrue)
		.on(event, function() {
			this.close();
		})
		.on(event, helper.okFalse).fire(event);
	});
});

// Misc methods
test("socket.option(key) should find the value of an option from the options merged with the default options and the given options", 3, function() {
	var socket;
	
	portal.defaults.tobeoverride = "A";
	portal.defaults.onlyindefaults = "B";
	
	socket = portal.open("dummy", {tobeoverride: "C", onlyinthis: "D"});
	strictEqual(socket.option("onlyindefaults"), "B");
	strictEqual(socket.option("tobeoverride"), "C");
	strictEqual(socket.option("onlyinthis"), "D");
});

test("socket.option('id') should return the socket id", 1, function() {
	strictEqual(typeof portal.open("dummy").option("id"), "string");
});

test("socket.option('url') should return an absolute url of the original url", 1, function() {
	strictEqual(portal.open("dummy").option("url"), portal.support.getAbsoluteURL("dummy"));
});

test("socket.data(key) and socket.data(key, value) should return and store the connection-scoped data with the specified key", 1, function() {
	strictEqual(portal.open("dummy").data("var", "variable").data("var"), "variable");
});

asyncTest("The connection scope should reset every time the socket opens", 2, function() {
	var latch;
	
	portal.open("dummy").data("var", "variable").connecting(function() {
		if (latch) {
			ok(this.data("var") == null);
			start();
		} else {
			latch = true;
			strictEqual(this.data("var"), "variable");
			
		}
	})
	.fire("close");
});

// Communication
test("socket.send(event) should send an event whose type is a given event to the server", 1, function() {
	portal.open("mock", {transports: ["mock"]}).send("event")
	.server().on("event", helper.okTrue).fire("open");
});

test("socket.send(event, data) should send an event whose type is a given event and data is a given data to the server", 6, function() {
	var client = portal.open("mock", {transports: ["mock"]}),
		server = client.server();
	
	helper.each({string: "string", number: 1, object: {a: 0}, array: [0], "true": true, "false": false}, function(k, v) {
		client.send("event-" + k, v);
		server.on("event-" + k, function(data) {
			if (typeof data === "object") {
				deepEqual(data, v);
			} else {
				strictEqual(data, v);
			}
		});
	});
	server.fire("open");
});

test("socket.send(event, data, done, fail) should send the event and register done and fail callback", 8, function() {
	function assertData(data) {
		strictEqual(data, "data");
	}
	
	portal.open("mock", {transports: ["mock"]})
	.send("event-donewithoutdata", "data", helper.okTrue, helper.okFalse)
	.send("event-donewithdata", "data", assertData, helper.okFalse)
	.send("event-failwithoutdata", "data", helper.okFalse, helper.okTrue)
	.send("event-failwithdata", "data", helper.okFalse, assertData)
	.server().on("event-donewithoutdata", function(data, reply) {
		strictEqual(data, "data");
		reply();
	})
	.on("event-donewithdata", function(data, reply) {
		strictEqual(data, "data");
		reply(data);
	})
	.on("event-failwithoutdata", function(data, reply) {
		strictEqual(data, "data");
		this.send("reply", {id: this.option("lastEventId"), exception: true});
	})
	.on("event-failwithdata", function(data, reply) {
		strictEqual(data, "data");
		this.send("reply", {id: this.option("lastEventId"), exception: true, data: data});
	})
	.fire("open");
});

test("socket.send(event, data, done, fail) should send the event and register done and fail callback event name", 8, function() {
	portal.open("mock", {transports: ["mock"]})
	.on("okTrue", helper.okTrue)
	.on("okFalse", helper.okFalse)
	.on("assert-data", function(data) {
		strictEqual(data, "data");
	})
	.send("event-donewithoutdata", "data", "okTrue", "okFalse")
	.send("event-donewithdata", "data", "assert-data", "okFalse")
	.send("event-failwithoutdata", "data", "okFalse", "okTrue")
	.send("event-failwithdata", "data", "okFalse", "assert-data")
	.server().on("event-donewithoutdata", function(data, reply) {
		strictEqual(data, "data");
		reply();
	})
	.on("event-donewithdata", function(data, reply) {
		strictEqual(data, "data");
		reply(data);
	})
	.on("event-failwithoutdata", function(data, reply) {
		strictEqual(data, "data");
		this.send("reply", {id: this.option("lastEventId"), exception: true});
	})
	.on("event-failwithdata", function(data, reply) {
		strictEqual(data, "data");
		this.send("reply", {id: this.option("lastEventId"), exception: true, data: data});
	})
	.fire("open");
});

test("socket.close() should close the socket", 1, function() {
	portal.open("dummyk").close(helper.okTrue).close();
});

test("socket.close() should prevent reconnection", 1, function() {
	portal.open("dummyk").close(helper.okTrue).waiting(helper.okFalse);
});

// Options
test("transports option should be an array of the transport candidate id to be used, in order of index", 1, function() {
	var output = "",
		transports = ["bus", "subway", "bicycle"];
		
	helper.each(transports, function(i, name) {
		portal.transports[name] = function() {
			output += name;
		};
	});
	portal.open("dummy", {transports: transports});
	strictEqual(output, transports.join(""));
});

asyncTest("timeout option should start timeout timer on the connecting event", 2, function() {
	portal.open("dummy", {timeout: 10}).connecting(helper.okTrue).open(helper.okFalse).close(function() {
		ok(true);
		start();
	});
});

asyncTest("timeout option should cancel timeout timer on the open event", 2, function() {
	var socket = portal.open("dummy", {timeout: 10}).connecting(helper.okTrue).open(helper.okTrue).fire("open").close(helper.okFalse);
	setTimeout(function() {
		socket.off("close", helper.okFalse);
		start();
	}, 10);
});

asyncTest("heartbeat option should send a heartbeat event each time the value has elapsed", 6, function() {
	var i = 0;
	
	portal.open("mock", {transports: ["mock"], heartbeat: 60, _heartbeat: 30})
	.on("heartbeat", function() {
		ok(true);
		i++;
		if (i > 2) {
			this.close();
			start();
		}
	})
	.server().fire("open").on("heartbeat", helper.okTrue);
});

asyncTest("heartbeat option should fire the close event if the server makes no response to a heartbeat", 1, function() {
	portal.open("mock", {transports: ["mock"], heartbeat: 10, _heartbeat: 5})
	.on("heartbeat", helper.okFalse)
	.close(function() {
		start();
	})
	.server({noHeartbeat: true}).fire("open").on("heartbeat", helper.okTrue);
});

test("lastEventId option should be the last event id", 5, function() {
	var i = 0;
	
	function assertEventId() {
		strictEqual(this.option("lastEventId"), ++i);
	}
	
	portal.open("mock", {transports: ["mock"]}).message(assertEventId).on("another", assertEventId)
	.server().fire("open").send("message").send("message").send("message").send("another").send("another");
});

test("lastEventId option should start from the assigned value if it is set", 2, function() {
	portal.open("mock", {transports: ["mock"], lastEventId: 25})
	.open(function() {
		strictEqual(this.option("lastEventId"), 25);
	})
	.message(function() {
		strictEqual(this.option("lastEventId"), 1);
	})
	.server().fire("open").send("message");
});

test("prepare option should be called before the socket tries to connect", 1, function() {
	portal.open("dummy", {prepare: helper.okTrue}).connecting(helper.okFalse);
});

test("prepare option should receive a callback to connect, a callback to cancel and merged modifiable options", 4, function() {
	portal.open("dummy1", {
		vassline: "black silence",
		prepare: function(connect, cancel, options) {
			strictEqual(options.vassline, "black silence");
			connect();
		}
	})
	.connecting(helper.okTrue);
	
	portal.open("dummy2", {
		prepare: function(connect, cancel, options) {
			strictEqual(options.heartbeat, false);
			options.heartbeat = 5000;
			cancel();
		}
	})
	.connecting(helper.okFalse)
	.close(function() {
		strictEqual(this.option("heartbeat"), 5000);
	});
});

test("reconnect option should be executed to schedule reconnection on the close event", 1, function() {
	var output = "",
		out = function(str) {
			return function() {
				output += str;
			};
		};

	portal.open("dummy", {reconnect: out("B")}).close(out("A")).waiting(out("C")).fire("close");
	strictEqual(output, "ABC");
});

test("reconnect option should prevent the socket from reconnecting when it is or returns false", 3, function() {
	portal.open("dummy1", {reconnect: false}).fire("close").close(helper.okTrue).waiting(helper.okFalse);
	portal.open("dummy2", {
		reconnect: function() {
			ok(true);
			return false;
		}
	})
	.fire("close").close(helper.okTrue).waiting(helper.okFalse);
});

asyncTest("reconnect option should receive the last delay and the total number of reconnection attempts and return a delay to reconnect", 16, function() {
	var i = 0, lastDelay = -1;
	
	portal.open("dummy2", {
		reconnect: function(delay, attempts) {
			delay = delay || 0;
			strictEqual(attempts, i);
			strictEqual(delay, lastDelay + 1);
			lastDelay = delay;
			return delay + 1;
		}
	})
	.connecting(function() {
		i++;
		ok(true);
		this.fire("close");
	})
	.waiting(function(delay, attempts) {
		strictEqual(i, attempts);
		if (attempts > 3) {
			this.close();
			start();
		}
	});
});

test("idGenerator option should generate a socket id", 1, function() {
	strictEqual(portal.open("dummy", {
		idGenerator: function() {
			return "envy";
		}
	})
	.option("id"), "envy");
});

test("urlBuilder option should build an url receiving the absolute form of url, a params object and the when", 17, function() {
	var params,
		when,
		socket = portal.open("dummy", {
			urlBuilder: function(url, parameters, on) {
				strictEqual(url, portal.support.getAbsoluteURL("dummy"), "A");
				params = parameters;
				ok(delete params._);
				when = on;
				return "/wow-" + on;
			}
		});
	
	strictEqual(socket.buildURL("open"), "/wow-open");
	deepEqual(params, {id: socket.option("id"), transport: "dummy", heartbeat: false, lastEventId: 0});
	strictEqual(when, "open");
	
	strictEqual(socket.buildURL("poll"), "/wow-poll");
	deepEqual(params, {id: socket.option("id"), transport: "dummy", lastEventId: 0, lastEventIds: undefined /* default value is not specified */});
	strictEqual(when, "poll");

	strictEqual(socket.buildURL("abort"), "/wow-abort");
	deepEqual(params, {id: socket.option("id")});
	strictEqual(when, "abort");
});

test("params option should be merged with the default params and passed to the urlBuilder option", 8, function() {
	var params,
		when,
		noop = function() {},
		socket = portal.open("dummy", {
			params: {
				open: {val: "x", fn: noop},
				poll: {val: "y", fn: noop},
				abort: {val: "z", fn: noop}
			},
			urlBuilder: function(url, params, on) {
				switch (on) {
				case "open":
					strictEqual(params.val, "x");
					strictEqual(params.fn, noop);
					break;
				case "poll":
					strictEqual(params.val, "y");
					strictEqual(params.fn, noop);
					break;
				case "abort":
					strictEqual(params.val, "z");
					strictEqual(params.fn, noop);
					break;
				default:
					ok(false);
					break;
				}
				return url;
			}
		});
	
	socket.buildURL("open");
	socket.buildURL("poll");
	socket.buildURL("abort");
});

test("inbound option should convert data by the server into an event object", 6, function() {
	var inbound, socket;
	
	socket = portal.open("dummy", {
		inbound: function() {
			return inbound.apply(this, arguments);
		}
	})
	.fire("open");
	
	inbound = function(data) {
		return {type: "message"};
	};
	socket.one("message", function(data, reply) {
		ok(!data);
		ok(!reply);
	})
	._fire("a");
	
	inbound = function(data) {
		return {type: "message", data: data};
	};
	socket.one("message", function(data, reply) {
		strictEqual(data, "a");
		ok(!reply);
	})
	._fire("a");

	inbound = function(data) {
		return {type: "message", data: data, reply: true};
	};
	socket.one("message", function(data, reply) {
		strictEqual(data, "a");
		ok(reply);
	})
	._fire("a");
});

test("outbound option should convert an event object into data to be sent to the server", 24, function() {
	var outboundInternal, socket, i = 0;
	
	portal.transports.dummy = function() {
		return {
			open: function() {},
			send: function(payload) {
				strictEqual(payload, "payload");
			},
			close: function() {}
		};
	};
	socket = portal.open("dummy", {
		outbound: function() {
			outboundInternal.apply(this, arguments);
			return "payload";
		}
	})
	.fire("open");
	
	outboundInternal = function(event) {
		strictEqual(event.socket, socket.option("id"));
		strictEqual(event.id, ++i);
		strictEqual(event.type, "event");
		ok(!event.data);
		ok(!event.reply);
	};
	socket.send("event");
	
	outboundInternal = function(event) {
		strictEqual(event.socket, socket.option("id"));
		strictEqual(event.id, ++i);
		strictEqual(event.type, "event");
		strictEqual(event.data, "data");
		ok(!event.reply);
	};
	socket.send("event", "data");
	
	outboundInternal = function(event) {
		strictEqual(event.socket, socket.option("id"));
		strictEqual(event.id, ++i);
		strictEqual(event.type, "event");
		strictEqual(event.data, "data");
		ok(event.reply, "data");
	};
	socket.send("event", "data", function() {});
	
	outboundInternal = function(event) {
		strictEqual(event.socket, socket.option("id"));
		strictEqual(event.id, ++i);
		strictEqual(event.type, "event");
		strictEqual(event.data, "data");
		ok(event.reply, "data");
	};
	socket.send("event", "data", null, function() {});
});