Add m-esr52 at 52.6.0

1 files changed, 627 insertions, 0 deletions

diff --git a/testing/marionette/test_action.js b/testing/marionette/test_action.js
new file mode 100644
index 000000000..1c58ced76
--- /dev/null
+++ b/testing/marionette/test_action.js
@@ -0,0 +1,627 @@
+/* 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/. */
+
+"use strict";
+
+const {utils: Cu} = Components;
+
+Cu.import("chrome://marionette/content/action.js");
+Cu.import("chrome://marionette/content/element.js");
+Cu.import("chrome://marionette/content/error.js");
+
+action.inputStateMap = new Map();
+
+add_test(function test_createAction() {
+  Assert.throws(() => new action.Action(), InvalidArgumentError,
+      "Missing Action constructor args");
+  Assert.throws(() => new action.Action(1, 2), InvalidArgumentError,
+      "Missing Action constructor args");
+  Assert.throws(
+      () => new action.Action(1, 2, "sometype"), /Expected string/, "Non-string arguments.");
+  ok(new action.Action("id", "sometype", "sometype"));
+
+  run_next_test();
+});
+
+add_test(function test_defaultPointerParameters() {
+  let defaultParameters = {pointerType: action.PointerType.Mouse};
+  deepEqual(action.PointerParameters.fromJson(), defaultParameters);
+
+  run_next_test();
+});
+
+add_test(function test_processPointerParameters() {
+  let check = (regex, message, arg) => checkErrors(
+      regex, action.PointerParameters.fromJson, [arg], message);
+  let parametersData;
+  for (let d of ["foo", "", "get", "Get"]) {
+    parametersData = {pointerType: d};
+    let message = `parametersData: [pointerType: ${parametersData.pointerType}]`;
+    check(/Unknown pointerType/, message, parametersData);
+  }
+  parametersData.pointerType = "mouse"; //TODO "pen";
+  deepEqual(action.PointerParameters.fromJson(parametersData),
+      {pointerType: "mouse"}); //TODO action.PointerType.Pen});
+
+  run_next_test();
+});
+
+add_test(function test_processPointerUpDownAction() {
+  let actionItem = {type: "pointerDown"};
+  let actionSequence = {type: "pointer", id: "some_id"};
+  for (let d of [-1, "a"]) {
+    actionItem.button = d;
+    checkErrors(
+        /Expected 'button' \(.*\) to be >= 0/, action.Action.fromJson, [actionSequence, actionItem],
+        `button: ${actionItem.button}`);
+  }
+  actionItem.button = 5;
+  let act = action.Action.fromJson(actionSequence, actionItem);
+  equal(act.button, actionItem.button);
+
+  run_next_test();
+});
+
+add_test(function test_validateActionDurationAndCoordinates() {
+  let actionItem = {};
+  let actionSequence = {id: "some_id"};
+  let check = function (type, subtype, message = undefined) {
+    message = message || `duration: ${actionItem.duration}, subtype: ${subtype}`;
+    actionItem.type = subtype;
+    actionSequence.type = type;
+    checkErrors(/Expected '.*' \(.*\) to be >= 0/,
+        action.Action.fromJson, [actionSequence, actionItem], message);
+  };
+  for (let d of [-1, "a"]) {
+    actionItem.duration = d;
+    check("none", "pause");
+    check("pointer", "pointerMove");
+  }
+  actionItem.duration = 5000;
+  for (let name of ["x", "y"]) {
+    actionItem[name] = "a";
+    actionItem.type = "pointerMove";
+    actionSequence.type = "pointer";
+    checkErrors(/Expected '.*' \(.*\) to be an Integer/,
+        action.Action.fromJson, [actionSequence, actionItem],
+        `duration: ${actionItem.duration}, subtype: pointerMove`);
+  }
+  run_next_test();
+});
+
+add_test(function test_processPointerMoveActionOriginValidation() {
+  let actionSequence = {type: "pointer", id: "some_id"};
+  let actionItem = {duration: 5000, type: "pointerMove"};
+  for (let d of [-1, {a: "blah"}, []]) {
+    actionItem.origin = d;
+
+    checkErrors(/Expected \'origin\' to be a string or a web element reference/,
+        action.Action.fromJson,
+        [actionSequence, actionItem],
+        `actionItem.origin: (${getTypeString(d)})`);
+  }
+
+  run_next_test();
+});
+
+add_test(function test_processPointerMoveActionOriginStringValidation() {
+  let actionSequence = {type: "pointer", id: "some_id"};
+  let actionItem = {duration: 5000, type: "pointerMove"};
+  for (let d of ["a", "", "get", "Get"]) {
+    actionItem.origin = d;
+    checkErrors(/Unknown pointer-move origin/,
+        action.Action.fromJson,
+        [actionSequence, actionItem],
+        `actionItem.origin: ${d}`);
+  }
+
+  run_next_test();
+});
+
+add_test(function test_processPointerMoveActionElementOrigin() {
+  let actionSequence = {type: "pointer", id: "some_id"};
+  let actionItem = {duration: 5000, type: "pointerMove"};
+  actionItem.origin = {[element.Key]: "something"};
+  let a = action.Action.fromJson(actionSequence, actionItem);
+  deepEqual(a.origin, actionItem.origin);
+  run_next_test();
+});
+
+add_test(function test_processPointerMoveActionDefaultOrigin() {
+  let actionSequence = {type: "pointer", id: "some_id"};
+  // origin left undefined
+  let actionItem = {duration: 5000, type: "pointerMove"};
+  let a = action.Action.fromJson(actionSequence, actionItem);
+  deepEqual(a.origin, action.PointerOrigin.Viewport);
+  run_next_test();
+});
+
+add_test(function test_processPointerMoveAction() {
+  let actionSequence = {id: "some_id", type: "pointer"};
+  let actionItems = [
+    {
+      duration: 5000,
+      type: "pointerMove",
+      origin: undefined,
+      x: undefined,
+      y: undefined,
+    },
+    {
+      duration: undefined,
+      type: "pointerMove",
+      origin: {[element.Key]: "id", [element.LegacyKey]: "id"},
+      x: undefined,
+      y: undefined,
+    },
+    {
+      duration: 5000,
+      type: "pointerMove",
+      x: 0,
+      y: undefined,
+      origin: undefined,
+    },
+    {
+      duration: 5000,
+      type: "pointerMove",
+      x: 1,
+      y: 2,
+      origin: undefined,
+    },
+  ];
+  for (let expected of actionItems) {
+    let actual = action.Action.fromJson(actionSequence, expected);
+    ok(actual instanceof action.Action);
+    equal(actual.duration, expected.duration);
+    equal(actual.x, expected.x);
+    equal(actual.y, expected.y);
+
+    let origin = expected.origin;
+    if (typeof origin == "undefined") {
+      origin = action.PointerOrigin.Viewport;
+    }
+    deepEqual(actual.origin, origin);
+
+  }
+  run_next_test();
+});
+
+add_test(function test_computePointerDestinationViewport() {
+  let act = { type: "pointerMove", x: 100, y: 200, origin: "viewport"};
+  let inputState = new action.InputState.Pointer(action.PointerType.Mouse);
+  // these values should not affect the outcome
+  inputState.x = "99";
+  inputState.y = "10";
+  let target = action.computePointerDestination(act, inputState);
+  equal(act.x, target.x);
+  equal(act.y, target.y);
+
+  run_next_test();
+});
+
+add_test(function test_computePointerDestinationPointer() {
+  let act = { type: "pointerMove", x: 100, y: 200, origin: "pointer"};
+  let inputState = new action.InputState.Pointer(action.PointerType.Mouse);
+  inputState.x = 10;
+  inputState.y = 99;
+  let target = action.computePointerDestination(act, inputState);
+  equal(act.x + inputState.x, target.x);
+  equal(act.y + inputState.y, target.y);
+
+
+  run_next_test();
+});
+
+add_test(function test_computePointerDestinationElement() {
+  // origin represents a web element
+  // using an object literal instead to test default case in computePointerDestination
+  let act = {type: "pointerMove", x: 100, y: 200, origin: {}};
+  let inputState = new action.InputState.Pointer(action.PointerType.Mouse);
+  let elementCenter = {x: 10, y: 99};
+  let target = action.computePointerDestination(act, inputState, elementCenter);
+  equal(act.x + elementCenter.x, target.x);
+  equal(act.y + elementCenter.y, target.y);
+
+  Assert.throws(
+      () => action.computePointerDestination(act, inputState, {a: 1}),
+      InvalidArgumentError,
+      "Invalid element center coordinates.");
+
+  Assert.throws(
+      () => action.computePointerDestination(act, inputState, undefined),
+      InvalidArgumentError,
+      "Undefined element center coordinates.");
+
+  run_next_test();
+});
+
+add_test(function test_processPointerAction() {
+  let actionSequence = {
+    type: "pointer",
+    id: "some_id",
+    parameters: {
+      pointerType: "mouse" //TODO "touch"
+    },
+  };
+  let actionItems = [
+    {
+      duration: 2000,
+      type: "pause",
+    },
+    {
+      type: "pointerMove",
+      duration: 2000,
+    },
+    {
+      type: "pointerUp",
+      button: 1,
+    }
+  ];
+  for (let expected of actionItems) {
+    let actual = action.Action.fromJson(actionSequence, expected);
+    equal(actual.type, actionSequence.type);
+    equal(actual.subtype, expected.type);
+    equal(actual.id, actionSequence.id);
+    if (expected.type === "pointerUp") {
+      equal(actual.button, expected.button);
+    } else {
+      equal(actual.duration, expected.duration);
+    }
+    if (expected.type !== "pause") {
+      equal(actual.pointerType, actionSequence.parameters.pointerType);
+    }
+  }
+
+  run_next_test();
+});
+
+add_test(function test_processPauseAction() {
+  let actionItem = {type: "pause", duration: 5000};
+  let actionSequence = {id: "some_id"};
+  for (let type of ["none", "key", "pointer"]) {
+    actionSequence.type = type;
+    let act = action.Action.fromJson(actionSequence, actionItem);
+    ok(act instanceof action.Action);
+    equal(act.type, type);
+    equal(act.subtype, actionItem.type);
+    equal(act.id, actionSequence.id);
+    equal(act.duration, actionItem.duration);
+  }
+  actionItem.duration = undefined;
+  let act = action.Action.fromJson(actionSequence, actionItem);
+  equal(act.duration, actionItem.duration);
+
+  run_next_test();
+});
+
+add_test(function test_processActionSubtypeValidation() {
+  let actionItem = {type: "dancing"};
+  let actionSequence = {id: "some_id"};
+  let check = function (regex) {
+    let message = `type: ${actionSequence.type}, subtype: ${actionItem.type}`;
+    checkErrors(regex, action.Action.fromJson, [actionSequence, actionItem], message);
+  };
+  for (let type of ["none", "key", "pointer"]) {
+    actionSequence.type = type;
+    check(new RegExp(`Unknown subtype for ${type} action`));
+  }
+  run_next_test();
+});
+
+add_test(function test_processKeyActionUpDown() {
+  let actionSequence = {type: "key", id: "some_id"};
+  let actionItem = {type: "keyDown"};
+
+  for (let v of [-1, undefined, [], ["a"], {length: 1}, null]) {
+    actionItem.value = v;
+    let message = `actionItem.value: (${getTypeString(v)})`;
+    Assert.throws(() => action.Action.fromJson(actionSequence, actionItem),
+        InvalidArgumentError, message);
+    Assert.throws(() => action.Action.fromJson(actionSequence, actionItem),
+        /Expected 'value' to be a string that represents single code point/, message);
+  }
+
+  actionItem.value = "\uE004";
+  let act = action.Action.fromJson(actionSequence, actionItem);
+  ok(act instanceof action.Action);
+  equal(act.type, actionSequence.type);
+  equal(act.subtype, actionItem.type);
+  equal(act.id, actionSequence.id);
+  equal(act.value, actionItem.value);
+
+  run_next_test();
+});
+
+add_test(function test_processInputSourceActionSequenceValidation() {
+  let actionSequence = {type: "swim", id: "some id"};
+  let check = (message, regex) => checkErrors(
+      regex, action.Sequence.fromJson, [actionSequence], message);
+  check(`actionSequence.type: ${actionSequence.type}`, /Unknown action type/);
+  action.inputStateMap.clear();
+
+  actionSequence.type = "none";
+  actionSequence.id = -1;
+  check(`actionSequence.id: ${getTypeString(actionSequence.id)}`,
+      /Expected 'id' to be a string/);
+  action.inputStateMap.clear();
+
+  actionSequence.id = undefined;
+  check(`actionSequence.id: ${getTypeString(actionSequence.id)}`,
+      /Expected 'id' to be defined/);
+  action.inputStateMap.clear();
+
+  actionSequence.id = "some_id";
+  actionSequence.actions = -1;
+  check(`actionSequence.actions: ${getTypeString(actionSequence.actions)}`,
+      /Expected 'actionSequence.actions' to be an Array/);
+  action.inputStateMap.clear();
+
+  run_next_test();
+});
+
+add_test(function test_processInputSourceActionSequence() {
+  let actionItem = { type: "pause", duration: 5};
+  let actionSequence = {
+    type: "none",
+    id: "some id",
+    actions: [actionItem],
+  };
+  let expectedAction = new action.Action(actionSequence.id, "none", actionItem.type);
+  expectedAction.duration = actionItem.duration;
+  let actions = action.Sequence.fromJson(actionSequence);
+  equal(actions.length, 1);
+  deepEqual(actions[0], expectedAction);
+  action.inputStateMap.clear();
+  run_next_test();
+});
+
+add_test(function test_processInputSourceActionSequencePointer() {
+  let actionItem = {type: "pointerDown", button: 1};
+  let actionSequence = {
+    type: "pointer",
+    id: "9",
+    actions: [actionItem],
+    parameters: {
+      pointerType: "mouse" // TODO "pen"
+    },
+  };
+  let expectedAction = new action.Action(
+      actionSequence.id, actionSequence.type, actionItem.type);
+  expectedAction.pointerType = actionSequence.parameters.pointerType;
+  expectedAction.button = actionItem.button;
+  let actions = action.Sequence.fromJson(actionSequence);
+  equal(actions.length, 1);
+  deepEqual(actions[0], expectedAction);
+  action.inputStateMap.clear();
+  run_next_test();
+});
+
+add_test(function test_processInputSourceActionSequenceKey() {
+  let actionItem = {type: "keyUp", value: "a"};
+  let actionSequence = {
+    type: "key",
+    id: "9",
+    actions: [actionItem],
+  };
+  let expectedAction = new action.Action(
+      actionSequence.id, actionSequence.type, actionItem.type);
+  expectedAction.value = actionItem.value;
+  let actions = action.Sequence.fromJson(actionSequence);
+  equal(actions.length, 1);
+  deepEqual(actions[0], expectedAction);
+  action.inputStateMap.clear();
+  run_next_test();
+});
+
+
+add_test(function test_processInputSourceActionSequenceInputStateMap() {
+  let id = "1";
+  let actionItem = {type: "pause", duration: 5000};
+  let actionSequence = {
+    type: "key",
+    id: id,
+    actions: [actionItem],
+  };
+  let wrongInputState = new action.InputState.Null();
+  action.inputStateMap.set(actionSequence.id, wrongInputState);
+  checkErrors(/to be mapped to/, action.Sequence.fromJson, [actionSequence],
+      `${actionSequence.type} using ${wrongInputState}`);
+  action.inputStateMap.clear();
+  let rightInputState = new action.InputState.Key();
+  action.inputStateMap.set(id, rightInputState);
+  let acts = action.Sequence.fromJson(actionSequence);
+  equal(acts.length, 1);
+  action.inputStateMap.clear();
+  run_next_test();
+});
+
+add_test(function test_processPointerActionInputStateMap() {
+  let actionItem = {type: "pointerDown"};
+  let id = "1";
+  let parameters = {pointerType: "mouse"};
+  let a = new action.Action(id, "pointer", actionItem.type);
+  let wrongInputState = new action.InputState.Key();
+  action.inputStateMap.set(id, wrongInputState);
+  checkErrors(
+      /to be mapped to InputState whose type is/, action.processPointerAction,
+      [id, parameters, a],
+      `type "pointer" with ${wrongInputState.type} in inputState`);
+  action.inputStateMap.clear();
+
+  // TODO - uncomment once pen is supported
+  //wrongInputState = new action.InputState.Pointer("pen");
+  //action.inputStateMap.set(id, wrongInputState);
+  //checkErrors(
+  //    /to be mapped to InputState whose subtype is/, action.processPointerAction,
+  //    [id, parameters, a],
+  //    `subtype ${parameters.pointerType} with ${wrongInputState.subtype} in inputState`);
+  //action.inputStateMap.clear();
+
+  let rightInputState = new action.InputState.Pointer("mouse");
+  action.inputStateMap.set(id, rightInputState);
+  action.processPointerAction(id, parameters, a);
+  action.inputStateMap.clear();
+  run_next_test();
+});
+
+add_test(function test_createInputState() {
+  for (let kind in action.InputState) {
+    let state;
+    if (kind == "Pointer") {
+      state = new action.InputState[kind]("mouse");
+    } else {
+      state = new action.InputState[kind]();
+    }
+    ok(state);
+    if (kind === "Null") {
+      equal(state.type, "none");
+    } else {
+      equal(state.type, kind.toLowerCase());
+    }
+  }
+  Assert.throws(() => new action.InputState.Pointer(), InvalidArgumentError,
+      "Missing InputState.Pointer constructor arg");
+  Assert.throws(() => new action.InputState.Pointer("foo"), InvalidArgumentError,
+      "Invalid InputState.Pointer constructor arg");
+  run_next_test();
+});
+
+add_test(function test_extractActionChainValidation() {
+  for (let actions of [-1, "a", undefined, null]) {
+    let message = `actions: ${getTypeString(actions)}`;
+    Assert.throws(() => action.Chain.fromJson(actions),
+        InvalidArgumentError, message);
+    Assert.throws(() => action.Chain.fromJson(actions),
+        /Expected 'actions' to be an Array/, message);
+  }
+  run_next_test();
+});
+
+add_test(function test_extractActionChainEmpty() {
+  deepEqual(action.Chain.fromJson([]), []);
+  run_next_test();
+});
+
+add_test(function test_extractActionChain_oneTickOneInput() {
+  let actionItem = {type: "pause", duration: 5000};
+  let actionSequence = {
+    type: "none",
+    id: "some id",
+    actions: [actionItem],
+  };
+  let expectedAction = new action.Action(actionSequence.id, "none", actionItem.type);
+  expectedAction.duration = actionItem.duration;
+  let actionsByTick = action.Chain.fromJson([actionSequence]);
+  equal(1, actionsByTick.length);
+  equal(1, actionsByTick[0].length);
+  deepEqual(actionsByTick, [[expectedAction]]);
+  action.inputStateMap.clear();
+  run_next_test();
+});
+
+add_test(function test_extractActionChain_twoAndThreeTicks() {
+  let mouseActionItems = [
+    {
+      type: "pointerDown",
+      button: 2,
+    },
+    {
+      type: "pointerUp",
+      button: 2,
+    },
+  ];
+  let mouseActionSequence = {
+    type: "pointer",
+    id: "7",
+    actions: mouseActionItems,
+    parameters: {
+      pointerType: "mouse" //TODO "touch"
+    },
+  };
+  let keyActionItems = [
+    {
+      type: "keyDown",
+      value: "a",
+    },
+    {
+      type: "pause",
+      duration: 4,
+    },
+    {
+      type: "keyUp",
+      value: "a",
+    },
+  ];
+  let keyActionSequence = {
+    type: "key",
+    id: "1",
+    actions: keyActionItems,
+  };
+  let actionsByTick = action.Chain.fromJson([keyActionSequence, mouseActionSequence]);
+  // number of ticks is same as longest action sequence
+  equal(keyActionItems.length, actionsByTick.length);
+  equal(2, actionsByTick[0].length);
+  equal(2, actionsByTick[1].length);
+  equal(1, actionsByTick[2].length);
+  let expectedAction = new action.Action(keyActionSequence.id, "key", keyActionItems[2].type);
+  expectedAction.value = keyActionItems[2].value;
+  deepEqual(actionsByTick[2][0], expectedAction);
+  action.inputStateMap.clear();
+
+  // one empty action sequence
+  actionsByTick = action.Chain.fromJson(
+      [keyActionSequence, {type: "none", id: "some", actions: []}]);
+  equal(keyActionItems.length, actionsByTick.length);
+  equal(1, actionsByTick[0].length);
+  action.inputStateMap.clear();
+  run_next_test();
+});
+
+add_test(function test_computeTickDuration() {
+  let expected = 8000;
+  let tickActions = [
+    {type: "none", subtype: "pause", duration: 5000},
+    {type: "key", subtype: "pause", duration: 1000},
+    {type: "pointer", subtype: "pointerMove", duration: 6000},
+    // invalid because keyDown should not have duration, so duration should be ignored.
+    {type: "key", subtype: "keyDown", duration: 100000},
+    {type: "pointer", subtype: "pause", duration: expected},
+    {type: "pointer", subtype: "pointerUp"},
+  ];
+  equal(expected, action.computeTickDuration(tickActions));
+  run_next_test();
+});
+
+add_test(function test_computeTickDuration_empty() {
+  equal(0, action.computeTickDuration([]));
+  run_next_test();
+});
+
+add_test(function test_computeTickDuration_noDurations() {
+  let tickActions = [
+    // invalid because keyDown should not have duration, so duration should be ignored.
+    {type: "key", subtype: "keyDown", duration: 100000},
+    // undefined duration permitted
+    {type: "none", subtype: "pause"},
+    {type: "pointer", subtype: "pointerMove"},
+    {type: "pointer", subtype: "pointerDown"},
+    {type: "key", subtype: "keyUp"},
+  ];
+
+  equal(0, action.computeTickDuration(tickActions));
+  run_next_test();
+});
+
+
+// helpers
+function getTypeString(obj) {
+  return Object.prototype.toString.call(obj);
+};
+
+function checkErrors(regex, func, args, message) {
+  if (typeof message == "undefined") {
+    message = `actionFunc: ${func.name}; args: ${args}`;
+  }
+  Assert.throws(() => func.apply(this, args), InvalidArgumentError, message);
+  Assert.throws(() => func.apply(this, args), regex, message);
+};