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
|
/* Any copyright is dedicated to the Public Domain.
http://creativecommons.org/publicdomain/zero/1.0/ */
add_task(async function setup() {
useHttpServer();
await SearchTestUtils.useTestEngines();
Services.prefs.setCharPref(SearchUtils.BROWSER_SEARCH_PREF + "region", "US");
Services.prefs.setBoolPref(
SearchUtils.BROWSER_SEARCH_PREF + "separatePrivateDefault.ui.enabled",
true
);
Services.prefs.setBoolPref(
SearchUtils.BROWSER_SEARCH_PREF + "separatePrivateDefault",
true
);
await AddonTestUtils.promiseStartupManager();
});
function getDefault(privateMode) {
return privateMode
? Services.search.getDefaultPrivate()
: Services.search.getDefault();
}
async function checkBuiltinFallback(privateMode) {
info(
`Testing ${
privateMode ? "private" : "normal"
} default engine fallback (builtin)`
);
Assert.ok((await Services.search.getVisibleEngines()).length > 1);
Assert.ok(Services.search.isInitialized);
let defaultEngine = await getDefault(privateMode);
await Services.search.removeEngine(defaultEngine);
Assert.notEqual(
(await getDefault(privateMode)).name,
defaultEngine.name,
"Should have changed the default to a different engine"
);
Assert.ok(defaultEngine.hidden, "Should have hidden the removed engine");
for (let engine of await Services.search.getVisibleEngines()) {
await Services.search.removeEngine(engine);
}
Assert.strictEqual(
(await Services.search.getVisibleEngines()).length,
0,
"Should have no visible engines left after removal"
);
Assert.equal(
(await getDefault(privateMode)).name,
defaultEngine.name,
"Should fallback to the original default engine after removing all engines"
);
Assert.ok(
!defaultEngine.hidden,
"Should have unhidden the original default engine"
);
Assert.equal(
(await Services.search.getVisibleEngines()).length,
1,
"Should now have one engine visible"
);
if (privateMode) {
// When all engines have been hidden, and the default is re-obtained,
// then it first looks at visible engines, as the private engine has been
// re-established, we get that here.
Assert.equal(
(await getDefault(false)).name,
defaultEngine.name,
"Should still have the correct default in normal mode after adjusting the private mode default"
);
await Services.search.setDefault(
await Services.search.originalDefaultEngine
);
} else {
await Services.search.setDefaultPrivate(
await Services.search.originalPrivateDefaultEngine
);
}
// Re-enable all engines ready for the next test.
Services.search.restoreDefaultEngines();
}
add_task(async function test_default_fallback_builtin() {
await checkBuiltinFallback(false);
});
add_task(async function test_default_fallback_builtin_private() {
await checkBuiltinFallback(true);
});
async function checkNonBuiltinFallback(privateMode) {
info(
`Testing ${
privateMode ? "private" : "normal"
} default engine fallback (non-builtin)`
);
const [addedEngine] = await addTestEngines([
{ name: "A second test engine", xmlFileName: "engine2.xml" },
]);
const defaultEngine = await getDefault(privateMode);
if (privateMode) {
await Services.search.setDefaultPrivate(addedEngine);
} else {
await Services.search.setDefault(addedEngine);
}
// Remove the current engine...
await Services.search.removeEngine(addedEngine);
// ... and verify we've reverted to the normal default engine.
Assert.equal(
(await getDefault(privateMode)).name,
defaultEngine.name,
"Should revert to the original default engine"
);
}
add_task(async function test_default_fallback_non_builtin() {
await checkNonBuiltinFallback(false);
});
add_task(async function test_default_fallback_non_builtin_private() {
await checkNonBuiltinFallback(true);
});
|
