Diffstat (limited to 'frontend/gamma/tests/tests/Clipperz/PM/DataModel/Record.test.js') (more/less context) (show whitespace changes)
-rw-r--r-- | frontend/gamma/tests/tests/Clipperz/PM/DataModel/Record.test.js | 1285 |
1 files changed, 1285 insertions, 0 deletions
diff --git a/frontend/gamma/tests/tests/Clipperz/PM/DataModel/Record.test.js b/frontend/gamma/tests/tests/Clipperz/PM/DataModel/Record.test.js new file mode 100644 index 0000000..7d024d9 --- a/dev/null +++ b/frontend/gamma/tests/tests/Clipperz/PM/DataModel/Record.test.js | |||
@@ -0,0 +1,1285 @@ | |||
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 | 'recordUseOf_retrieveIndexDataFunction_and_getRemoteDataFunction_test': function (someTestArgs) { | ||
36 | var deferredResult; | ||
37 | var record; | ||
38 | |||
39 | //console.log("#### new Clipperz.PM.DataModel.Record [5]"); | ||
40 | record = new Clipperz.PM.DataModel.Record({ | ||
41 | 'reference': '<<< record reference >>>', | ||
42 | 'retrieveKeyFunction': MochiKit.Base.noop, | ||
43 | 'retrieveRemoteDataFunction': function (aRecordReference) { | ||
44 | SimpleTest.is(aRecordReference, '<<< record reference >>>', "Record correctly passes its record reference when asking for encrypted data"); | ||
45 | return MochiKit.Async.succeed({ | ||
46 | // fake server payload | ||
47 | 'data': "#### fake encrypted data ####", | ||
48 | 'version': "0.x", | ||
49 | 'currentVersion': { | ||
50 | 'reference': "<<< fake record version reference >>>", | ||
51 | 'data': "#### fake encrypted data ####", | ||
52 | 'version': "0.x" | ||
53 | } | ||
54 | }); | ||
55 | }, | ||
56 | 'updateDate': "Thu, 10 May 2007 13:01:21 UTC", | ||
57 | // 'encryptedDataKeypath': 'data', | ||
58 | // 'encryptedVersionKeypath': 'version', | ||
59 | |||
60 | 'retrieveIndexDataFunction':function (aRecordReference) { | ||
61 | SimpleTest.is(aRecordReference, '<<< record reference >>>', "Record correctly passes its record reference when asking for index data"); | ||
62 | return MochiKit.Async.succeed({ | ||
63 | key:'<< key >>', | ||
64 | label:'<< label >>', | ||
65 | notes:'<< notes >>' | ||
66 | }); | ||
67 | }, | ||
68 | 'updateIndexDataFunction': MochiKit.Base.noop | ||
69 | |||
70 | }); | ||
71 | |||
72 | deferredResult = new Clipperz.Async.Deferred("recordUseOf_retrieveIndexDataFunction_and_getEncryptedDataFunction_test", someTestArgs); | ||
73 | deferredResult.addMethod(record, 'label'); | ||
74 | deferredResult.addTest('<< label >>', "Record returns the right value for label"); | ||
75 | deferredResult.addMethod(record, 'notes'); | ||
76 | deferredResult.addTest('<< notes >>', "Record returns the right value for notes - even the legacy one, stored on the header"); | ||
77 | deferredResult.addMethod(record, 'getRemoteData'); | ||
78 | deferredResult.addCallback(Clipperz.Async.Test.isDeeply({ 'data': "#### fake encrypted data ####", 'version': "0.x", 'currentVersion': { 'reference': "<<< fake record version reference >>>", 'data': "#### fake encrypted data ####", 'version': "0.x" } }, "Record returns the expected encrypted data")); | ||
79 | deferredResult.callback(); | ||
80 | |||
81 | return deferredResult; | ||
82 | }, | ||
83 | |||
84 | //------------------------------------------------------------------------- | ||
85 | |||
86 | 'createRecordWithoutAllRequiredParameters_test': function (someTestArgs) { | ||
87 | varrecord; | ||
88 | |||
89 | try { | ||
90 | //console.log("#### new Clipperz.PM.DataModel.Record [6]"); | ||
91 | record = new Clipperz.PM.DataModel.Record({reference:'--'}); | ||
92 | SimpleTest.ok(false, "creating a record without all parameters should raise an exception"); | ||
93 | } catch(exception) { | ||
94 | // SimpleTest.is(exception.name, "Clipperz.Base.exception.MandatoryParameter", "creating a record without all parameters raises an exception"); | ||
95 | SimpleTest.ok(/Clipperz\.Base\.exception\.MandatoryParameter.*/.test(exception.name), "creating a record without all parameters raises an exception"); | ||
96 | } | ||
97 | }, | ||
98 | |||
99 | //------------------------------------------------------------------------- | ||
100 | |||
101 | 'recordFromOldData_version_0.1_test': function (someTestArgs) { | ||
102 | var deferredResult; | ||
103 | var proxy; | ||
104 | var user; | ||
105 | var recordID; | ||
106 | |||
107 | //console.log("#### new Clipperz.PM.DataModel.Record [7]"); | ||
108 | /* | ||
109 | record = new Clipperz.PM.DataModel.Record({ | ||
110 | 'reference':'05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a', | ||
111 | 'retrieveKeyFunction': MochiKit.Base.partial(MochiKit.Async.succeed, 'e038652297f981d5ca917d88fa2c4c3251a12c0fa41bf7313a4d24a9738fe6c6'), | ||
112 | 'retrieveRemoteDataFunction':MochiKit.Base.partial(MochiKit.Async.succeed, { | ||
113 | 'data': '4ec19a7093534e7dcf7c796b889283c6cec224b1895720ba3ff43ce091dc72c61fd5ea56def418ba3f15239f73228c6c8558585311f5e6673efe57482a1f9c9fe71e921576989eace671ec543685e3ad8f976bbfa4c2dbc629fab936c227d4fd4da3a1561ea79e553bae7b758ff91762572c1448a2d18bec797e12721238ef5ba18ddf1fba8ae773a8debe1040b3b158220aec6be9c7190687139f589a30d9c8887792fd7040e3c7cf3f9999fb9dde1f9f334d17c996996d538a7e374ac93135acafdaf5fce738a1702182897b63d2cb8e308b94156473cba63dcc557d17dcbdb55fcff63d9ba5edf68c42855052e34207d6fabe94fe024c3db616b45f494da42c62224d3897e320080072cc442d4212e7b1e8d5b3d9e3c25d48f4e7c37112ef4c6b2c0c8aff0bd3ce05694370e4378701463dde26c7c0322f8a9eb5a724106039b16b35050a9a9b5717b2eec803efa962b88b9655742f5e7b180ea567449671fb5a2ce563d8b47bc25705821938192eae420391c208182a788dd06fb6448b9858a4104a14efd7717671c65cd08fd979a4da7c01712bc5d4e949a10ef1ea65caf1f07cee34b063bab01bfb7a59047fef30c3059ea652f1c92b9e72aac515ac8851756703772e1fa05384ee7f0d5c7a3c', | ||
114 | 'version': '0.1', | ||
115 | 'currentVersion': { | ||
116 | 'reference': '05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a', | ||
117 | 'data': '4ec19a7093534e7dcf7c796b889283c6cec224b1895720ba3ff43ce091dc72c61fd5ea56def418ba3f15239f73228c6c8558585311f5e6673efe57482a1f9c9fe71e921576989eace671ec543685e3ad8f976bbfa4c2dbc629fab936c227d4fd4da3a1561ea79e553bae7b758ff91762572c1448a2d18bec797e12721238ef5ba18ddf1fba8ae773a8debe1040b3b158220aec6be9c7190687139f589a30d9c8887792fd7040e3c7cf3f9999fb9dde1f9f334d17c996996d538a7e374ac93135acafdaf5fce738a1702182897b63d2cb8e308b94156473cba63dcc557d17dcbdb55fcff63d9ba5edf68c42855052e34207d6fabe94fe024c3db616b45f494da42c62224d3897e320080072cc442d4212e7b1e8d5b3d9e3c25d48f4e7c37112ef4c6b2c0c8aff0bd3ce05694370e4378701463dde26c7c0322f8a9eb5a724106039b16b35050a9a9b5717b2eec803efa962b88b9655742f5e7b180ea567449671fb5a2ce563d8b47bc25705821938192eae420391c208182a788dd06fb6448b9858a4104a14efd7717671c65cd08fd979a4da7c01712bc5d4e949a10ef1ea65caf1f07cee34b063bab01bfb7a59047fef30c3059ea652f1c92b9e72aac515ac8851756703772e1fa05384ee7f0d5c7a3c', | ||
118 | 'version': '0.1' | ||
119 | } | ||
120 | |||
121 | }), | ||
122 | |||
123 | 'retrieveIndexDataFunction':MochiKit.Base.partial(MochiKit.Async.succeed, { | ||
124 | // 'key': 'e038652297f981d5ca917d88fa2c4c3251a12c0fa41bf7313a4d24a9738fe6c6', | ||
125 | 'label': '<< label >>', | ||
126 | 'notes': '<< notes >>' | ||
127 | }), | ||
128 | 'updateIndexDataFunction': MochiKit.Base.noop, | ||
129 | 'updateDate': 'Mon Oct 02 10:01:52 CEST 2006' | ||
130 | }); | ||
131 | */ | ||
132 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
133 | user = new Clipperz.PM.DataModel.User({username:'test', getPassphraseFunction:function () { return 'test';}}); | ||
134 | recordID = "05aad20ee399b11ddc923e601fcd1d096233634f2ad4c55db4f6435e5f9cc17a"; | ||
135 | |||
136 | deferredResult = new Clipperz.Async.Deferred("recordFromOldData_version_0.1_test", someTestArgs); | ||
137 | |||
138 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['test_test_someExtraOldData']); | ||
139 | deferredResult.addMethod(user, 'login'); | ||
140 | |||
141 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
142 | deferredResult.addMethodcaller('hasAnyCleanTextData'); | ||
143 | deferredResult.addTest(false, "When first loaded, the record has no clean text data"); | ||
144 | |||
145 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
146 | deferredResult.addMethodcaller('label'); | ||
147 | deferredResult.addTest("Card encoded with an old algorithm", "Record returns the right value for label"); | ||
148 | |||
149 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
150 | deferredResult.addMethodcaller('notes'); | ||
151 | deferredResult.addTest("", "Record returns the right value for notes - even the legacy one, stored on the header"); | ||
152 | |||
153 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
154 | deferredResult.addMethodcaller('hasAnyCleanTextData'); | ||
155 | deferredResult.addTest(true, "After reading some values, the record has some clean text data"); | ||
156 | |||
157 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
158 | deferredResult.addMethodcaller('fields'); | ||
159 | deferredResult.addCallback(function (someFields) { | ||
160 | SimpleTest.is(MochiKit.Base.values(someFields).length, 6, "the card has 6 fields"); | ||
161 | }); | ||
162 | deferredResult.callback(); | ||
163 | |||
164 | return deferredResult; | ||
165 | |||
166 | }, | ||
167 | |||
168 | //------------------------------------------------------------------------- | ||
169 | |||
170 | 'removeDirectLogin': function (someTestArgs) { | ||
171 | var deferredResult; | ||
172 | var proxy; | ||
173 | var user; | ||
174 | |||
175 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; //YAHOO (4) | ||
176 | var directLoginID ='dba0db679802f0e6aa6d0b7a6aaf42350aabc5f057409edd99a268a92ebb6496'; | ||
177 | |||
178 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
179 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
180 | user2 = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
181 | |||
182 | deferredResult = new Clipperz.Async.Deferred("Record.test.removeDirectLogin", someTestArgs); | ||
183 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
184 | deferredResult.addMethod(user, 'login'); | ||
185 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
186 | deferredResult.addMethodcaller('directLogins'); | ||
187 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
188 | deferredResult.addMethodcaller('remove'); | ||
189 | |||
190 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
191 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
192 | deferredResult.addTest(true, "removing a direct login to a record should result in pending changes on the record"); | ||
193 | |||
194 | deferredResult.addMethod(user, 'saveChanges'); | ||
195 | deferredResult.addMethod(user, 'hasPendingChanges'); | ||
196 | deferredResult.addTest(false, "after saving there should be not any pending changes"); | ||
197 | |||
198 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
199 | deferredResult.addMethodcaller('directLogins'); | ||
200 | deferredResult.addCallback(MochiKit.Base.keys); | ||
201 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
202 | deferredResult.addTest(3, "after saving changes, the record should have only 3 direct logins"); | ||
203 | |||
204 | deferredResult.addMethod(user2, 'login'); | ||
205 | deferredResult.addMethod(user2, 'getRecord', recordID); | ||
206 | deferredResult.addMethodcaller('directLogins'); | ||
207 | deferredResult.addCallback(MochiKit.Base.keys); | ||
208 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
209 | deferredResult.addTest(3, "also reloading all the data with a new user, the direct logins should always be 3"); | ||
210 | |||
211 | deferredResult.callback(); | ||
212 | |||
213 | return deferredResult; | ||
214 | }, | ||
215 | |||
216 | //------------------------------------------------------------------------- | ||
217 | |||
218 | 'removeDirectLoginAndRevertChanges': function (someTestArgs) { | ||
219 | var deferredResult; | ||
220 | var proxy; | ||
221 | var user; | ||
222 | |||
223 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; | ||
224 | var directLoginID ='dba0db679802f0e6aa6d0b7a6aaf42350aabc5f057409edd99a268a92ebb6496'; | ||
225 | |||
226 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
227 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
228 | |||
229 | deferredResult = new Clipperz.Async.Deferred("Record.test.removeDirectLoginAndRevertChanges", someTestArgs); | ||
230 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
231 | deferredResult.addMethod(user, 'login'); | ||
232 | |||
233 | deferredResult.addMethod(user, 'getDirectLogins'); | ||
234 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
235 | deferredResult.addTest(22, "the user has 22 initially"); | ||
236 | |||
237 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
238 | deferredResult.addMethodcaller('directLogins'); | ||
239 | deferredResult.addCallback(MochiKit.Base.keys); | ||
240 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
241 | deferredResult.addTest(4, "the selected record has 4 direct logins"); | ||
242 | |||
243 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
244 | deferredResult.addMethodcaller('directLogins'); | ||
245 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
246 | deferredResult.addMethodcaller('remove'); | ||
247 | |||
248 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
249 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
250 | deferredResult.addTest(true, "removing a direct login to a record should result in pending changes on the record"); | ||
251 | |||
252 | deferredResult.addMethod(user, 'revertChanges'); | ||
253 | deferredResult.addMethod(user, 'hasPendingChanges'); | ||
254 | deferredResult.addTest(false, "after reverting the changes, the user should not have pending changes"); | ||
255 | |||
256 | deferredResult.addMethod(user, 'getDirectLogins'); | ||
257 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
258 | deferredResult.addTest(22, "after reverting the changes, the user should still have 22 direct logins"); | ||
259 | |||
260 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
261 | deferredResult.addMethodcaller('directLogins'); | ||
262 | deferredResult.addCallback(MochiKit.Base.keys); | ||
263 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
264 | deferredResult.addTest(4, "after reverting the changes, the record should still have 4 direct logins"); | ||
265 | |||
266 | deferredResult.callback(); | ||
267 | |||
268 | return deferredResult; | ||
269 | }, | ||
270 | |||
271 | //------------------------------------------------------------------------- | ||
272 | |||
273 | 'addDirectLoginAndRevertChanges': function (someTestArgs) { | ||
274 | var deferredResult; | ||
275 | var proxy; | ||
276 | var user, user2; | ||
277 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; //YAHOO (4) | ||
278 | var directLoginReference; | ||
279 | |||
280 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
281 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
282 | user2 = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
283 | |||
284 | deferredResult = new Clipperz.Async.Deferred("Record.test.addDirectLoginAndRevertChanges", someTestArgs); | ||
285 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
286 | deferredResult.addMethod(user, 'login'); | ||
287 | |||
288 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
289 | deferredResult.setValue('record'); | ||
290 | deferredResult.addMethodcaller('directLogins'); | ||
291 | deferredResult.addCallback(MochiKit.Base.keys); | ||
292 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
293 | deferredResult.addTest(4, "the record, when initially loaded, has 4 direct logins"); | ||
294 | |||
295 | deferredResult.getValue('record'); | ||
296 | deferredResult.addMethodcaller('createNewDirectLogin'); | ||
297 | deferredResult.setValue('directLogin'); | ||
298 | |||
299 | deferredResult.getValue('directLogin'); | ||
300 | deferredResult.addMethodcaller('setLabel', "New direct login"); | ||
301 | |||
302 | deferredResult.getValue('directLogin'); | ||
303 | deferredResult.addMethodcaller('setBookmarkletConfiguration', '{"page": {"title": "Parallels Account"}, "form": {"attributes": {"action": "https://www.parallels.com/account/", "method": "post"}, "inputs": [{"type": "text", "name": "Email", "value": ""}, {"type": "password", "name": "Password", "value": ""}]}, "version": "0.2.3"}'); | ||
304 | |||
305 | deferredResult.addMethod(user, 'revertChanges'); | ||
306 | //deferredResult.addCallback(function () { console.log("###################################"); }); | ||
307 | deferredResult.addMethod(user, 'hasPendingChanges'); | ||
308 | deferredResult.addTest(false, "after reverting the changes, the user should NOT have pending changes"); | ||
309 | |||
310 | deferredResult.getValue('record'); | ||
311 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
312 | deferredResult.addTest(false, "after reverting the changes, the record should NOT have pending changes"); | ||
313 | |||
314 | deferredResult.addMethod(user2, 'login'); | ||
315 | |||
316 | deferredResult.addMethod(user2, 'getRecord', recordID); | ||
317 | deferredResult.setValue('record_2'); | ||
318 | deferredResult.addMethodcaller('directLogins'); | ||
319 | deferredResult.addCallback(MochiKit.Base.keys); | ||
320 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
321 | deferredResult.addTest(4, "the record, when reloaded from scratch, has still 4 direct logins"); | ||
322 | |||
323 | deferredResult.callback(); | ||
324 | |||
325 | return deferredResult; | ||
326 | }, | ||
327 | |||
328 | //------------------------------------------------------------------------- | ||
329 | |||
330 | 'addDirectLoginAndSaveChanges': function (someTestArgs) { | ||
331 | var deferredResult; | ||
332 | var proxy; | ||
333 | var user, user2; | ||
334 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; //YAHOO (4) | ||
335 | var directLoginReference; | ||
336 | |||
337 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
338 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
339 | user2 = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
340 | |||
341 | deferredResult = new Clipperz.Async.Deferred("Record.test.addDirectLoginAndSaveChanges", someTestArgs); | ||
342 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
343 | deferredResult.addMethod(user, 'login'); | ||
344 | |||
345 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
346 | deferredResult.addMethodcaller('hasAnyCleanTextData'); | ||
347 | deferredResult.addTest(false, "When first loaded, the record has no clean text data [2]"); | ||
348 | |||
349 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
350 | deferredResult.setValue('record'); | ||
351 | deferredResult.addMethodcaller('directLogins'); | ||
352 | deferredResult.addCallback(MochiKit.Base.keys); | ||
353 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
354 | deferredResult.addTest(4, "the selected record has 4 direct logins"); | ||
355 | |||
356 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
357 | deferredResult.addMethodcaller('hasAnyCleanTextData'); | ||
358 | deferredResult.addTest(false, "Still no clean text data is stored on the record, as all accessed data are stored on the index"); | ||
359 | |||
360 | deferredResult.addMethod(user, 'hasAnyCleanTextData'); | ||
361 | deferredResult.addTest(true, "the user has some clean text data"); | ||
362 | |||
363 | deferredResult.getValue('record'); | ||
364 | deferredResult.addMethodcaller('createNewDirectLogin'); | ||
365 | deferredResult.setValue('directLogin'); | ||
366 | |||
367 | deferredResult.getValue('directLogin'); | ||
368 | deferredResult.addMethodcaller('label'); | ||
369 | deferredResult.addTest(null, "The label of a initially created direct login is empty"); | ||
370 | |||
371 | deferredResult.getValue('directLogin'); | ||
372 | deferredResult.addMethodcaller('bookmarkletConfiguration'); | ||
373 | deferredResult.addTest('', "The bookmaraklet configuration of a initially created direct login is empty"); | ||
374 | |||
375 | deferredResult.getValue('directLogin'); | ||
376 | deferredResult.addMethodcaller('bindings'); | ||
377 | deferredResult.addCallback(Clipperz.Async.Test.isDeeply({}, "The bindings of a initially created direct login is empty")); | ||
378 | |||
379 | deferredResult.getValue('directLogin'); | ||
380 | deferredResult.addMethodcaller('setLabel', "New direct login"); | ||
381 | |||
382 | deferredResult.getValue('directLogin'); | ||
383 | deferredResult.addMethodcaller('setBookmarkletConfiguration', directLoginConfigurations['Parallels']); | ||
384 | |||
385 | deferredResult.getValue('directLogin'); | ||
386 | deferredResult.addMethodcaller('bindings'); | ||
387 | deferredResult.addCallback(MochiKit.Base.itemgetter('Email')); | ||
388 | deferredResult.addMethodcaller('setFieldKey', '4cfaf1e782086e7527bd0e0cc82b67eb773e8157ad0c5babe516f7bc945a02a9'); //"userID" | ||
389 | |||
390 | deferredResult.getValue('directLogin'); | ||
391 | deferredResult.addMethodcaller('bindings'); | ||
392 | deferredResult.addCallback(MochiKit.Base.itemgetter('Password')); | ||
393 | deferredResult.addMethodcaller('setFieldKey', 'ef2dee54322bf401540657d469e158a50e9228bc0a192a31d2e3ee56a77e565b'); //"password" | ||
394 | |||
395 | deferredResult.getValue('directLogin'); | ||
396 | deferredResult.addMethodcaller('favicon'), | ||
397 | deferredResult.addTest('http://www.parallels.com/favicon.ico', "the original favicon is the expected one"), | ||
398 | |||
399 | deferredResult.getValue('directLogin'); | ||
400 | deferredResult.addMethodcaller('reference'); | ||
401 | deferredResult.addCallback(function (aReference) { | ||
402 | directLoginReference = aReference; | ||
403 | }); | ||
404 | |||
405 | deferredResult.addMethod(user, 'hasPendingChanges'); | ||
406 | deferredResult.addTest(true, "after adding a new direct login, the user should have pending changes"); | ||
407 | |||
408 | deferredResult.getValue('record'); | ||
409 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
410 | deferredResult.addTest(true, "after adding a new direct login, the record should have pending changes"); | ||
411 | |||
412 | deferredResult.getValue('record'); | ||
413 | deferredResult.addMethodcaller('directLogins'); | ||
414 | deferredResult.addCallback(MochiKit.Base.keys); | ||
415 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
416 | deferredResult.addTest(5, "after adding a new direct login, the record has now 5 direct logins"); | ||
417 | |||
418 | |||
419 | deferredResult.addMethod(user, 'saveChanges'); | ||
420 | deferredResult.addMethod(user, 'hasPendingChanges'); | ||
421 | deferredResult.addTest(false, "after saving the changes, the user should NOT have pending changes"); | ||
422 | |||
423 | |||
424 | deferredResult.addMethod(user2, 'login'); | ||
425 | |||
426 | deferredResult.addMethod(user2, 'getRecord', recordID); | ||
427 | deferredResult.setValue('record_2'); | ||
428 | deferredResult.addMethodcaller('directLogins'); | ||
429 | deferredResult.addCallback(MochiKit.Base.keys); | ||
430 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
431 | deferredResult.addTest(5, "the record, when reloaded from scratch, has still 5 direct logins"); | ||
432 | |||
433 | deferredResult.getValue('record_2'); | ||
434 | deferredResult.addMethodcaller('directLogins'); | ||
435 | deferredResult.addCallback(MochiKit.Base.values); | ||
436 | deferredResult.addCallback(MochiKit.Base.itemgetter('4')); //TODO: accessing directLogins by index is not really nice | ||
437 | deferredResult.setValue('directLogin_2'); | ||
438 | deferredResult.addMethodcaller('label'); | ||
439 | deferredResult.addTest('New direct login', "The label of the direct login has been correctly saved"); | ||
440 | |||
441 | deferredResult.getValue('directLogin_2'); | ||
442 | deferredResult.addMethodcaller('bindings'); | ||
443 | deferredResult.addCallback(MochiKit.Base.itemgetter('Email')); | ||
444 | deferredResult.addMethodcaller('field'); | ||
445 | deferredResult.addMethodcaller('value'); | ||
446 | deferredResult.addTest('joe.clipperz', "The value bound to the direct login 'Email' field is correct"); | ||
447 | |||
448 | deferredResult.getValue('directLogin_2'); | ||
449 | deferredResult.addMethodcaller('bindings'); | ||
450 | deferredResult.addCallback(MochiKit.Base.itemgetter('Password')); | ||
451 | deferredResult.addMethodcaller('field'); | ||
452 | deferredResult.addMethodcaller('value'); | ||
453 | deferredResult.addTest('enfvDG1RxAsl', "The value bound to the direct login 'Password' field is correct"); | ||
454 | |||
455 | deferredResult.callback(); | ||
456 | |||
457 | return deferredResult; | ||
458 | }, | ||
459 | |||
460 | //------------------------------------------------------------------------- | ||
461 | |||
462 | 'readDirectLoginAttributes': function (someTestArgs) { | ||
463 | var deferredResult; | ||
464 | var proxy; | ||
465 | var user; | ||
466 | |||
467 | var recordID = '2977aa5f99a9f6e5596c1bd7871e82d7328c3716c9ef8ba349ae65f10d97924e'; | ||
468 | var directLoginID ='03251dc1cbc5398789e4c4b45c52cfac3fcd8c1a4f19a81fa68fc6feae31d55c'; | ||
469 | |||
470 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
471 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
472 | |||
473 | deferredResult = new Clipperz.Async.Deferred("Record.test.readDirectLoginAttributes", someTestArgs); | ||
474 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_with_multipleRecordVersions_data']); | ||
475 | deferredResult.addMethod(user, 'login'); | ||
476 | |||
477 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
478 | deferredResult.addMethodcaller('directLogins'); | ||
479 | deferredResult.addCallback(MochiKit.Base.itemgetter('03251dc1cbc5398789e4c4b45c52cfac3fcd8c1a4f19a81fa68fc6feae31d55c')); | ||
480 | deferredResult.setValue('directLogin'); | ||
481 | |||
482 | deferredResult.getValue('directLogin'); | ||
483 | deferredResult.addMethodcaller('inputs'); | ||
484 | deferredResult.addCallback(MochiKit.Base.keys); | ||
485 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
486 | deferredResult.addTest(13, "Amazon direct login has 13 inputs"); | ||
487 | |||
488 | deferredResult.getValue('directLogin'); | ||
489 | deferredResult.addMethodcaller('inputs'); | ||
490 | deferredResult.addCallback(MochiKit.Base.values); | ||
491 | deferredResult.addCallback(MochiKit.Base.filter, MochiKit.Base.methodcaller('needsFormValue')); | ||
492 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
493 | deferredResult.addTest(1, "Amazon direct login has 1 field needing a form value"); | ||
494 | |||
495 | deferredResult.getValue('directLogin'); | ||
496 | deferredResult.addMethodcaller('inputs'); | ||
497 | deferredResult.addCallback(MochiKit.Base.values); | ||
498 | deferredResult.addCallback(MochiKit.Base.filter, MochiKit.Base.methodcaller('needsBinding')); | ||
499 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
500 | deferredResult.addTest(2, "Amazon direct login has 2 field needing a binding"); | ||
501 | |||
502 | |||
503 | deferredResult.getValue('directLogin'); | ||
504 | deferredResult.addMethodcaller('bindings'); | ||
505 | deferredResult.addCallback(MochiKit.Base.keys); | ||
506 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
507 | deferredResult.addTest(2, "Amazon direct login has just two bindings"); | ||
508 | |||
509 | deferredResult.getValue('directLogin'); | ||
510 | deferredResult.addMethodcaller('bindings'); | ||
511 | deferredResult.addCallback(MochiKit.Base.itemgetter('email')); | ||
512 | deferredResult.addMethodcaller('fieldKey'); | ||
513 | deferredResult.addTest('5e822c34aaf1a9fbc0b52585c1915f3a3758abd51923a4d35ae85373bbb839c2', "Amazon direct login 'email' binding points to the correct field"); | ||
514 | |||
515 | deferredResult.getValue('directLogin'); | ||
516 | deferredResult.addMethodcaller('bindings'); | ||
517 | deferredResult.addCallback(MochiKit.Base.itemgetter('password')); | ||
518 | deferredResult.setValue('passwordBinding'); | ||
519 | deferredResult.addMethodcaller('fieldKey'); | ||
520 | deferredResult.addTest('01e4bb6dcf054f312c535de8160bcf50bdccd664bdc05721b10d4e69583765f7', "Amazon direct login 'password' binding points to the correct field"); | ||
521 | |||
522 | deferredResult.getValue('passwordBinding'); | ||
523 | deferredResult.addMethodcaller('field'); | ||
524 | deferredResult.addMethodcaller('label'); | ||
525 | deferredResult.addTest('password', "Amazon direct login 'password' binding points to the 'password' field"); | ||
526 | |||
527 | |||
528 | deferredResult.getValue('directLogin'); | ||
529 | deferredResult.addMethodcaller('formValues'); | ||
530 | deferredResult.addCallback(MochiKit.Base.keys); | ||
531 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
532 | deferredResult.addTest(1, "Amazon direct login has just one formValue"); | ||
533 | |||
534 | deferredResult.getValue('directLogin'); | ||
535 | deferredResult.addMethodcaller('formValues'); | ||
536 | deferredResult.addCallback(MochiKit.Base.itemgetter('action')); | ||
537 | deferredResult.addMethodcaller('value'); | ||
538 | deferredResult.addTest('sign-in', "Amazon direct 'action' formValue is set to 'sign-in'"); | ||
539 | |||
540 | |||
541 | deferredResult.callback(); | ||
542 | |||
543 | return deferredResult; | ||
544 | }, | ||
545 | |||
546 | //------------------------------------------------------------------------- | ||
547 | |||
548 | 'editDirectLoginLabel': function (someTestArgs) { | ||
549 | var deferredResult; | ||
550 | var proxy; | ||
551 | var user; | ||
552 | var oldLabel; | ||
553 | var newLabel; | ||
554 | |||
555 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; | ||
556 | var directLoginID ='dba0db679802f0e6aa6d0b7a6aaf42350aabc5f057409edd99a268a92ebb6496'; | ||
557 | |||
558 | oldLabel = "Yahoo! Mail"; | ||
559 | newLabel = "YAHOO! Mail"; | ||
560 | |||
561 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
562 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
563 | |||
564 | deferredResult = new Clipperz.Async.Deferred("Record.test.editDirectLoginLabel", someTestArgs); | ||
565 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
566 | deferredResult.addMethod(user, 'login'); | ||
567 | |||
568 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
569 | deferredResult.addMethodcaller('directLogins'); | ||
570 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
571 | deferredResult.addMethodcaller('label'); | ||
572 | deferredResult.addTest(oldLabel, "the current label of the direct login"); | ||
573 | |||
574 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
575 | deferredResult.addMethodcaller('directLogins'); | ||
576 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
577 | deferredResult.addMethodcaller('setLabel', newLabel); | ||
578 | |||
579 | deferredResult.addMethod(user, 'hasPendingChanges'); | ||
580 | deferredResult.addTest(true, "changing the label of a direct login should trigger some changes"); | ||
581 | |||
582 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
583 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
584 | deferredResult.addTest(true, "changing the label of a direct login should trigger some changes also on the record itself"); | ||
585 | |||
586 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
587 | deferredResult.addMethodcaller('directLogins'); | ||
588 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
589 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
590 | deferredResult.addTest(true, "changing the label of a direct login should trigger some changes also on the directLogin itself"); | ||
591 | |||
592 | deferredResult.callback(); | ||
593 | |||
594 | return deferredResult; | ||
595 | }, | ||
596 | |||
597 | //------------------------------------------------------------------------- | ||
598 | |||
599 | 'editDirectLoginFormValueAndRestoreChanges': function (someTestArgs) { | ||
600 | var deferredResult; | ||
601 | var proxy; | ||
602 | var user; | ||
603 | |||
604 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; | ||
605 | var directLoginID ='dba0db679802f0e6aa6d0b7a6aaf42350aabc5f057409edd99a268a92ebb6496'; | ||
606 | |||
607 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
608 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
609 | |||
610 | deferredResult = new Clipperz.Async.Deferred("Record.test.editDirectLoginFormValueAndRestoreChanges", someTestArgs); | ||
611 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
612 | deferredResult.addMethod(user, 'login'); | ||
613 | |||
614 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
615 | deferredResult.addMethodcaller('directLogins'); | ||
616 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
617 | deferredResult.setValue('directLogin'); | ||
618 | deferredResult.addMethodcaller('formValues'); | ||
619 | deferredResult.addCallback(MochiKit.Base.itemgetter('.persistent')); | ||
620 | deferredResult.addMethodcaller('value'); | ||
621 | deferredResult.addTest(null, "original formValue value matches"); | ||
622 | |||
623 | deferredResult.getValue('directLogin'); | ||
624 | deferredResult.addMethodcaller('formValues'); | ||
625 | deferredResult.addCallback(MochiKit.Base.itemgetter('.persistent')) | ||
626 | deferredResult.addMethodcaller('setValue', 'y'); | ||
627 | |||
628 | deferredResult.getValue('directLogin'); | ||
629 | deferredResult.addMethodcaller('formValues'); | ||
630 | deferredResult.addCallback(MochiKit.Base.itemgetter('.persistent')) | ||
631 | deferredResult.addMethodcaller('value'); | ||
632 | deferredResult.addTest('y', "the newly set value is retained"); | ||
633 | |||
634 | |||
635 | deferredResult.addMethod(user, 'hasPendingChanges'); | ||
636 | deferredResult.addTest(true, "changing the label of a direct login should trigger some changes"); | ||
637 | |||
638 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
639 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
640 | deferredResult.addTest(true, "changing the label of a direct login should trigger some changes also on the record itself"); | ||
641 | |||
642 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
643 | deferredResult.addMethodcaller('directLogins'); | ||
644 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
645 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
646 | deferredResult.addTest(true, "changing the label of a direct login should trigger some changes also on the directLogin itself"); | ||
647 | |||
648 | deferredResult.addMethod(user, 'revertChanges'); | ||
649 | |||
650 | deferredResult.getValue('directLogin'); | ||
651 | deferredResult.addMethodcaller('formValues'); | ||
652 | deferredResult.addCallback(MochiKit.Base.itemgetter('.persistent')) | ||
653 | deferredResult.addMethodcaller('value'); | ||
654 | deferredResult.addTest(null, "the old formValue value is correctly restored"); | ||
655 | |||
656 | deferredResult.callback(); | ||
657 | |||
658 | return deferredResult; | ||
659 | }, | ||
660 | |||
661 | //------------------------------------------------------------------------- | ||
662 | |||
663 | 'editDirectLoginConfigurationAndRevertChanges': function (someTestArgs) { | ||
664 | var deferredResult; | ||
665 | var proxy; | ||
666 | var user; | ||
667 | |||
668 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; | ||
669 | var directLoginID ='dba0db679802f0e6aa6d0b7a6aaf42350aabc5f057409edd99a268a92ebb6496'; | ||
670 | |||
671 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
672 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
673 | |||
674 | deferredResult = new Clipperz.Async.Deferred("Record.test.editDirectLoginConfigurationAndRevertChanges", someTestArgs); | ||
675 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
676 | deferredResult.addMethod(user, 'login'); | ||
677 | |||
678 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
679 | deferredResult.addMethodcaller('directLogins'); | ||
680 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
681 | |||
682 | deferredResult.addCallback(function (aDirectLogin) { | ||
683 | // var newBookmarkletConfiguration; | ||
684 | |||
685 | // newBookmarkletConfiguration = '{\n \"page\": {\n \"title\": \"Yahoo! Mail\"\n },\n \"form\": {\n \"attributes\": {\n \"action\": \"https://login.yahoo.com/config/login?\",\n \"method\": \"post\"\n },\n \"inputs\": [\n {\n \"type\": \"text\",\n \"name\": \"login\",\n \"value\": \"\"\n },\n {\n \"type\": \"password\",\n \"name\": \"passwd\",\n \"value\": \"\"\n },\n {\n \"type\": \"checkbox\",\n \"name\": \".persistent\",\n \"value\": \"y\"\n }\n ]\n },\n \"version\": \"0.2\"\n}'; | ||
686 | return Clipperz.Async.callbacks("Record.test.editDirectLoginConfiguration [inner call]", [ | ||
687 | MochiKit.Base.method(aDirectLogin, 'bookmarkletConfiguration'), | ||
688 | Clipperz.Async.Test.is(directLoginConfigurations['Yahoo! Mail'], "the current bookmarkletConfiguration"), | ||
689 | |||
690 | MochiKit.Base.method(aDirectLogin, 'favicon'), | ||
691 | Clipperz.Async.Test.is('http://login.yahoo.com/favicon.ico', "the original favicon is the expected one"), | ||
692 | |||
693 | MochiKit.Base.method(aDirectLogin, 'setBookmarkletConfiguration', directLoginConfigurations['Parallels']), | ||
694 | |||
695 | MochiKit.Base.method(aDirectLogin, 'favicon'), | ||
696 | Clipperz.Async.Test.is('http://login.yahoo.com/favicon.ico', "the original favicon is the expected one"), | ||
697 | |||
698 | MochiKit.Base.method(aDirectLogin, 'hasPendingChanges'), | ||
699 | Clipperz.Async.Test.ok("changing the configuration should trigger the pending changes on the direct login"), | ||
700 | MochiKit.Base.method(aDirectLogin.record(), 'hasPendingChanges'), | ||
701 | Clipperz.Async.Test.ok("changing the configuration should trigger the pending changes also on the record"), | ||
702 | MochiKit.Base.method(user, 'hasPendingChanges'), | ||
703 | Clipperz.Async.Test.ok("changing the configuration should trigger the pending changes also on the user"), | ||
704 | |||
705 | MochiKit.Base.method(aDirectLogin, 'revertChanges'), | ||
706 | |||
707 | MochiKit.Base.method(aDirectLogin, 'hasPendingChanges'), | ||
708 | Clipperz.Async.Test.fail("reverting changes should reset pending changes on the direct login"), | ||
709 | MochiKit.Base.method(aDirectLogin.record(), 'hasPendingChanges'), | ||
710 | Clipperz.Async.Test.fail("reverting changes should reset pending changes also on the record"), | ||
711 | MochiKit.Base.method(user, 'hasPendingChanges'), | ||
712 | Clipperz.Async.Test.fail("reverting changes should reset pending changes also on the user"), | ||
713 | |||
714 | MochiKit.Base.noop | ||
715 | ], someTestArgs); | ||
716 | }) | ||
717 | |||
718 | deferredResult.callback(); | ||
719 | |||
720 | return deferredResult; | ||
721 | }, | ||
722 | |||
723 | //------------------------------------------------------------------------- | ||
724 | |||
725 | 'editDirectLoginConfiguration_keepingTheSameStructure_AndSaveChanges': function (someTestArgs) { | ||
726 | var deferredResult; | ||
727 | var proxy; | ||
728 | var user; | ||
729 | var user2; | ||
730 | var newBookmarkletConfiguration; | ||
731 | |||
732 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; | ||
733 | var directLoginID ='dba0db679802f0e6aa6d0b7a6aaf42350aabc5f057409edd99a268a92ebb6496'; | ||
734 | |||
735 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
736 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
737 | user2 = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
738 | |||
739 | newBookmarkletConfiguration = '{\n \"page\": {\n \"title\": \"Yahoo! Mail\"\n },\n \"form\": {\n \"attributes\": {\n \"action\": \"https://login.yahoo.com/config/login?\",\n \"method\": \"post\"\n },\n \"inputs\": [\n {\n \"type\": \"text\",\n \"name\": \"login\",\n \"value\": \"\"\n },\n {\n \"type\": \"password\",\n \"name\": \"passwd\",\n \"value\": \"\"\n },\n {\n \"type\": \"checkbox\",\n \"name\": \".persistent\",\n \"value\": \"y\"\n }\n ]\n },\n \"version\": \"0.2\"\n}'; | ||
740 | |||
741 | deferredResult = new Clipperz.Async.Deferred("Record.test.editDirectLoginConfiguration_keepingTheSameStructure_AndSaveChanges", someTestArgs); | ||
742 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
743 | deferredResult.addMethod(user, 'login'); | ||
744 | |||
745 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
746 | deferredResult.addMethodcaller('directLogins'); | ||
747 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
748 | deferredResult.addCallback(function (aDirectLogin) { | ||
749 | return Clipperz.Async.callbacks("Record.test.editDirectLoginConfiguration_keepingTheSameStructure_AndSaveChanges [inner call 1]", [ | ||
750 | MochiKit.Base.method(aDirectLogin, 'bookmarkletConfiguration'), | ||
751 | Clipperz.Async.Test.is(directLoginConfigurations['Yahoo! Mail'], "the current bookmarkletConfiguration (1)"), | ||
752 | |||
753 | MochiKit.Base.method(aDirectLogin, 'inputs'), | ||
754 | MochiKit.Base.keys, | ||
755 | MochiKit.Base.itemgetter('length'), | ||
756 | Clipperz.Async.Test.is(26, "The original direct login had 26 inputs"), | ||
757 | |||
758 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
759 | MochiKit.Base.keys, | ||
760 | MochiKit.Base.itemgetter('length'), | ||
761 | Clipperz.Async.Test.is(2, "The original direct login had 2 inputs"), | ||
762 | |||
763 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
764 | MochiKit.Base.itemgetter('login'), | ||
765 | MochiKit.Base.methodcaller('field'), | ||
766 | MochiKit.Base.methodcaller('reference'), | ||
767 | Clipperz.Async.Test.is('4cfaf1e782086e7527bd0e0cc82b67eb773e8157ad0c5babe516f7bc945a02a9', "the original 'login' direct login binding points to the correct field"), | ||
768 | |||
769 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
770 | MochiKit.Base.keys, | ||
771 | MochiKit.Base.itemgetter('length'), | ||
772 | Clipperz.Async.Test.is(1, "The original direct login had 1 form values"), | ||
773 | |||
774 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
775 | MochiKit.Base.itemgetter('.persistent'), | ||
776 | MochiKit.Base.methodcaller('type'), | ||
777 | Clipperz.Async.Test.is('checkbox', "the original formValue has the expected type"), | ||
778 | |||
779 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
780 | MochiKit.Base.itemgetter('.persistent'), | ||
781 | MochiKit.Base.methodcaller('value'), | ||
782 | Clipperz.Async.Test.is(null, "the original formValue is correct (1)"), | ||
783 | |||
784 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
785 | MochiKit.Base.itemgetter('.persistent'), | ||
786 | MochiKit.Base.methodcaller('setValue', 'y'), | ||
787 | |||
788 | |||
789 | MochiKit.Base.method(aDirectLogin, 'setBookmarkletConfiguration', newBookmarkletConfiguration), | ||
790 | MochiKit.Base.method(user, 'saveChanges'), | ||
791 | |||
792 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
793 | MochiKit.Base.itemgetter('login'), | ||
794 | MochiKit.Base.methodcaller('field'), | ||
795 | MochiKit.Base.methodcaller('reference'), | ||
796 | Clipperz.Async.Test.is('4cfaf1e782086e7527bd0e0cc82b67eb773e8157ad0c5babe516f7bc945a02a9', "the 'login' binding is still valid after the new configuration is set"), | ||
797 | |||
798 | MochiKit.Base.method(aDirectLogin, 'hasPendingChanges'), | ||
799 | Clipperz.Async.Test.fail("reverting changes should reset pending changes on the direct login (2)"), | ||
800 | MochiKit.Base.method(aDirectLogin.record(), 'hasPendingChanges'), | ||
801 | Clipperz.Async.Test.fail("reverting changes should reset pending changes also on the record (2)"), | ||
802 | MochiKit.Base.method(user, 'hasPendingChanges'), | ||
803 | Clipperz.Async.Test.fail("reverting changes should reset pending changes also on the user (2)"), | ||
804 | |||
805 | MochiKit.Base.noop | ||
806 | ], someTestArgs); | ||
807 | }) | ||
808 | |||
809 | deferredResult.addMethod(user2, 'login'); | ||
810 | |||
811 | deferredResult.addMethod(user2, 'getRecord', recordID); | ||
812 | deferredResult.addMethodcaller('directLogins'); | ||
813 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
814 | deferredResult.addCallback(function (aDirectLogin) { | ||
815 | return Clipperz.Async.callbacks("Record.test.editDirectLoginConfiguration_keepingTheSameStructure_AndSaveChanges [inner call 2]", [ | ||
816 | MochiKit.Base.method(aDirectLogin, 'bookmarkletConfiguration'), | ||
817 | Clipperz.Async.Test.is(newBookmarkletConfiguration, "the direct login has the new bookmarkletConfiguration even after being reloaded"), | ||
818 | |||
819 | MochiKit.Base.method(aDirectLogin, 'inputs'), | ||
820 | MochiKit.Base.keys, | ||
821 | MochiKit.Base.itemgetter('length'), | ||
822 | Clipperz.Async.Test.is(3, "The new direct login has 3 inputs"), | ||
823 | |||
824 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
825 | MochiKit.Base.keys, | ||
826 | MochiKit.Base.itemgetter('length'), | ||
827 | Clipperz.Async.Test.is(2, "The new direct login had 2 inputs"), | ||
828 | |||
829 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
830 | MochiKit.Base.itemgetter('login'), | ||
831 | MochiKit.Base.methodcaller('field'), | ||
832 | MochiKit.Base.methodcaller('reference'), | ||
833 | Clipperz.Async.Test.is('4cfaf1e782086e7527bd0e0cc82b67eb773e8157ad0c5babe516f7bc945a02a9', "the new 'login' direct login binding still points to the correct field"), | ||
834 | |||
835 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
836 | MochiKit.Base.keys, | ||
837 | MochiKit.Base.itemgetter('length'), | ||
838 | Clipperz.Async.Test.is(1, "The new direct login had 1 form values (1)"), | ||
839 | |||
840 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
841 | MochiKit.Base.itemgetter('.persistent'), | ||
842 | MochiKit.Base.methodcaller('value'), | ||
843 | Clipperz.Async.Test.is(null, "the formValue is still correctly set"), | ||
844 | |||
845 | MochiKit.Base.noop | ||
846 | ], someTestArgs); | ||
847 | }); | ||
848 | |||
849 | deferredResult.callback(); | ||
850 | |||
851 | return deferredResult; | ||
852 | }, | ||
853 | |||
854 | //------------------------------------------------------------------------- | ||
855 | |||
856 | 'editDirectLoginConfiguration_changingTheStructure_AndSaveChanges': function (someTestArgs) { | ||
857 | var deferredResult; | ||
858 | var proxy; | ||
859 | var user; | ||
860 | var user2; | ||
861 | |||
862 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; | ||
863 | var directLoginID ='dba0db679802f0e6aa6d0b7a6aaf42350aabc5f057409edd99a268a92ebb6496'; | ||
864 | |||
865 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
866 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
867 | user2 = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
868 | |||
869 | deferredResult = new Clipperz.Async.Deferred("Record.test.editDirectLoginConfiguration_changingTheStructure_AndSaveChanges", someTestArgs); | ||
870 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
871 | deferredResult.addMethod(user, 'login'); | ||
872 | |||
873 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
874 | deferredResult.addMethodcaller('directLogins'); | ||
875 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
876 | deferredResult.addCallback(function (aDirectLogin) { | ||
877 | return Clipperz.Async.callbacks("Record.test.editDirectLoginConfiguration_changingTheStructure_AndSaveChanges [inner call 1]", [ | ||
878 | MochiKit.Base.method(aDirectLogin, 'bookmarkletConfiguration'), | ||
879 | Clipperz.Async.Test.is(directLoginConfigurations['Yahoo! Mail'], "the current bookmarkletConfiguration (2)"), | ||
880 | |||
881 | MochiKit.Base.method(aDirectLogin, 'inputs'), | ||
882 | MochiKit.Base.keys, | ||
883 | MochiKit.Base.itemgetter('length'), | ||
884 | Clipperz.Async.Test.is(26, "The original direct login had 26 inputs"), | ||
885 | |||
886 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
887 | MochiKit.Base.keys, | ||
888 | MochiKit.Base.itemgetter('length'), | ||
889 | Clipperz.Async.Test.is(2, "The original direct login had 2 inputs"), | ||
890 | |||
891 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
892 | MochiKit.Base.itemgetter('login'), | ||
893 | MochiKit.Base.methodcaller('field'), | ||
894 | MochiKit.Base.methodcaller('reference'), | ||
895 | Clipperz.Async.Test.is('4cfaf1e782086e7527bd0e0cc82b67eb773e8157ad0c5babe516f7bc945a02a9', "the original 'login' direct login binding points to the correct field"), | ||
896 | |||
897 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
898 | MochiKit.Base.keys, | ||
899 | MochiKit.Base.itemgetter('length'), | ||
900 | Clipperz.Async.Test.is(1, "The original direct login had 1 form values"), | ||
901 | |||
902 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
903 | MochiKit.Base.itemgetter('.persistent'), | ||
904 | MochiKit.Base.methodcaller('value'), | ||
905 | Clipperz.Async.Test.is(null, "the original formValue is correct (2)"), | ||
906 | |||
907 | |||
908 | MochiKit.Base.method(aDirectLogin, 'setBookmarkletConfiguration', directLoginConfigurations['Parallels']), | ||
909 | MochiKit.Base.method(user, 'saveChanges'), | ||
910 | |||
911 | MochiKit.Base.method(aDirectLogin, 'inputs'), | ||
912 | MochiKit.Base.keys, | ||
913 | MochiKit.Base.itemgetter('length'), | ||
914 | Clipperz.Async.Test.is(2, "The new direct login has 2 inputs"), | ||
915 | |||
916 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
917 | MochiKit.Base.keys, | ||
918 | MochiKit.Base.itemgetter('length'), | ||
919 | Clipperz.Async.Test.is(0, "The new direct login has no form values"), | ||
920 | |||
921 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
922 | MochiKit.Base.keys, | ||
923 | MochiKit.Base.itemgetter('length'), | ||
924 | Clipperz.Async.Test.is(2, "The new direct login has 2 inputs"), | ||
925 | |||
926 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
927 | MochiKit.Base.itemgetter('login'), | ||
928 | Clipperz.Async.Test.is(null, "the 'login' binding should not exist within the new configuration"), | ||
929 | |||
930 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
931 | MochiKit.Base.itemgetter('passwd'), | ||
932 | Clipperz.Async.Test.is(null, "the 'passwd' binding should not exist within the new configuration"), | ||
933 | |||
934 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
935 | MochiKit.Base.itemgetter('Email'), | ||
936 | Clipperz.Async.Test.ok("the 'Email' binding should exist within the new configuration"), | ||
937 | |||
938 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
939 | MochiKit.Base.itemgetter('Password'), | ||
940 | Clipperz.Async.Test.ok("the 'Password' binding should exist within the new configuration"), | ||
941 | |||
942 | |||
943 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
944 | MochiKit.Base.itemgetter('Email'), | ||
945 | MochiKit.Base.methodcaller('field'), | ||
946 | Clipperz.Async.Test.is(null, "the 'Email' binding should not point to any field, yet"), | ||
947 | |||
948 | |||
949 | MochiKit.Base.method(aDirectLogin, 'hasPendingChanges'), | ||
950 | Clipperz.Async.Test.fail("reverting changes should reset pending changes on the direct login (2)"), | ||
951 | MochiKit.Base.method(aDirectLogin.record(), 'hasPendingChanges'), | ||
952 | Clipperz.Async.Test.fail("reverting changes should reset pending changes also on the record (2)"), | ||
953 | MochiKit.Base.method(user, 'hasPendingChanges'), | ||
954 | Clipperz.Async.Test.fail("reverting changes should reset pending changes also on the user (2)"), | ||
955 | |||
956 | MochiKit.Base.noop | ||
957 | ], someTestArgs); | ||
958 | }) | ||
959 | |||
960 | deferredResult.addMethod(user2, 'login'); | ||
961 | |||
962 | deferredResult.addMethod(user2, 'getRecord', recordID); | ||
963 | deferredResult.addMethodcaller('directLogins'); | ||
964 | deferredResult.addCallback(MochiKit.Base.itemgetter(directLoginID)); | ||
965 | deferredResult.addCallback(function (aDirectLogin) { | ||
966 | return Clipperz.Async.callbacks("Record.test.editDirectLoginConfiguration_changingTheStructure_AndSaveChanges [inner call 2]", [ | ||
967 | MochiKit.Base.method(aDirectLogin, 'bookmarkletConfiguration'), | ||
968 | Clipperz.Base.evalJSON, | ||
969 | MochiKit.Base.itemgetter('form'), | ||
970 | Clipperz.Async.Test.isDeeply(Clipperz.Base.evalJSON(directLoginConfigurations['Parallels'])['form'], "the direct login has the new bookmarkletConfiguration even after being reloaded"), | ||
971 | |||
972 | MochiKit.Base.method(aDirectLogin, 'inputs'), | ||
973 | MochiKit.Base.keys, | ||
974 | MochiKit.Base.itemgetter('length'), | ||
975 | Clipperz.Async.Test.is(2, "The new -reloaded- direct login has 2 inputs"), | ||
976 | |||
977 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
978 | MochiKit.Base.keys, | ||
979 | MochiKit.Base.itemgetter('length'), | ||
980 | Clipperz.Async.Test.is(2, "The new direct login had 2 inputs"), | ||
981 | |||
982 | MochiKit.Base.method(aDirectLogin, 'bindings'), | ||
983 | MochiKit.Base.itemgetter('login'), | ||
984 | Clipperz.Async.Test.is(null, "the 'login' binding should not exist within the new configuration"), | ||
985 | |||
986 | MochiKit.Base.method(aDirectLogin, 'formValues'), | ||
987 | MochiKit.Base.keys, | ||
988 | MochiKit.Base.itemgetter('length'), | ||
989 | Clipperz.Async.Test.is(0, "The new direct login has no form values (2)"), | ||
990 | |||
991 | MochiKit.Base.noop | ||
992 | ], someTestArgs); | ||
993 | }); | ||
994 | |||
995 | deferredResult.callback(); | ||
996 | |||
997 | return deferredResult; | ||
998 | }, | ||
999 | |||
1000 | //------------------------------------------------------------------------- | ||
1001 | |||
1002 | 'editFieldValueAndRestoreIt': function (someTestArgs) { | ||
1003 | var deferredResult; | ||
1004 | var proxy; | ||
1005 | var user; | ||
1006 | |||
1007 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; | ||
1008 | |||
1009 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
1010 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
1011 | |||
1012 | deferredResult = new Clipperz.Async.Deferred("Record.test.editValueAndRestoreIt", someTestArgs); | ||
1013 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
1014 | deferredResult.addMethod(user, 'login'); | ||
1015 | |||
1016 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1017 | deferredResult.addMethodcaller('fields'); | ||
1018 | deferredResult.addCallback(MochiKit.Base.itemgetter('4cfaf1e782086e7527bd0e0cc82b67eb773e8157ad0c5babe516f7bc945a02a9')); | ||
1019 | deferredResult.addMethodcaller('value'); | ||
1020 | deferredResult.addTest('joe.clipperz', "the current field value is 'joe.clipperz'"); | ||
1021 | |||
1022 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1023 | deferredResult.addMethodcaller('fields'); | ||
1024 | deferredResult.addCallback(MochiKit.Base.itemgetter('4cfaf1e782086e7527bd0e0cc82b67eb773e8157ad0c5babe516f7bc945a02a9')); | ||
1025 | deferredResult.addMethodcaller('setValue', 'fake.clipperz'); | ||
1026 | |||
1027 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1028 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
1029 | deferredResult.addTest(true, "changing the value of a field should trigger pending changes"); | ||
1030 | |||
1031 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1032 | deferredResult.addMethodcaller('fields'); | ||
1033 | deferredResult.addCallback(MochiKit.Base.itemgetter('4cfaf1e782086e7527bd0e0cc82b67eb773e8157ad0c5babe516f7bc945a02a9')); | ||
1034 | deferredResult.addMethodcaller('setValue', 'joe.clipperz'); | ||
1035 | |||
1036 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1037 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
1038 | deferredResult.addTest(false, "restoring the value of a field should revert pending changes"); | ||
1039 | |||
1040 | |||
1041 | deferredResult.callback(); | ||
1042 | |||
1043 | return deferredResult; | ||
1044 | }, | ||
1045 | |||
1046 | //------------------------------------------------------------------------- | ||
1047 | |||
1048 | 'accessFieldValues': function (someTestArgs) { | ||
1049 | var deferredResult; | ||
1050 | var proxy; | ||
1051 | var user; | ||
1052 | |||
1053 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; | ||
1054 | |||
1055 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
1056 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
1057 | |||
1058 | deferredResult = new Clipperz.Async.Deferred("Record.test.accessFieldValues", someTestArgs); | ||
1059 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
1060 | deferredResult.addMethod(user, 'login'); | ||
1061 | |||
1062 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1063 | deferredResult.addMethodcaller('fieldWithLabel', 'userID'); | ||
1064 | deferredResult.addMethodcaller('value'); | ||
1065 | deferredResult.addTest('joe.clipperz', "the current field value is 'joe.clipperz'"); | ||
1066 | |||
1067 | |||
1068 | deferredResult.callback(); | ||
1069 | |||
1070 | return deferredResult; | ||
1071 | }, | ||
1072 | |||
1073 | //------------------------------------------------------------------------- | ||
1074 | |||
1075 | 'editFieldValueAndSaveIt': function (someTestArgs) { | ||
1076 | var deferredResult; | ||
1077 | var proxy; | ||
1078 | var user, user2; | ||
1079 | |||
1080 | var recordID ='2977aa5f99a9f6e5596c1bd7871e82d7328c3716c9ef8ba349ae65f10d97924e'; | ||
1081 | var passwordFieldID ='01e4bb6dcf054f312c535de8160bcf50bdccd664bdc05721b10d4e69583765f7'; | ||
1082 | |||
1083 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
1084 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
1085 | user2 = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
1086 | |||
1087 | deferredResult = new Clipperz.Async.Deferred("Record.test.editValueAndRestoreIt", someTestArgs); | ||
1088 | // deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
1089 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_with_multipleRecordVersions_data']); | ||
1090 | deferredResult.addMethod(user, 'login'); | ||
1091 | |||
1092 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1093 | deferredResult.addMethodcaller('getVersions'); | ||
1094 | deferredResult.addCallback(MochiKit.Base.keys); | ||
1095 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
1096 | deferredResult.addTest(5, "the selected record has 5 versions"); | ||
1097 | |||
1098 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1099 | deferredResult.addMethodcaller('fields'); | ||
1100 | deferredResult.addCallback(MochiKit.Base.itemgetter(passwordFieldID)); | ||
1101 | deferredResult.collectResults({ | ||
1102 | 'label': MochiKit.Base.methodcaller('label'), | ||
1103 | 'value': MochiKit.Base.methodcaller('value') | ||
1104 | }); | ||
1105 | deferredResult.addTest({'label': 'password', 'value': 'HRRd7ycaFVG6'},"the current field label and value match", true); | ||
1106 | |||
1107 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1108 | deferredResult.addMethodcaller('fields'); | ||
1109 | deferredResult.addCallback(MochiKit.Base.itemgetter(passwordFieldID)); | ||
1110 | deferredResult.addMethodcaller('setValue', '<<pippo>>'); | ||
1111 | |||
1112 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1113 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
1114 | deferredResult.addTest(true, "changing the value of a field should trigger pending changes"); | ||
1115 | |||
1116 | deferredResult.addMethod(user, 'saveChanges'); | ||
1117 | deferredResult.addMethod(user, 'hasPendingChanges'); | ||
1118 | deferredResult.addTest(false, "after saving, there should be no pending changes"); | ||
1119 | |||
1120 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1121 | deferredResult.addMethodcaller('getVersions'); | ||
1122 | deferredResult.addCallback(MochiKit.Base.keys); | ||
1123 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
1124 | deferredResult.addTest(6, "the selected record, after saving a new version, has now 6 versions"); | ||
1125 | |||
1126 | deferredResult.addMethod(user2, 'login'); | ||
1127 | |||
1128 | deferredResult.addMethod(user2, 'getRecord', recordID); | ||
1129 | deferredResult.addMethodcaller('getVersions'); | ||
1130 | deferredResult.addCallback(MochiKit.Base.keys); | ||
1131 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
1132 | deferredResult.addTest(6, "the selected record - reloaded from the db - has 6 versions"); | ||
1133 | |||
1134 | deferredResult.addMethod(user2, 'getRecord', recordID); | ||
1135 | deferredResult.addMethodcaller('fields'); | ||
1136 | deferredResult.addCallback(MochiKit.Base.itemgetter(passwordFieldID)); | ||
1137 | deferredResult.collectResults({ | ||
1138 | 'label': MochiKit.Base.methodcaller('label'), | ||
1139 | 'value': MochiKit.Base.methodcaller('value') | ||
1140 | }); | ||
1141 | deferredResult.addTest({'label': 'password', 'value': '<<pippo>>'},"the current field label and value match", true); | ||
1142 | |||
1143 | /* | ||
1144 | deferredResult.addCallback(function (aValue) { console.log("FIELDS", aValue); return aValue}); | ||
1145 | |||
1146 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1147 | deferredResult.addMethodcaller('fields'); | ||
1148 | deferredResult.addCallback(MochiKit.Base.itemgetter('4cfaf1e782086e7527bd0e0cc82b67eb773e8157ad0c5babe516f7bc945a02a9')); | ||
1149 | deferredResult.addMethodcaller('setValue', 'joe.clipperz'); | ||
1150 | |||
1151 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1152 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
1153 | deferredResult.addTest(false, "restoring the value of a field should revert pending changes"); | ||
1154 | */ | ||
1155 | |||
1156 | deferredResult.callback(); | ||
1157 | |||
1158 | return deferredResult; | ||
1159 | }, | ||
1160 | |||
1161 | //------------------------------------------------------------------------- | ||
1162 | |||
1163 | 'editNotesAndRestoreIt': function (someTestArgs) { | ||
1164 | var deferredResult; | ||
1165 | var proxy; | ||
1166 | var user; | ||
1167 | |||
1168 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; | ||
1169 | |||
1170 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
1171 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
1172 | |||
1173 | deferredResult = new Clipperz.Async.Deferred("Record.test.editNotesAndRestoreIt", someTestArgs); | ||
1174 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
1175 | deferredResult.addMethod(user, 'login'); | ||
1176 | |||
1177 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1178 | deferredResult.addMethodcaller('notes'); | ||
1179 | deferredResult.addTest('', "the current note is the empty string even if nothing is set on the record"); | ||
1180 | |||
1181 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1182 | deferredResult.addMethodcaller('setNotes', ''); | ||
1183 | |||
1184 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1185 | deferredResult.addMethodcaller('hasPendingChanges'); | ||
1186 | deferredResult.addTest(false, "setting notes to an empty string should be the same has not having the notes altogether"); | ||
1187 | |||
1188 | deferredResult.callback(); | ||
1189 | |||
1190 | return deferredResult; | ||
1191 | }, | ||
1192 | |||
1193 | //------------------------------------------------------------------------- | ||
1194 | |||
1195 | 'loadAllRecordVersions': function (someTestArgs) { | ||
1196 | var deferredResult; | ||
1197 | var proxy; | ||
1198 | var user; | ||
1199 | |||
1200 | var recordID = '2977aa5f99a9f6e5596c1bd7871e82d7328c3716c9ef8ba349ae65f10d97924e'; | ||
1201 | |||
1202 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
1203 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
1204 | |||
1205 | deferredResult = new Clipperz.Async.Deferred("Record.test.loadAllRecordVersions", someTestArgs); | ||
1206 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_with_multipleRecordVersions_data']); | ||
1207 | deferredResult.addMethod(user, 'login'); | ||
1208 | |||
1209 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1210 | deferredResult.addMethodcaller('label'); | ||
1211 | deferredResult.addTest('Amazon.com', "the selected record is the expected one"); | ||
1212 | |||
1213 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1214 | deferredResult.addMethodcaller('getVersions'); | ||
1215 | deferredResult.addCallback(MochiKit.Base.keys); | ||
1216 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
1217 | deferredResult.addTest(5, "the 'Amazon' record has 5 versions"); | ||
1218 | |||
1219 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1220 | deferredResult.addMethodcaller('getCurrentRecordVersion'); | ||
1221 | deferredResult.addMethodcaller('fields'); | ||
1222 | deferredResult.addCallback(MochiKit.Base.keys); | ||
1223 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
1224 | deferredResult.addTest(3, "the current version of 'Amazon' record has 3 fields"); | ||
1225 | |||
1226 | deferredResult.callback(); | ||
1227 | |||
1228 | return deferredResult; | ||
1229 | }, | ||
1230 | |||
1231 | //------------------------------------------------------------------------- | ||
1232 | |||
1233 | 'createDirectLoginAndDeleteItAfterward': function (someTestArgs) { | ||
1234 | var deferredResult; | ||
1235 | var proxy; | ||
1236 | var user, user2; | ||
1237 | var recordID = 'd5f700b9c3367c39551ea49e00a9ab20dae09dd79d46047b983fc7c4bfaa050d'; //YAHOO (4) | ||
1238 | var directLoginReference; | ||
1239 | |||
1240 | proxy = new Clipperz.PM.Proxy.Test({shouldPayTolls:false, isDefault:true, readOnly:false}); | ||
1241 | user = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
1242 | user2 = new Clipperz.PM.DataModel.User({username:'joe', getPassphraseFunction:function () { return 'clipperz';}}); | ||
1243 | |||
1244 | deferredResult = new Clipperz.Async.Deferred("Record.test.addDirectLoginAndRevertChanges", someTestArgs); | ||
1245 | deferredResult.addMethod(proxy.dataStore(), 'setupWithEncryptedData', testData['joe_clipperz_offline_copy_data']); | ||
1246 | deferredResult.addMethod(user, 'login'); | ||
1247 | |||
1248 | deferredResult.addMethod(user, 'getRecord', recordID); | ||
1249 | deferredResult.setValue('record'); | ||
1250 | deferredResult.addMethodcaller('directLogins'); | ||
1251 | deferredResult.addCallback(MochiKit.Base.keys); | ||
1252 | deferredResult.addCallback(MochiKit.Base.itemgetter('length')); | ||
1253 | deferredResult.addTest(4, "the record, when initially loaded, has 4 direct logins"); | ||
1254 | |||
1255 | deferredResult.getValue('record'); | ||
1256 | deferredResult.addMethodcaller('createNewDirectLogin'); | ||
1257 | deferredResult.setValue('directLogin'); | ||
1258 | |||
1259 | deferredResult.getValue('directLogin'); | ||
1260 | deferredResult.addMethodcaller('setLabel', "New direct login"); | ||
1261 | |||
1262 | deferredResult.getValue('directLogin'); | ||
1263 | deferredResult.addMethodcaller('setBookmarkletConfiguration', '{"page": {"title": "Parallels Account"}, "form": {"attributes": {"action": "https://www.parallels.com/account/", "method": "post"}, "inputs": [{"type": "text", "name": "Email", "value": ""}, {"type": "password", "name": "Password", "value": ""}]}, "version": "0.2.3"}'); | ||
1264 | |||
1265 | deferredResult.getValue('directLogin'); | ||
1266 | deferredResult.addMethodcaller('remove'); | ||
1267 | |||
1268 | deferredResult.addMethod(user, 'hasPendingChanges'); | ||
1269 | deferredResult.addTest(false, "after reverting the changes, the user should NOT have pending changes"); | ||
1270 | |||
1271 | deferredResult.callback(); | ||
1272 | |||
1273 | return deferredResult; | ||
1274 | }, | ||
1275 | |||
1276 | //------------------------------------------------------------------------- | ||
1277 | |||
1278 | 'syntaxFix': MochiKit.Base.noop | ||
1279 | }; | ||
1280 | |||
1281 | |||
1282 | |||
1283 | //############################################################################# | ||
1284 | |||
1285 | SimpleTest.runDeferredTests("Clipperz.PM.DataModel.Record", tests, {trace:false}); | ||