Add m-esr52 at 52.6.0

1 files changed, 319 insertions, 0 deletions

diff --git a/devtools/server/tests/unit/test_protocol_simple.js b/devtools/server/tests/unit/test_protocol_simple.js
new file mode 100644
index 000000000..c85003954
--- /dev/null
+++ b/devtools/server/tests/unit/test_protocol_simple.js
@@ -0,0 +1,319 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test simple requests using the protocol helpers.
+ */
+
+var protocol = require("devtools/shared/protocol");
+var {Arg, Option, RetVal} = protocol;
+var events = require("sdk/event/core");
+
+function simpleHello() {
+  return {
+    from: "root",
+    applicationType: "xpcshell-tests",
+    traits: [],
+  };
+}
+
+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()
+    },
+    nestedArgs: {
+      request: {
+        firstArg: Arg(0),
+        nest: {
+          secondArg: Arg(1),
+          nest: {
+            thirdArg: Arg(2)
+          }
+        }
+      },
+      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
+    }
+  }
+});
+
+var RootActor = protocol.ActorClassWithSpec(rootSpec, {
+  initialize: function (conn) {
+    protocol.Actor.prototype.initialize.call(this, conn);
+    // Root actor owns itself.
+    this.manage(this);
+    this.actorID = "root";
+  },
+
+  sayHello: simpleHello,
+
+  simpleReturn: function () {
+    return 1;
+  },
+
+  promiseReturn: function () {
+    return promise.resolve(1);
+  },
+
+  simpleArgs: function (a, b) {
+    return { firstResponse: a + 1, secondResponse: b + 1 };
+  },
+
+  nestedArgs: function (a, b, c) {
+    return { a: a, b: b, c: c };
+  },
+
+  optionArgs: function (options) {
+    return { option1: options.option1, option2: options.option2 };
+  },
+
+  optionalArgs: function (a, b = 200) {
+    return b;
+  },
+
+  arrayArgs: function (a) {
+    return a;
+  },
+
+  nestedArrayArgs: function (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: function (a) {
+    if (this.conn.currentPacket.type != "echo") {
+      return "goodbye";
+    }
+    return a;
+  },
+
+  testOneWay: function (a) {
+    // Emit to show that we got this message, because there won't be a response.
+    events.emit(this, "oneway", a);
+  },
+
+  emitFalsyOptions: function () {
+    events.emit(this, "falsyOptions", { zero: 0, farce: false });
+  }
+});
+
+var RootFront = protocol.FrontClassWithSpec(rootSpec, {
+  initialize: function (client) {
+    this.actorID = "root";
+    protocol.Front.prototype.initialize.call(this, client);
+    // Root owns itself.
+    this.manage(this);
+  }
+});
+
+function run_test()
+{
+  DebuggerServer.createRootActor = (conn => {
+    return RootActor(conn);
+  });
+  DebuggerServer.init();
+
+  check_except(() => {
+    let badActor = ActorClassWithSpec({}, {
+      missing: preEvent("missing-event", function () {
+      })
+    });
+  });
+
+  protocol.types.getType("array:array:array:number");
+  protocol.types.getType("array:array:array:number");
+
+  check_except(() => protocol.types.getType("unknown"));
+  check_except(() => protocol.types.getType("array:unknown"));
+  check_except(() => protocol.types.getType("unknown:number"));
+  let trace = connectPipeTracing();
+  let client = new DebuggerClient(trace);
+  let rootClient;
+
+  client.connect().then(([applicationType, traits]) => {
+    trace.expectReceive({"from":"<actorid>", "applicationType":"xpcshell-tests", "traits":[]});
+    do_check_eq(applicationType, "xpcshell-tests");
+
+    rootClient = RootFront(client);
+
+    rootClient.simpleReturn().then(ret => {
+      trace.expectSend({"type":"simpleReturn", "to":"<actorid>"});
+      trace.expectReceive({"value":1, "from":"<actorid>"});
+      do_check_eq(ret, 1);
+    }).then(() => {
+      return rootClient.promiseReturn();
+    }).then(ret => {
+      trace.expectSend({"type":"promiseReturn", "to":"<actorid>"});
+      trace.expectReceive({"value":1, "from":"<actorid>"});
+      do_check_eq(ret, 1);
+    }).then(() => {
+      // Missing argument should throw an exception
+      check_except(() => {
+        rootClient.simpleArgs(5);
+      });
+
+      return rootClient.simpleArgs(5, 10);
+    }).then(ret => {
+      trace.expectSend({"type":"simpleArgs", "firstArg":5, "secondArg":10, "to":"<actorid>"});
+      trace.expectReceive({"firstResponse":6, "secondResponse":11, "from":"<actorid>"});
+      do_check_eq(ret.firstResponse, 6);
+      do_check_eq(ret.secondResponse, 11);
+    }).then(() => {
+      return rootClient.nestedArgs(1, 2, 3);
+    }).then(ret => {
+      trace.expectSend({"type":"nestedArgs", "firstArg":1, "nest":{"secondArg":2, "nest":{"thirdArg":3}}, "to":"<actorid>"});
+      trace.expectReceive({"a":1, "b":2, "c":3, "from":"<actorid>"});
+      do_check_eq(ret.a, 1);
+      do_check_eq(ret.b, 2);
+      do_check_eq(ret.c, 3);
+    }).then(() => {
+      return rootClient.optionArgs({
+        "option1": 5,
+        "option2": 10
+      });
+    }).then(ret => {
+      trace.expectSend({"type":"optionArgs", "option1":5, "option2":10, "to":"<actorid>"});
+      trace.expectReceive({"option1":5, "option2":10, "from":"<actorid>"});
+      do_check_eq(ret.option1, 5);
+      do_check_eq(ret.option2, 10);
+    }).then(() => {
+      return rootClient.optionArgs({});
+    }).then(ret => {
+      trace.expectSend({"type":"optionArgs", "to":"<actorid>"});
+      trace.expectReceive({"from":"<actorid>"});
+      do_check_true(typeof (ret.option1) === "undefined");
+      do_check_true(typeof (ret.option2) === "undefined");
+    }).then(() => {
+      // Explicitly call an optional argument...
+      return rootClient.optionalArgs(5, 10);
+    }).then(ret => {
+      trace.expectSend({"type":"optionalArgs", "a":5, "b":10, "to":"<actorid>"});
+      trace.expectReceive({"value":10, "from":"<actorid>"});
+      do_check_eq(ret, 10);
+    }).then(() => {
+      // Now don't pass the optional argument, expect the default.
+      return rootClient.optionalArgs(5);
+    }).then(ret => {
+      trace.expectSend({"type":"optionalArgs", "a":5, "to":"<actorid>"});
+      trace.expectReceive({"value":200, "from":"<actorid>"});
+      do_check_eq(ret, 200);
+    }).then(ret => {
+      return rootClient.arrayArgs([0, 1, 2, 3, 4, 5]);
+    }).then(ret => {
+      trace.expectSend({"type":"arrayArgs", "a":[0, 1, 2, 3, 4, 5], "to":"<actorid>"});
+      trace.expectReceive({"arrayReturn":[0, 1, 2, 3, 4, 5], "from":"<actorid>"});
+      do_check_eq(ret[0], 0);
+      do_check_eq(ret[5], 5);
+    }).then(() => {
+      return rootClient.arrayArgs([[5]]);
+    }).then(ret => {
+      trace.expectSend({"type":"arrayArgs", "a":[[5]], "to":"<actorid>"});
+      trace.expectReceive({"arrayReturn":[[5]], "from":"<actorid>"});
+      do_check_eq(ret[0][0], 5);
+    }).then(() => {
+      return rootClient.renamedEcho("hello");
+    }).then(str => {
+      trace.expectSend({"type":"echo", "a":"hello", "to":"<actorid>"});
+      trace.expectReceive({"value":"hello", "from":"<actorid>"});
+
+      do_check_eq(str, "hello");
+
+      let deferred = promise.defer();
+      rootClient.on("oneway", (response) => {
+        trace.expectSend({"type":"testOneWay", "a":"hello", "to":"<actorid>"});
+        trace.expectReceive({"type":"oneway", "a":"hello", "from":"<actorid>"});
+
+        do_check_eq(response, "hello");
+        deferred.resolve();
+      });
+      do_check_true(typeof (rootClient.testOneWay("hello")) === "undefined");
+      return deferred.promise;
+    }).then(() => {
+      let deferred = promise.defer();
+      rootClient.on("falsyOptions", res => {
+        trace.expectSend({"type":"emitFalsyOptions", "to":"<actorid>"});
+        trace.expectReceive({"type":"falsyOptions", "farce":false, "zero": 0, "from":"<actorid>"});
+
+        do_check_true(res.zero === 0);
+        do_check_true(res.farce === false);
+        deferred.resolve();
+      });
+      rootClient.emitFalsyOptions();
+      return deferred.promise;
+    }).then(() => {
+      client.close().then(() => {
+        do_test_finished();
+      });
+    }).then(null, err => {
+      do_report_unexpected_exception(err, "Failure executing test");
+    });
+  });
+  do_test_pending();
+}