/*

Copyright 2008-2011 Clipperz Srl

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.

* 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.

* 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 Clipperz Community Edition.  If not, see
  <http://www.gnu.org/licenses/>.

*/

Clipperz.Crypto.PRNG.defaultRandomGenerator().fastEntropyAccumulationForTestingPurpose();

var tests = {

    //-------------------------------------------------------------------------

	'simple_tests': function(someTestArgs) {
		var	deferredResult;
		var	encryptedRemoteObject;

		var	key;
		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) {
		var	deferredResult;
		var	encryptedRemoteObject;
		var	key;
		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) {
		var	deferredResult;
		var	encryptedRemoteObject;
		var	key;
		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) {
		var	deferredResult;
		var	encryptedRemoteObject;
		var	key;
//		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});