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
227
228
229
230
231
232
233
234
235
236
237
|
/* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/ */
const { Service } = ChromeUtils.import("resource://services-sync/service.js");
// This sucks, but this test fails if this engine is enabled, due to dumb
// things that aren't related to this engine. In short:
// * Because the addon manager isn't initialized, the addons engine fails to
// initialize. So we end up writing a meta/global with `extension-storage`
// but not addons.
// * After we sync, we discover 'addons' is locally enabled, but because it's
// not in m/g, we decide it's been remotely declined (and it decides this
// without even considering `declined`). So we disable 'addons'.
// * Disabling 'addons' means 'extension-storage' is disabled - but because
// that *is* in meta/global we re-update meta/global to remove it.
// * This test fails due to the extra, unexpected update of m/g.
//
// Another option would be to ensure the addons manager is initialized, but
// that's a larger patch and still isn't strictly relevant to what's being
// tested here, so...
Services.prefs.setBoolPref(
"services.sync.engine.extension-storage.force",
false
);
add_task(async function run_test() {
enableValidationPrefs();
validate_all_future_pings();
Log.repository.rootLogger.addAppender(new Log.DumpAppender());
let clients = new ServerCollection();
let meta_global = new ServerWBO("global");
let collectionsHelper = track_collections_helper();
let upd = collectionsHelper.with_updated_collection;
let collections = collectionsHelper.collections;
function wasCalledHandler(wbo) {
let handler = wbo.handler();
return function() {
wbo.wasCalled = true;
handler.apply(this, arguments);
};
}
let keysWBO = new ServerWBO("keys");
let cryptoColl = new ServerCollection({ keys: keysWBO });
let metaColl = new ServerCollection({ global: meta_global });
do_test_pending();
/**
* Handle the bulk DELETE request sent by wipeServer.
*/
function storageHandler(request, response) {
Assert.equal("DELETE", request.method);
Assert.ok(request.hasHeader("X-Confirm-Delete"));
_("Wiping out all collections.");
cryptoColl.delete({});
clients.delete({});
metaColl.delete({});
let ts = new_timestamp();
collectionsHelper.update_collection("crypto", ts);
collectionsHelper.update_collection("clients", ts);
collectionsHelper.update_collection("meta", ts);
return_timestamp(request, response, ts);
}
const GLOBAL_PATH = "/1.1/johndoe/storage/meta/global";
let handlers = {
"/1.1/johndoe/storage": storageHandler,
"/1.1/johndoe/storage/crypto/keys": upd("crypto", keysWBO.handler()),
"/1.1/johndoe/storage/crypto": upd("crypto", cryptoColl.handler()),
"/1.1/johndoe/storage/clients": upd("clients", clients.handler()),
"/1.1/johndoe/storage/meta": upd("meta", wasCalledHandler(metaColl)),
"/1.1/johndoe/storage/meta/global": upd(
"meta",
wasCalledHandler(meta_global)
),
"/1.1/johndoe/info/collections": collectionsHelper.handler,
};
function mockHandler(path, mock) {
server.registerPathHandler(path, mock(handlers[path]));
return {
restore() {
server.registerPathHandler(path, handlers[path]);
},
};
}
let server = httpd_setup(handlers);
try {
_("Checking Status.sync with no credentials.");
await Service.verifyAndFetchSymmetricKeys();
Assert.equal(Service.status.sync, CREDENTIALS_CHANGED);
Assert.equal(Service.status.login, LOGIN_FAILED_NO_PASSPHRASE);
await configureIdentity({ username: "johndoe" }, server);
await Service.login();
_("Checking that remoteSetup returns true when credentials have changed.");
(await Service.recordManager.get(Service.metaURL)).payload.syncID =
"foobar";
Assert.ok(await Service._remoteSetup());
let returnStatusCode = (method, code) => oldMethod => (req, res) => {
if (req.method === method) {
res.setStatusLine(req.httpVersion, code, "");
} else {
oldMethod(req, res);
}
};
let mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 401));
Service.recordManager.del(Service.metaURL);
_(
"Checking that remoteSetup returns false on 401 on first get /meta/global."
);
Assert.equal(false, await Service._remoteSetup());
mock.restore();
await Service.login();
mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 503));
Service.recordManager.del(Service.metaURL);
_(
"Checking that remoteSetup returns false on 503 on first get /meta/global."
);
Assert.equal(false, await Service._remoteSetup());
Assert.equal(Service.status.sync, METARECORD_DOWNLOAD_FAIL);
mock.restore();
await Service.login();
mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 404));
Service.recordManager.del(Service.metaURL);
_("Checking that remoteSetup recovers on 404 on first get /meta/global.");
Assert.ok(await Service._remoteSetup());
mock.restore();
let makeOutdatedMeta = async () => {
Service.metaModified = 0;
let infoResponse = await Service._fetchInfo();
return {
status: infoResponse.status,
obj: {
crypto: infoResponse.obj.crypto,
clients: infoResponse.obj.clients,
meta: 1,
},
};
};
_(
"Checking that remoteSetup recovers on 404 on get /meta/global after clear cached one."
);
mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 404));
Service.recordManager.set(Service.metaURL, { isNew: false });
Assert.ok(await Service._remoteSetup(await makeOutdatedMeta()));
mock.restore();
_(
"Checking that remoteSetup returns false on 503 on get /meta/global after clear cached one."
);
mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 503));
Service.status.sync = "";
Service.recordManager.set(Service.metaURL, { isNew: false });
Assert.equal(false, await Service._remoteSetup(await makeOutdatedMeta()));
Assert.equal(Service.status.sync, "");
mock.restore();
metaColl.delete({});
_("Do an initial sync.");
await Service.sync();
_("Checking that remoteSetup returns true.");
Assert.ok(await Service._remoteSetup());
_("Verify that the meta record was uploaded.");
Assert.equal(meta_global.data.syncID, Service.syncID);
Assert.equal(meta_global.data.storageVersion, STORAGE_VERSION);
Assert.equal(
meta_global.data.engines.clients.version,
Service.clientsEngine.version
);
Assert.equal(
meta_global.data.engines.clients.syncID,
await Service.clientsEngine.getSyncID()
);
_(
"Set the collection info hash so that sync() will remember the modified times for future runs."
);
let lastSync = await Service.clientsEngine.getLastSync();
collections.meta = lastSync;
collections.clients = lastSync;
await Service.sync();
_("Sync again and verify that meta/global wasn't downloaded again");
meta_global.wasCalled = false;
await Service.sync();
Assert.ok(!meta_global.wasCalled);
_(
"Fake modified records. This will cause a redownload, but not reupload since it hasn't changed."
);
collections.meta += 42;
meta_global.wasCalled = false;
let metaModified = meta_global.modified;
await Service.sync();
Assert.ok(meta_global.wasCalled);
Assert.equal(metaModified, meta_global.modified);
// Try to screw up HMAC calculation.
// Re-encrypt keys with a new random keybundle, and upload them to the
// server, just as might happen with a second client.
_("Attempting to screw up HMAC by re-encrypting keys.");
let keys = Service.collectionKeys.asWBO();
let b = new BulkKeyBundle("hmacerror");
await b.generateRandom();
collections.crypto = keys.modified = 100 + Date.now() / 1000; // Future modification time.
await keys.encrypt(b);
await keys.upload(Service.resource(Service.cryptoKeysURL));
Assert.equal(false, await Service.verifyAndFetchSymmetricKeys());
Assert.equal(Service.status.login, LOGIN_FAILED_INVALID_PASSPHRASE);
} finally {
Svc.Prefs.resetBranch("");
server.stop(do_test_finished);
}
});
|
