The Tor Browser: comparison toolkit/devtools/server/tests/unit/test_forwardingprefix.js

comparison: toolkit/devtools/server/tests/unit/test_forwardingprefix.js

toolkit/devtools/server/tests/unit/test_forwardingprefix.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:104b5f63f289
+/* Any copyright is dedicated to the Public Domain.
+http://creativecommons.org/publicdomain/zero/1.0/ */
+/* Exercise prefix-based forwarding of packets to other transports. */
+var gMainConnection, gMainTransport;
+var gSubconnection1, gSubconnection2;
+var gClient;
+function run_test()
+{
+DebuggerServer.init();
+add_test(createMainConnection);
+add_test(TestNoForwardingYet);
+add_test(createSubconnection1);
+add_test(TestForwardPrefix1OnlyRoot);
+add_test(createSubconnection2);
+add_test(TestForwardPrefix12OnlyRoot);
+add_test(TestForwardPrefix12WithActor1);
+add_test(TestForwardPrefix12WithActor12);
+run_next_test();
+}
+/*
+* Create a pipe connection, and return an object |{ conn, transport }|,
+* where |conn| is the new DebuggerServerConnection instance, and
+* |transport| is the client side of the transport on which it communicates
+* (that is, packets sent on |transport| go to the new connection, and
+* |transport|'s hooks receive replies).
+*
+* |aPrefix| is optional; if present, it's the prefix (minus the ':') for
+* actors in the new connection.
+*/
+function newConnection(aPrefix)
+{
+var conn;
+DebuggerServer.createRootActor = function (aConn) {
+conn = aConn;
+return new DebuggerServer.RootActor(aConn, {});
+};
+var transport = DebuggerServer.connectPipe(aPrefix);
+return { conn: conn, transport: transport };
+}
+/* Create the main connection for these tests. */
+function createMainConnection()
+{
+({ conn: gMainConnection, transport: gMainTransport }) = newConnection();
+gClient = new DebuggerClient(gMainTransport);
+gClient.connect((aType, aTraits) => run_next_test());
+}
+/*
+* Exchange 'echo' messages with five actors:
+* - root
+* - prefix1:root
+* - prefix1:actor
+* - prefix2:root
+* - prefix2:actor
+*
+* Expect proper echos from those named in |aReachables|, and 'noSuchActor'
+* errors from the others. When we've gotten all our replies (errors or
+* otherwise), call |aCompleted|.
+*
+* To avoid deep stacks, we call aCompleted from the next tick.
+*/
+function tryActors(aReachables, aCompleted) {
+let count = 0;
+let outerActor;
+for (outerActor of [ 'root',
+'prefix1:root', 'prefix1:actor',
+'prefix2:root', 'prefix2:actor' ]) {
+/*
+* Let each callback capture its own iteration's value; outerActor is
+* local to the whole loop, not to a single iteration.
+*/
+let actor = outerActor;
+count++;
+gClient.request({ to: actor, type: 'echo', value: 'tango'}, // phone home
+(aResponse) => {
+if (aReachables.has(actor))
+do_check_matches({ from: actor, type: 'echo', value: 'tango' }, aResponse);
+else
+do_check_matches({ from: actor, error: 'noSuchActor' }, aResponse);
+if (--count == 0)
+do_execute_soon(aCompleted, "tryActors callback " + aCompleted.name);
+});
+}
+}
+/*
+* With no forwarding established, sending messages to root should work,
+* but sending messages to prefixed actor names, or anyone else, should get
+* an error.
+*/
+function TestNoForwardingYet()
+{
+tryActors(Set(['root']), run_next_test);
+}
+/*
+* Create a new pipe connection which forwards its reply packets to
+* gMainConnection's client, and to which gMainConnection forwards packets
+* directed to actors whose names begin with |aPrefix + ':'|, and.
+*
+* Return an object { conn, transport }, as for newConnection.
+*/
+function newSubconnection(aPrefix)
+{
+let { conn, transport } = newConnection(aPrefix);
+transport.hooks = {
+onPacket: (aPacket) => gMainConnection.send(aPacket),
+onClosed: () => {}
+}
+gMainConnection.setForwarding(aPrefix, transport);
+return { conn: conn, transport: transport };
+}
+/* Create a second root actor, to which we can forward things. */
+function createSubconnection1()
+{
+let { conn, transport } = newSubconnection('prefix1');
+gSubconnection1 = conn;
+transport.ready();
+gClient.expectReply('prefix1:root', (aReply) => run_next_test());
+}
+// Establish forwarding, but don't put any actors in that server.
+function TestForwardPrefix1OnlyRoot()
+{
+tryActors(Set(['root', 'prefix1:root']), run_next_test);
+}
+/* Create a third root actor, to which we can forward things. */
+function createSubconnection2()
+{
+let { conn, transport } = newSubconnection('prefix2');
+gSubconnection2 = conn;
+transport.ready();
+gClient.expectReply('prefix2:root', (aReply) => run_next_test());
+}
+function TestForwardPrefix12OnlyRoot()
+{
+tryActors(Set(['root', 'prefix1:root', 'prefix2:root']), run_next_test);
+}
+// A dumb actor that implements 'echo'.
+//
+// It's okay that both subconnections' actors behave identically, because
+// the reply-sending code attaches the replying actor's name to the packet,
+// so simply matching the 'from' field in the reply ensures that we heard
+// from the right actor.
+function EchoActor(aConnection)
+{
+this.conn = aConnection;
+}
+EchoActor.prototype.actorPrefix = "EchoActor";
+EchoActor.prototype.onEcho = function (aRequest) {
+/*
+* Request packets are frozen. Copy aRequest, so that
+* DebuggerServerConnection.onPacket can attach a 'from' property.
+*/
+return JSON.parse(JSON.stringify(aRequest));
+};
+EchoActor.prototype.requestTypes = {
+"echo": EchoActor.prototype.onEcho
+};
+function TestForwardPrefix12WithActor1()
+{
+let actor = new EchoActor(gSubconnection1)
+actor.actorID = 'prefix1:actor';
+gSubconnection1.addActor(actor);
+tryActors(Set(['root', 'prefix1:root', 'prefix1:actor', 'prefix2:root']), run_next_test);
+}
+function TestForwardPrefix12WithActor12()
+{
+let actor = new EchoActor(gSubconnection2)
+actor.actorID = 'prefix2:actor';
+gSubconnection2.addActor(actor);
+tryActors(Set(['root', 'prefix1:root', 'prefix1:actor', 'prefix2:root', 'prefix2:actor']), run_next_test);
+}