Diffstat (limited to 'frontend/gamma/tests/tests/Clipperz/PM/DataModel/User.test.js') (more/less context) (ignore whitespace changes)
-rw-r--r-- | frontend/gamma/tests/tests/Clipperz/PM/DataModel/User.test.js | 2082 |
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 | |||
3 | Copyright 2008-2011 Clipperz Srl | ||
4 | |||
5 | This file is part of Clipperz's Javascript Crypto Library. | ||
6 | Javascript Crypto Library provides web developers with an extensive | ||
7 | and efficient set of cryptographic functions. The library aims to | ||
8 | obtain maximum execution speed while preserving modularity and | ||
9 | reusability. | ||
10 | For further information about its features and functionalities please | ||
11 | refer 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 | |||
29 | Clipperz.Crypto.PRNG.defaultRandomGenerator().fastEntropyAccumulationForTestingPurpose(); | ||
30 | |||
31 | var 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 | |||
2082 | SimpleTest.runDeferredTests("Clipperz.PM.DataModel.User", tests, {trace:false}); | ||