summaryrefslogtreecommitdiff
path: root/frontend/gamma/tests/tests/Clipperz/PM/DataModel/User.test.js
Unidiff
Diffstat (limited to 'frontend/gamma/tests/tests/Clipperz/PM/DataModel/User.test.js') (more/less context) (show whitespace changes)
-rw-r--r--frontend/gamma/tests/tests/Clipperz/PM/DataModel/User.test.js2082
1 files changed, 2082 insertions, 0 deletions
diff --git a/frontend/gamma/tests/tests/Clipperz/PM/DataModel/User.test.js b/frontend/gamma/tests/tests/Clipperz/PM/DataModel/User.test.js
new file mode 100644
index 0000000..4e7a21f
--- a/dev/null
+++ b/frontend/gamma/tests/tests/Clipperz/PM/DataModel/User.test.js
@@ -0,0 +1,2082 @@
1/*
2
3Copyright 2008-2011 Clipperz Srl
4
5This file is part of Clipperz's Javascript Crypto Library.
6Javascript Crypto Library provides web developers with an extensive
7and efficient set of cryptographic functions. The library aims to
8obtain maximum execution speed while preserving modularity and
9reusability.
10For further information about its features and functionalities please
11refer to http://www.clipperz.com
12
13* Javascript Crypto Library is free software: you can redistribute
14 it and/or modify it under the terms of the GNU Affero General Public
15 License as published by the Free Software Foundation, either version
16 3 of the License, or (at your option) any later version.
17
18* Javascript Crypto Library is distributed in the hope that it will
19 be useful, but WITHOUT ANY WARRANTY; without even the implied
20 warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
21 See the GNU Affero General Public License for more details.
22
23* You should have received a copy of the GNU Affero General Public
24 License along with Javascript Crypto Library. If not, see
25 <http://www.gnu.org/licenses/>.
26
27*/
28
29Clipperz.Crypto.PRNG.defaultRandomGenerator().fastEntropyAccumulationForTestingPurpose();
30
31var tests = {
32
33 //-------------------------------------------------------------------------
34
35 'invertIndex_test': function (someTestArgs) {
36 var testIndex;
37 var invertedIndex;
38
39 testIndex = {
40 'key1': 'value1',
41 'key2': 'value2',
42 'key3': 'value3',
43 'key4': 'value4',
44 'key5': 'value5'
45 };
46
47 invertedIndex = Clipperz.PM.DataModel.User.Header.RecordIndex.invertIndex(testIndex);
48
49 SimpleTest.is(MochiKit.Base.keys(invertedIndex).length, MochiKit.Base.keys(testIndex).length, "the inverted index has the same number of elements as the original index");
50 SimpleTest.is(invertedIndex['value1'], 'key1', "the first element has been correctly inverted");
51 SimpleTest.is(invertedIndex['value2'], 'key2', "the second element has been correctly inverted");
52 SimpleTest.is(invertedIndex['value3'], 'key3', "the third element has been correctly inverted");
53 SimpleTest.is(invertedIndex['value4'], 'key4', "the forth element has been correctly inverted");
54 SimpleTest.is(invertedIndex['value5'], 'key5', "the fifth element has been correctly inverted");
55 return MochiKit.Async.succeed('done');
56 },
57
58 //-------------------------------------------------------------------------
59
60 'joe_clipperz_offline_copy_test': function(someTestArgs) {
61 var deferredResult;
62 var proxy;
63 var user;
64
65 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
66 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
67
68 deferredResult = new Clipperz.Async.Deferred("joe_clipperz_offline_copy_test", someTestArgs);
69 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
70 deferredResult.addMethod(user, 'login');
71 deferredResult.addMethod(user, 'getRecords');
72 deferredResult.addCallback(function (someRecords) {
73 is(someRecords.length, 20,"joe_clipperz_offline_copy_test - joe has 20 records");
74 });
75
76 deferredResult.addMethod(user, 'getRecords');
77 deferredResult.addCallback(MochiKit.Base.map, MochiKit.Base.methodcaller('label'));
78 deferredResult.addCallback(Clipperz.Async.collectAll);
79 deferredResult.addCallback(MochiKit.Base.methodcaller('sort'));
80 deferredResult.addCallback(function (someSortedLabels) {
81 SimpleTest.is(someSortedLabels.length, 20, "We got all the labels");
82 SimpleTest.is(someSortedLabels[0], "Amazon.com", "The first label is correct");
83 SimpleTest.is(someSortedLabels[1], "American Airlines", "The second label is correct");
84 SimpleTest.is(someSortedLabels[2], "Bloglines", "The third label is correct");
85 SimpleTest.is(someSortedLabels[3], "Digg", "The fourth label is correct");
86 SimpleTest.is(someSortedLabels[4], "Example Attack", "The fifth label is correct");
87 SimpleTest.is(someSortedLabels[5], "Expedia.com", "The sixth label is correct");
88 SimpleTest.is(someSortedLabels[6], "Google Account", "The seventh label is correct");
89 SimpleTest.is(someSortedLabels[7], "Home burglar alarm", "The eighth label is correct");
90 SimpleTest.is(someSortedLabels[8], "Jaiku", "The ninth label is correct");
91 SimpleTest.is(someSortedLabels[9], "LinkedIn", "The 10th label is correct");
92 SimpleTest.is(someSortedLabels[10], "Lufthansa", "The 11th label is correct");
93 SimpleTest.is(someSortedLabels[11], "Microsoft Office CD Key","The 12th label is correct");
94 SimpleTest.is(someSortedLabels[12], "MyBlogLog", "The 13th label is correct");
95 SimpleTest.is(someSortedLabels[13], "MySpace", "The 14th label is correct");
96 SimpleTest.is(someSortedLabels[14], "SAP - Login", "The 15th label is correct");
97 SimpleTest.is(someSortedLabels[15], "The New York Times", "The 16th label is correct");
98 SimpleTest.is(someSortedLabels[16], "Web password", "The 17th label is correct");
99 SimpleTest.is(someSortedLabels[17], "Web password", "The 18th label is correct");
100 SimpleTest.is(someSortedLabels[18], "Yahoo! Account", "The 19th label is correct");
101 SimpleTest.is(someSortedLabels[19], "del.icio.us", "The 20th label is correct");
102 });
103 deferredResult.callback();
104
105 return deferredResult;
106 },
107
108 //-------------------------------------------------------------------------
109
110 'joe_clipperz_offline_copy_getDirectLogins_test': function(someTestArgs) {
111 var deferredResult;
112 var proxy;
113 var user;
114
115 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
116 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
117
118 deferredResult = new Clipperz.Async.Deferred("joe_clipperz_offline_copy_getDirectLogins_test", someTestArgs);
119 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
120 deferredResult.addMethod(user, 'login');
121 deferredResult.addMethod(user, 'getDirectLogins');
122 deferredResult.addCallback(function (someDirectLogins) {
123 SimpleTest.is(someDirectLogins.length, 22,"joe has 22 direct logins");
124 });
125
126 deferredResult.addMethod(user, 'getDirectLogins');
127 deferredResult.addCallback(MochiKit.Base.map, MochiKit.Base.methodcaller('label'));
128 deferredResult.addCallback(Clipperz.Async.collectAll);
129 deferredResult.addCallback(MochiKit.Base.methodcaller('sort'));
130 deferredResult.addCallback(function (someSortedLabels) {
131 SimpleTest.is(someSortedLabels.length, 22, "We got all the labels");
132 SimpleTest.is(someSortedLabels[0], "Amazon.com", "The first label is correct");
133 SimpleTest.is(someSortedLabels[1], "American Airlines","The second label is correct");
134 SimpleTest.is(someSortedLabels[2], "Bloglines", "The third label is correct");
135 SimpleTest.is(someSortedLabels[3], "Digg", "The fourth label is correct");
136 SimpleTest.is(someSortedLabels[4], "Example Attack", "The 5th label is correct");
137 SimpleTest.is(someSortedLabels[5], "Expedia.com", "The 6th label is correct");
138 SimpleTest.is(someSortedLabels[6], "Flickr", "The 7th label is correct");
139 SimpleTest.is(someSortedLabels[7], "Google Account", "The 8th label is correct");
140 SimpleTest.is(someSortedLabels[8], "Google Calendar", "The 9th label is correct");
141 SimpleTest.is(someSortedLabels[9], "Google Docs", "The 10th label is correct");
142 SimpleTest.is(someSortedLabels[10], "Google Mail", "The 11th label is correct");
143 SimpleTest.is(someSortedLabels[11], "Jaiku", "The 12th label is correct");
144 SimpleTest.is(someSortedLabels[12], "LinkedIn", "The 13th label is correct");
145 SimpleTest.is(someSortedLabels[13], "Lufthansa", "The 14th label is correct");
146 SimpleTest.is(someSortedLabels[14], "My Yahoo!", "The 15th label is correct");
147 SimpleTest.is(someSortedLabels[15], "MyBlogLog", "The 16th label is correct");
148 SimpleTest.is(someSortedLabels[16], "MySpace", "The 17th label is correct");
149 SimpleTest.is(someSortedLabels[17], "SAP - Login", "The 18th label is correct");
150 SimpleTest.is(someSortedLabels[18], "SAP - Login", "The 19th label is correct");
151 SimpleTest.is(someSortedLabels[19], "The New York Times","The 20th label is correct");
152 SimpleTest.is(someSortedLabels[20], "Yahoo! Groups", "The 21st label is correct");
153 SimpleTest.is(someSortedLabels[21], "Yahoo! Mail", "The 22nd label is correct");
154 });
155
156 deferredResult.callback();
157
158 return deferredResult;
159 },
160
161 //-------------------------------------------------------------------------
162
163 'getCredentials_test': function (someTestArgs) {
164 var deferredResult;
165 var user;
166
167 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
168
169 deferredResult = new Clipperz.Async.Deferred("getCredentials_test", someTestArgs);
170 deferredResult.addMethod(user, 'getCredentials');
171 deferredResult.addCallback(function(aResult) {
172 SimpleTest.is(aResult.username, 'joe', "the username of the credentaials is correct");
173 SimpleTest.is(aResult.password, 'clipperz', "the password of the credentaials is correct");
174 })
175 deferredResult.callback();
176
177 return deferredResult;
178 },
179
180 //-------------------------------------------------------------------------
181
182 'loginWithOfflineData_test': function (someTestArgs) {
183 var deferredResult;
184 var user;
185 var proxy;
186
187 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
188 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
189
190 deferredResult = new Clipperz.Async.Deferred("loginWithOfflineData_test", someTestArgs);
191 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
192 deferredResult.addMethod(user, 'login');
193 deferredResult.addCallback(function(aResult) {
194 SimpleTest.is(aResult.result, 'done', "successfully logged in");
195 })
196 deferredResult.callback();
197
198 return deferredResult;
199 },
200
201 //-------------------------------------------------------------------------
202
203 'getRecords_fromOfflineData_OLD_test': function (someTestArgs) {
204 var deferredResult;
205 var user;
206 var proxy;
207
208 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
209 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
210
211 deferredResult = new Clipperz.Async.Deferred("getRecords_fromOfflineData_OLD_test", someTestArgs);
212 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['OLD_joe_clipperz_offline_copy_data']);
213 deferredResult.addMethod(user, 'login');
214 deferredResult.addCallback(function(aResult) {
215 SimpleTest.is(aResult.result, 'done', "successfully logged in");
216 });
217 deferredResult.addMethod(user, 'getRecords');
218 deferredResult.addCallback(function(someRecords) {
219 SimpleTest.is(someRecords.length, 15, "the OLD test user has just 15 records");
220 });
221 deferredResult.addMethod(user, 'getRecords');
222 deferredResult.addCallback(MochiKit.Base.map, MochiKit.Base.methodcaller('label'));
223 deferredResult.addCallback(Clipperz.Async.collectAll);
224 deferredResult.addCallback(MochiKit.Base.methodcaller('sort'));
225 deferredResult.addCallback(function (someSortedLabels) {
226 SimpleTest.is(someSortedLabels.length, 15, "We got all the labels");
227 SimpleTest.is(someSortedLabels[0], "Amazon.com", "The first label is correct");
228 SimpleTest.is(someSortedLabels[1], "American Airlines","The second label is correct");
229 SimpleTest.is(someSortedLabels[2], "Bloglines", "The third label is correct");
230 SimpleTest.is(someSortedLabels[3], "Digg", "The fourth label is correct");
231 SimpleTest.is(someSortedLabels[4], "Expedia.com", "The fifth label is correct");
232 SimpleTest.is(someSortedLabels[5], "Google Account","The sixth label is correct");
233 SimpleTest.is(someSortedLabels[6], "Home burglar alarm","The seventh label is correct");
234 });
235/*
236*/
237 deferredResult.callback();
238
239 return deferredResult;
240 },
241
242 //-------------------------------------------------------------------------
243
244 'getDirectLogins_fromOfflineData_OLD_test': function (someTestArgs) {
245 var deferredResult;
246 var user;
247 var proxy;
248
249 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
250 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
251
252 deferredResult = new Clipperz.Async.Deferred("getRecords_fromOfflineData_OLD_test", someTestArgs);
253 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['OLD_joe_clipperz_offline_copy_data']);
254 deferredResult.addMethod(user, 'login');
255 deferredResult.addCallback(function(aResult) {
256 SimpleTest.is(aResult.result, 'done', "successfully logged in");
257 });
258 deferredResult.addMethod(user, 'getDirectLogins');
259 deferredResult.addCallback(function(someDirectLogins) {
260 SimpleTest.is(someDirectLogins.length, 17, "the OLD test user has 17 direct logins");
261 });
262 deferredResult.addMethod(user, 'getDirectLogins');
263 deferredResult.addCallback(MochiKit.Base.map, MochiKit.Base.methodcaller('label'));
264 deferredResult.addCallback(Clipperz.Async.collectAll);
265 deferredResult.addCallback(MochiKit.Base.methodcaller('sort'));
266 deferredResult.addCallback(function (someSortedLabels) {
267 SimpleTest.is(someSortedLabels.length, 17, "We got all the labels");
268 SimpleTest.is(someSortedLabels[0], "Amazon.com", "The first label is correct");
269 SimpleTest.is(someSortedLabels[1], "American Airlines","The second label is correct");
270 SimpleTest.is(someSortedLabels[2], "Bloglines", "The third label is correct");
271 SimpleTest.is(someSortedLabels[3], "Digg", "The fourth label is correct");
272 SimpleTest.is(someSortedLabels[4], "Expedia.com", "The fifth label is correct");
273 SimpleTest.is(someSortedLabels[5], "Flickr", "The sixth label is correct");
274 SimpleTest.is(someSortedLabels[6], "Google Calendar", "The seventh label is correct");
275 SimpleTest.is(someSortedLabels[7], "Google Docs", "The 8th label is correct");
276 SimpleTest.is(someSortedLabels[8], "Google Mail", "The 9th label is correct");
277 SimpleTest.is(someSortedLabels[9], "LinkedIn", "The 10th label is correct");
278 SimpleTest.is(someSortedLabels[10], "Lufthansa", "The 11th label is correct");
279 SimpleTest.is(someSortedLabels[11], "My Yahoo!", "The 12th label is correct");
280 SimpleTest.is(someSortedLabels[12], "MyBlogLog", "The 13th label is correct");
281 SimpleTest.is(someSortedLabels[13], "MySpace", "The 14th label is correct");
282 SimpleTest.is(someSortedLabels[14], "The New York Times","The 15th label is correct");
283 SimpleTest.is(someSortedLabels[15], "Yahoo! Groups", "The 16th label is correct");
284 SimpleTest.is(someSortedLabels[16], "Yahoo! Mail", "The 17th label is correct");
285 });
286
287 deferredResult.callback();
288
289 return deferredResult;
290 },
291
292 //-------------------------------------------------------------------------
293
294 'sortRecords_test': function (someTestArgs) {
295 var deferredResult;
296 var proxy;
297 var user;
298 var caseInsensitiveCompare;
299
300 caseInsensitiveCompare = function (aValue, bValue) {
301 return MochiKit.Base.compare(aValue.toLowerCase(), bValue.toLowerCase());
302 };
303
304 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
305 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
306
307 deferredResult = new Clipperz.Async.Deferred("sortRecords_test", someTestArgs);
308 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
309 deferredResult.addMethod(user, 'login');
310
311 deferredResult.addMethod(user, 'getRecords');
312 deferredResult.addCallback(Clipperz.Async.deferredSort, function (aRecord, bRecord) {
313 return Clipperz.Async.deferredCompare(MochiKit.Base.compare, aRecord.label(), bRecord.label());
314 });
315 deferredResult.addCallback(MochiKit.Base.itemgetter('0'));
316 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
317 deferredResult.addTest("Amazon.com", "Sorting the records themselves (by labels), the first one is 'Amazon.com'");
318
319 deferredResult.addMethod(user, 'getRecords');
320 deferredResult.addCallback(Clipperz.Async.deferredSort, function (aRecord, bRecord) {
321 return Clipperz.Async.deferredCompare(MochiKit.Base.compare, aRecord.label(), bRecord.label());
322 });
323 deferredResult.addCallback(MochiKit.Base.itemgetter('5'));
324 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
325 deferredResult.addTest("Expedia.com", "Sorting the records themselves (by labels), the sixth element is 'Expedia.com'");
326
327 deferredResult.addMethod(user, 'getRecords');
328 deferredResult.addCallback(Clipperz.Async.deferredSort, function (aRecord, bRecord) {
329 return Clipperz.Async.deferredCompare(MochiKit.Base.compare, aRecord.label(), bRecord.label());
330 });
331 deferredResult.addCallback(MochiKit.Base.itemgetter('19'));
332 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
333 deferredResult.addTest("del.icio.us", "Sorting the records themselves (by labels), the 20th element is 'del.icio.us'");
334
335
336
337 deferredResult.addMethod(user, 'getRecords');
338 deferredResult.addCallback(Clipperz.Async.deferredSort, function (aRecord, bRecord) {
339 return Clipperz.Async.deferredCompare(caseInsensitiveCompare, aRecord.label(), bRecord.label());
340 });
341 deferredResult.addCallback(MochiKit.Base.itemgetter('3'));
342 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
343 deferredResult.addTest("del.icio.us", "Sorting with case insensitive mode (by labels), the fourth record is 'del.ico.us'");
344
345 deferredResult.addMethod(user, 'getRecords');
346 deferredResult.addCallback(Clipperz.Async.deferredSort, function (aRecord, bRecord) {
347 return Clipperz.Async.deferredCompare(caseInsensitiveCompare, aRecord.label(), bRecord.label());
348 });
349 deferredResult.addCallback(MochiKit.Base.itemgetter('19'));
350 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
351 deferredResult.addTest("Yahoo! Account", "Sorting with case insensitive mode (by labels), the 20th record is 'Yahoo! Account'");
352
353 deferredResult.callback();
354
355 return deferredResult;
356 },
357
358 //-------------------------------------------------------------------------
359
360 'accessToSingleRecord_test': function (someTestArgs) {
361 var deferredResult;
362 var proxy;
363 var user;
364
365 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
366 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
367
368 deferredResult = new Clipperz.Async.Deferred("sortRecords_test", someTestArgs);
369 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
370 deferredResult.addMethod(user, 'login');
371 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
372 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
373 deferredResult.addTest("Amazon.com", "Sorting the records themselves (by labels), the first one is 'Amazon.com'");
374 deferredResult.callback();
375
376 return deferredResult;
377 },
378
379 //-------------------------------------------------------------------------
380
381 'accessToSingleRecordContent_test': function (someTestArgs) {
382 var deferredResult;
383 var proxy;
384 var user;
385
386 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
387 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
388
389 deferredResult = new Clipperz.Async.Deferred("sortRecords_test", someTestArgs);
390 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
391 deferredResult.addMethod(user, 'login');
392 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
393 deferredResult.addCallback(MochiKit.Base.methodcaller('fields'));
394 deferredResult.addCallback(function (someRecordFields) {
395 SimpleTest.is(MochiKit.Base.keys(someRecordFields).length, 2, "The number of fields of the Amazon.com record matches");
396 return someRecordFields;
397 });
398 deferredResult.addCallback(MochiKit.Base.itemgetter('5e822c34aaf1a9fbc0b52585c1915f3a3758abd51923a4d35ae85373bbb839c2'));
399 deferredResult.collectResults({
400 'label':MochiKit.Base.methodcaller('label'),
401 'value':MochiKit.Base.methodcaller('value')
402 })
403 deferredResult.addCallback(function (someValues) {
404 SimpleTest.is(someValues['label'], 'email', "the first field label matches");
405 SimpleTest.is(someValues['value'], 'joe@clipperz.com',"the first field value matches");
406 });
407 deferredResult.callback();
408
409 return deferredResult;
410 },
411
412 //-------------------------------------------------------------------------
413
414 'modifyRecordLabelAndCheckForPendingChanges_test': function (someTestArgs) {
415 var deferredResult;
416 var proxy;
417 var user;
418
419 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
420 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
421
422 deferredResult = new Clipperz.Async.Deferred("modifyRecordAndCheckForPendingChanges_test", someTestArgs);
423 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
424 deferredResult.addMethod(user, 'login');
425
426 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
427 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
428 deferredResult.addTest("Amazon.com", "This is the record the test was expecting");
429
430 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
431 deferredResult.addCallback(MochiKit.Base.methodcaller('setLabel', "New label"));
432
433 deferredResult.addMethod(user, 'hasPendingChanges');
434 deferredResult.addTest(true, "setting a label on one of the user's record, trigger the 'hasPendingChanges' flag");
435
436 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
437 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
438 deferredResult.addTest("New label", "once set the new label value, I can still get back its value");
439
440 deferredResult.addMethod(user, 'revertChanges');
441 deferredResult.addMethod(user, 'hasPendingChanges');
442 deferredResult.addTest(false, "reverting changes should return to the original state");
443
444 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
445 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
446 deferredResult.addTest("Amazon.com", "The label of the record is restored to its initial value");
447
448 deferredResult.callback();
449
450 return deferredResult;
451 },
452
453 //-------------------------------------------------------------------------
454
455 'modifyRecordFieldsAndCheckForPendingChanges_test': function (someTestArgs) {
456 var deferredResult;
457 var proxy;
458 var user;
459
460 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
461 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
462
463 deferredResult = new Clipperz.Async.Deferred("modifyRecordFieldsAndCheckForPendingChanges_test", someTestArgs);
464 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
465 deferredResult.addMethod(user, 'login');
466
467 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
468 deferredResult.addCallback(MochiKit.Base.methodcaller('fields'));
469 deferredResult.addCallback(MochiKit.Base.itemgetter('5e822c34aaf1a9fbc0b52585c1915f3a3758abd51923a4d35ae85373bbb839c2'));
470 deferredResult.addCallback(MochiKit.Base.methodcaller('value'));
471 deferredResult.addTest("joe@clipperz.com", "The value of the record field is correct");
472
473 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
474 deferredResult.addCallback(MochiKit.Base.methodcaller('fields'));
475 deferredResult.addCallback(MochiKit.Base.itemgetter('5e822c34aaf1a9fbc0b52585c1915f3a3758abd51923a4d35ae85373bbb839c2'));
476 deferredResult.addCallback(MochiKit.Base.methodcaller('setValue', 'joe@example.com'));
477
478 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
479 deferredResult.addCallback(MochiKit.Base.methodcaller('fields'));
480 deferredResult.addCallback(MochiKit.Base.itemgetter('5e822c34aaf1a9fbc0b52585c1915f3a3758abd51923a4d35ae85373bbb839c2'));
481 deferredResult.addCallback(MochiKit.Base.methodcaller('value'));
482 deferredResult.addTest("joe@example.com", "The record field correctly returns the newly updated value");
483
484 deferredResult.addMethod(user, 'hasPendingChanges');
485 deferredResult.addTest(true, "changing the value of a record's field trigger the 'hasPendingChanges' flag");
486
487 deferredResult.addMethod(user, 'revertChanges');
488 deferredResult.addMethod(user, 'hasPendingChanges');
489 deferredResult.addTest(false, "reverting changes should return to the original state");
490
491 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
492 deferredResult.addCallback(MochiKit.Base.methodcaller('fields'));
493 deferredResult.addCallback(MochiKit.Base.itemgetter('5e822c34aaf1a9fbc0b52585c1915f3a3758abd51923a4d35ae85373bbb839c2'));
494 deferredResult.addCallback(MochiKit.Base.methodcaller('value'));
495 deferredResult.addTest("joe@clipperz.com", "The original value of the record field is returned after reverting the changes");
496
497 deferredResult.callback();
498
499 return deferredResult;
500 },
501
502 //-------------------------------------------------------------------------
503
504 'modifyRecordNoteAndCheckForPendingChanges_test': function (someTestArgs) {
505 var deferredResult;
506 var proxy;
507 var user;
508
509 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
510 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
511
512 deferredResult = new Clipperz.Async.Deferred("modifyRecordNoteAndCheckForPendingChanges_test", someTestArgs);
513 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
514 deferredResult.addMethod(user, 'login');
515
516 deferredResult.addMethod(user, 'getRecord', '084e23120544603f0297368fd3891a3818e0fe13488e2f2c6079913c8d1bed8d');
517 deferredResult.addCallback(MochiKit.Base.methodcaller('notes'));
518 deferredResult.addTest("aproofofconcept\n<script>alert(\"nothing bad in here\");</script><script>alert(\"AAHHGGGH!\");</script>", "The value of the record note is correct");
519
520 deferredResult.addMethod(user, 'getRecord', '084e23120544603f0297368fd3891a3818e0fe13488e2f2c6079913c8d1bed8d');
521 deferredResult.addCallback(MochiKit.Base.methodcaller('setNotes', "A new note text"));
522
523 deferredResult.addMethod(user, 'getRecord', '084e23120544603f0297368fd3891a3818e0fe13488e2f2c6079913c8d1bed8d');
524 deferredResult.addCallback(MochiKit.Base.methodcaller('notes'));
525 deferredResult.addTest("A new note text", "The value of the record note has been updated");
526
527 deferredResult.addMethod(user, 'hasPendingChanges');
528 deferredResult.addTest(true, "changing the value of record's notes trigger the 'hasPendingChanges' flag");
529
530 deferredResult.addMethod(user, 'getRecord', '084e23120544603f0297368fd3891a3818e0fe13488e2f2c6079913c8d1bed8d');
531 deferredResult.addCallback(MochiKit.Base.methodcaller('hasPendingChanges'));
532 deferredResult.addTest(true, "also the record should flat its pending changes on the note field");
533
534 deferredResult.addMethod(user, 'revertChanges');
535 deferredResult.addMethod(user, 'hasPendingChanges');
536 deferredResult.addTest(false, "reverting changes should return to the original state");
537
538 deferredResult.addMethod(user, 'getRecord', '084e23120544603f0297368fd3891a3818e0fe13488e2f2c6079913c8d1bed8d');
539 deferredResult.addCallback(MochiKit.Base.methodcaller('notes'));
540 deferredResult.addTest("aproofofconcept\n<script>alert(\"nothing bad in here\");</script><script>alert(\"AAHHGGGH!\");</script>", "The value of the record note is restored to its initial value");
541 deferredResult.callback();
542
543 return deferredResult;
544 },
545
546 //-------------------------------------------------------------------------
547
548 'loadUser_withoutPreferences_andTryToAccessThem_test': function (someTestArgs) {
549 var deferredResult;
550 var proxy;
551 var user;
552
553 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
554 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
555
556 deferredResult = new Clipperz.Async.Deferred("loadUser_withoutPreferences_andTryToAccessThem_test", someTestArgs);
557 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
558 deferredResult.addMethod(user, 'login');
559
560 deferredResult.collectResults({
561 'preferences': [
562 MochiKit.Base.method(user, 'getHeaderIndex', 'preferences'),
563 MochiKit.Base.methodcaller('getDecryptedData')
564 ],
565 'oneTimePasswords': [
566 MochiKit.Base.method(user, 'getHeaderIndex', 'oneTimePasswords'),
567 MochiKit.Base.methodcaller('getDecryptedData')
568 ]
569 });
570 deferredResult.addCallback(function (someValues) {
571 SimpleTest.is(Clipperz.Base.serializeJSON(someValues['preferences']), '{}', "The preferences are empty");
572 });
573
574 deferredResult.callback();
575
576 return deferredResult;
577 },
578
579 //-------------------------------------------------------------------------
580
581 'modifyRecordTitleAndCheckForPendingChanges_test': function (someTestArgs) {
582 var deferredResult;
583 var proxy;
584 var user;
585
586 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
587 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
588
589 deferredResult = new Clipperz.Async.Deferred("modifyRecordTitleAndCheckForPendingChanges_test", someTestArgs);
590 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
591 deferredResult.addMethod(user, 'login');
592
593 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
594 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
595 deferredResult.addTest("Card 1", "The value of the record note is correct");
596
597 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
598 deferredResult.addCallback(MochiKit.Base.methodcaller('setLabel', "Edited card 1"));
599
600 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
601 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
602 deferredResult.addTest("Edited card 1", "The value of the record label has been updated");
603
604 deferredResult.addMethod(user, 'hasPendingChanges');
605 deferredResult.addTest(true, "changing the value of record's label trigger the 'hasPendingChanges' flag");
606
607 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
608 deferredResult.addCallback(MochiKit.Base.methodcaller('hasPendingChanges'));
609 // deferredResult.addTest(true, "also the record should flag its pending changes on the label - 1");
610 deferredResult.addTest(false, "changing just the label (or any other attribute stored on the header) should not trigger the 'hasPendingChanges' flag");
611
612 deferredResult.addMethod(user, 'revertChanges');
613 deferredResult.addMethod(user, 'hasPendingChanges');
614 deferredResult.addTest(false, "reverting changes should return to the original state");
615
616 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
617 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
618 deferredResult.addTest("Card 1", "The value of the record label is restored to its initial value");
619 deferredResult.callback();
620
621 return deferredResult;
622 },
623
624 //-------------------------------------------------------------------------
625
626 'modifyRecordTitleAndCheckForPendingChanges_take2_test': function (someTestArgs) {
627 var deferredResult;
628 var proxy;
629 var user;
630
631 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
632 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
633
634 deferredResult = new Clipperz.Async.Deferred("modifyRecordTitleAndCheckForPendingChanges_take2_test", someTestArgs);
635 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
636 deferredResult.addMethod(user, 'login');
637
638 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
639 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
640 deferredResult.addTest("Card 1", "The value of the record note is correct");
641
642 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
643 deferredResult.addCallback(MochiKit.Base.methodcaller('setLabel', "Edited card 1"));
644
645 deferredResult.addMethod(user, 'hasPendingChanges');
646 deferredResult.addTest(true, "changing the value of record's label trigger the 'hasPendingChanges' flag");
647
648 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
649 deferredResult.addCallback(MochiKit.Base.methodcaller('hasPendingChanges'));
650 // deferredResult.addTest(true, "also the record should flag its pending changes on the label - 2");
651 deferredResult.addTest(false, "only the label has changed, and this should not trigger the 'hasPendingChanges' flag on the record as it is stored in the header");
652
653 // deferredResult.addCallback(Clipperz.log, "=======================================================");
654 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
655 deferredResult.addCallback(MochiKit.Base.methodcaller('setLabel', "Card 1"));
656
657 deferredResult.addMethod(user, 'hasPendingChanges');
658 deferredResult.addTest(false, "Setting the old value back should void all pending changes");
659
660 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
661 deferredResult.addCallback(MochiKit.Base.methodcaller('hasPendingChanges'));
662 deferredResult.addTest(false, "also the record should not flag any pending changes, as the original value has been restored");
663
664 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
665 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
666 deferredResult.addTest("Card 1", "The value of the record label is restored to its initial value");
667 deferredResult.callback();
668
669 return deferredResult;
670 },
671
672 //-------------------------------------------------------------------------
673
674 'modifyRecordNoteAndThanResetOriginalValue_test': function (someTestArgs) {
675 var deferredResult;
676 var proxy;
677 var user;
678
679 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
680 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
681
682 deferredResult = new Clipperz.Async.Deferred("modifyRecordNoteAndThanResetOriginalValue_test", someTestArgs);
683 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
684 deferredResult.addMethod(user, 'login');
685
686 deferredResult.addMethod(user, 'getRecord', '084e23120544603f0297368fd3891a3818e0fe13488e2f2c6079913c8d1bed8d');
687 deferredResult.addCallback(MochiKit.Base.methodcaller('notes'));
688 deferredResult.addTest("aproofofconcept\n<script>alert(\"nothing bad in here\");</script><script>alert(\"AAHHGGGH!\");</script>", "The value of the record note is correct");
689
690 deferredResult.addMethod(user, 'getRecord', '084e23120544603f0297368fd3891a3818e0fe13488e2f2c6079913c8d1bed8d');
691 deferredResult.addCallback(MochiKit.Base.methodcaller('setNotes', "A new note text"));
692
693 deferredResult.addMethod(user, 'hasPendingChanges');
694 deferredResult.addTest(true, "changing the value of record's notes trigger the 'hasPendingChanges' flag");
695
696 deferredResult.addMethod(user, 'getRecord', '084e23120544603f0297368fd3891a3818e0fe13488e2f2c6079913c8d1bed8d');
697 deferredResult.addCallback(MochiKit.Base.methodcaller('setNotes', "aproofofconcept\n<script>alert(\"nothing bad in here\");</script><script>alert(\"AAHHGGGH!\");</script>"));
698
699 deferredResult.addMethod(user, 'hasPendingChanges');
700 deferredResult.addTest(false, "setting the field to its original value basically reset the change, like 'revertChanges' would have done");
701 deferredResult.callback();
702
703 return deferredResult;
704 },
705
706 //-------------------------------------------------------------------------
707
708 'modifyRecordNoteAndCommitChanges_test': function (someTestArgs) {
709 var deferredResult;
710 var proxy;
711 var user;
712 var user2;
713 var newNoteText;
714
715 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
716 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
717 user2 = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
718 newNoteText = "A new note text";
719
720 deferredResult = new Clipperz.Async.Deferred("modifyRecordAndCommitChanges_test", someTestArgs);
721 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
722 deferredResult.addMethod(user, 'login');
723 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
724 deferredResult.addCallback(MochiKit.Base.methodcaller('notes'));
725 deferredResult.addTest("", "This is the original value of the notes");
726
727 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
728 deferredResult.addCallback(MochiKit.Base.methodcaller('setNotes', newNoteText));
729
730 deferredResult.addMethod(user, 'hasPendingChanges');
731 deferredResult.addTest(true, "changing the value of record's notes trigger the 'hasPendingChanges' flag");
732
733 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
734 deferredResult.addCallback(MochiKit.Base.methodcaller('hasPendingChanges'));
735 deferredResult.addTest(true, "changing the value of record's notes trigger the 'hasPendingChanges' flag also on the record itself");
736
737 deferredResult.addMethod(user, 'saveChanges');
738
739 deferredResult.addMethod(user, 'hasPendingChanges');
740 deferredResult.addTest(false, "saving changes should return the user to a state with not changes pending - 1");
741
742 deferredResult.addMethod(user2, 'login');
743 deferredResult.addMethod(user2, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
744 deferredResult.addCallback(MochiKit.Base.methodcaller('notes'));
745 deferredResult.addTest(newNoteText, "It looks like the data edited was correctly stored and reloaded here");
746
747 deferredResult.callback();
748
749 return deferredResult;
750 },
751
752 //-------------------------------------------------------------------------
753
754 'multipleModificationToRecordTitleAndCommitChanges_test': function (someTestArgs) {
755 var deferredResult;
756 var proxy;
757 var user;
758 var user2;
759 var user3;
760 var newRecordTitle;
761
762 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
763 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
764 user2 = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
765 user3 = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
766 newRecordTitle = "A nice new title here";
767
768 deferredResult = new Clipperz.Async.Deferred("multipleModificationToRecordTitleAndCommitChanges_test", someTestArgs);
769 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
770 deferredResult.addMethod(user, 'login');
771 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
772
773 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
774 deferredResult.addTest("Card 1", "This is the original value of the label");
775
776 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
777 deferredResult.addCallback(MochiKit.Base.methodcaller('setLabel', newRecordTitle));
778
779 deferredResult.addMethod(user, 'hasPendingChanges');
780 deferredResult.addTest(true, "changing the value of record's label trigger the 'hasPendingChanges' flag");
781
782 deferredResult.addMethod(user, 'saveChanges');
783 deferredResult.addMethod(user, 'hasPendingChanges');
784 deferredResult.addTest(false, "saving changes should return the user to a state with not changes pending - 2"); //FAIL
785
786 deferredResult.addMethod(user2, 'login');
787 deferredResult.addMethod(user2, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
788 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
789 deferredResult.addTest(newRecordTitle, "It looks like the label edited was correctly stored and reloaded here");
790
791 deferredResult.addMethod(user2, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
792 deferredResult.addCallback(MochiKit.Base.methodcaller('setLabel', newRecordTitle + "-" + newRecordTitle));
793 deferredResult.addMethod(user2, 'hasPendingChanges');
794 deferredResult.addTest(true, "changing again the value of record's label trigger the 'hasPendingChanges' flag also on the new user");
795
796 deferredResult.addMethod(user2, 'saveChanges');
797 deferredResult.addMethod(user2, 'hasPendingChanges');
798 deferredResult.addTest(false, "after committing the changes, the user has no pending changes"); //FAIL
799
800 deferredResult.addMethod(user3, 'login');
801 deferredResult.addMethod(user3, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
802 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
803 deferredResult.addTest(newRecordTitle + "-" + newRecordTitle, "It looks like the label edited was correctly stored and reloaded here");
804
805 deferredResult.callback();
806
807 return deferredResult;
808 },
809
810 //-------------------------------------------------------------------------
811
812 'saveChangesWithADeletedRecord_test': function (someTestArgs) {
813 var deferredResult;
814 var proxy;
815 var user;
816
817 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
818 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
819
820 deferredResult = new Clipperz.Async.Deferred("saveChangesWithADeletedRecord_test", someTestArgs);
821 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
822 deferredResult.addMethod(user, 'login');
823
824 deferredResult.addMethod(user, 'getRecords');
825 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
826 deferredResult.addTest(1, "This account has oly a single card");
827
828 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
829 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
830 deferredResult.addTest("Card 1", "This is the initial value of the label ...");
831
832 deferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
833 deferredResult.addCallback(MochiKit.Base.methodcaller('prepareRemoteDataForChangedRecords'));
834 deferredResult.addCallback(function (aResult) {
835 SimpleTest.ok(aResult['updated'] != null, "There updated key is not null");
836 SimpleTest.isDeeply(aResult['updated'], [], "There are no updated cards");
837 SimpleTest.ok(aResult['deleted'] != null, "There deleted key is not null");
838 SimpleTest.isDeeply(aResult['deleted'], [], "There are no deleted references");
839 return aResult;
840 })
841 deferredResult.addMethod(user, 'revertChanges');
842
843 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
844 deferredResult.addMethod(user, 'deleteRecord');
845 deferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
846 deferredResult.addCallback(MochiKit.Base.methodcaller('prepareRemoteDataForChangedRecords'));
847 deferredResult.addCallback(function (aResult) {
848 SimpleTest.isDeeply(aResult['deleted'], ['8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13'], "The deleted record reference is correctly reported");
849 return aResult;
850 })
851 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
852 deferredResult.shouldFail("accessing the deleted record reference should raise an exception");
853
854 deferredResult.addMethod(user, 'getRecord', '0000000000000000000000000000000000000000000000000000000000000000');
855 deferredResult.shouldFail("accessing a fake record reference should raise an exception");
856
857 deferredResult.addMethod(user, 'saveChanges');
858 deferredResult.addMethod(user, 'getRecords');
859 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
860 deferredResult.addTest(0, "after deleting the only record, there should be no records bound to the user");
861
862 deferredResult.callback();
863
864 return deferredResult;
865 },
866
867 //-------------------------------------------------------------------------
868
869 'revertingChangesAfterDeletingACard_test': function (someTestArgs) {
870 var deferredResult;
871 var proxy;
872 var user;
873
874 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
875 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
876
877 deferredResult = new Clipperz.Async.Deferred("simpleSaveChanges_test", someTestArgs);
878 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
879 deferredResult.addMethod(user, 'login');
880
881 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
882 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
883 deferredResult.addTest("Card 1", "This is the initial value of the label ...");
884
885 deferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
886 deferredResult.addCallback(MochiKit.Base.methodcaller('prepareRemoteDataForChangedRecords'));
887 deferredResult.addCallback(function (aResult) {
888 SimpleTest.ok(aResult['updated'] != null, "There updated key is not null");
889 SimpleTest.isDeeply(aResult['updated'], [], "There are no updated cards");
890 SimpleTest.ok(aResult['deleted'] != null, "There deleted key is not null");
891 SimpleTest.isDeeply(aResult['deleted'], [], "There are no deleted references");
892 return aResult;
893 })
894 deferredResult.addMethod(user, 'revertChanges');
895
896 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
897 deferredResult.addMethod(user, 'deleteRecord');
898 deferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
899 deferredResult.addCallback(MochiKit.Base.methodcaller('prepareRemoteDataForChangedRecords'));
900 deferredResult.addCallback(function (aResult) {
901 SimpleTest.isDeeply(aResult['deleted'], ['8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13'], "The deleted record reference is correctly reported");
902 return aResult;
903 })
904 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
905 deferredResult.shouldFail("accessing the deleted record reference should raise an exception");
906
907 deferredResult.addMethod(user, 'getRecord', '0000000000000000000000000000000000000000000000000000000000000000');
908 deferredResult.shouldFail("accessing a fake record reference should raise an exception");
909
910 deferredResult.addMethod(user, 'revertChanges');
911 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
912 deferredResult.addCallback(SimpleTest.ok, true, "after reverting all changes, the deleted card is restored");
913
914 deferredResult.callback();
915
916 return deferredResult;
917 },
918
919 //-------------------------------------------------------------------------
920
921 'lockUnlockAccountAfterDeletingACard_test': function (someTestArgs) {
922 var deferredResult;
923 var proxy;
924 var user;
925 var recordID;
926
927 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
928 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
929
930 recordID = 'eeda70e0392261967bda71c3764da78989c45bbd2bb7be6b941b90f81d9b81b5';
931 // recordID = '507f38b06d587d8889698ae1ebbba7ef8f0539b82550dd25779fd9ee88fc0c7a';
932
933 deferredResult = new Clipperz.Async.Deferred("lockUnlockAccountAfterDeletingACard_test", someTestArgs);
934 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
935 deferredResult.addMethod(user, 'login');
936
937 deferredResult.addMethod(user, 'getRecords');
938 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
939 deferredResult.addTest(20, "Initially the user has 20 cards");
940
941 deferredResult.addMethod(user, 'getDirectLogins');
942 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
943 deferredResult.addTest(22, "Initially the user has 22 direct logins");
944
945 deferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
946 deferredResult.addMethodcaller('directLoginsData');
947 deferredResult.addMethodcaller('values');
948 deferredResult.addCallback(MochiKit.Base.values);
949 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
950 deferredResult.addTest(22, "There should be also 22 direct login references");
951
952 deferredResult.addMethod(user, 'getRecord', recordID);
953 deferredResult.addMethodcaller('directLogins');
954 deferredResult.addCallback(MochiKit.Base.values);
955 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
956 deferredResult.addTest(4, "The selected record has 4 direct logins");
957
958 deferredResult.addMethod(user, 'getRecord', recordID);
959 deferredResult.addMethod(user, 'deleteRecord');
960 deferredResult.addMethod(user, 'saveChanges');
961
962 deferredResult.addMethod(user, 'hasAnyCleanTextData');
963 deferredResult.addTest(true, "after saving changes, hasAnyCleanTextData should be true");
964
965 deferredResult.addMethod(user, 'deleteAllCleanTextData');
966
967 deferredResult.addMethod(user, 'hasAnyCleanTextData');
968 deferredResult.addTest(false, "after deleting all clean text data, hasAnyCleanTextData should be true");
969
970 deferredResult.addMethod(user, 'login');
971
972 deferredResult.addMethod(user, 'getRecords');
973 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
974 deferredResult.addTest((20 - 1), "After deleting a card, only 19 are left");
975
976 deferredResult.addMethod(user, 'getDirectLogins');
977 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
978 deferredResult.addTest((22 - 4), "Initially the user has 18 direct logins");
979
980 deferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
981 deferredResult.addMethodcaller('directLoginsData');
982 deferredResult.addMethodcaller('values');
983 deferredResult.addCallback(MochiKit.Base.values);
984 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
985 deferredResult.addTest((22 - 4), "Once deleted the card, there should be just 18 direct login references left");
986
987 deferredResult.addCallback(function () {
988 SimpleTest.ok(true, "nothing wrong had happen 'till here");
989 });
990
991 deferredResult.callback();
992
993 return deferredResult;
994 },
995
996 //-------------------------------------------------------------------------
997
998 'lockUnlockAccountAfterDeletingACard_2_test': function (someTestArgs) {
999 var deferredResult;
1000 var proxy;
1001 var user;
1002
1003 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1004 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
1005
1006 deferredResult = new Clipperz.Async.Deferred("lockUnlockAccountAfterDeletingACard_2_test", someTestArgs);
1007 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
1008 deferredResult.addMethod(user, 'login');
1009
1010 deferredResult.addMethod(user, 'getRecords');
1011 deferredResult.addCallback(function (someRecords) {
1012 SimpleTest.is(someRecords.length, 20, "Initially the user has 20 cards");
1013 });
1014
1015 deferredResult.addMethod(user, 'getDirectLogins');
1016 deferredResult.addCallback(function (someDirectLogins) {
1017 SimpleTest.is(someDirectLogins.length, 22, "Initially the user has 42 direct logins");
1018 });
1019
1020 deferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
1021 deferredResult.addMethodcaller('directLoginsData');
1022 deferredResult.addMethodcaller('values');
1023 deferredResult.addCallback(MochiKit.Base.values);
1024 deferredResult.addCallback(function (someDirectLoginReferences) {
1025 SimpleTest.is(someDirectLoginReferences.length, 22, "There should be also 22 direct login references - 2");
1026 });
1027
1028 deferredResult.addMethod(user, 'getRecord', '507f38b06d587d8889698ae1ebbba7ef8f0539b82550dd25779fd9ee88fc0c7a');
1029 deferredResult.addMethodcaller('directLogins');
1030 deferredResult.addCallback(MochiKit.Base.values);
1031 deferredResult.addCallback(function (someDirectLogins) {
1032 SimpleTest.is(someDirectLogins.length, 1, "The selected record has 4 direct logins");
1033 });
1034
1035
1036 deferredResult.addMethod(user, 'getRecord', '507f38b06d587d8889698ae1ebbba7ef8f0539b82550dd25779fd9ee88fc0c7a');
1037 deferredResult.addMethod(user, 'deleteRecord');
1038 deferredResult.addMethod(user, 'saveChanges');
1039 deferredResult.addMethod(user, 'deleteAllCleanTextData');
1040 deferredResult.addMethod(user, 'login');
1041
1042 deferredResult.addMethod(user, 'getRecords');
1043 deferredResult.addCallback(function (someRecords) {
1044 SimpleTest.is(someRecords.length, (20 -1), "After deleting a card, only 19 are left - 2");
1045 });
1046
1047 deferredResult.addMethod(user, 'getDirectLogins');
1048 deferredResult.addCallback(function (someDirectLogins) {
1049 SimpleTest.is(someDirectLogins.length, (22 - 1), "Initially the user has 21 direct logins - 2");
1050 });
1051
1052 deferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
1053 deferredResult.addMethodcaller('directLoginsData');
1054 deferredResult.addMethodcaller('values');
1055 deferredResult.addCallback(MochiKit.Base.values);
1056 deferredResult.addCallback(function (someDirectLoginReferences) {
1057 SimpleTest.is(someDirectLoginReferences.length, (22 - 1), "Once deleted the card, there should be just 21 direct login references left");
1058 });
1059
1060 deferredResult.addCallback(function () {
1061 SimpleTest.ok(true, "nothing wrong had happen 'till here - 2");
1062 });
1063
1064 deferredResult.callback();
1065
1066 return deferredResult;
1067 },
1068
1069 //-------------------------------------------------------------------------
1070
1071 'simpleSaveChanges_test': function (someTestArgs) {
1072 var deferredResult;
1073 var proxy;
1074 var user;
1075
1076 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1077 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1078
1079 deferredResult = new Clipperz.Async.Deferred("simpleSaveChanges_test", someTestArgs);
1080 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
1081 deferredResult.addMethod(user, 'login');
1082
1083 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1084 deferredResult.addCallback(MochiKit.Base.methodcaller('label'));
1085 deferredResult.addTest("Card 1", "This is the initial value of the label ...");
1086
1087 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1088 deferredResult.addCallback(MochiKit.Base.methodcaller('setLabel', "New label for Card 1"));
1089
1090 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1091 deferredResult.addCallback(MochiKit.Base.methodcaller('setNotes', "Setting just the label would not trigger the update of the record data and nothing will end up in the 'updated' list"));
1092
1093 deferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
1094 deferredResult.addCallback(MochiKit.Base.methodcaller('prepareRemoteDataForChangedRecords'));
1095 deferredResult.addCallback(function (aResult) {
1096 SimpleTest.is(aResult['updated'].length, 1, "The updadated record should be listed in the changes getting ready for commit");
1097 return aResult;
1098 })
1099
1100 deferredResult.callback();
1101
1102 return deferredResult;
1103 },
1104
1105 //-------------------------------------------------------------------------
1106
1107 'saveChangesAndDataCaching_test': function (someTestArgs) {
1108 var deferredResult;
1109 var proxy;
1110 var user;
1111 var record_1;
1112 var record_2;
1113
1114 record_1 = '062af892bcfba49ffcff05c56d99b7af2d508358e39c058c2e1fc83531436f80';
1115 record_2 = '084e23120544603f0297368fd3891a3818e0fe13488e2f2c6079913c8d1bed8d';
1116
1117 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1118 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
1119
1120 deferredResult = new Clipperz.Async.Deferred("saveChangesAndDataCaching_test", someTestArgs);
1121 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
1122 deferredResult.addMethod(user, 'login');
1123
1124 deferredResult.addMethod(user, 'getRecord', record_1);
1125 deferredResult.addMethodcaller('hasLoadedRemoteData');
1126 deferredResult.addTest(false, "The card data should have not been loaded yet");
1127
1128 deferredResult.addMethod(user, 'getRecord', record_2);
1129 deferredResult.addMethodcaller('hasLoadedRemoteData');
1130 deferredResult.addTest(false, "Also the other card data should have not been loaded yet");
1131
1132 deferredResult.addMethod(user, 'getRecord', record_1);
1133 deferredResult.addMethodcaller('setLabel', "New title");
1134
1135 deferredResult.addMethod(user, 'getRecord', record_1);
1136 deferredResult.addMethodcaller('hasLoadedRemoteData');
1137 deferredResult.addTest(false, "Changing just the label should not trigger the full loading of the card");
1138
1139 deferredResult.addMethod(user, 'getRecord', record_1);
1140 deferredResult.addMethodcaller('setNotes', "New note text");
1141
1142 deferredResult.addMethod(user, 'getRecord', record_1);
1143 deferredResult.addMethodcaller('hasLoadedRemoteData');
1144 deferredResult.addTest(true, "Changing the notes should trigger the loading of the card");
1145
1146 deferredResult.addMethod(user, 'getRecord', record_2);
1147 deferredResult.addMethodcaller('hasLoadedRemoteData');
1148 deferredResult.addTest(false, "Changing record_1 should not trigger the loading of record_2");
1149
1150 deferredResult.addMethod(user, 'hasPendingChanges');
1151 deferredResult.addTest(true, "changing the value of record's label trigger the 'hasPendingChanges' flag");
1152
1153 deferredResult.addMethod(user, 'saveChanges');
1154 deferredResult.addMethod(user, 'hasPendingChanges');
1155 deferredResult.addTest(false, "saving changes should return the user to a state with not changes pending - 3");
1156
1157 deferredResult.addMethod(user, 'getRecord', record_1);
1158 deferredResult.addMethodcaller('hasLoadedRemoteData');
1159 deferredResult.addTest(true, "After saving the changes, record_1 sould not have the remote data");
1160
1161 deferredResult.addMethod(user, 'getRecord', record_2);
1162 deferredResult.addMethodcaller('hasLoadedRemoteData');
1163 deferredResult.addTest(false, "After saving, record_2 should still be NOT loaded");
1164
1165
1166 deferredResult.callback();
1167
1168 return deferredResult;
1169 },
1170
1171 //-------------------------------------------------------------------------
1172
1173 'addNewRecordFieldAndSave_test': function (someTestArgs) {
1174 var deferredResult;
1175 var proxy;
1176 var user;
1177
1178 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1179 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1180
1181 deferredResult = new Clipperz.Async.Deferred("simpleSaveChanges_test", someTestArgs);
1182 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
1183 deferredResult.addMethod(user, 'login');
1184
1185 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1186 deferredResult.addMethodcaller('fields');
1187 deferredResult.addCallback(function (someFields) {
1188 SimpleTest.is(MochiKit.Base.values(someFields).length, 3, "The record has initially 3 fields");
1189 });
1190
1191 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1192 deferredResult.addCallback(MochiKit.Base.methodcaller('addField', {'label':"New field label", 'value':"New field value", 'isHidden':false}));
1193
1194 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1195 deferredResult.addMethodcaller('hasPendingChanges');
1196 deferredResult.addTest(true, "adding a field should mark the record as having pending changes");
1197
1198 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1199 deferredResult.addMethodcaller('fields');
1200 deferredResult.addCallback(function (someFields) {
1201 SimpleTest.is(MochiKit.Base.values(someFields).length, 4, "The record has now 4 fields");
1202 });
1203
1204 deferredResult.addMethod(user, 'saveChanges');
1205 deferredResult.addMethod(user, 'hasPendingChanges');
1206 deferredResult.addTest(false, "saving changes should return the user to a state with not changes pending - 4");
1207
1208 deferredResult.addMethod(user, 'hasAnyCleanTextData');
1209 deferredResult.addTest(true, "after saving changes, hasAnyCleanTextData should be true");
1210
1211//deferredResult.addCallback(function (aValue) { console.log(">>> #################################################"); return aValue});
1212 deferredResult.addMethod(user, 'deleteAllCleanTextData');
1213//deferredResult.addCallback(function (aValue) { console.log("<<< #################################################"); return aValue});
1214
1215 deferredResult.addMethod(user, 'hasAnyCleanTextData');
1216 deferredResult.addTest(false, "after deleting all clean text, hasAnyCleanTextData should be false");
1217
1218 deferredResult.callback();
1219
1220 return deferredResult;
1221 },
1222
1223 //-------------------------------------------------------------------------
1224
1225 'deleteRecordFieldAndSave_test': function (someTestArgs) {
1226 var deferredResult;
1227 var proxy;
1228 var user;
1229 var user2;
1230
1231 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1232 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1233 user2 = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1234
1235 deferredResult = new Clipperz.Async.Deferred("simpleSaveChanges_test", someTestArgs);
1236 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
1237 deferredResult.addMethod(user, 'login');
1238
1239 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1240 deferredResult.addMethodcaller('fields');
1241 deferredResult.addCallback(function (someFields) {
1242 SimpleTest.is(MochiKit.Base.values(someFields).length, 3, "The record has initially 3 fields");
1243 });
1244
1245 deferredResult.collectResults({
1246 'record': MochiKit.Base.method(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13'),
1247 'field': [
1248 MochiKit.Base.method(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13'),
1249 MochiKit.Base.methodcaller('fields'),
1250 MochiKit.Base.values,
1251 MochiKit.Base.itemgetter('0')
1252 ]
1253 })
1254 deferredResult.addCallback(function (someValues) {
1255 someValues['record'].removeField(someValues['field']);
1256 });
1257
1258 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1259 deferredResult.addMethodcaller('hasPendingChanges');
1260 deferredResult.addTest(true, "removing a field should mark the record as having pending changes");
1261
1262 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1263 deferredResult.addMethodcaller('fields');
1264 deferredResult.addCallback(function (someFields) {
1265 SimpleTest.is(MochiKit.Base.values(someFields).length, 2, "The record has now 2 fields");
1266 });
1267
1268 deferredResult.addMethod(user, 'saveChanges');
1269 deferredResult.addMethod(user, 'hasPendingChanges');
1270 deferredResult.addTest(false, "saving changes should return the user to a state with not changes pending - 5");
1271
1272 //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1273
1274 deferredResult.addMethod(user2, 'login');
1275 deferredResult.addMethod(user2, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
1276 deferredResult.addMethodcaller('fields');
1277 deferredResult.addCallback(function (someFields) {
1278 SimpleTest.is(MochiKit.Base.values(someFields).length, 2, "Once saved, the record is left with just two fields");
1279 });
1280
1281 deferredResult.callback();
1282
1283 return deferredResult;
1284 },
1285
1286 //-------------------------------------------------------------------------
1287
1288 'loadDirectLogin_test': function (someTestArgs) {
1289 var deferredResult;
1290 var proxy;
1291 var user;
1292
1293 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
1294 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
1295
1296 deferredResult = new Clipperz.Async.Deferred("loadDirectLogin_test", someTestArgs);
1297 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
1298 deferredResult.addMethod(user, 'login');
1299
1300 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
1301 deferredResult.addCallback(MochiKit.Base.methodcaller('directLogins'));
1302 deferredResult.addCallback(function (someDirectLogins) {
1303 SimpleTest.is(1, MochiKit.Base.keys(someDirectLogins).length, "the Amazon.com card has just one direct login");
1304 });
1305
1306 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
1307 deferredResult.addCallback(MochiKit.Base.methodcaller('hasPendingChanges'));
1308 deferredResult.addTest(false, "initially the record does not have any pending changes");
1309
1310 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
1311 deferredResult.addCallback(MochiKit.Base.methodcaller('directLogins'));
1312 deferredResult.addCallback(MochiKit.Base.itemgetter('03251dc1cbc5398789e4c4b45c52cfac3fcd8c1a4f19a81fa68fc6feae31d55c'));
1313 // deferredResult.addCallback(MochiKit.Base.methodcaller('runDirectLogin', true));
1314 deferredResult.addCallback(Clipperz.PM.UI.Common.Controllers.DirectLoginRunner.testDirectLogin);
1315
1316 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
1317 deferredResult.addCallback(MochiKit.Base.methodcaller('getFieldsValues'));
1318 deferredResult.addCallback(function (someFieldsValues) {
1319 SimpleTest.is(MochiKit.Base.keys(someFieldsValues).length, 2, "the Amazon.com card has just two fields");
1320 });
1321
1322 deferredResult.addMethod(user, 'getRecord', '13a5e52976337ab210903cd04872588e1b21fb72bc183e91aa25c494b8138551');
1323 deferredResult.addCallback(MochiKit.Base.methodcaller('hasPendingChanges'));
1324 deferredResult.addTest(false, "accessing fields values should not trigger the 'hasPendingChanges' flag");
1325
1326 deferredResult.callback();
1327
1328 return deferredResult;
1329 },
1330
1331 //-------------------------------------------------------------------------
1332
1333 'readingVeryOldCards_test': function (someTestArgs) {
1334 var deferredResult;
1335 var proxy;
1336 var user;
1337
1338 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true});
1339 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1340
1341 deferredResult = new Clipperz.Async.Deferred("readingVeryOldCards_test", someTestArgs);
1342 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_someExtraOldData']);
1343 deferredResult.addMethod(user, 'login');
1344
1345 deferredResult.addMethod(user, 'getRecord', '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a');
1346 deferredResult.addMethodcaller('label');
1347 deferredResult.addTest('Card encoded with an old algorithm', 'the label of the selected record is the expected one');
1348
1349 deferredResult.addMethod(user, 'getRecord', '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a');
1350 deferredResult.addCallback(MochiKit.Base.methodcaller('fields'));
1351 deferredResult.addCallback(function (someFields) {
1352 SimpleTest.is(6, MochiKit.Base.keys(someFields).length, "the 'Card encoded with an old algorithm' card has six fields");
1353 });
1354
1355 deferredResult.addMethod(user, 'getRecord', '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a');
1356 deferredResult.addMethodcaller('hasPendingChanges');
1357 deferredResult.addTest(false, "accessing the card fields should not trigger the hasPendingChanges flag");
1358
1359 deferredResult.addMethod(user, 'getRecord', '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a');
1360 deferredResult.addCallback(MochiKit.Base.methodcaller('addField', {'label':"New field label", 'value':"New field value", 'isHidden':false}));
1361
1362 deferredResult.addMethod(user, 'getRecord', '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a');
1363 deferredResult.addCallback(MochiKit.Base.methodcaller('fields'));
1364 deferredResult.addCallback(function (someFields) {
1365 SimpleTest.is(7, MochiKit.Base.keys(someFields).length, "adding a field shoult bring the total field count to 7");
1366 });
1367
1368 deferredResult.addMethod(user, 'getRecord', '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a');
1369 deferredResult.addMethodcaller('hasPendingChanges');
1370 deferredResult.addTest(true, "adding a field should mark the record as having pending changes - 2");
1371
1372 deferredResult.callback();
1373
1374 return deferredResult;
1375 },
1376
1377 //-------------------------------------------------------------------------
1378
1379 'addingNewEmptyRecordAndSaveChanges_test': function (someTestArgs) {
1380 var deferredResult;
1381 var proxy;
1382 var user;
1383 var newRecordReference;
1384
1385 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1386 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1387 user2 = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1388
1389 deferredResult = new Clipperz.Async.Deferred("addingNewEmptyRecordAndSaveChanges_test", someTestArgs);
1390 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_someExtraOldData']);
1391 deferredResult.addMethod(user, 'login');
1392
1393 deferredResult.addMethod(user, 'getRecords');
1394 deferredResult.addCallback(function (someRecords) {
1395 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 1, "The user has initially just one record");
1396 });
1397
1398 deferredResult.addMethod(user, 'createNewRecord');
1399 deferredResult.addMethodcaller('reference');
1400 deferredResult.addCallback(function (aNewRecordReference) {
1401 newRecordReference = aNewRecordReference;
1402 })
1403
1404 deferredResult.addMethod(user, 'getRecords');
1405 deferredResult.addCallback(function (someRecords) {
1406 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 2, "After having created a new record, the total should be updated accordingly");
1407 });
1408
1409 deferredResult.addMethod(user, 'getRecord', '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a');
1410 deferredResult.addMethodcaller('hasPendingChanges');
1411 deferredResult.addTest(false, "adding a new record should not trigger any changes on a sibling record");
1412
1413 deferredResult.addMethod(user, 'hasPendingChanges');
1414 deferredResult.addTest(true, "adding a new record should trigger the 'has pending changes' flag on the user");
1415
1416 deferredResult.addMethod(user, 'saveChanges');
1417
1418 deferredResult.addMethod(user2, 'login');
1419 deferredResult.addMethod(user2, 'getRecords');
1420 deferredResult.addCallback(function (someRecords) {
1421 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 1, "Reloading the data, just one record is available, as a brand new record without any changes should not be saved");
1422 });
1423
1424 deferredResult.callback();
1425
1426 return deferredResult;
1427 },
1428
1429 //-------------------------------------------------------------------------
1430
1431 'addNewRecordAndSaveChanges_test': function (someTestArgs) {
1432 var deferredResult;
1433 var proxy;
1434 var user;
1435
1436 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1437 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1438 user2 = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1439
1440 deferredResult = new Clipperz.Async.Deferred("addNewRecordAndSaveChanges_test", someTestArgs);
1441 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_someExtraOldData']);
1442 deferredResult.addMethod(user, 'login');
1443
1444 deferredResult.addMethod(user, 'getRecords');
1445 deferredResult.addCallback(function (someRecords) {
1446 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 1, "The user has initially just one record");
1447 });
1448
1449 deferredResult.addMethod(user, 'createNewRecord');
1450 deferredResult.addCallback(function (aNewRecord) {
1451 var innerDeferredResult;
1452
1453 innerDeferredResult = new Clipperz.Async.Deferred("addNewRecordAndSaveChanges_test <internal>", {trace:false});
1454
1455 innerDeferredResult.addMethod(aNewRecord, 'label');
1456 innerDeferredResult.addTest('', "The label of a brand new record should be the empty string");
1457
1458 innerDeferredResult.addMethod(aNewRecord, 'setLabel', "New record label");
1459 innerDeferredResult.addMethod(aNewRecord, 'setNotes', "New record notes");
1460 innerDeferredResult.addMethod(aNewRecord, 'addField', {'label':"Label 1", 'value':"Value 1", 'isHidden':false});
1461 innerDeferredResult.addMethod(aNewRecord, 'addField', {'label':"Label 2", 'value':"Value 2", 'isHidden':false});
1462 innerDeferredResult.addMethod(aNewRecord, 'addField', {'label':"Label 3", 'value':"Value 3", 'isHidden':true});
1463 innerDeferredResult.addMethod(aNewRecord, 'addField', {'label':"Label 4", 'value':"Value 4", 'isHidden':false});
1464 innerDeferredResult.callback();
1465
1466 return innerDeferredResult;
1467 })
1468
1469 deferredResult.addMethod(user, 'getRecords');
1470 deferredResult.addCallback(function (someRecords) {
1471 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 2, "After having created a new record, the total should be updated accordingly");
1472 });
1473
1474 deferredResult.addMethod(user, 'getRecord', '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a');
1475 deferredResult.addMethodcaller('hasPendingChanges');
1476 deferredResult.addTest(false, "adding a new record should not trigger any changes on a sibling record");
1477
1478 deferredResult.addMethod(user, 'hasPendingChanges');
1479 deferredResult.addTest(true, "adding a new record should trigger the 'has pending changes' flag on the user");
1480
1481 deferredResult.addMethod(user, 'saveChanges');
1482
1483 deferredResult.addCallback(function () {
1484 var recordData
1485 var recordVersionData;
1486
1487 recordData = MochiKit.Base.values(proxy.dataStore().data()['users']['9a984e219b07f9b645ef35f4de938b4741abe2e0b4adc88b40e9367170c91cc8']['records'])[1];
1488 recordVersionData = MochiKit.Base.values(recordData['versions'])[0];
1489
1490 SimpleTest.is(recordVersionData['previousVersionKey'], Clipperz.PM.Crypto.nullValue, "The previous version key on the first version of a newly created record is equal to Clipperz.PM.Crypto.nullValue");
1491 });
1492
1493 deferredResult.addMethod(user2, 'login');
1494 deferredResult.addMethod(user2, 'getRecords');
1495 deferredResult.addCallback(function (someRecords) {
1496 SimpleTest.is(someRecords.length, 2, "Reloading the data, two records are available.");
1497 return someRecords;
1498 });
1499 deferredResult.addCallback(MochiKit.Base.itemgetter('1'));
1500 deferredResult.collectResults({
1501 'label':[
1502 MochiKit.Base.methodcaller('label'),
1503 Clipperz.Async.Test.is("New record label", "The label is correct")
1504 ],
1505 'notes':[
1506 MochiKit.Base.methodcaller('notes'),
1507 Clipperz.Async.Test.is("New record notes", "The note is correct")
1508 ],
1509 'fields':[
1510 MochiKit.Base.methodcaller('fields'),
1511 function (someFields) {
1512 SimpleTest.is(MochiKit.Base.values(someFields).length, 4, "The fields are 4, as expected");
1513 return someFields;
1514 }
1515 ]
1516 })
1517
1518 deferredResult.callback();
1519
1520 return deferredResult;
1521 },
1522
1523 //-------------------------------------------------------------------------
1524
1525 'addNewRecordAndTestNewRecordIndex_test': function (someTestArgs) {
1526 var deferredResult;
1527 var proxy;
1528 var user;
1529
1530 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1531 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
1532
1533 deferredResult = new Clipperz.Async.Deferred("addNewRecordAndTestNewRecordIndex_test", someTestArgs);
1534 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
1535 deferredResult.addMethod(user, 'login');
1536
1537 deferredResult.addMethod(user, 'getRecords');
1538 deferredResult.addCallback(function (someRecords) {
1539 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 20, "The user has initially 20 records");
1540 });
1541
1542 deferredResult.addMethod(user, 'createNewRecord');
1543 deferredResult.addCallback(function (aNewRecord) {
1544 var innerDeferredResult;
1545
1546 innerDeferredResult = new Clipperz.Async.Deferred("addNewRecordAndTestNewRecordIndex_test <internal>", {trace:false});
1547
1548 innerDeferredResult.addMethod(user, 'getHeaderIndex', 'recordsIndex');
1549 innerDeferredResult.addMethodcaller('recordsIndex');
1550 innerDeferredResult.addCallback(MochiKit.Base.itemgetter(aNewRecord.reference()));
1551 innerDeferredResult.addTest(20, "The index of the new record should be 20");
1552
1553 innerDeferredResult.callback();
1554
1555 return innerDeferredResult;
1556 })
1557
1558 deferredResult.callback();
1559
1560 return deferredResult;
1561 },
1562
1563 //-------------------------------------------------------------------------
1564
1565 'editRecordAndTestForChangesInPreferencesAndOTP_test': function (someTestArgs) {
1566 var deferredResult;
1567 var proxy;
1568 var user;
1569 var user_2;
1570 var originalPreferences;
1571 var originalOTPs;
1572
1573 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1574 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
1575 user_2 = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
1576
1577 deferredResult = new Clipperz.Async.Deferred("editRecordAndTestForChangesInPreferencesAndOTP_test", someTestArgs);
1578 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_with_preferences_and_OTPs_data']);
1579 deferredResult.addMethod(user, 'login');
1580 deferredResult.addMethod(user, 'getServerData');
1581
1582 deferredResult.collectResults({
1583 'preferences': [
1584 MochiKit.Base.method(user, 'getHeaderIndex', 'preferences'),
1585 MochiKit.Base.methodcaller('getDecryptedData')
1586 ],
1587 'oneTimePasswords': [
1588 MochiKit.Base.method(user, 'getHeaderIndex', 'oneTimePasswords'),
1589 MochiKit.Base.methodcaller('getDecryptedData')
1590 ]
1591 });
1592
1593 deferredResult.addCallback(function (someValues) {
1594//console.log("SOME VALUES", someValues);
1595 originalPreferences = Clipperz.Base.deepClone(someValues['preferences']);
1596 originalOTPs = Clipperz.Base.deepClone(someValues['oneTimePasswords']);
1597
1598 SimpleTest.is(originalPreferences['preferredLanguage'], 'en-US', "Preference.language is ok");
1599 SimpleTest.is(originalPreferences['shouldShowDonationPanel'], false, "Preference.shouldShowDonationPanel is ok");
1600
1601 SimpleTest.is(MochiKit.Base.keys(originalOTPs).length, 6, "the number of OTPs is as expected");
1602 });
1603
1604 deferredResult.addMethod(user, 'getRecord', '35b30f9e923ce913365815d44cf344ce66cb71b636093b8ec55b8245d13df82b');
1605 deferredResult.addCallback(MochiKit.Base.methodcaller('setLabel', "NEW LABEL"));
1606 deferredResult.addMethod(user, 'saveChanges');
1607
1608 deferredResult.addMethod(user_2, 'login');
1609 deferredResult.addMethod(user_2, 'getServerData');
1610
1611 deferredResult.collectResults({
1612 'preferences': [
1613 MochiKit.Base.method(user_2, 'getHeaderIndex', 'preferences'),
1614 MochiKit.Base.methodcaller('getDecryptedData')
1615 ],
1616 'oneTimePasswords': [
1617 MochiKit.Base.method(user_2, 'getHeaderIndex', 'oneTimePasswords'),
1618 MochiKit.Base.methodcaller('getDecryptedData')
1619 ]
1620 });
1621
1622 deferredResult.addCallback(function (someValues) {
1623//console.log("SOME VALUES", someValues);
1624 // originalPreferences = Clipperz.Base.deepClone(someValues['preferences']);
1625 // originalOTPs = Clipperz.Base.deepClone(someValues['oneTimePasswords']);
1626
1627 SimpleTest.is(someValues['preferences']['preferredLanguage'], originalPreferences['preferredLanguage'], "Preference.language is preserved");
1628 SimpleTest.is(someValues['preferences']['shouldShowDonationPanel'], originalPreferences['shouldShowDonationPanel'], "Preference.shouldShowDonationPanel is preserved");
1629
1630 SimpleTest.is(MochiKit.Base.keys(someValues['oneTimePasswords']).length, MochiKit.Base.keys(originalOTPs).length, "the number of OTPs is preserved");
1631 });
1632
1633 deferredResult.callback();
1634
1635 return deferredResult;
1636 },
1637
1638 //-------------------------------------------------------------------------
1639
1640 'addRecordAndSaveChangesMultipleTimes_test': function (someTestArgs) {
1641 var deferredResult;
1642 var proxy;
1643 var user;
1644
1645 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1646 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1647 user2 = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1648
1649 deferredResult = new Clipperz.Async.Deferred("addRecordAndSaveChangesMultipleTimes_test", someTestArgs);
1650 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_someExtraOldData']);
1651 deferredResult.addMethod(user, 'login');
1652
1653 deferredResult.addMethod(user, 'getRecords');
1654 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
1655 deferredResult.addTest(1, "The user has one record stored in its account");
1656
1657 deferredResult.addMethod(user, 'hasPendingChanges');
1658 deferredResult.addTest(false, "After loading records, the user should have no pending changes");
1659
1660 deferredResult.addMethod(user, 'createNewRecord');
1661 deferredResult.addCallback(function (aNewRecord) {
1662 var innerDeferredResult;
1663
1664 innerDeferredResult = new Clipperz.Async.Deferred("addRecordAndSaveChangesMultipleTimes_test <internal [1]>", {trace:false});
1665
1666 innerDeferredResult.addMethod(aNewRecord, 'setLabel', "New record 1");
1667 innerDeferredResult.addMethod(aNewRecord, 'addField', {'label':'record number', 'value':"1", 'isHidden':false});
1668 innerDeferredResult.addMethod(aNewRecord, 'addField', {'label':'field count', 'value':"2", 'isHidden':false});
1669 innerDeferredResult.callback();
1670
1671 return innerDeferredResult;
1672 })
1673
1674 deferredResult.addMethod(user, 'hasPendingChanges');
1675 deferredResult.addTest(true, "Before saving, the user has pending changes");
1676
1677 deferredResult.addMethod(user, 'saveChanges');
1678 deferredResult.addCallback(SimpleTest.ok, true, "Saving worked (apparently) fine");
1679
1680 deferredResult.addMethod(user, 'hasPendingChanges');
1681 deferredResult.addTest(false, "After saving, the user has no pending changes");
1682
1683 deferredResult.addMethod(user, 'createNewRecord');
1684 deferredResult.addCallback(function (aNewRecord) {
1685 var innerDeferredResult;
1686
1687 innerDeferredResult = new Clipperz.Async.Deferred("addRecordAndSaveChangesMultipleTimes_test <internal [2]>", {trace:false});
1688
1689 innerDeferredResult.addMethod(aNewRecord, 'setLabel', "New record 2");
1690 innerDeferredResult.addMethod(aNewRecord, 'addField', {'label':"record number", 'value':"2", 'isHidden':false});
1691 innerDeferredResult.callback();
1692
1693 return innerDeferredResult;
1694 })
1695 deferredResult.addMethod(user, 'saveChanges');
1696
1697 deferredResult.addMethod(user, 'getRecords');
1698 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
1699 deferredResult.addTest(3, "After having created two new records, the total should be updated accordingly");
1700
1701
1702 deferredResult.addMethod(user2, 'login');
1703 deferredResult.addMethod(user2, 'getRecords');
1704 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
1705 deferredResult.addTest(3, "Reloading the data, three records are available");
1706
1707 deferredResult.addMethod(user2, 'recordWithLabel', 'New record 1');
1708//deferredResult.addCallback(function (aValue) { console.log("RECORD with Label", aValue); return aValue; });
1709 deferredResult.collectResults({
1710 'label':[
1711 MochiKit.Base.methodcaller('label'),
1712 MochiKit.Base.partial(Clipperz.Async.Test.is, 'New record label', "The label is correct")
1713 ],
1714 'notes':[
1715 MochiKit.Base.methodcaller('notes'),
1716 Clipperz.Async.Test.is('', "The note of the new created record is empty")
1717 ],
1718 'fields':[
1719 MochiKit.Base.methodcaller('fields'),
1720 MochiKit.Base.values,
1721 MochiKit.Base.itemgetter('length'),
1722 Clipperz.Async.Test.is(2, "The new record has just one field, as expected")
1723 ],
1724 'fieldValues_1': [
1725 MochiKit.Base.methodcaller('fieldWithLabel', 'record number'),
1726 MochiKit.Base.methodcaller('value'),
1727 Clipperz.Async.Test.is('1', "The field value is as expected")
1728 ],
1729 'fieldValues_2': [
1730 MochiKit.Base.methodcaller('fieldWithLabel', 'field count'),
1731 MochiKit.Base.methodcaller('value'),
1732 Clipperz.Async.Test.is('2', "Also the second field value is as expected")
1733 ]
1734 })
1735
1736 deferredResult.callback();
1737
1738 return deferredResult;
1739 },
1740
1741 //-------------------------------------------------------------------------
1742
1743 'addNewRecordAndRevertChanges_test': function (someTestArgs) {
1744 var deferredResult;
1745 var proxy;
1746 var user, user2;
1747
1748 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1749 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1750 user2 = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
1751
1752 deferredResult = new Clipperz.Async.Deferred("addNewRecordAndRevertChanges_test", someTestArgs);
1753 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_someExtraOldData']);
1754 deferredResult.addMethod(user, 'login');
1755
1756 deferredResult.addMethod(user, 'getRecords');
1757 deferredResult.addCallback(function (someRecords) {
1758 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 1, "The user has initially just one record");
1759 });
1760
1761 deferredResult.addMethod(user, 'createNewRecord');
1762 deferredResult.addCallback(function (aNewRecord) {
1763 returnClipperz.Async.callbacks("addNewRecordAndRevertChanges_test <internal>", [
1764 MochiKit.Base.method(aNewRecord, 'setLabel', "New record label"),
1765 MochiKit.Base.method(aNewRecord, 'setNotes', "New record notes"),
1766 MochiKit.Base.method(aNewRecord, 'addField', {'label':"Label 1", 'value':"Value 1", 'isHidden':false}),
1767 MochiKit.Base.method(aNewRecord, 'addField', {'label':"Label 2", 'value':"Value 2", 'isHidden':false}),
1768 MochiKit.Base.method(aNewRecord, 'addField', {'label':"Label 3", 'value':"Value 3", 'isHidden':true}),
1769 MochiKit.Base.method(aNewRecord, 'addField', {'label':"Label 4", 'value':"Value 4", 'isHidden':false})
1770 ], {trace:false});
1771 })
1772
1773 deferredResult.addMethod(user, 'getRecords');
1774 deferredResult.addCallback(function (someRecords) {
1775 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 2, "After having created a new record, the total should be updated accordingly");
1776 });
1777
1778 deferredResult.addMethod(user, 'getRecord', '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a');
1779 deferredResult.addMethodcaller('hasPendingChanges');
1780 deferredResult.addTest(false, "adding a new record should not trigger any changes on a sibling record");
1781
1782 deferredResult.addMethod(user, 'hasPendingChanges');
1783 deferredResult.addTest(true, "adding a new record should trigger the 'has pending changes' flag on the user");
1784
1785 deferredResult.addMethod(user, 'revertChanges');
1786 deferredResult.addMethod(user, 'hasPendingChanges');
1787 deferredResult.addTest(false, "reverting changes shoud restore the previous state on the user");
1788
1789 deferredResult.addMethod(user2, 'login');
1790 deferredResult.addMethod(user2, 'getRecords');
1791 deferredResult.addCallback(function (someRecords) {
1792 SimpleTest.is(someRecords.length, 1, "Reloading the data, just one record is available.");
1793 return someRecords;
1794 });
1795
1796 deferredResult.callback();
1797
1798 return deferredResult;
1799 },
1800
1801 //-------------------------------------------------------------------------
1802
1803 'logout_test': function (someTestArgs) {
1804 var deferredResult;
1805 var proxy;
1806 var user;
1807
1808 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1809 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
1810
1811 deferredResult = new Clipperz.Async.Deferred("logout_test", someTestArgs);
1812 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_with_preferences_and_OTPs_data']);
1813 deferredResult.addMethod(user, 'login');
1814
1815 deferredResult.addMethod(user, 'getRecords');
1816 deferredResult.addCallback(function (someRecords) {
1817 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 18, "The user has 18 records");
1818 });
1819
1820 deferredResult.addMethod(user, 'logout');
1821 deferredResult.shouldSucceed("Logging out should not trigger an exception");
1822
1823 deferredResult.callback();
1824
1825 return deferredResult;
1826 },
1827
1828 //-------------------------------------------------------------------------
1829
1830 'lock_test': function (someTestArgs) {
1831 var deferredResult;
1832 var proxy;
1833 var user;
1834 var returnPassword= function () { return MochiKit.Async.succeed('clipperz'); };
1835 var failPassword= function () { throw "Unexpected access to the password"; };
1836 var currentPasswordFunction = returnPassword;
1837 var passwordFunction = function () { return currentPasswordFunction(); };
1838
1839
1840 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1841 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:passwordFunction});
1842
1843 deferredResult = new Clipperz.Async.Deferred("lock_test", someTestArgs);
1844 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_with_preferences_and_OTPs_data']);
1845
1846 deferredResult.addMethod(user, 'login');
1847
1848 deferredResult.addMethod(user, 'getRecords');
1849 deferredResult.addCallback(function (someRecords) {
1850 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 18, "The user has 18 records");
1851 });
1852
1853 deferredResult.addMethod(user, 'getDirectLogins');
1854 deferredResult.addCallback(function (someDirectLogins) {
1855 SimpleTest.is(MochiKit.Base.keys(someDirectLogins).length, 22, "The user has 22 direct logins");
1856 });
1857
1858 deferredResult.addMethod(proxy, 'shouldNotReceiveAnyFurtherRequest');
1859 deferredResult.addCallback(function () { currentPasswordFunction = failPassword; });
1860
1861 deferredResult.addMethod(user, 'lock');
1862 deferredResult.shouldSucceed("Locking out should not trigger an exception");
1863
1864 deferredResult.addMethod(proxy, 'unexpectedRequests');
1865 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
1866 deferredResult.addTest(0, "The proxy should have not received any extra request");
1867//deferredResult.addCallback(function (aValue) { console.log("PROXY.unexpectedRequests", Clipperz.Base.serializeJSON(proxy.unexpectedRequests())); return aValue; });
1868 deferredResult.addMethod(proxy, 'mayReceiveMoreRequests');
1869 deferredResult.addCallback(function () { currentPasswordFunction = returnPassword; });
1870
1871 deferredResult.callback();
1872
1873 return deferredResult;
1874 },
1875
1876 //-------------------------------------------------------------------------
1877
1878 'registerNewUser_test': function (someTestArgs) {
1879 var deferredResult;
1880 var proxy;
1881 var user, user2;
1882 var username;
1883 var passphrase;
1884
1885 username = "new";
1886 passphrase = "user";
1887
1888 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1889 // user2 = new Clipperz.PM.DataModel.User({username:username, getPassphraseFunction:function () { return MochiKit.Async.succeed(passphrase);}});
1890 user2 = new Clipperz.PM.DataModel.User({username:username, getPassphraseFunction:function () { return passphrase;}});
1891
1892 deferredResult = new Clipperz.Async.Deferred("registerNewUser_test", someTestArgs);
1893 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_with_preferences_and_OTPs_data']);
1894
1895 deferredResult.addCallback(Clipperz.PM.DataModel.User.registerNewAccount, username, function () { return MochiKit.Async.succeed(passphrase);});
1896 deferredResult.setValue('user');
1897
1898 deferredResult.addMethodcaller('getRecords');
1899 deferredResult.addCallback(function (someRecords) {
1900 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 0, "The newly created user has no records");
1901 });
1902 deferredResult.getValue('user');
1903 deferredResult.addMethodcaller('logout');
1904
1905 deferredResult.addMethod(user2, 'login');
1906 deferredResult.addMethod(user2, 'getDirectLogins');
1907 deferredResult.addCallback(function (someDirectLogins) {
1908 SimpleTest.is(MochiKit.Base.keys(someDirectLogins).length, 0, "The user has no direct logins");
1909 });
1910
1911 deferredResult.callback();
1912
1913 return deferredResult;
1914 },
1915
1916 //-------------------------------------------------------------------------
1917
1918 'registerNewUserAndAddARecord_test': function (someTestArgs) {
1919 var deferredResult;
1920 var proxy;
1921 var user, user2;
1922 var username;
1923 var passphrase;
1924
1925 username = "new";
1926 passphrase = "user";
1927
1928 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1929 user2 = new Clipperz.PM.DataModel.User({username:username, getPassphraseFunction:function () { return passphrase;}});
1930
1931 deferredResult = new Clipperz.Async.Deferred("registerNewUserAndAddARecord_test", someTestArgs);
1932 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_with_preferences_and_OTPs_data']);
1933
1934 deferredResult.addCallback(Clipperz.PM.DataModel.User.registerNewAccount, username, function () { return MochiKit.Async.succeed(passphrase);});
1935 deferredResult.setValue('user');
1936
1937 deferredResult.addMethodcaller('getRecords');
1938 deferredResult.addCallback(function (someRecords) {
1939 SimpleTest.is(MochiKit.Base.keys(someRecords).length, 0, "The newly created user has no records");
1940 });
1941
1942 deferredResult.getValue('user');
1943 deferredResult.addMethodcaller('createNewRecord');
1944 deferredResult.addCallback(function (aNewRecord) {
1945 var innerDeferredResult;
1946
1947 innerDeferredResult = new Clipperz.Async.Deferred("addRecordAndSaveChangesMultipleTimes_test <internal [1]>", {trace:false});
1948
1949 innerDeferredResult.addMethod(aNewRecord, 'setLabel', "New record 1");
1950 innerDeferredResult.addMethod(aNewRecord, 'addField', {'label':'record number', 'value':"1", 'isHidden':false});
1951 innerDeferredResult.addMethod(aNewRecord, 'addField', {'label':'field count', 'value':"2", 'isHidden':false});
1952 innerDeferredResult.callback();
1953
1954 return innerDeferredResult;
1955 })
1956
1957 deferredResult.getValue('user');
1958 deferredResult.addMethodcaller('saveChanges');
1959 deferredResult.addCallback(SimpleTest.ok, true, "Saving worked (apparently) fine");
1960
1961
1962 deferredResult.getValue('user');
1963 deferredResult.addMethodcaller('logout');
1964
1965 deferredResult.addMethod(user2, 'login');
1966 deferredResult.addMethod(user2, 'getRecords');
1967 deferredResult.addCallback(function (someDirectLogins) {
1968 SimpleTest.is(MochiKit.Base.keys(someDirectLogins).length, 1, "The user - even after a brand new login - has the newly created record");
1969 });
1970
1971 deferredResult.callback();
1972
1973 return deferredResult;
1974 },
1975
1976 //-------------------------------------------------------------------------
1977
1978 'changePassphrase_test': function (someTestArgs) {
1979 var deferredResult;
1980 var proxy;
1981 var user;
1982 var user2;
1983 var newPassphrase;
1984
1985 newPassphrase = 'zreppilc';
1986 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
1987 user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}});
1988 user2 = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return newPassphrase;}});
1989
1990 deferredResult = new Clipperz.Async.Deferred("changePassphrase_test", someTestArgs);
1991 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']);
1992
1993 deferredResult.addMethod(user, 'login');
1994
1995 deferredResult.addMethod(user, 'getRecords');
1996 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
1997 deferredResult.addTest(20, "This account has oly a single card");
1998
1999 deferredResult.addMethod(user, 'changePassphrase', newPassphrase);
2000 deferredResult.addMethod(user, 'logout');
2001
2002 deferredResult.addMethod(user2, 'login');
2003 deferredResult.addMethod(user2, 'getRecords');
2004 deferredResult.addCallback(MochiKit.Base.itemgetter('length'));
2005 deferredResult.addTest(20, "This account has oly a single card");
2006
2007 deferredResult.callback();
2008
2009 return deferredResult;
2010 },
2011
2012 //-------------------------------------------------------------------------
2013/*
2014 'rearrangeRecordFieldOrderAndSave_test': function (someTestArgs) {
2015 var deferredResult;
2016 var proxy;
2017 var user;
2018
2019 proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:true, isDefault:true, readOnly:false});
2020 user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}});
2021
2022 deferredResult = new Clipperz.Async.Deferred("simpleSaveChanges_test", someTestArgs);
2023 deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_offline_copy_data']);
2024 deferredResult.addMethod(user, 'login');
2025
2026 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
2027 deferredResult.addMethodcaller('fields');
2028 deferredResult.addCallback(function (someFields) {
2029 var fields;
2030
2031 fields = MochiKit.Base.values(someFields);
2032 SimpleTest.is(fields.length, 3, "The record has initially 3 fields");
2033 SimpleTest.is(fields[0].reference(), '6a84c414866dd6d266186f0255a595e9330fb34973c085a81a6e4906876c721b', "the first field is the expected one");
2034 SimpleTest.is(fields[1].reference(), 'fde88847cdbae6f7ee7e38aca1a242492888ff430a79c997bc6ba4afd0540ca2', "the second field is the expected one");
2035 SimpleTest.is(fields[2].reference(), 'bd4e3bb9d3497f63c4c3a507d4b80f489fdb57deb9d1b342a5e1cff65936a410', "the third field is the expected one");
2036 });
2037
2038 // "6a84c414866dd6d266186f0255a595e9330fb34973c085a81a6e4906876c721b": {
2039 // "label":"Label 1","value":"Value 1","type":"TXT","hidden":false
2040 // },
2041 // "fde88847cdbae6f7ee7e38aca1a242492888ff430a79c997bc6ba4afd0540ca2": {
2042 // "label":"Label 2","value":"Value 2","type":"PWD","hidden":true
2043 // },
2044 // "bd4e3bb9d3497f63c4c3a507d4b80f489fdb57deb9d1b342a5e1cff65936a410": {
2045 // "label":"Label 3","value":"http://www.example.com","type":"URL","hidden":false
2046 // }
2047
2048 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
2049 deferredResult.addCallback(MochiKit.Base.methodcaller('sortFieldReference', [
2050 'bd4e3bb9d3497f63c4c3a507d4b80f489fdb57deb9d1b342a5e1cff65936a410',
2051 '6a84c414866dd6d266186f0255a595e9330fb34973c085a81a6e4906876c721b',
2052 'bd4e3bb9d3497f63c4c3a507d4b80f489fdb57deb9d1b342a5e1cff65936a410'
2053 ]));
2054
2055 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
2056 deferredResult.addMethodcaller('hasPendingChanges');
2057 deferredResult.addTest(true, "adding a field should mark the record as having pending changes");
2058
2059 deferredResult.addMethod(user, 'getRecord', '8280842f41162b673335b63860637e8472e8bbff0efa2bc78b0dbc5e09712e13');
2060 deferredResult.addMethodcaller('fields');
2061 deferredResult.addCallback(function (someFields) {
2062 SimpleTest.is(MochiKit.Base.values(someFields).length, 4, "The record has now 4 fields");
2063 });
2064
2065 deferredResult.addMethod(user, 'saveChanges');
2066 deferredResult.addMethod(user, 'hasPendingChanges');
2067 deferredResult.addTest(false, "saving changes should return the user to a state with not changes pending - 4");
2068
2069 deferredResult.callback();
2070
2071 return deferredResult;
2072 },
2073*/
2074 //-------------------------------------------------------------------------
2075 'syntaxFix': MochiKit.Base.noop
2076};
2077
2078
2079
2080//#############################################################################
2081
2082SimpleTest.runDeferredTests("Clipperz.PM.DataModel.User", tests, {trace:false});