1 files changed, 6 insertions, 9 deletions

diff --git a/frontend/gamma/tests/tests/Clipperz/PM/DataModel/EncryptedRemoteObject.test.js b/frontend/gamma/tests/tests/Clipperz/PM/DataModel/EncryptedRemoteObject.test.js
index 0a4fe0c..9c50c43 100644
--- a/frontend/gamma/tests/tests/Clipperz/PM/DataModel/EncryptedRemoteObject.test.js
+++ b/frontend/gamma/tests/tests/Clipperz/PM/DataModel/EncryptedRemoteObject.test.js
@@ -1,225 +1,222 @@
 /*
 
 Copyright 2008-2011 Clipperz Srl
 
-This file is part of Clipperz's Javascript Crypto Library.
-Javascript Crypto Library provides web developers with an extensive
-and efficient set of cryptographic functions. The library aims to
-obtain maximum execution speed while preserving modularity and
-reusability.
+This file is part of Clipperz Community Edition.
+Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
-refer to http://www.clipperz.com
+refer to http://www.clipperz.com.
 
-* Javascript Crypto Library is free software: you can redistribute
+* Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
-* Javascript Crypto Library is distributed in the hope that it will
+* Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
-  License along with Javascript Crypto Library.  If not, see
+  License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 */
 
 Clipperz.Crypto.PRNG.defaultRandomGenerator().fastEntropyAccumulationForTestingPurpose();
 
 var tests = {
 
     //-------------------------------------------------------------------------
 
         'simple_tests': function(someTestArgs) {
                         vardeferredResult;
                         varencryptedRemoteObject;
 
                         varkey;
                 var version;
                 var rawData;
                 
                 key = "just a random key";
                 version = Clipperz.PM.Crypto.encryptingFunctions.currentVersion;
                 rawData = "just a random text to encrypt";
                 
                 encryptedRemoteObject = new Clipperz.PM.DataModel.EncryptedRemoteObject({
                                 'retrieveKeyFunction':          MochiKit.Base.noop,
                                 'retrieveRemoteDataFunction':function () { return  "--"},
                                 'encryptedDataKeypath':                 '--',
                                 'encryptedVersionKeypath':      '--'
                 });
                 SimpleTest.ok(encryptedRemoteObject != null, "create an encryptedRemoteObject");
                 
                 deferredResult = Clipperz.Async.callbacks("EncryptedRemoteObject.test - simple_tests", [
                         MochiKit.Base.method(encryptedRemoteObject, 'getRemoteData'),
                         function(aResult) {
                                 SimpleTest.is(aResult, "--", "setting and getting serverData works");
                         }
                 ], someTestArgs);
 
                 return deferredResult;
         },
 
     //-------------------------------------------------------------------------
 
         'decrypt_test': function (someTestArgs) {
                         vardeferredResult;
                         varencryptedRemoteObject;
                         varkey;
                 var version;
                 var rawData;
                 
                 key = "just a random key";
                 version = Clipperz.PM.Crypto.encryptingFunctions.currentVersion;
                 rawData = "just a random text to encrypt";
 
                 encryptedRemoteObject = new Clipperz.PM.DataModel.EncryptedRemoteObject({
                                 'retrieveKeyFunction':          MochiKit.Base.partial(MochiKit.Async.succeed, key),
                                 'retrieveRemoteDataFunction':MochiKit.Base.partial(Clipperz.Async.callbacks, "EncryptedRemoteObject.test - decrypt_test <encrypt data>", [
                                 MochiKit.Base.partial(Clipperz.PM.Crypto.deferredEncrypt, {key:key, value:rawData, version:version}),
                                 function (someEncryptedData) {
                                         return {
                                                 'data': someEncryptedData,
                                                 'version': version
                                         }
                                 }
                         ], someTestArgs)//,
         //                      'encryptedDataKeypath':                 'data',
         //                      'encryptedVersionKeypath':      'version'
                 });
 
                 deferredResult = new Clipperz.Async.Deferred("decrypt_test", someTestArgs);
                 deferredResult.addMethod(encryptedRemoteObject, 'getDecryptedData');
                 deferredResult.addCallback(function (aResult) {
                         SimpleTest.is(aResult, rawData, "encrypt and decrypt works");
                 })
                 deferredResult.callback();
                 
                 return deferredResult;
         },
 
     //-------------------------------------------------------------------------
 
         'getValue_test': function (someTestArgs) {
                         vardeferredResult;
                         varencryptedRemoteObject;
                         varkey;
                 var version;
                 var rawData;
                 
                 key = "just a random key";
                 version = Clipperz.PM.Crypto.encryptingFunctions.currentVersion;
                 rawData = {
                         key1: 'value1',
                         key2: 'value2'
                 };
 
                 encryptedRemoteObject = new Clipperz.PM.DataModel.EncryptedRemoteObject({
                                 'reference':                            "testReference",
                                 'retrieveKeyFunction':          MochiKit.Base.partial(MochiKit.Async.succeed, key),
                                 'retrieveRemoteDataFunction':MochiKit.Base.partial(Clipperz.Async.callbacks, "EncryptedRemoteObject.test - decrypt_test <encrypt data>", [
                                 MochiKit.Base.partial(Clipperz.PM.Crypto.deferredEncrypt, {key:key, value:rawData, version:version}),
                                 function (someEncryptedData) {
                                         return {
                                                 'data': someEncryptedData,
                                                 'version': version
                                         }
                                 }
                         ], someTestArgs)//,
         //                      'encryptedDataKeypath':                 'data',
         //                      'encryptedVersionKeypath':      'version'
                 });
 
                 deferredResult = new Clipperz.Async.Deferred("decrypt_test", someTestArgs);
 
                 deferredResult.addMethod(encryptedRemoteObject, 'getValue', 'key1');
                 deferredResult.addTest('value1', "getting 'key1' works");
                 deferredResult.addMethod(encryptedRemoteObject, 'hasAnyCleanTextData');
                 deferredResult.addTest(true, "After accessing a value, hasAnyCleanTextData returns false");
 
                 deferredResult.addMethod(encryptedRemoteObject, 'hasPendingChanges');
                 deferredResult.addTest(false, "if nothing has changed, the object should return not pending changes");
 
                 deferredResult.addMethod(encryptedRemoteObject, 'deleteAllCleanTextData');
                 deferredResult.addMethod(encryptedRemoteObject, 'hasAnyCleanTextData');
                 deferredResult.addTest(false, "After deleting all cleanTextData, hasAnyCleanTextData returns false");
                 
                 deferredResult.addMethod(encryptedRemoteObject, 'getValue', 'key1');
                 deferredResult.addTest('value1', "getting 'key1' (also after a lock) works correctly");
 
                 deferredResult.addMethod(encryptedRemoteObject, 'setValue', 'key1', 'new value1');
                 deferredResult.addMethod(encryptedRemoteObject, 'getValue', 'key1');
                 deferredResult.addTest('new value1', "after setting a new value, it is correctly returned");
 
                 deferredResult.addMethod(encryptedRemoteObject, 'values');
                 deferredResult.addCallback(function (someValues) {
                         SimpleTest.is(someValues['key1'], 'new value1', "the value got straight from the objectStore is correct");
                 });
 
                 deferredResult.addMethod(encryptedRemoteObject, 'hasPendingChanges');
                 deferredResult.addTest(true, "once a value has been changed, the object should return that there're some pending changes");
 
                 deferredResult.addMethod(encryptedRemoteObject, 'revertChanges');
                 deferredResult.addMethod(encryptedRemoteObject, 'hasPendingChanges');
                 deferredResult.addTest(false, "reverting the changes should return the object to its initial state, without any peding changes");
 
                 deferredResult.addMethod(encryptedRemoteObject, 'getValue', 'key1');
                 deferredResult.addTest('value1', "also the value of the changed item has been restored");
 
                 deferredResult.callback();
                 
                 return deferredResult;
         },
 
     //-------------------------------------------------------------------------
 
         'encrypt_with_new_object_test': function (someTestArgs) {
                         vardeferredResult;
                         varencryptedRemoteObject;
                         varkey;
         //      var version;
         //      var rawData;
                 
                 key = "just a random key";
         //      version = Clipperz.PM.Crypto.encryptingFunctions.currentVersion;
         //      rawData = "just a random text to encrypt";
 
                 encryptedRemoteObject = new Clipperz.PM.DataModel.EncryptedRemoteObject({
                                 'retrieveRemoteDataFunction':MochiKit.Base.noop
                 });
 
                 encryptedRemoteObject.setValue('key1', "value1");
                 encryptedRemoteObject.setValue('key2', "value2");
                 encryptedRemoteObject.setValue('key3', "value3");
 
                 deferredResult = new Clipperz.Async.Deferred("encrypt_with_new_object_test", someTestArgs);
                 deferredResult.addMethod(encryptedRemoteObject, 'prepareRemoteDataWithKey', key);
                 deferredResult.addCallback(MochiKit.Base.itemgetter('data'));
                 deferredResult.collectResults({
                                 'key':  MochiKit.Base.partial(MochiKit.Async.succeed, key),
                                 'value':MochiKit.Async.succeed,
                                 'version':MochiKit.Base.partial(MochiKit.Async.succeed, Clipperz.PM.Crypto.encryptingFunctions.currentVersion)
                 });
                 deferredResult.addCallback(Clipperz.PM.Crypto.deferredDecrypt);
                 deferredResult.addCallback(function (aResult) {
                         SimpleTest.is(aResult['key1'], "value1", "encrypt and decrypt works for first element");
                         SimpleTest.is(aResult['key2'], "value2", "encrypt and decrypt works for second element");
                         SimpleTest.is(aResult['key3'], "value3", "encrypt and decrypt works for third element");
                 })
                 deferredResult.callback();
                 
                 return deferredResult;
         },
 
     //-------------------------------------------------------------------------
     //-------------------------------------------------------------------------
     //-------------------------------------------------------------------------
     //-------------------------------------------------------------------------
     'syntaxFix': MochiKit.Base.noop
 };
 
 //#############################################################################
 
 SimpleTest.runDeferredTests("Clipperz.PM.DataModel.EncryptedRemoteObject", tests, {trace:false});