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, 244 insertions, 0 deletions

diff --git a/comm/calendar/test/browser/browser_taskUndoRedo.js b/comm/calendar/test/browser/browser_taskUndoRedo.js
new file mode 100644
index 0000000000..09cf9a8de2
--- /dev/null
+++ b/comm/calendar/test/browser/browser_taskUndoRedo.js
@@ -0,0 +1,244 @@
+/* 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";
+
+/**
+ * Tests for ensuring the undo/redo options are enabled properly when
+ * manipulating tasks.
+ */
+
+var { mailTestUtils } = ChromeUtils.import("resource://testing-common/mailnews/MailTestUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  CalTodo: "resource:///modules/CalTodo.jsm",
+  CalTransactionManager: "resource:///modules/CalTransactionManager.jsm",
+});
+
+const calendar = CalendarTestUtils.createCalendar("Undo Redo Test", "memory");
+const calTransManager = CalTransactionManager.getInstance();
+
+/**
+ * Checks the value of the "disabled" property for items in either the "Edit"
+ * menu bar or the app menu. Display of the relevant menu is triggered first so
+ * the UI code can update the respective items.
+ *
+ * @param {XULElement} element - The menu item we want to check, if its id begins
+ *                               with "menu" then we assume it is in the menu
+ *                               bar, if "appmenu" then the app menu.
+ */
+async function isDisabled(element) {
+  let targetMenu = document.getElementById("menu_EditPopup");
+
+  let shownPromise = BrowserTestUtils.waitForEvent(targetMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(document.getElementById("menu_Edit"), {});
+  await shownPromise;
+
+  let hiddenPromise = BrowserTestUtils.waitForEvent(targetMenu, "popuphidden");
+  let status = element.disabled;
+  EventUtils.synthesizeKey("VK_ESCAPE");
+  await hiddenPromise;
+  return status;
+}
+
+/**
+ * Removes CalTransaction items from the CalTransactionManager stacks so other
+ * tests are unhindered.
+ */
+function clearTransactions() {
+  calTransManager.undoStack = [];
+  calTransManager.redoStack = [];
+}
+
+/**
+ * Test the undo/redo functionality for task creation.
+ *
+ * @param {string} undoId - The id of the "undo" menu item.
+ * @param {string} redoId - The id of the "redo" menu item.
+ */
+async function taskAddUndoRedoTask(undoId, redoId) {
+  let undo = document.getElementById(undoId);
+  let redo = document.getElementById(redoId);
+  Assert.ok(await isDisabled(undo), `#${undoId} is disabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  let newBtn = document.getElementById("sidePanelNewTask");
+  let windowPromise = CalendarTestUtils.waitForEventDialog("edit");
+  EventUtils.synthesizeMouseAtCenter(newBtn, {});
+
+  let win = await windowPromise;
+  let iframeWin = win.document.getElementById("calendar-item-panel-iframe").contentWindow;
+  await CalendarTestUtils.items.setData(win, iframeWin, { title: "New Task" });
+  await CalendarTestUtils.items.saveAndCloseItemDialog(win);
+
+  let tree = document.querySelector("#calendar-task-tree");
+  let refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+
+  Assert.equal(tree.view.rowCount, 1);
+  Assert.ok(!(await isDisabled(undo)), `#${undoId} is enabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  // Test undo.
+  undo.doCommand();
+  await TestUtils.waitForCondition(
+    () => tree.view.rowCount == 0,
+    `${undoId} did not remove task in time`
+  );
+  Assert.equal(tree.view.rowCount, 0, `#${undoId} reverses task creation`);
+
+  // Test redo.
+  redo.doCommand();
+  await TestUtils.waitForCondition(
+    () => tree.view.rowCount == 1,
+    `${redoId} did not re-create task in time`
+  );
+
+  let task = tree.getTaskAtRow(0);
+  Assert.equal(task.title, "New Task", `#${redoId} redos task creation`);
+  await calendar.deleteItem(task);
+  clearTransactions();
+}
+
+/**
+ * Test the undo/redo functionality for task modification.
+ *
+ * @param {string} undoId - The id of the "undo" menu item.
+ * @param {string} redoId - The id of the "redo" menu item.
+ */
+async function testModifyUndoRedoTask(undoId, redoId) {
+  let undo = document.getElementById(undoId);
+  let redo = document.getElementById(redoId);
+  Assert.ok(await isDisabled(undo), `#${undoId} is disabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  let task = new CalTodo();
+  task.title = "Modifiable Task";
+  task.entryDate = cal.dtz.now();
+  await calendar.addItem(task);
+
+  let tree = document.querySelector("#calendar-task-tree");
+  let refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+
+  let windowPromise = CalendarTestUtils.waitForEventDialog("edit");
+  mailTestUtils.treeClick(EventUtils, window, tree, 0, 1, { clickCount: 2 });
+
+  let win = await windowPromise;
+  let iframeWin = win.document.getElementById("calendar-item-panel-iframe").contentWindow;
+  await CalendarTestUtils.items.setData(win, iframeWin, { title: "Modified Task" });
+  await CalendarTestUtils.items.saveAndCloseItemDialog(win);
+
+  Assert.equal(tree.getTaskAtRow(0).title, "Modified Task");
+  Assert.ok(!(await isDisabled(undo)), `#${undoId} is enabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  // Test undo.
+  undo.doCommand();
+  refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+  Assert.equal(
+    tree.getTaskAtRow(0).title,
+    "Modifiable Task",
+    `#${undoId} reverses task modification`
+  );
+
+  // Test redo.
+  redo.doCommand();
+  refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+  Assert.equal(tree.getTaskAtRow(0).title, "Modified Task", `#${redoId} redos task modification`);
+
+  clearTransactions();
+  await calendar.deleteItem(tree.getTaskAtRow(0));
+}
+
+/**
+ * Test the undo/redo functionality for task deletion.
+ *
+ * @param {string} undoId - The id of the "undo" menu item.
+ * @param {string} redoId - The id of the "redo" menu item.
+ */
+async function testDeleteUndoRedoTask(undoId, redoId) {
+  let undo = document.getElementById(undoId);
+  let redo = document.getElementById(redoId);
+  Assert.ok(await isDisabled(undo), `#${undoId} is disabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  let task = new CalTodo();
+  task.title = "Deletable Task";
+  task.startDate = cal.dtz.now();
+  task.entryDate = cal.dtz.now();
+  await calendar.addItem(task);
+
+  let tree = document.querySelector("#calendar-task-tree");
+  let refreshPromise = BrowserTestUtils.waitForEvent(tree, "refresh");
+  tree.refresh();
+  await refreshPromise;
+  Assert.equal(tree.view.rowCount, 1);
+
+  mailTestUtils.treeClick(EventUtils, window, tree, 0, 1, { clickCount: 1 });
+  EventUtils.synthesizeKey("VK_DELETE");
+  await TestUtils.waitForCondition(() => tree.view.rowCount == 0, "task was not removed in time");
+
+  Assert.ok(!(await isDisabled(undo)), `#${undoId} is enabled`);
+  Assert.ok(await isDisabled(redo), `#${redoId} is disabled`);
+
+  // Test undo.
+  undo.doCommand();
+  tree.refresh();
+  await TestUtils.waitForCondition(
+    () => tree.view.rowCount == 1,
+    "undo did not restore task in time"
+  );
+  Assert.equal(tree.getTaskAtRow(0).title, "Deletable Task", `#${undoId} reverses item deletion`);
+
+  // Test redo.
+  redo.doCommand();
+  await TestUtils.waitForCondition(
+    () => tree.view.rowCount == 0,
+    `#${redoId} redo did not delete item in time`
+  );
+  Assert.ok(!tree.getTaskAtRow(0), `#${redoId} redos item deletion`);
+
+  clearTransactions();
+}
+
+/**
+ * Ensure the menu bar is visible and navigate to the task view.
+ */
+add_setup(async function () {
+  registerCleanupFunction(() => {
+    CalendarTestUtils.removeCalendar(calendar);
+  });
+
+  clearTransactions();
+  document.getElementById("toolbar-menubar").setAttribute("autohide", null);
+  await openTasksTab();
+});
+
+/**
+ * Tests the menu bar's undo/redo after adding an event.
+ */
+add_task(async function testMenuBarAddTaskUndoRedo() {
+  return taskAddUndoRedoTask("menu_undo", "menu_redo");
+}).__skipMe = AppConstants.platform == "macosx"; // Can't click menu bar on Mac.
+
+/**
+ * Tests the menu bar's undo/redo after modifying an event.
+ */
+add_task(async function testMenuBarModifyTaskUndoRedo() {
+  return testModifyUndoRedoTask("menu_undo", "menu_redo");
+}).__skipMe = AppConstants.platform == "macosx"; // Can't click menu bar on Mac.
+
+/**
+ * Tests the menu bar's undo/redo after deleting an event.
+ */
+add_task(async function testMenuBarDeleteTaskUndoRedo() {
+  return testDeleteUndoRedoTask("menu_undo", "menu_redo");
+}).__skipMe = AppConstants.platform == "macosx"; // Can't click menu bar on Mac.