Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 245 insertions, 0 deletions

diff --git a/remote/marionette/test/xpcshell/test_message.js b/remote/marionette/test/xpcshell/test_message.js
new file mode 100644
index 0000000000..9926aea191
--- /dev/null
+++ b/remote/marionette/test/xpcshell/test_message.js
@@ -0,0 +1,245 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { error } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Errors.sys.mjs"
+);
+const { Command, Message, Response } = ChromeUtils.importESModule(
+  "chrome://remote/content/marionette/message.sys.mjs"
+);
+
+add_task(function test_Message_Origin() {
+  equal(0, Message.Origin.Client);
+  equal(1, Message.Origin.Server);
+});
+
+add_task(function test_Message_fromPacket() {
+  let cmd = new Command(4, "foo");
+  let resp = new Response(5, () => {});
+  resp.error = "foo";
+
+  ok(Message.fromPacket(cmd.toPacket()) instanceof Command);
+  ok(Message.fromPacket(resp.toPacket()) instanceof Response);
+  Assert.throws(
+    () => Message.fromPacket([3, 4, 5, 6]),
+    /Unrecognised message type in packet/
+  );
+});
+
+add_task(function test_Command() {
+  let cmd = new Command(42, "foo", { bar: "baz" });
+  equal(42, cmd.id);
+  equal("foo", cmd.name);
+  deepEqual({ bar: "baz" }, cmd.parameters);
+  equal(null, cmd.onerror);
+  equal(null, cmd.onresult);
+  equal(Message.Origin.Client, cmd.origin);
+  equal(false, cmd.sent);
+});
+
+add_task(function test_Command_onresponse() {
+  let onerrorOk = false;
+  let onresultOk = false;
+
+  let cmd = new Command(7, "foo");
+  cmd.onerror = () => (onerrorOk = true);
+  cmd.onresult = () => (onresultOk = true);
+
+  let errorResp = new Response(8, () => {});
+  errorResp.error = new error.WebDriverError("foo");
+
+  let bodyResp = new Response(9, () => {});
+  bodyResp.body = "bar";
+
+  cmd.onresponse(errorResp);
+  equal(true, onerrorOk);
+  equal(false, onresultOk);
+
+  cmd.onresponse(bodyResp);
+  equal(true, onresultOk);
+});
+
+add_task(function test_Command_ctor() {
+  let cmd = new Command(42, "bar", { bar: "baz" });
+  let msg = cmd.toPacket();
+
+  equal(Command.Type, msg[0]);
+  equal(cmd.id, msg[1]);
+  equal(cmd.name, msg[2]);
+  equal(cmd.parameters, msg[3]);
+});
+
+add_task(function test_Command_toString() {
+  let cmd = new Command(42, "foo", { bar: "baz" });
+  equal(JSON.stringify(cmd.toPacket()), cmd.toString());
+});
+
+add_task(function test_Command_fromPacket() {
+  let c1 = new Command(42, "foo", { bar: "baz" });
+
+  let msg = c1.toPacket();
+  let c2 = Command.fromPacket(msg);
+
+  equal(c1.id, c2.id);
+  equal(c1.name, c2.name);
+  equal(c1.parameters, c2.parameters);
+
+  Assert.throws(
+    () => Command.fromPacket([null, 2, "foo", {}]),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => Command.fromPacket([1, 2, "foo", {}]),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => Command.fromPacket([0, null, "foo", {}]),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => Command.fromPacket([0, 2, null, {}]),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => Command.fromPacket([0, 2, "foo", false]),
+    /InvalidArgumentError/
+  );
+
+  let nullParams = Command.fromPacket([0, 2, "foo", null]);
+  equal(
+    "[object Object]",
+    Object.prototype.toString.call(nullParams.parameters)
+  );
+});
+
+add_task(function test_Command_Type() {
+  equal(0, Command.Type);
+});
+
+add_task(function test_Response_ctor() {
+  let handler = () => {
+    throw new Error("foo");
+  };
+
+  let resp = new Response(42, handler);
+  equal(42, resp.id);
+  equal(null, resp.error);
+  ok("origin" in resp);
+  equal(Message.Origin.Server, resp.origin);
+  equal(false, resp.sent);
+  equal(handler, resp.respHandler_);
+});
+
+add_task(function test_Response_sendConditionally() {
+  let fired = false;
+  let resp = new Response(42, () => (fired = true));
+  resp.sendConditionally(() => false);
+  equal(false, resp.sent);
+  equal(false, fired);
+  resp.sendConditionally(() => true);
+  equal(true, resp.sent);
+  equal(true, fired);
+});
+
+add_task(function test_Response_send() {
+  let fired = false;
+  let resp = new Response(42, () => (fired = true));
+  resp.send();
+  equal(true, resp.sent);
+  equal(true, fired);
+});
+
+add_task(function test_Response_sendError_sent() {
+  let resp = new Response(42, r => equal(false, r.sent));
+  resp.sendError(new error.WebDriverError());
+  ok(resp.sent);
+  Assert.throws(() => resp.send(), /already been sent/);
+});
+
+add_task(function test_Response_sendError_body() {
+  let resp = new Response(42, r => equal(null, r.body));
+  resp.sendError(new error.WebDriverError());
+});
+
+add_task(function test_Response_sendError_errorSerialisation() {
+  let err1 = new error.WebDriverError();
+  let resp1 = new Response(42);
+  resp1.sendError(err1);
+  equal(err1.status, resp1.error.error);
+  deepEqual(err1.toJSON(), resp1.error);
+
+  let err2 = new error.InvalidArgumentError();
+  let resp2 = new Response(43);
+  resp2.sendError(err2);
+  equal(err2.status, resp2.error.error);
+  deepEqual(err2.toJSON(), resp2.error);
+});
+
+add_task(function test_Response_sendError_wrapInternalError() {
+  let err = new ReferenceError("foo");
+
+  // errors that originate from JavaScript (i.e. Marionette implementation
+  // issues) should be converted to UnknownError for transport
+  let resp = new Response(42, r => {
+    equal("unknown error", r.error.error);
+    equal(false, resp.sent);
+  });
+
+  // they should also throw after being sent
+  Assert.throws(() => resp.sendError(err), /foo/);
+  equal(true, resp.sent);
+});
+
+add_task(function test_Response_toPacket() {
+  let resp = new Response(42, () => {});
+  let msg = resp.toPacket();
+
+  equal(Response.Type, msg[0]);
+  equal(resp.id, msg[1]);
+  equal(resp.error, msg[2]);
+  equal(resp.body, msg[3]);
+});
+
+add_task(function test_Response_toString() {
+  let resp = new Response(42, () => {});
+  resp.error = "foo";
+  resp.body = "bar";
+
+  equal(JSON.stringify(resp.toPacket()), resp.toString());
+});
+
+add_task(function test_Response_fromPacket() {
+  let r1 = new Response(42, () => {});
+  r1.error = "foo";
+  r1.body = "bar";
+
+  let msg = r1.toPacket();
+  let r2 = Response.fromPacket(msg);
+
+  equal(r1.id, r2.id);
+  equal(r1.error, r2.error);
+  equal(r1.body, r2.body);
+
+  Assert.throws(
+    () => Response.fromPacket([null, 2, "foo", {}]),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => Response.fromPacket([0, 2, "foo", {}]),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => Response.fromPacket([1, null, "foo", {}]),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => Response.fromPacket([1, 2, null, {}]),
+    /InvalidArgumentError/
+  );
+  Response.fromPacket([1, 2, "foo", null]);
+});
+
+add_task(function test_Response_Type() {
+  equal(1, Response.Type);
+});