diff options
Diffstat (limited to '')
15 files changed, 2239 insertions, 0 deletions
diff --git a/devtools/shared/protocol/tests/xpcshell/.eslintrc.js b/devtools/shared/protocol/tests/xpcshell/.eslintrc.js new file mode 100644 index 0000000000..8611c174f5 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/.eslintrc.js @@ -0,0 +1,6 @@ +"use strict"; + +module.exports = { + // Extend from the common devtools xpcshell eslintrc config. + extends: "../../../../.eslintrc.xpcshell.js", +}; diff --git a/devtools/shared/protocol/tests/xpcshell/head.js b/devtools/shared/protocol/tests/xpcshell/head.js new file mode 100644 index 0000000000..dd055ddb42 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/head.js @@ -0,0 +1,99 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { require } = ChromeUtils.importESModule( + "resource://devtools/shared/loader/Loader.sys.mjs" +); +const { + DevToolsServer, +} = require("resource://devtools/server/devtools-server.js"); +const { + DevToolsClient, +} = require("resource://devtools/client/devtools-client.js"); + +function dumpn(msg) { + dump("DBG-TEST: " + msg + "\n"); +} + +function connectPipeTracing() { + return new TracingTransport(DevToolsServer.connectPipe()); +} + +/** + * Mock the `Transport` class in order to intercept all the packet + * getting in and out and then being able to assert them and dump them. + */ +function TracingTransport(childTransport) { + this.hooks = null; + this.child = childTransport; + this.child.hooks = this; + + this.expectations = []; + this.packets = []; + this.checkIndex = 0; +} + +TracingTransport.prototype = { + // Remove actor names + normalize(packet) { + return JSON.parse( + JSON.stringify(packet, (key, value) => { + if (key === "to" || key === "from" || key === "actor") { + return "<actorid>"; + } + return value; + }) + ); + }, + send(packet) { + this.packets.push({ + type: "sent", + packet: this.normalize(packet), + }); + return this.child.send(packet); + }, + close() { + return this.child.close(); + }, + ready() { + return this.child.ready(); + }, + onPacket(packet) { + this.packets.push({ + type: "received", + packet: this.normalize(packet), + }); + this.hooks.onPacket(packet); + }, + onTransportClosed() { + if (this.hooks.onTransportClosed) { + this.hooks.onTransportClosed(); + } + }, + + expectSend(expected) { + const packet = this.packets[this.checkIndex++]; + Assert.equal(packet.type, "sent"); + deepEqual(packet.packet, this.normalize(expected)); + }, + + expectReceive(expected) { + const packet = this.packets[this.checkIndex++]; + Assert.equal(packet.type, "received"); + deepEqual(packet.packet, this.normalize(expected)); + }, + + // Write your tests, call dumpLog at the end, inspect the output, + // then sprinkle the calls through the right places in your test. + dumpLog() { + for (const entry of this.packets) { + if (entry.type === "sent") { + dumpn("trace.expectSend(" + entry.packet + ");"); + } else { + dumpn("trace.expectReceive(" + entry.packet + ");"); + } + } + }, +}; diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_abort.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_abort.js new file mode 100644 index 0000000000..ce237e1c00 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_abort.js @@ -0,0 +1,79 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * Outstanding requests should be rejected when the connection aborts + * unexpectedly. + */ + +var protocol = require("resource://devtools/shared/protocol.js"); +var { RetVal } = protocol; + +const rootSpec = protocol.generateActorSpec({ + typeName: "root", + + methods: { + simpleReturn: { + response: { value: RetVal() }, + }, + }, +}); + +class RootActor extends protocol.Actor { + constructor(conn) { + super(conn, rootSpec); + + // Root actor owns itself. + this.manage(this); + this.actorID = "root"; + this.sequence = 0; + } + + sayHello() { + return { + from: "root", + applicationType: "xpcshell-tests", + traits: [], + }; + } + + simpleReturn() { + return this.sequence++; + } +} + +class RootFront extends protocol.FrontClassWithSpec(rootSpec) { + constructor(client) { + super(client); + this.actorID = "root"; + // Root owns itself. + this.manage(this); + } +} +protocol.registerFront(RootFront); + +add_task(async function () { + DevToolsServer.createRootActor = conn => new RootActor(conn); + DevToolsServer.init(); + + const trace = connectPipeTracing(); + const client = new DevToolsClient(trace); + await client.connect(); + + const rootFront = client.mainRoot; + + const onSimpleReturn = rootFront.simpleReturn(); + trace.close(); + + try { + await onSimpleReturn; + ok(false, "Connection was aborted, request shouldn't resolve"); + } catch (e) { + const error = e.toString(); + ok(true, "Connection was aborted, request rejected correctly"); + ok(error.includes("Request stack:"), "Error includes request stack"); + ok(error.includes("test_protocol_abort.js"), "Stack includes this test"); + } +}); diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_async.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_async.js new file mode 100644 index 0000000000..dd7196710b --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_async.js @@ -0,0 +1,192 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * Make sure we get replies in the same order that we sent their + * requests even when earlier requests take several event ticks to + * complete. + */ + +const { waitForTick } = require("resource://devtools/shared/DevToolsUtils.js"); +const protocol = require("resource://devtools/shared/protocol.js"); +const { Arg, RetVal } = protocol; + +const rootSpec = protocol.generateActorSpec({ + typeName: "root", + + methods: { + simpleReturn: { + response: { value: RetVal() }, + }, + promiseReturn: { + request: { toWait: Arg(0, "number") }, + response: { value: RetVal("number") }, + }, + simpleThrow: { + response: { value: RetVal("number") }, + }, + promiseThrow: { + request: { toWait: Arg(0, "number") }, + response: { value: RetVal("number") }, + }, + }, +}); + +class RootActor extends protocol.Actor { + constructor(conn) { + super(conn, rootSpec); + + // Root actor owns itself. + this.manage(this); + this.actorID = "root"; + this.sequence = 0; + } + + sayHello() { + return { + from: "root", + applicationType: "xpcshell-tests", + traits: [], + }; + } + + simpleReturn() { + return this.sequence++; + } + + // Guarantee that this resolves after simpleReturn returns. + async promiseReturn(toWait) { + const sequence = this.sequence++; + + // Wait until the number of requests specified by toWait have + // happened, to test queuing. + while (this.sequence - sequence < toWait) { + await waitForTick(); + } + + return sequence; + } + + simpleThrow() { + throw new Error(this.sequence++); + } + + // Guarantee that this resolves after simpleReturn returns. + promiseThrow(toWait) { + return this.promiseReturn(toWait).then(Promise.reject); + } +} + +class RootFront extends protocol.FrontClassWithSpec(rootSpec) { + constructor(client) { + super(client); + this.actorID = "root"; + // Root owns itself. + this.manage(this); + } +} +protocol.registerFront(RootFront); + +add_task(async function () { + DevToolsServer.createRootActor = conn => new RootActor(conn); + DevToolsServer.init(); + + const trace = connectPipeTracing(); + const client = new DevToolsClient(trace); + await client.connect(); + + const rootFront = client.mainRoot; + + const calls = []; + let sequence = 0; + + // Execute a call that won't finish processing until 2 + // more calls have happened + calls.push( + rootFront.promiseReturn(2).then(ret => { + // Check right return order + Assert.equal(sequence, 0); + // Check request handling order + Assert.equal(ret, sequence++); + }) + ); + + // Put a few requests into the backlog + + calls.push( + rootFront.simpleReturn().then(ret => { + // Check right return order + Assert.equal(sequence, 1); + // Check request handling order + Assert.equal(ret, sequence++); + }) + ); + + calls.push( + rootFront.simpleReturn().then(ret => { + // Check right return order + Assert.equal(sequence, 2); + // Check request handling order + Assert.equal(ret, sequence++); + }) + ); + + calls.push( + rootFront.simpleThrow().then( + () => { + Assert.ok(false, "simpleThrow shouldn't succeed!"); + }, + error => { + // Check right return order + Assert.equal(sequence++, 3); + } + ) + ); + + calls.push( + rootFront.promiseThrow(2).then( + () => { + Assert.ok(false, "promiseThrow shouldn't succeed!"); + }, + error => { + // Check right return order + Assert.equal(sequence++, 4); + Assert.ok(true, "simple throw should throw"); + } + ) + ); + + calls.push( + rootFront.simpleReturn().then(ret => { + // Check right return order + Assert.equal(sequence, 5); + // Check request handling order + Assert.equal(ret, sequence++); + }) + ); + + // Break up the backlog with a long request that waits + // for another simpleReturn before completing + calls.push( + rootFront.promiseReturn(1).then(ret => { + // Check right return order + Assert.equal(sequence, 6); + // Check request handling order + Assert.equal(ret, sequence++); + }) + ); + + calls.push( + rootFront.simpleReturn().then(ret => { + // Check right return order + Assert.equal(sequence, 7); + // Check request handling order + Assert.equal(ret, sequence++); + }) + ); + + await Promise.all(calls); + await client.close(); +}); diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_children.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_children.js new file mode 100644 index 0000000000..728e58c6b9 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_children.js @@ -0,0 +1,700 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +/* eslint-disable max-nested-callbacks */ + +"use strict"; + +/** + * Test simple requests using the protocol helpers. + */ +const protocol = require("resource://devtools/shared/protocol.js"); +const { types, Arg, RetVal } = protocol; + +// Predeclaring the actor type so that it can be used in the +// implementation of the child actor. +types.addActorType("childActor"); +types.addActorType("otherChildActor"); +types.addPolymorphicType("polytype", ["childActor", "otherChildActor"]); + +const childSpec = protocol.generateActorSpec({ + typeName: "childActor", + + events: { + event1: { + a: Arg(0), + b: Arg(1), + c: Arg(2), + }, + event2: { + a: Arg(0), + b: Arg(1), + c: Arg(2), + }, + "named-event": { + type: "namedEvent", + a: Arg(0), + b: Arg(1), + c: Arg(2), + }, + "object-event": { + type: "objectEvent", + detail: Arg(0, "childActor#actorid"), + }, + "array-object-event": { + type: "arrayObjectEvent", + detail: Arg(0, "array:childActor#actorid"), + }, + }, + + methods: { + echo: { + request: { str: Arg(0) }, + response: { str: RetVal("string") }, + }, + getDetail1: { + response: { + child: RetVal("childActor#actorid"), + }, + }, + getDetail2: { + response: { + child: RetVal("childActor#actorid"), + }, + }, + getIDDetail: { + response: { + idDetail: RetVal("childActor#actorid"), + }, + }, + getIntArray: { + request: { inputArray: Arg(0, "array:number") }, + response: { + intArray: RetVal("array:number"), + }, + }, + getSibling: { + request: { id: Arg(0) }, + response: { sibling: RetVal("childActor") }, + }, + emitEvents: { + response: { value: RetVal("string") }, + }, + release: { + release: true, + }, + }, +}); + +class ChildActor extends protocol.Actor { + constructor(conn, id) { + super(conn, childSpec); + this.childID = id; + } + + // Actors returned by this actor should be owned by the root actor. + marshallPool() { + return this.getParent(); + } + + toString() { + return "[ChildActor " + this.childID + "]"; + } + + destroy() { + super.destroy(); + this.destroyed = true; + } + + form() { + return { + actor: this.actorID, + childID: this.childID, + }; + } + + echo(str) { + return str; + } + + getDetail1() { + return this; + } + + getDetail2() { + return this; + } + + getIDDetail() { + return this; + } + + getIntArray(inputArray) { + // Test that protocol.js converts an iterator to an array. + const f = function* () { + for (const i of inputArray) { + yield 2 * i; + } + }; + return f(); + } + + getSibling(id) { + return this.getParent().getChild(id); + } + + emitEvents() { + this.emit("event1", 1, 2, 3); + this.emit("event2", 4, 5, 6); + this.emit("named-event", 1, 2, 3); + this.emit("object-event", this); + this.emit("array-object-event", [this]); + return "correct response"; + } + + release() {} +} + +class ChildFront extends protocol.FrontClassWithSpec(childSpec) { + constructor(client, targetFront, parentFront) { + super(client, targetFront, parentFront); + this._parentFront = parentFront; + + this.before("event1", this.onEvent1.bind(this)); + this.before("event2", this.onEvent2a.bind(this)); + this.on("event2", this.onEvent2b.bind(this)); + } + + destroy() { + this.destroyed = true; + // Call parent's destroy, which may be re-entrant and recall this function + this._parentFront.destroy(); + super.destroy(); + } + + marshallPool() { + return this.getParent(); + } + + toString() { + return "[child front " + this.childID + "]"; + } + + form(form) { + this.childID = form.childID; + } + + onEvent1(a, b, c) { + this.event1arg3 = c; + } + + onEvent2a(a, b, c) { + return Promise.resolve().then(() => { + this.event2arg3 = c; + }); + } + + onEvent2b(a, b, c) { + this.event2arg2 = b; + } +} +protocol.registerFront(ChildFront); + +const otherChildSpec = protocol.generateActorSpec({ + typeName: "otherChildActor", + methods: { + getOtherChild: { + request: {}, + response: { sibling: RetVal("otherChildActor") }, + }, + }, + events: {}, +}); + +class OtherChildActor extends protocol.Actor { + constructor(conn) { + super(conn, otherChildSpec); + } + + getOtherChild() { + return new OtherChildActor(this.conn); + } +} + +class OtherChildFront extends protocol.FrontClassWithSpec(otherChildSpec) {} +protocol.registerFront(OtherChildFront); + +types.addDictType("manyChildrenDict", { + child5: "childActor", + more: "array:childActor", +}); + +const rootSpec = protocol.generateActorSpec({ + typeName: "root", + + methods: { + getChild: { + request: { str: Arg(0) }, + response: { actor: RetVal("childActor") }, + }, + getOtherChild: { + request: {}, + response: { sibling: RetVal("otherChildActor") }, + }, + getChildren: { + request: { ids: Arg(0, "array:string") }, + response: { children: RetVal("array:childActor") }, + }, + getChildren2: { + request: { ids: Arg(0, "array:childActor") }, + response: { children: RetVal("array:childActor") }, + }, + getManyChildren: { + response: RetVal("manyChildrenDict"), + }, + getPolymorphism: { + request: { id: Arg(0, "number") }, + response: { child: RetVal("polytype") }, + }, + requestPolymorphism: { + request: { + id: Arg(0, "number"), + actor: Arg(1, "polytype"), + }, + response: { child: RetVal("polytype") }, + }, + }, +}); + +let rootActor = null; +class RootActor extends protocol.Actor { + constructor(conn) { + super(conn, rootSpec); + + rootActor = this; + this.actorID = "root"; + this._children = {}; + } + + toString() { + return "[root actor]"; + } + + sayHello() { + return { + from: "root", + applicationType: "xpcshell-tests", + traits: [], + }; + } + + getChild(id) { + if (id in this._children) { + return this._children[id]; + } + const child = new ChildActor(this.conn, id); + this._children[id] = child; + return child; + } + + // Other child actor won't all be own by the root actor + // and can have their own children + getOtherChild() { + return new OtherChildActor(this.conn); + } + + getChildren(ids) { + return ids.map(id => this.getChild(id)); + } + + getChildren2(ids) { + const f = function* () { + for (const c of ids) { + yield c; + } + }; + return f(); + } + + getManyChildren() { + return { + // note that this isn't in the specialization array. + foo: "bar", + child5: this.getChild("child5"), + more: [this.getChild("child6"), this.getChild("child7")], + }; + } + + getPolymorphism(id) { + if (id == 0) { + return new ChildActor(this.conn, id); + } else if (id == 1) { + return new OtherChildActor(this.conn); + } + throw new Error("Unexpected id"); + } + + requestPolymorphism(id, actor) { + if (id == 0 && actor instanceof ChildActor) { + return actor; + } else if (id == 1 && actor instanceof OtherChildActor) { + return actor; + } + throw new Error("Unexpected id or actor"); + } +} + +class RootFront extends protocol.FrontClassWithSpec(rootSpec) { + constructor(client, targetFront, parentFront) { + super(client, targetFront, parentFront); + this.actorID = "root"; + // Root actor owns itself. + this.manage(this); + } + + toString() { + return "[root front]"; + } +} + +let rootFront, childFront; +function expectRootChildren(size) { + Assert.equal(rootActor._poolMap.size, size); + Assert.equal(rootFront._poolMap.size, size + 1); + if (childFront) { + Assert.equal(childFront._poolMap.size, 0); + } +} +protocol.registerFront(RootFront); + +function childrenOfType(pool, type) { + const children = [...rootFront.poolChildren()]; + return children.filter(child => child instanceof type); +} + +add_task(async function () { + DevToolsServer.createRootActor = conn => { + return new RootActor(conn); + }; + DevToolsServer.init(); + + const trace = connectPipeTracing(); + const client = new DevToolsClient(trace); + const [applicationType] = await client.connect(); + trace.expectReceive({ + from: "<actorid>", + applicationType: "xpcshell-tests", + traits: [], + }); + Assert.equal(applicationType, "xpcshell-tests"); + + rootFront = client.mainRoot; + + await testSimpleChildren(trace); + await testDetail(trace); + await testSibling(trace); + await testEvents(trace); + await testManyChildren(trace); + await testGenerator(trace); + await testPolymorphism(trace); + await testUnmanageChildren(trace); + // Execute that assertion very last as it destroy the root front and actor + await testDestroy(trace); + + await client.close(); +}); + +async function testSimpleChildren(trace) { + childFront = await rootFront.getChild("child1"); + trace.expectSend({ type: "getChild", str: "child1", to: "<actorid>" }); + trace.expectReceive({ actor: "<actorid>", from: "<actorid>" }); + + Assert.ok(childFront instanceof ChildFront); + Assert.equal(childFront.childID, "child1"); + expectRootChildren(1); + + // Request the child again, make sure the same is returned. + let ret = await rootFront.getChild("child1"); + trace.expectSend({ type: "getChild", str: "child1", to: "<actorid>" }); + trace.expectReceive({ actor: "<actorid>", from: "<actorid>" }); + + expectRootChildren(1); + Assert.ok(ret === childFront); + + ret = await childFront.echo("hello"); + trace.expectSend({ type: "echo", str: "hello", to: "<actorid>" }); + trace.expectReceive({ str: "hello", from: "<actorid>" }); + + Assert.equal(ret, "hello"); +} + +async function testDetail(trace) { + let ret = await childFront.getDetail1(); + trace.expectSend({ type: "getDetail1", to: "<actorid>" }); + trace.expectReceive({ child: childFront.actorID, from: "<actorid>" }); + Assert.ok(ret === childFront); + + ret = await childFront.getDetail2(); + trace.expectSend({ type: "getDetail2", to: "<actorid>" }); + trace.expectReceive({ child: childFront.actorID, from: "<actorid>" }); + Assert.ok(ret === childFront); + + ret = await childFront.getIDDetail(); + trace.expectSend({ type: "getIDDetail", to: "<actorid>" }); + trace.expectReceive({ + idDetail: childFront.actorID, + from: "<actorid>", + }); + Assert.ok(ret === childFront); +} + +async function testSibling(trace) { + await childFront.getSibling("siblingID"); + trace.expectSend({ + type: "getSibling", + id: "siblingID", + to: "<actorid>", + }); + trace.expectReceive({ + sibling: { actor: "<actorid>", childID: "siblingID" }, + from: "<actorid>", + }); + + expectRootChildren(2); +} + +async function testEvents(trace) { + const ret = await rootFront.getChildren(["child1", "child2"]); + trace.expectSend({ + type: "getChildren", + ids: ["child1", "child2"], + to: "<actorid>", + }); + trace.expectReceive({ + children: [ + { actor: "<actorid>", childID: "child1" }, + { actor: "<actorid>", childID: "child2" }, + ], + from: "<actorid>", + }); + + expectRootChildren(3); + Assert.ok(ret[0] === childFront); + Assert.ok(ret[1] !== childFront); + Assert.ok(ret[1] instanceof ChildFront); + + // On both children, listen to events. We're only + // going to trigger events on the first child, so an event + // triggered on the second should cause immediate failures. + + const set = new Set([ + "event1", + "event2", + "named-event", + "object-event", + "array-object-event", + ]); + + childFront.on("event1", (a, b, c) => { + Assert.equal(a, 1); + Assert.equal(b, 2); + Assert.equal(c, 3); + // Verify that the pre-event handler was called. + Assert.equal(childFront.event1arg3, 3); + set.delete("event1"); + }); + childFront.on("event2", (a, b, c) => { + Assert.equal(a, 4); + Assert.equal(b, 5); + Assert.equal(c, 6); + // Verify that the async pre-event handler was called, + // setting the property before this handler was called. + Assert.equal(childFront.event2arg3, 6); + // And check that the sync preEvent with the same name is also + // executed + Assert.equal(childFront.event2arg2, 5); + set.delete("event2"); + }); + childFront.on("named-event", (a, b, c) => { + Assert.equal(a, 1); + Assert.equal(b, 2); + Assert.equal(c, 3); + set.delete("named-event"); + }); + childFront.on("object-event", obj => { + Assert.ok(obj === childFront); + set.delete("object-event"); + }); + childFront.on("array-object-event", array => { + Assert.ok(array[0] === childFront); + set.delete("array-object-event"); + }); + + const fail = function () { + do_throw("Unexpected event"); + }; + ret[1].on("event1", fail); + ret[1].on("event2", fail); + ret[1].on("named-event", fail); + ret[1].on("object-event", fail); + ret[1].on("array-object-event", fail); + + await childFront.emitEvents(); + trace.expectSend({ type: "emitEvents", to: "<actorid>" }); + trace.expectReceive({ + type: "event1", + a: 1, + b: 2, + c: 3, + from: "<actorid>", + }); + trace.expectReceive({ + type: "event2", + a: 4, + b: 5, + c: 6, + from: "<actorid>", + }); + trace.expectReceive({ + type: "namedEvent", + a: 1, + b: 2, + c: 3, + from: "<actorid>", + }); + trace.expectReceive({ + type: "objectEvent", + detail: childFront.actorID, + from: "<actorid>", + }); + trace.expectReceive({ + type: "arrayObjectEvent", + detail: [childFront.actorID], + from: "<actorid>", + }); + trace.expectReceive({ value: "correct response", from: "<actorid>" }); + + Assert.equal(set.size, 0); +} + +async function testManyChildren(trace) { + const ret = await rootFront.getManyChildren(); + trace.expectSend({ type: "getManyChildren", to: "<actorid>" }); + trace.expectReceive({ + foo: "bar", + child5: { actor: "<actorid>", childID: "child5" }, + more: [ + { actor: "<actorid>", childID: "child6" }, + { actor: "<actorid>", childID: "child7" }, + ], + from: "<actorid>", + }); + + // Check all the crazy stuff we did in getManyChildren + Assert.equal(ret.foo, "bar"); + Assert.equal(ret.child5.childID, "child5"); + Assert.equal(ret.more[0].childID, "child6"); + Assert.equal(ret.more[1].childID, "child7"); +} + +async function testGenerator(trace) { + // Test accepting a generator. + const f = function* () { + for (const i of [1, 2, 3, 4, 5]) { + yield i; + } + }; + let ret = await childFront.getIntArray(f()); + Assert.equal(ret.length, 5); + const expected = [2, 4, 6, 8, 10]; + for (let i = 0; i < 5; ++i) { + Assert.equal(ret[i], expected[i]); + } + + const ids = await rootFront.getChildren(["child1", "child2"]); + const f2 = function* () { + for (const id of ids) { + yield id; + } + }; + ret = await rootFront.getChildren2(f2()); + Assert.equal(ret.length, 2); + Assert.ok(ret[0] === childFront); + Assert.ok(ret[1] !== childFront); + Assert.ok(ret[1] instanceof ChildFront); +} + +async function testPolymorphism(trace) { + // Check polymorphic types returned by an actor + const firstChild = await rootFront.getPolymorphism(0); + Assert.ok(firstChild instanceof ChildFront); + + // Check polymorphic types passed to a front + const sameFirstChild = await rootFront.requestPolymorphism(0, firstChild); + Assert.ok(sameFirstChild instanceof ChildFront); + Assert.equal(sameFirstChild, firstChild); + + // Same with the second possible type + const secondChild = await rootFront.getPolymorphism(1); + Assert.ok(secondChild instanceof OtherChildFront); + + const sameSecondChild = await rootFront.requestPolymorphism(1, secondChild); + Assert.ok(sameSecondChild instanceof OtherChildFront); + Assert.equal(sameSecondChild, secondChild); + + // Check that any other type is rejected + Assert.throws(() => { + rootFront.requestPolymorphism(0, null); + }, /Was expecting one of these actors 'childActor,otherChildActor' but instead got an empty value/); + Assert.throws(() => { + rootFront.requestPolymorphism(0, 42); + }, /Was expecting one of these actors 'childActor,otherChildActor' but instead got value: '42'/); + Assert.throws(() => { + rootFront.requestPolymorphism(0, rootFront); + }, /Was expecting one of these actors 'childActor,otherChildActor' but instead got an actor of type: 'root'/); +} + +async function testUnmanageChildren(trace) { + // There is already one front of type OtherChildFront + Assert.equal(childrenOfType(rootFront, OtherChildFront).length, 1); + + // Create another front of type OtherChildFront + const front = await rootFront.getPolymorphism(1); + Assert.ok(front instanceof OtherChildFront); + Assert.equal(childrenOfType(rootFront, OtherChildFront).length, 2); + + // Remove all fronts of type OtherChildFront + rootFront.unmanageChildren(OtherChildFront); + Assert.ok( + !front.isDestroyed(), + "Unmanaged front is not considered as destroyed" + ); + Assert.equal(childrenOfType(rootFront, OtherChildFront).length, 0); +} + +async function testDestroy(trace) { + const front = await rootFront.getOtherChild(); + const otherChildFront = await front.getOtherChild(); + Assert.equal( + otherChildFront.getParent(), + front, + "the child is a children of first front" + ); + + front.destroy(); + Assert.ok(front.isDestroyed(), "sibling is correctly reported as destroyed"); + Assert.ok(!front.getParent(), "sibling has no more parent declared"); + Assert.ok(otherChildFront.isDestroyed(), "the child is also destroyed"); + Assert.ok( + !otherChildFront.getParent(), + "the child also has no more parent declared" + ); + Assert.ok( + !otherChildFront.parentPool, + "the child also has its parentPool attribute nullified" + ); + + // Verify that re-entrant Front.destroy doesn't throw, nor loop + // Execute that very last as it will destroy the root actor and front + const sibling = await childFront.getSibling("siblingID"); + sibling.destroy(); +} diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_index.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_index.js new file mode 100644 index 0000000000..ef566d6b97 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_index.js @@ -0,0 +1,52 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; +const { lazyLoadFront } = require("resource://devtools/shared/specs/index.js"); +const Types = + require("resource://devtools/shared/specs/index.js").__TypesForTests; +const { getType } = require("resource://devtools/shared/protocol.js").types; + +function run_test() { + test_index_is_alphabetically_sorted(); + test_specs(); + test_fronts(); +} + +// Check alphabetic order of specs defined in devtools/shared/specs/index.js, +// in order to ease its maintenance and readability. +function test_index_is_alphabetically_sorted() { + let lastSpec = ""; + for (const type of Types) { + const spec = type.spec; + if (lastSpec && spec < lastSpec) { + ok(false, `Spec definition for "${spec}" should be before "${lastSpec}"`); + } + lastSpec = spec; + } + ok(true, "Specs index is alphabetically sorted"); +} + +function test_specs() { + for (const type of Types) { + for (const typeName of type.types) { + ok(!!getType(typeName), `${typeName} spec is defined`); + } + } + ok(true, "Specs are all accessible"); +} + +function test_fronts() { + for (const item of Types) { + if (!item.front) { + continue; + } + for (const typeName of item.types) { + lazyLoadFront(typeName); + const type = getType(typeName); + ok(!!type, `Front for ${typeName} has a spec`); + ok(type.frontClass, `${typeName} has a front correctly defined`); + } + } + ok(true, "Front are all accessible"); +} diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_invalid_response.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_invalid_response.js new file mode 100644 index 0000000000..6b530f0a61 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_invalid_response.js @@ -0,0 +1,52 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const protocol = require("resource://devtools/shared/protocol.js"); +const { RetVal } = protocol; + +// Test invalid response specs throw when generating the Actor specification. + +// Test top level array response +add_task(async function () { + Assert.throws(() => { + protocol.generateActorSpec({ + typeName: "invalidArrayResponse", + methods: { + invalidMethod: { + response: RetVal("array:string"), + }, + }, + }); + }, /Arrays should be wrapped in objects/); + + protocol.generateActorSpec({ + typeName: "validArrayResponse", + methods: { + validMethod: { + response: { + someArray: RetVal("array:string"), + }, + }, + }, + }); + ok(true, "Arrays wrapped in object are valid response packets"); +}); + +// Test response with several placeholders +add_task(async function () { + Assert.throws(() => { + protocol.generateActorSpec({ + typeName: "tooManyPlaceholdersResponse", + methods: { + invalidMethod: { + response: { + prop1: RetVal("json"), + prop2: RetVal("json"), + }, + }, + }, + }); + }, /More than one RetVal specified in response/); +}); diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_lifecycle.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_lifecycle.js new file mode 100644 index 0000000000..bd887ba88a --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_lifecycle.js @@ -0,0 +1,27 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { Actor } = require("resource://devtools/shared/protocol/Actor.js"); +const { Front } = require("resource://devtools/shared/protocol/Front.js"); + +add_task(async function () { + // Front constructor expect to be provided a client object + const client = {}; + const front = new Front(client); + ok( + !front.isDestroyed(), + "Blank front with no actor ID is not considered as destroyed" + ); + front.destroy(); + ok(front.isDestroyed(), "Front is destroyed"); + + const actor = new Actor(null, { typeName: "actor", methods: [] }); + ok( + !actor.isDestroyed(), + "Blank actor with no actor ID is not considered as destroyed" + ); + actor.destroy(); + ok(actor.isDestroyed(), "Actor is destroyed"); +}); diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_longstring.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_longstring.js new file mode 100644 index 0000000000..cda1708520 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_longstring.js @@ -0,0 +1,310 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +/* eslint-disable max-nested-callbacks */ + +"use strict"; + +/** + * Test simple requests using the protocol helpers. + */ +var protocol = require("resource://devtools/shared/protocol.js"); +var { RetVal, Arg } = protocol; +var EventEmitter = require("resource://devtools/shared/event-emitter.js"); +var { + LongStringActor, +} = require("resource://devtools/server/actors/string.js"); + +// The test implicitly relies on this. +require("resource://devtools/client/fronts/string.js"); + +DevToolsServer.LONG_STRING_LENGTH = + DevToolsServer.LONG_STRING_INITIAL_LENGTH = + DevToolsServer.LONG_STRING_READ_LENGTH = + 5; + +var SHORT_STR = "abc"; +var LONG_STR = "abcdefghijklmnop"; + +var rootActor = null; + +const rootSpec = protocol.generateActorSpec({ + typeName: "root", + + events: { + "string-event": { + str: Arg(0, "longstring"), + }, + }, + + methods: { + shortString: { + response: { value: RetVal("longstring") }, + }, + longString: { + response: { value: RetVal("longstring") }, + }, + emitShortString: { + oneway: true, + }, + emitLongString: { + oneway: true, + }, + }, +}); + +class RootActor extends protocol.Actor { + constructor(conn) { + super(conn, rootSpec); + + rootActor = this; + // Root actor owns itself. + this.manage(this); + this.actorID = "root"; + } + + sayHello() { + return { + from: "root", + applicationType: "xpcshell-tests", + traits: [], + }; + } + + shortString() { + return new LongStringActor(this.conn, SHORT_STR); + } + + longString() { + return new LongStringActor(this.conn, LONG_STR); + } + + emitShortString() { + EventEmitter.emit( + this, + "string-event", + new LongStringActor(this.conn, SHORT_STR) + ); + } + + emitLongString() { + EventEmitter.emit( + this, + "string-event", + new LongStringActor(this.conn, LONG_STR) + ); + } +} + +class RootFront extends protocol.FrontClassWithSpec(rootSpec) { + constructor(client) { + super(client); + this.actorID = "root"; + + // Root owns itself. + this.manage(this); + } +} +protocol.registerFront(RootFront); + +function run_test() { + DevToolsServer.createRootActor = conn => { + return new RootActor(conn); + }; + + DevToolsServer.init(); + + const trace = connectPipeTracing(); + const client = new DevToolsClient(trace); + let rootFront; + + let strfront = null; + + const expectRootChildren = function (size) { + Assert.equal(rootActor.__poolMap.size, size + 1); + Assert.equal(rootFront.__poolMap.size, size + 1); + }; + + client.connect().then(([applicationType, traits]) => { + rootFront = client.mainRoot; + + // Root actor has no children yet. + expectRootChildren(0); + + trace.expectReceive({ + from: "<actorid>", + applicationType: "xpcshell-tests", + traits: [], + }); + Assert.equal(applicationType, "xpcshell-tests"); + rootFront + .shortString() + .then(ret => { + trace.expectSend({ type: "shortString", to: "<actorid>" }); + trace.expectReceive({ value: "abc", from: "<actorid>" }); + + // Should only own the one reference (itself) at this point. + expectRootChildren(0); + strfront = ret; + }) + .then(() => { + return strfront.string(); + }) + .then(ret => { + Assert.equal(ret, SHORT_STR); + }) + .then(() => { + return rootFront.longString(); + }) + .then(ret => { + trace.expectSend({ type: "longString", to: "<actorid>" }); + trace.expectReceive({ + value: { + type: "longString", + actor: "<actorid>", + length: 16, + initial: "abcde", + }, + from: "<actorid>", + }); + + strfront = ret; + // Should own a reference to itself and an extra string now. + expectRootChildren(1); + }) + .then(() => { + return strfront.string(); + }) + .then(ret => { + trace.expectSend({ + type: "substring", + start: 5, + end: 10, + to: "<actorid>", + }); + trace.expectReceive({ substring: "fghij", from: "<actorid>" }); + trace.expectSend({ + type: "substring", + start: 10, + end: 15, + to: "<actorid>", + }); + trace.expectReceive({ substring: "klmno", from: "<actorid>" }); + trace.expectSend({ + type: "substring", + start: 15, + end: 20, + to: "<actorid>", + }); + trace.expectReceive({ substring: "p", from: "<actorid>" }); + + Assert.equal(ret, LONG_STR); + }) + .then(() => { + return strfront.release(); + }) + .then(() => { + trace.expectSend({ type: "release", to: "<actorid>" }); + trace.expectReceive({ from: "<actorid>" }); + + // That reference should be removed now. + expectRootChildren(0); + }) + .then(() => { + return new Promise(resolve => { + rootFront.once("string-event", str => { + trace.expectSend({ type: "emitShortString", to: "<actorid>" }); + trace.expectReceive({ + type: "string-event", + str: "abc", + from: "<actorid>", + }); + + Assert.ok(!!str); + strfront = str; + // Shouldn't generate any new references + expectRootChildren(0); + // will generate no packets. + strfront.string().then(value => { + resolve(value); + }); + }); + rootFront.emitShortString(); + }); + }) + .then(value => { + Assert.equal(value, SHORT_STR); + }) + .then(() => { + // Will generate no packets + return strfront.release(); + }) + .then(() => { + return new Promise(resolve => { + rootFront.once("string-event", str => { + trace.expectSend({ type: "emitLongString", to: "<actorid>" }); + trace.expectReceive({ + type: "string-event", + str: { + type: "longString", + actor: "<actorid>", + length: 16, + initial: "abcde", + }, + from: "<actorid>", + }); + + Assert.ok(!!str); + // Should generate one new reference + expectRootChildren(1); + strfront = str; + strfront.string().then(value => { + trace.expectSend({ + type: "substring", + start: 5, + end: 10, + to: "<actorid>", + }); + trace.expectReceive({ substring: "fghij", from: "<actorid>" }); + trace.expectSend({ + type: "substring", + start: 10, + end: 15, + to: "<actorid>", + }); + trace.expectReceive({ substring: "klmno", from: "<actorid>" }); + trace.expectSend({ + type: "substring", + start: 15, + end: 20, + to: "<actorid>", + }); + trace.expectReceive({ substring: "p", from: "<actorid>" }); + + resolve(value); + }); + }); + rootFront.emitLongString(); + }); + }) + .then(value => { + Assert.equal(value, LONG_STR); + }) + .then(() => { + return strfront.release(); + }) + .then(() => { + trace.expectSend({ type: "release", to: "<actorid>" }); + trace.expectReceive({ from: "<actorid>" }); + expectRootChildren(0); + }) + .then(() => { + client.close().then(() => { + do_test_finished(); + }); + }) + .catch(err => { + do_report_unexpected_exception(err, "Failure executing test"); + }); + }); + do_test_pending(); +} diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_simple.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_simple.js new file mode 100644 index 0000000000..523d147f6c --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_simple.js @@ -0,0 +1,316 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * Test simple requests using the protocol helpers. + */ + +var protocol = require("resource://devtools/shared/protocol.js"); +var { Arg, Option, RetVal } = protocol; +var EventEmitter = require("resource://devtools/shared/event-emitter.js"); + +const rootSpec = protocol.generateActorSpec({ + typeName: "root", + + events: { + oneway: { a: Arg(0) }, + falsyOptions: { + zero: Option(0), + farce: Option(0), + }, + }, + + methods: { + simpleReturn: { + response: { value: RetVal() }, + }, + promiseReturn: { + response: { value: RetVal("number") }, + }, + simpleArgs: { + request: { + firstArg: Arg(0), + secondArg: Arg(1), + }, + response: RetVal(), + }, + optionArgs: { + request: { + option1: Option(0), + option2: Option(0), + }, + response: RetVal(), + }, + optionalArgs: { + request: { + a: Arg(0), + b: Arg(1, "nullable:number"), + }, + response: { + value: RetVal("number"), + }, + }, + arrayArgs: { + request: { + a: Arg(0, "array:number"), + }, + response: { + arrayReturn: RetVal("array:number"), + }, + }, + nestedArrayArgs: { + request: { a: Arg(0, "array:array:number") }, + response: { value: RetVal("array:array:number") }, + }, + renamedEcho: { + request: { + type: "echo", + a: Arg(0), + }, + response: { + value: RetVal("string"), + }, + }, + testOneWay: { + request: { a: Arg(0) }, + oneway: true, + }, + emitFalsyOptions: { + oneway: true, + }, + }, +}); + +class RootActor extends protocol.Actor { + constructor(conn) { + super(conn, rootSpec); + + // Root actor owns itself. + this.manage(this); + this.actorID = "root"; + } + + sayHello() { + return { + from: "root", + applicationType: "xpcshell-tests", + traits: [], + }; + } + + simpleReturn() { + return 1; + } + + promiseReturn() { + return Promise.resolve(1); + } + + simpleArgs(a, b) { + return { firstResponse: a + 1, secondResponse: b + 1 }; + } + + optionArgs(options) { + return { option1: options.option1, option2: options.option2 }; + } + + optionalArgs(a, b = 200) { + return b; + } + + arrayArgs(a) { + return a; + } + + nestedArrayArgs(a) { + return a; + } + + /** + * Test that the 'type' part of the request packet works + * correctly when the type isn't the same as the method name + */ + renamedEcho(a) { + if (this.conn.currentPacket.type != "echo") { + return "goodbye"; + } + return a; + } + + testOneWay(a) { + // Emit to show that we got this message, because there won't be a response. + EventEmitter.emit(this, "oneway", a); + } + + emitFalsyOptions() { + EventEmitter.emit(this, "falsyOptions", { zero: 0, farce: false }); + } +} + +class RootFront extends protocol.FrontClassWithSpec(rootSpec) { + constructor(client) { + super(client); + this.actorID = "root"; + // Root owns itself. + this.manage(this); + } +} +protocol.registerFront(RootFront); + +add_task(async function () { + DevToolsServer.createRootActor = conn => { + return new RootActor(conn); + }; + DevToolsServer.init(); + + protocol.types.getType("array:array:array:number"); + protocol.types.getType("array:array:array:number"); + + Assert.throws( + () => protocol.types.getType("unknown"), + /Unknown type:/, + "Should throw for unknown type" + ); + Assert.throws( + () => protocol.types.getType("array:unknown"), + /Unknown type:/, + "Should throw for unknown type" + ); + Assert.throws( + () => protocol.types.getType("unknown:number"), + /Unknown collection type:/, + "Should throw for unknown collection type" + ); + const trace = connectPipeTracing(); + const client = new DevToolsClient(trace); + + const [applicationType] = await client.connect(); + trace.expectReceive({ + from: "<actorid>", + applicationType: "xpcshell-tests", + traits: [], + }); + Assert.equal(applicationType, "xpcshell-tests"); + + const rootFront = client.mainRoot; + + let ret = await rootFront.simpleReturn(); + trace.expectSend({ type: "simpleReturn", to: "<actorid>" }); + trace.expectReceive({ value: 1, from: "<actorid>" }); + Assert.equal(ret, 1); + + ret = await rootFront.promiseReturn(); + trace.expectSend({ type: "promiseReturn", to: "<actorid>" }); + trace.expectReceive({ value: 1, from: "<actorid>" }); + Assert.equal(ret, 1); + + Assert.throws( + () => rootFront.simpleArgs(5), + /undefined passed where a value is required/, + "Should throw if simpleArgs is missing an argument." + ); + + ret = await rootFront.simpleArgs(5, 10); + trace.expectSend({ + type: "simpleArgs", + firstArg: 5, + secondArg: 10, + to: "<actorid>", + }); + trace.expectReceive({ + firstResponse: 6, + secondResponse: 11, + from: "<actorid>", + }); + Assert.equal(ret.firstResponse, 6); + Assert.equal(ret.secondResponse, 11); + + ret = await rootFront.optionArgs({ + option1: 5, + option2: 10, + }); + trace.expectSend({ + type: "optionArgs", + option1: 5, + option2: 10, + to: "<actorid>", + }); + trace.expectReceive({ option1: 5, option2: 10, from: "<actorid>" }); + Assert.equal(ret.option1, 5); + Assert.equal(ret.option2, 10); + + ret = await rootFront.optionArgs({}); + trace.expectSend({ type: "optionArgs", to: "<actorid>" }); + trace.expectReceive({ from: "<actorid>" }); + Assert.ok(typeof ret.option1 === "undefined"); + Assert.ok(typeof ret.option2 === "undefined"); + + // Explicitly call an optional argument... + ret = await rootFront.optionalArgs(5, 10); + trace.expectSend({ + type: "optionalArgs", + a: 5, + b: 10, + to: "<actorid>", + }); + trace.expectReceive({ value: 10, from: "<actorid>" }); + Assert.equal(ret, 10); + + // Now don't pass the optional argument, expect the default. + ret = await rootFront.optionalArgs(5); + trace.expectSend({ type: "optionalArgs", a: 5, to: "<actorid>" }); + trace.expectReceive({ value: 200, from: "<actorid>" }); + Assert.equal(ret, 200); + + ret = await rootFront.arrayArgs([0, 1, 2, 3, 4, 5]); + trace.expectSend({ + type: "arrayArgs", + a: [0, 1, 2, 3, 4, 5], + to: "<actorid>", + }); + trace.expectReceive({ + arrayReturn: [0, 1, 2, 3, 4, 5], + from: "<actorid>", + }); + Assert.equal(ret[0], 0); + Assert.equal(ret[5], 5); + + ret = await rootFront.arrayArgs([[5]]); + trace.expectSend({ type: "arrayArgs", a: [[5]], to: "<actorid>" }); + trace.expectReceive({ arrayReturn: [[5]], from: "<actorid>" }); + Assert.equal(ret[0][0], 5); + + const str = await rootFront.renamedEcho("hello"); + trace.expectSend({ type: "echo", a: "hello", to: "<actorid>" }); + trace.expectReceive({ value: "hello", from: "<actorid>" }); + Assert.equal(str, "hello"); + + const onOneWay = rootFront.once("oneway"); + Assert.ok(typeof rootFront.testOneWay("hello") === "undefined"); + const response = await onOneWay; + trace.expectSend({ type: "testOneWay", a: "hello", to: "<actorid>" }); + trace.expectReceive({ + type: "oneway", + a: "hello", + from: "<actorid>", + }); + Assert.equal(response, "hello"); + + const onFalsyOptions = rootFront.once("falsyOptions"); + rootFront.emitFalsyOptions(); + const res = await onFalsyOptions; + trace.expectSend({ type: "emitFalsyOptions", to: "<actorid>" }); + trace.expectReceive({ + type: "falsyOptions", + farce: false, + zero: 0, + from: "<actorid>", + }); + + Assert.ok(res.zero === 0); + Assert.ok(res.farce === false); + + await client.close(); +}); diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_stack.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_stack.js new file mode 100644 index 0000000000..faf8402ea6 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_stack.js @@ -0,0 +1,98 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * Client request stacks should span the entire process from before making the + * request to handling the reply from the server. The server frames are not + * included, nor can they be in most cases, since the server can be a remote + * device. + */ + +var protocol = require("resource://devtools/shared/protocol.js"); +var { RetVal } = protocol; + +const rootSpec = protocol.generateActorSpec({ + typeName: "root", + + methods: { + simpleReturn: { + response: { value: RetVal() }, + }, + }, +}); + +class RootActor extends protocol.Actor { + constructor(conn) { + super(conn, rootSpec); + + // Root actor owns itself. + this.manage(this); + this.actorID = "root"; + this.sequence = 0; + } + + sayHello() { + return { + from: "root", + applicationType: "xpcshell-tests", + traits: [], + }; + } + + simpleReturn() { + return this.sequence++; + } +} + +class RootFront extends protocol.FrontClassWithSpec(rootSpec) { + constructor(client) { + super(client); + this.actorID = "root"; + // Root owns itself. + this.manage(this); + } +} +protocol.registerFront(RootFront); + +function run_test() { + DevToolsServer.createRootActor = conn => new RootActor(conn); + DevToolsServer.init(); + + const trace = connectPipeTracing(); + const client = new DevToolsClient(trace); + let rootFront; + + client.connect().then(function onConnect() { + rootFront = client.mainRoot; + + rootFront + .simpleReturn() + .then( + () => { + let stack = Components.stack; + while (stack) { + info(stack.name); + if (stack.name.includes("onConnect")) { + // Reached back to outer function before request + ok(true, "Complete stack"); + return; + } + stack = stack.asyncCaller || stack.caller; + } + ok(false, "Incomplete stack"); + }, + () => { + ok(false, "Request failed unexpectedly"); + } + ) + .then(() => { + client.close().then(() => { + do_test_finished(); + }); + }); + }); + + do_test_pending(); +} diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_types.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_types.js new file mode 100644 index 0000000000..4a62c5e073 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_types.js @@ -0,0 +1,65 @@ +"use strict"; + +const { types } = require("resource://devtools/shared/protocol.js"); + +function run_test() { + types.addActorType("myActor1"); + types.addActorType("myActor2"); + types.addActorType("myActor3"); + + types.addPolymorphicType("ptype1", ["myActor1", "myActor2"]); + const ptype1 = types.getType("ptype1"); + Assert.equal(ptype1.name, "ptype1"); + Assert.equal(ptype1.category, "polymorphic"); + + types.addPolymorphicType("ptype2", ["myActor1", "myActor2", "myActor3"]); + const ptype2 = types.getType("ptype2"); + Assert.equal(ptype2.name, "ptype2"); + Assert.equal(ptype2.category, "polymorphic"); + + // Polymorphic types only accept actor types + try { + types.addPolymorphicType("ptype", ["myActor1", "myActor4"]); + Assert.ok(false, "getType should fail"); + } catch (ex) { + Assert.equal(ex.toString(), "Error: Unknown type: myActor4"); + } + try { + types.addPolymorphicType("ptype", ["myActor1", "string"]); + Assert.ok(false, "getType should fail"); + } catch (ex) { + Assert.equal( + ex.toString(), + "Error: In polymorphic type 'myActor1,string', the type 'string' isn't an actor" + ); + } + try { + types.addPolymorphicType("ptype", ["myActor1", "boolean"]); + Assert.ok(false, "getType should fail"); + } catch (ex) { + Assert.equal( + ex.toString(), + "Error: In polymorphic type 'myActor1,boolean', the type 'boolean' isn't an actor" + ); + } + + // Polymorphic types are not compatible with array or nullables + try { + types.addPolymorphicType("ptype", ["array:myActor1", "myActor2"]); + Assert.ok(false, "addType should fail"); + } catch (ex) { + Assert.equal( + ex.toString(), + "Error: In polymorphic type 'array:myActor1,myActor2', the type 'array:myActor1' isn't an actor" + ); + } + try { + types.addPolymorphicType("ptype", ["nullable:myActor1", "myActor2"]); + Assert.ok(false, "addType should fail"); + } catch (ex) { + Assert.equal( + ex.toString(), + "Error: In polymorphic type 'nullable:myActor1,myActor2', the type 'nullable:myActor1' isn't an actor" + ); + } +} diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_unregister.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_unregister.js new file mode 100644 index 0000000000..060a1743b1 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_unregister.js @@ -0,0 +1,41 @@ +"use strict"; + +const { types } = require("resource://devtools/shared/protocol.js"); + +function run_test() { + types.addType("test", { + read: v => "successful read: " + v, + write: v => "successful write: " + v, + }); + + // Verify the type registered correctly. + + const type = types.getType("test"); + const arrayType = types.getType("array:test"); + Assert.equal(type.read("foo"), "successful read: foo"); + Assert.equal(arrayType.read(["foo"])[0], "successful read: foo"); + + types.removeType("test"); + + Assert.equal(type.name, "DEFUNCT:test"); + try { + types.getType("test"); + Assert.ok(false, "getType should fail"); + } catch (ex) { + Assert.equal(ex.toString(), "Error: Unknown type: test"); + } + + try { + type.read("foo"); + Assert.ok(false, "type.read should have thrown an exception."); + } catch (ex) { + Assert.equal(ex.toString(), "Error: Using defunct type: test"); + } + + try { + arrayType.read(["foo"]); + Assert.ok(false, "array:test.read should have thrown an exception."); + } catch (ex) { + Assert.equal(ex.toString(), "Error: Using defunct type: test"); + } +} diff --git a/devtools/shared/protocol/tests/xpcshell/test_protocol_watchFronts.js b/devtools/shared/protocol/tests/xpcshell/test_protocol_watchFronts.js new file mode 100644 index 0000000000..16f98f176b --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/test_protocol_watchFronts.js @@ -0,0 +1,183 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * Test Front.watchFronts method. + */ + +const protocol = require("resource://devtools/shared/protocol.js"); +const { RetVal } = protocol; + +const childSpec = protocol.generateActorSpec({ + typeName: "childActor", + + methods: { + release: { + release: true, + }, + }, +}); + +class ChildActor extends protocol.Actor { + constructor(conn, id) { + super(conn, childSpec); + this.childID = id; + } + + release() {} + + form() { + return { + actor: this.actorID, + childID: this.childID, + foo: "bar", + }; + } +} + +const rootSpec = protocol.generateActorSpec({ + typeName: "root", + + methods: { + createChild: { + request: {}, + response: { actor: RetVal("childActor") }, + }, + }, +}); + +class RootActor extends protocol.Actor { + constructor(conn) { + super(conn, rootSpec); + + this.actorID = "root"; + + // Root actor owns itself. + this.manage(this); + + this.sequence = 0; + } + + sayHello() { + return { + from: "root", + applicationType: "xpcshell-tests", + traits: [], + }; + } + + createChild() { + return new ChildActor(this.conn, this.sequence++); + } +} + +class ChildFront extends protocol.FrontClassWithSpec(childSpec) { + form(form) { + this.childID = form.childID; + this.foo = form.foo; + } +} +protocol.registerFront(ChildFront); + +class RootFront extends protocol.FrontClassWithSpec(rootSpec) { + constructor(client) { + super(client); + this.actorID = "root"; + // Root owns itself. + this.manage(this); + } +} +protocol.registerFront(RootFront); + +add_task(async function run_test() { + DevToolsServer.createRootActor = conn => new RootActor(conn); + DevToolsServer.init(); + + const trace = connectPipeTracing(); + const client = new DevToolsClient(trace); + await client.connect(); + + const rootFront = client.mainRoot; + + const fronts = []; + const listener = front => { + equal( + front.foo, + "bar", + "Front's form is set before watchFronts listeners are called" + ); + fronts.push(front); + }; + rootFront.watchFronts("childActor", listener); + + const firstChild = await rootFront.createChild(); + ok( + firstChild instanceof ChildFront, + "createChild returns a ChildFront instance" + ); + equal(firstChild.childID, 0, "First child has ID=0"); + + equal( + fronts.length, + 1, + "watchFronts fires the callback, even if the front is created in the future" + ); + equal( + fronts[0], + firstChild, + "watchFronts fires the callback with the right front instance" + ); + + const watchFrontsAfter = await new Promise(resolve => { + rootFront.watchFronts("childActor", resolve); + }); + equal( + watchFrontsAfter, + firstChild, + "watchFronts fires the callback, even if the front is already created, " + + " with the same front instance" + ); + + equal( + fronts.length, + 1, + "There is still only one front reported from the first listener" + ); + + const secondChild = await rootFront.createChild(); + + equal( + fronts.length, + 2, + "After a second call to createChild, two fronts are reported" + ); + equal(fronts[1], secondChild, "And the new front is the right instance"); + + // Test unregistering a front listener + rootFront.unwatchFronts("childActor", listener); + + const thirdChild = await rootFront.createChild(); + equal( + fronts.length, + 2, + "After calling unwatchFronts, the listener is no longer called" + ); + + // Test front destruction + const destroyed = []; + rootFront.watchFronts("childActor", null, front => { + destroyed.push(front); + }); + await thirdChild.release(); + equal( + destroyed.length, + 1, + "After the destruction of the front, one destruction is reported" + ); + equal(destroyed[0], thirdChild, "And the destroyed front is the right one"); + + trace.close(); + await client.close(); +}); diff --git a/devtools/shared/protocol/tests/xpcshell/xpcshell.ini b/devtools/shared/protocol/tests/xpcshell/xpcshell.ini new file mode 100644 index 0000000000..9af8c5de49 --- /dev/null +++ b/devtools/shared/protocol/tests/xpcshell/xpcshell.ini @@ -0,0 +1,19 @@ +[DEFAULT] +tags = devtools +head = head.js +firefox-appdir = browser +skip-if = toolkit == 'android' +support-files = + +[test_protocol_abort.js] +[test_protocol_async.js] +[test_protocol_children.js] +[test_protocol_index.js] +[test_protocol_invalid_response.js] +[test_protocol_lifecycle.js] +[test_protocol_longstring.js] +[test_protocol_simple.js] +[test_protocol_stack.js] +[test_protocol_types.js] +[test_protocol_unregister.js] +[test_protocol_watchFronts.js] |