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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
/* Any copyright is dedicated to the Public Domain.
https://creativecommons.org/publicdomain/zero/1.0/ */
"use strict";
const { PlacesBackupResource } = ChromeUtils.importESModule(
"resource:///modules/backup/PlacesBackupResource.sys.mjs"
);
const { PrivateBrowsingUtils } = ChromeUtils.importESModule(
"resource://gre/modules/PrivateBrowsingUtils.sys.mjs"
);
const HISTORY_ENABLED_PREF = "places.history.enabled";
const SANITIZE_ON_SHUTDOWN_PREF = "privacy.sanitize.sanitizeOnShutdown";
registerCleanupFunction(() => {
/**
* Even though test_backup_no_saved_history clears user prefs too,
* clear them here as well in case that test fails and we don't
* reach the end of the test, which handles the cleanup.
*/
Services.prefs.clearUserPref(HISTORY_ENABLED_PREF);
Services.prefs.clearUserPref(SANITIZE_ON_SHUTDOWN_PREF);
});
/**
* Tests that we can measure Places DB related files in the profile directory.
*/
add_task(async function test_measure() {
Services.fog.testResetFOG();
const EXPECTED_PLACES_DB_SIZE = 5240;
const EXPECTED_FAVICONS_DB_SIZE = 5240;
// Create resource files in temporary directory
const tempDir = PathUtils.tempDir;
let tempPlacesDBPath = PathUtils.join(tempDir, "places.sqlite");
let tempFaviconsDBPath = PathUtils.join(tempDir, "favicons.sqlite");
await createKilobyteSizedFile(tempPlacesDBPath, EXPECTED_PLACES_DB_SIZE);
await createKilobyteSizedFile(tempFaviconsDBPath, EXPECTED_FAVICONS_DB_SIZE);
let placesBackupResource = new PlacesBackupResource();
await placesBackupResource.measure(tempDir);
let placesMeasurement = Glean.browserBackup.placesSize.testGetValue();
let faviconsMeasurement = Glean.browserBackup.faviconsSize.testGetValue();
let scalars = TelemetryTestUtils.getProcessScalars("parent", false, false);
// Compare glean vs telemetry measurements
TelemetryTestUtils.assertScalar(
scalars,
"browser.backup.places_size",
placesMeasurement,
"Glean and telemetry measurements for places.sqlite should be equal"
);
TelemetryTestUtils.assertScalar(
scalars,
"browser.backup.favicons_size",
faviconsMeasurement,
"Glean and telemetry measurements for favicons.sqlite should be equal"
);
// Compare glean measurements vs actual file sizes
Assert.equal(
placesMeasurement,
EXPECTED_PLACES_DB_SIZE,
"Should have collected the correct glean measurement for places.sqlite"
);
Assert.equal(
faviconsMeasurement,
EXPECTED_FAVICONS_DB_SIZE,
"Should have collected the correct glean measurement for favicons.sqlite"
);
await maybeRemovePath(tempPlacesDBPath);
await maybeRemovePath(tempFaviconsDBPath);
});
/**
* Tests that the backup method correctly copies places.sqlite and
* favicons.sqlite from the profile directory into the staging directory.
*/
add_task(async function test_backup() {
let sandbox = sinon.createSandbox();
let placesBackupResource = new PlacesBackupResource();
let sourcePath = await IOUtils.createUniqueDirectory(
PathUtils.tempDir,
"PlacesBackupResource-source-test"
);
let stagingPath = await IOUtils.createUniqueDirectory(
PathUtils.tempDir,
"PlacesBackupResource-staging-test"
);
let fakeConnection = {
backup: sandbox.stub().resolves(true),
close: sandbox.stub().resolves(true),
};
sandbox.stub(Sqlite, "openConnection").returns(fakeConnection);
await placesBackupResource.backup(stagingPath, sourcePath);
Assert.ok(
fakeConnection.backup.calledTwice,
"Backup should have been called twice"
);
Assert.ok(
fakeConnection.backup.firstCall.calledWith(
PathUtils.join(stagingPath, "places.sqlite")
),
"places.sqlite should have been backed up first"
);
Assert.ok(
fakeConnection.backup.secondCall.calledWith(
PathUtils.join(stagingPath, "favicons.sqlite")
),
"favicons.sqlite should have been backed up second"
);
await maybeRemovePath(stagingPath);
await maybeRemovePath(sourcePath);
sandbox.restore();
});
/**
* Tests that the backup method correctly creates a compressed bookmarks JSON file when users
* don't want history saved, even on shutdown.
*/
add_task(async function test_backup_no_saved_history() {
let sandbox = sinon.createSandbox();
let placesBackupResource = new PlacesBackupResource();
let sourcePath = await IOUtils.createUniqueDirectory(
PathUtils.tempDir,
"PlacesBackupResource-source-test"
);
let stagingPath = await IOUtils.createUniqueDirectory(
PathUtils.tempDir,
"PlacesBackupResource-staging-test"
);
let fakeConnection = {
backup: sandbox.stub().resolves(true),
close: sandbox.stub().resolves(true),
};
sandbox.stub(Sqlite, "openConnection").returns(fakeConnection);
/**
* First verify that remember history pref alone affects backup file type for places,
* despite sanitize on shutdown pref value.
*/
Services.prefs.setBoolPref(HISTORY_ENABLED_PREF, false);
Services.prefs.setBoolPref(SANITIZE_ON_SHUTDOWN_PREF, false);
await placesBackupResource.backup(stagingPath, sourcePath);
Assert.ok(
fakeConnection.backup.notCalled,
"No sqlite connections should have been made with remember history disabled"
);
await assertFilesExist(stagingPath, [{ path: "bookmarks.jsonlz4" }]);
await IOUtils.remove(PathUtils.join(stagingPath, "bookmarks.jsonlz4"));
/**
* Now verify that the sanitize shutdown pref alone affects backup file type for places,
* even if the user is okay with remembering history while browsing.
*/
Services.prefs.setBoolPref(HISTORY_ENABLED_PREF, true);
Services.prefs.setBoolPref(SANITIZE_ON_SHUTDOWN_PREF, true);
fakeConnection.backup.resetHistory();
await placesBackupResource.backup(stagingPath, sourcePath);
Assert.ok(
fakeConnection.backup.notCalled,
"No sqlite connections should have been made with sanitize shutdown enabled"
);
await assertFilesExist(stagingPath, [{ path: "bookmarks.jsonlz4" }]);
await maybeRemovePath(stagingPath);
await maybeRemovePath(sourcePath);
sandbox.restore();
Services.prefs.clearUserPref(HISTORY_ENABLED_PREF);
Services.prefs.clearUserPref(SANITIZE_ON_SHUTDOWN_PREF);
});
/**
* Tests that the backup method correctly creates a compressed bookmarks JSON file when
* permanent private browsing mode is enabled.
*/
add_task(async function test_backup_private_browsing() {
let sandbox = sinon.createSandbox();
let placesBackupResource = new PlacesBackupResource();
let sourcePath = await IOUtils.createUniqueDirectory(
PathUtils.tempDir,
"PlacesBackupResource-source-test"
);
let stagingPath = await IOUtils.createUniqueDirectory(
PathUtils.tempDir,
"PlacesBackupResource-staging-test"
);
let fakeConnection = {
backup: sandbox.stub().resolves(true),
close: sandbox.stub().resolves(true),
};
sandbox.stub(Sqlite, "openConnection").returns(fakeConnection);
sandbox.stub(PrivateBrowsingUtils, "permanentPrivateBrowsing").value(true);
await placesBackupResource.backup(stagingPath, sourcePath);
Assert.ok(
fakeConnection.backup.notCalled,
"No sqlite connections should have been made with permanent private browsing enabled"
);
await assertFilesExist(stagingPath, [{ path: "bookmarks.jsonlz4" }]);
await maybeRemovePath(stagingPath);
await maybeRemovePath(sourcePath);
sandbox.restore();
});
|
