1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/* 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/. */
/*
* Test that we can open and close a standalone message display window from the
* folder pane.
*/
"use strict";
var {
add_message_sets_to_folders,
assert_selected_and_displayed,
be_in_folder,
create_folder,
create_thread,
open_selected_message_in_new_window,
plan_for_message_display,
press_delete,
select_click_row,
wait_for_message_display_completion,
} = ChromeUtils.import(
"resource://testing-common/mozmill/FolderDisplayHelpers.jsm"
);
var { plan_for_window_close, wait_for_window_close } = ChromeUtils.import(
"resource://testing-common/mozmill/WindowHelpers.jsm"
);
var folderA, folderB;
var curMessage;
add_setup(async function () {
folderA = await create_folder("MessageWindowA");
folderB = await create_folder("MessageWindowB");
// create three messages in the folder to display
let msg1 = create_thread(1);
let msg2 = create_thread(1);
let thread1 = create_thread(2);
let thread2 = create_thread(2);
await add_message_sets_to_folders([folderA], [msg1, msg2, thread1, thread2]);
// add two more messages in another folder
let msg3 = create_thread(1);
let msg4 = create_thread(1);
await add_message_sets_to_folders([folderB], [msg3, msg4]);
folderA.msgDatabase.dBFolderInfo.viewFlags =
Ci.nsMsgViewFlagsType.kThreadedDisplay;
});
/** The message window controller. */
var msgc;
add_task(async function test_open_message_window() {
await be_in_folder(folderA);
// select the first message
curMessage = select_click_row(0);
// display it
msgc = await open_selected_message_in_new_window();
assert_selected_and_displayed(msgc, curMessage);
});
/**
* Use the "m" keyboard accelerator to mark a message as read or unread.
*/
add_task(function test_toggle_read() {
curMessage.markRead(false);
EventUtils.synthesizeKey("m", {}, msgc.window);
Assert.ok(curMessage.isRead, "Message should have been marked read!");
EventUtils.synthesizeKey("m", {}, msgc.window);
Assert.ok(!curMessage.isRead, "Message should have been marked unread!");
});
/**
* Use the "f" keyboard accelerator to navigate to the next message,
* and verify that it is indeed loaded.
*/
add_task(function test_navigate_to_next_message() {
plan_for_message_display(msgc);
EventUtils.synthesizeKey("f", {}, msgc.window);
wait_for_message_display_completion(msgc, true);
assert_selected_and_displayed(msgc, 1);
}).skip();
/**
* Delete a single message and verify the next message is loaded. This sets
* us up for the next test, which is delete on a collapsed thread after
* the previous message was deleted.
*/
add_task(function test_delete_single_message() {
plan_for_message_display(msgc);
press_delete(msgc);
wait_for_message_display_completion(msgc, true);
assert_selected_and_displayed(msgc, 1);
}).skip();
/**
* Delete the current message, and verify that it only deletes
* a single message, not the messages in the collapsed thread
*/
add_task(function test_del_collapsed_thread() {
plan_for_message_display(msgc);
press_delete(msgc);
if (folderA.getTotalMessages(false) != 4) {
throw new Error("should have only deleted one message");
}
wait_for_message_display_completion(msgc, true);
assert_selected_and_displayed(msgc, 1);
}).skip();
/**
* Hit n enough times to mark all messages in folder A read, and then accept the
* modal dialog saying that we should move to the next folder. Then, assert that
* the message displayed in the standalone message window is folder B's first
* message (since all messages in folder B were unread).
*/
add_task(async function test_next_unread() {
for (let i = 0; i < 3; ++i) {
plan_for_message_display(msgc);
EventUtils.synthesizeKey("n", {}, msgc.window);
wait_for_message_display_completion(msgc, true);
}
for (let m of folderA.messages) {
Assert.ok(m.isRead, `${m.messageId} is read`);
}
let dialogPromise = BrowserTestUtils.promiseAlertDialog("accept");
EventUtils.synthesizeKey("n", {}, msgc.window);
plan_for_message_display(msgc);
await dialogPromise;
wait_for_message_display_completion(msgc, true);
// move to folder B
await be_in_folder(folderB);
// select the first message, and make sure it's not read
let msg = select_click_row(0);
// make sure we've been displaying the right message
assert_selected_and_displayed(msgc, msg);
}).skip();
/**
* Close the window by hitting escape.
*/
add_task(function test_close_message_window() {
plan_for_window_close(msgc);
EventUtils.synthesizeKey("VK_ESCAPE", {}, msgc.window);
wait_for_window_close(msgc);
});
|
