/*

* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <s32mem.h>

#include "tauthdbstep.h"

#include <f32file.h>

using namespace AuthServer;

const TIdentityId KIdentity1Id = 'I1ID';

const TIdentityId KIdentity2Id = 'I2ID';

const TIdentityId KIdentity3Id = 'I3ID';

_LIT(KIdentity1Desc, "identity-1-desc");

_LIT(KIdentity1DescB, "identity-1-descB");

_LIT(KIdentity2Desc, "identity-2-desc");

_LIT(KIdentity3Desc, "identity-3-desc");

const TPluginId KPlugin1Id = 'PID1';

const TPluginId KPlugin2Id = 'PID2';

const TPluginId KPlugin3Id = 'PID3';

const TPluginId KPlugin4Id = 'PID4';

const TPluginId KPluginAId = 'PIDA';

const TPluginId KPluginBId = 'PIDB';

CTStepPersist2::CTStepPersist2()

	{

	SetTestStepName(KTStepCreateTestDb);

	}

TVerdict CTStepPersist2::doTestStepL()

	{

	__UHEAP_MARK;

	RemoveExistingDbL();

	TestOpenCloseL();

	TestIdentitiesL();

	TestPrefsL();

	TestTrainedPluginsL();

	TestTrainingStatusL();

	TestRepairL();

	TestCompressL();

	__UHEAP_MARKEND;

	return EPass;

	}

void CTStepPersist2::TestOpenCloseL()

/**

	Test simply opening and closing a database,

	without using any other operations.

 */

	{

	CAuthDb2* db = CAuthDb2::NewL(iFs);

	delete db;

	}

void CTStepPersist2::TestIdentitiesL()

	{

	TInt r;

	__UHEAP_MARK;

	RemoveExistingDbL();

	CAuthDb2* db = CAuthDb2::NewLC(iFs);

	RArray<TIdentityId> ids;

	// get id list before any ids defined

	ids.AppendL('SYMB');	// garbage; ensure removed

	db->IdentitiesL(ids);

	TESTL(ids.Count() == 0);

	// add an identity

	db->AddIdentityL(KIdentity1Id, KIdentity1Desc);

	db->IdentitiesL(ids);

	TESTL(ids.Count() == 1);

	TESTL(ids[0] == KIdentity1Id);

	// retrieve the identity's description

	TestDescriptionL(db, KIdentity1Id, KIdentity1Desc);

	// change the identity's description

	db->SetDescriptionL(KIdentity1Id, KIdentity1DescB);

	TestDescriptionL(db, KIdentity1Id, KIdentity1DescB);

	// change the identity's description to a string which is

	// too long; ensure fails.

	TBuf<KMaxDescLen + 1> dbuf;

	dbuf.Fill('a', KMaxDescLen - 1);		// limit - 1

	db->SetDescriptionL(KIdentity1Id, dbuf);

	TestDescriptionL(db, KIdentity1Id, dbuf);

	dbuf.Fill('a', KMaxDescLen);			// limit

	db->SetDescriptionL(KIdentity1Id, dbuf);

	TestDescriptionL(db, KIdentity1Id, dbuf);

	db->SetDescriptionL(KIdentity1Id, KIdentity1DescB);

	TestDescriptionL(db, KIdentity1Id, KIdentity1DescB);

	dbuf.Fill('a', KMaxDescLen + 1);		// limit + 1

	TRAP(r, db->SetDescriptionL(KIdentity1Id, dbuf));

	TESTL(r == KErrAuthServDescTooLong);

	TestDescriptionL(db, KIdentity1Id, KIdentity1DescB);	// keep old desc

	// add a second identity

	db->AddIdentityL(KIdentity2Id, KIdentity2Desc);

	db->IdentitiesL(ids);

	TESTL(ids.Count() == 2);

	TESTL(	(ids[0] == KIdentity1Id && ids[1] == KIdentity2Id)

		||	(ids[0] == KIdentity2Id && ids[1] == KIdentity1Id) );

	TestDescriptionL(db, KIdentity1Id, KIdentity1DescB);

	TestDescriptionL(db, KIdentity2Id, KIdentity2Desc);

	// add an identity which already exists

	TRAP(r, db->AddIdentityL(KIdentity2Id, KIdentity2Desc));

	TESTL(r == KErrAuthServIdentityAlreadyExists);

	// retrieve description for an unregistered identity

	TRAP(r, db->DescriptionL(KIdentity3Id));

	TESTL(r == KErrAuthServIdentityNotFound);

	// set description for an unregistered identity

	TRAP(r, db->SetDescriptionL(KIdentity3Id, KIdentity3Desc));

	TESTL(r == KErrAuthServIdentityNotFound);

	// remove an unregistered identity

	TRAP(r, db->RemoveIdentityL(KIdentity3Id));

	TESTL(r == KErrAuthServIdentityNotFound);

	// remove an identity

	db->RemoveIdentityL(KIdentity1Id);

	db->IdentitiesL(ids);

	TESTL(ids.Count() == 1);

	TESTL(ids[0] == KIdentity2Id);

	TestDescriptionL(db, KIdentity2Id, KIdentity2Desc);

	// remove the last identity

	db->RemoveIdentityL(KIdentity2Id);

	db->IdentitiesL(ids);

	TESTL(ids.Count() == 0);

	// create an identity with a description to a string which is

	// too long; ensure fails.

	dbuf.Fill('a', KMaxDescLen - 1);		// limit - 1

	db->AddIdentityL(KIdentity3Id, dbuf);

	TestDescriptionL(db, KIdentity3Id, dbuf);

	db->RemoveIdentityL(KIdentity3Id);

	dbuf.Fill('a', KMaxDescLen);			// limit

	db->AddIdentityL(KIdentity3Id, dbuf);

	TestDescriptionL(db, KIdentity3Id, dbuf);

	db->RemoveIdentityL(KIdentity3Id);

	dbuf.Fill('a', KMaxDescLen + 1);		// limit + 1

	TRAP(r, db->AddIdentityL(KIdentity3Id, dbuf));

	TESTL(r == KErrAuthServDescTooLong);

	db->IdentitiesL(ids);							// no identity created

	TESTL(ids.Count() == 0);

	CleanupStack::PopAndDestroy(db);

	__UHEAP_MARKEND;

	}

void CTStepPersist2::TestDescriptionL(

	CAuthDb2* aDb, TIdentityId aIdentityId, const TDesC& aExpDesc)

/**

	Helper function for TestIdentitiesL.  Ensures the

	supplied identity has the supplied description.

	@param	aDb				Database which contains the identity.

	@param	aIdentity		Identity whose description should be

							retrieved.

	@param	aDesc			Expected description.

 */

	{

	HBufC* desc = aDb->DescriptionL(aIdentityId);

	CleanupStack::PushL(desc);

	TESTL(*desc == aExpDesc);

	CleanupStack::PopAndDestroy(desc);

	}

void CTStepPersist2::TestPrefsL()

/**

	Tests adding, modifying, and removing

	preferences from the database.

 */

	{

	TPluginId prefId;	

	__UHEAP_MARK;

	RemoveExistingDbL();

	CAuthDb2* db = CAuthDb2::NewLC(iFs);

	// get a preferred plugin for a type with no preferred plugin

	prefId = db->PreferredPluginL(EAuthBiometric);

	TESTL(prefId == KUnknownPluginId);

	// set a type's preferred plugin

	db->SetPreferredPluginL(EAuthBiometric, KPlugin1Id);

	prefId = db->PreferredPluginL(EAuthBiometric);

	TESTL(prefId == KPlugin1Id);

	// change a type's preferred plugin

	db->SetPreferredPluginL(EAuthBiometric, KPlugin2Id);

	prefId = db->PreferredPluginL(EAuthBiometric);

	TESTL(prefId == KPlugin2Id);

	// clear a type's preferred plugin

	db->ClearPreferredPluginL(EAuthBiometric);

	prefId = db->PreferredPluginL(EAuthBiometric);

	TESTL(prefId == KUnknownPluginId);

	// set preferred plugin for more than one type

	db->SetPreferredPluginL(EAuthBiometric, KPlugin3Id);

	db->SetPreferredPluginL(EAuthKnowledge, KPlugin4Id);

	prefId = db->PreferredPluginL(EAuthBiometric);

	TESTL(prefId == KPlugin3Id);

	prefId = db->PreferredPluginL(EAuthKnowledge);

	TESTL(prefId == KPlugin4Id);

	CleanupStack::PopAndDestroy(db);

	__UHEAP_MARKEND;

	}

void CTStepPersist2::TestTrainedPluginsL()

/**

	Test adding and removing trained plugins.

 */

	{

	__UHEAP_MARK;

	TInt r;

	RemoveExistingDbL();

	CAuthDb2* db = CAuthDb2::NewLC(iFs);

	const CTransientKeyInfo& tkiA = *iId1Keys[0];

	const CTransientKeyInfo& tkiB = *iId1Keys[1];

	const CTransientKeyInfo& tkiC = *iId1Keys[2];

	// set key info for an unregistered identity

	TRAP(r, db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA));

	TESTL(r == KErrAuthServIdentityNotFound);

	// set key info for a registered identity

	db->AddIdentityL(KIdentity1Id, KIdentity1Desc);

	db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA);

	// get key info for a trained identity

	TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiA);

	// change key info for a trained identity

	db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiB);

	TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiB);

	// ---- bad KeyInfoL args ----

	// get key info for registered identity but untrained plugin

	TRAP(r, db->KeyInfoL(KIdentity1Id, KPluginBId))

	TESTL(r == KErrAuthServTrainingNotFound);

	// get key info for unregistered identity but trained plugin	

	TRAP(r, db->KeyInfoL(KIdentity3Id, KPluginAId))

	TESTL(r == KErrAuthServTrainingNotFound);

	// get key info for unregistered identity and untrained plugin

	TRAP(r, db->KeyInfoL(KIdentity3Id, KPluginBId));

	TESTL(r == KErrAuthServTrainingNotFound);

	// ---- bad RemoveTrainedPluginL args ----

	// clear key info for registered identity but untrained plugin

	TRAP(r, db->KeyInfoL(KIdentity1Id, KPluginBId))

	TESTL(r == KErrAuthServTrainingNotFound);

	// clear key info for unregistered identity but trained plugin	

	TRAP(r, db->RemoveTrainedPluginL(KIdentity3Id, KPluginAId))

	TESTL(r == KErrAuthServTrainingNotFound);

	// clear key info for unregistered identity and untrained plugin

	TRAP(r, db->RemoveTrainedPluginL(KIdentity3Id, KPluginBId));

	TESTL(r == KErrAuthServTrainingNotFound);

	// -----

	// clear a present trained plugin

	db->RemoveTrainedPluginL(KIdentity1Id, KPluginAId);

	TRAP(r, db->KeyInfoL(KIdentity3Id, KPluginAId))

	TESTL(r == KErrAuthServTrainingNotFound);

	// register multiple trained plugins for a single identity	

	db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA);

	db->SetTrainedPluginL(KIdentity1Id, KPluginBId, tkiB);

	TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiA);

	TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiB);

	// train a single plugin for multiple identities

	db->AddIdentityL(KIdentity2Id, KIdentity2Desc);

	db->SetTrainedPluginL(KIdentity2Id, KPluginAId, tkiC);

	TestKeyPresentL(db, KIdentity1Id, KPluginAId, tkiA);

	TestKeyPresentL(db, KIdentity1Id, KPluginBId, tkiB);

	TestKeyPresentL(db, KIdentity2Id, KPluginAId, tkiC);

	// ---- atomic identity and key addition ----

	// add identity with trained plugin

	db->AddIdentityWithTrainedPluginL(KIdentity3Id, KIdentity3Desc, tkiA);

	TestKeyPresentL(db, KIdentity3Id, tkiA.PluginId(), tkiA);

	// fail to add identity with trained plugin - id already exists

	TRAP(r, db->AddIdentityWithTrainedPluginL(KIdentity3Id, KIdentity3Desc, tkiA));

	TESTL(r == KErrAuthServIdentityAlreadyExists);

	CleanupStack::PopAndDestroy(db);

	__UHEAP_MARKEND;

	}

void CTStepPersist2::TestKeyPresentL(

	CAuthDb2* aAuthDb, TIdentityId aIdentityId, TPluginId aPluginId,

	const CTransientKeyInfo& aTarget)

/**

	Helper function for TestTrainedPluginsL.

	Test the described transient key exists in the database,

	and that is is equal to the supplied key.  Leaves if not

	the case.

	@param	aAuthDb			Authorisation database to retrieve

							transient key info from.

	@param	aIdentityId		Identity which should be trained for

							the supplied plugin.

	@param	aPluginId		Plugin for which the supplied identity

							should be trained.

	@param	aTarget			The retrieved transient key info should

							be equal to this.

 */

	{

	CTransientKeyInfo* tkiActual = aAuthDb->KeyInfoL(aIdentityId, aPluginId);

	CleanupStack::PushL(tkiActual);

	// ensure key infos have same externalized size

	TSizeStream ssTarget;

	RWriteStream wsTarget(&ssTarget);

	aTarget.ExternalizeL(wsTarget);

	TInt targetSize = ssTarget.Size();

	TSizeStream ssActual;

	RWriteStream wsActual(&ssActual);

	tkiActual->ExternalizeL(wsActual);

	TESTL(targetSize == ssActual.Size());

	HBufC8* targetBuf = HBufC8::NewLC(targetSize);

	TPtr8 targetBufDes = targetBuf->Des();

	RDesWriteStream dwsTarget(targetBufDes);

	aTarget.ExternalizeL(dwsTarget);

	HBufC8* actualBuf = HBufC8::NewLC(targetSize);

	TPtr8 actualBufDes = actualBuf->Des();

	RDesWriteStream dwsActual(actualBufDes);

	tkiActual->ExternalizeL(dwsActual);

	TESTL(targetBufDes == actualBufDes);

	CleanupStack::PopAndDestroy(3, tkiActual);

	}

void CTStepPersist2::TestTrainingStatusL()

/**

	Test the plugins' training statuses accurately

	reflect the identities which are registered

	with them.

 */

	{

	__UHEAP_MARK;

	RemoveExistingDbL();

	CAuthDb2* db = CAuthDb2::NewLC(iFs);

	// if there are no users then a plugin should be marked

	// as untrained, even though its training count is equal

	// to the number of registered identities.

	TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained);

	// untrained when no users trained

	db->AddIdentityL(KIdentity1Id, KIdentity1Desc);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained);

	db->AddIdentityL(KIdentity2Id, KIdentity2Desc);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained);

	// trained when some, but not all, users trained

	const CTransientKeyInfo& tkiA = *iId1Keys[0];

	db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthTrained);

	// fully trained when all users trained

	db->SetTrainedPluginL(KIdentity2Id, KPluginAId, tkiA);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthFullyTrained);

	// back to trained when identity untrained

	db->RemoveTrainedPluginL(KIdentity1Id, KPluginAId);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthTrained);

	// back to untrained when last training removed

	db->RemoveTrainedPluginL(KIdentity2Id, KPluginAId);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained);

	// restored to trained when identity trained

	db->SetTrainedPluginL(KIdentity1Id, KPluginAId, tkiA);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthTrained);

	// restored to fully trained when last identity trained

	db->SetTrainedPluginL(KIdentity2Id, KPluginAId, tkiA);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthFullyTrained);

	// back to trained when new identity added

	db->AddIdentityL(KIdentity3Id, KIdentity3Desc);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthTrained);

	// upgraded to fully trained when untrained identity removed

	db->RemoveIdentityL(KIdentity3Id);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthFullyTrained);

	// kept at fully trained when trained identity removed

	db->RemoveIdentityL(KIdentity2Id);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthFullyTrained);

	// drop to untrained when last identity removed

	db->RemoveIdentityL(KIdentity1Id);

	TESTL(db->PluginStatusL(KPluginAId) == EAuthUntrained);

	CleanupStack::PopAndDestroy(db);

	__UHEAP_MARKEND;

	}

static void IdToTestDesc(TIdentityId aId, TDes& aDesc)

/**

	Helper function for TestRepairL generates a description

	from the supplied identity.

	@param	aId				Identity Id.

	@param	aDesc			Out paramater is populated with

							description text.

 */

	{

	_LIT(KDescFmt, "desc_%08x");

	aDesc.Format(KDescFmt, aId);

	}

void CTStepPersist2::TestRepairL()

/**

	Test CAuthDb repairs the database if possible.

 */

	{

	RemoveExistingDbL();

	CAuthDb2* db = CAuthDb2::NewLC(iFs);

	// create a set of identities

	const TInt KTestIdCount = 8;

	for (TInt i = 1; i <= KTestIdCount; ++i)

		{

		TBuf<13> buf;

		IdToTestDesc(i, buf);

		db->AddIdentityL(i, buf);

		}

	CleanupStack::PopAndDestroy(db);

	// damage the database by inserting a new entry but then

	// rolling it back.

	RDbNamedDatabase ndb;

	TFileName dbName(KDbName);

	dbName[0] = RFs::GetSystemDriveChar();

	User::LeaveIfError(ndb.Open(iFs, dbName));

	CleanupClosePushL(ndb);

	User::LeaveIfError(ndb.Begin());

	RDbTable table;

	CleanupClosePushL(table);

	User::LeaveIfError(table.Open(ndb, KIdentitiesTableName));

	table.InsertL();

	table.SetColL(KIdentitiesIdentityIdCol, KTestIdCount+1);

	table.SetColL(KIdentitiesDescCol, _L("descb"));

	table.PutL();

	table.Close();

	ndb.Rollback();

	TESTL(ndb.IsDamaged());

	CleanupStack::PopAndDestroy(2, &ndb);	// table ndb

	// ensure db contains the same identities when it

	// is reopened.

	db = CAuthDb2::NewLC(iFs);

	RArray<TIdentityId> ids;

	db->IdentitiesL(ids);

	TInt idCount = ids.Count();

	ids.Reset();

	TESTL(idCount == KTestIdCount);