/*

* Copyright (c) 2003-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 <test/testexecutelog.h>

#include <s32mem.h>

#include "cafserver.h"

#include "SupplierStep.h"

#include "supplier.h"

#include "cafmimeheader.h"

#include "caferr.h"

#include "metadataarray.h"

#include "supplieroutputfile.h"

#include "attribute.h"

#include "bitset.h"

#include <uri8.h>

#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY

#include <http.h>

#include <http/rhttpsession.h>

#include <http/rhttptransaction.h>

#include <http/rhttpheaders.h>

#endif

using namespace ContentAccess;

/* 

 * This step imports a DCF file into CAF 

 *

 */

CCafSupplierStep::~CCafSupplierStep()

	{

	}

CCafSupplierStep::CCafSupplierStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFSupplierStep);

	}

TVerdict CCafSupplierStep::doTestStepL()

	{

	SetTestStepResult(EInconclusive);

	RFs fs;

	RFile file;

	TBuf8 <128> readBuffer;

	INFO_PRINTF1(_L("Supplier Test - Agent provides output files"));

	TPtrC outputDirectory, sourceFileName, suggestedFileName, mimeType;

	TInt expectedLeave;

	// Get parameters from INI file

	GetStringFromConfig(ConfigSection(),_L("OutputPath"),outputDirectory);

	GetStringFromConfig(ConfigSection(),_L("SourceFileName"),sourceFileName);

	GetStringFromConfig(ConfigSection(),_L("SuggestedFileName"),suggestedFileName);

	GetStringFromConfig(ConfigSection(),_L("MimeType"),mimeType);

	GetIntFromConfig(ConfigSection(),_L("LeaveResult"),expectedLeave);

	StartApparcServerL();

	__UHEAP_MARK;

	HBufC8 *mime = ConvertDes16toHBufC8LC(mimeType);

	CCafMimeHeader *header = CCafMimeHeader::NewL(mime->Des());

	CleanupStack::PushL(header);

	CSupplier *mySupplier = CSupplier::NewLC();

	mySupplier->SetOutputDirectoryL(outputDirectory);

	// ignore return value, just exercises code for CCover

	mySupplier->IsImportSupported(header->StandardMimeData(EContentType));

	CImportFile *import = NULL;

	TRAPD(leaveResult, import = mySupplier->ImportFileL(*header, suggestedFileName));

	if(leaveResult != expectedLeave)

		{

		SetTestStepResult(EFail);

		}

	if(leaveResult == KErrNone)

		{

		CleanupStack::PushL(import);

		// read the input file and pass it to the CAF

		fs.Connect();

		CleanupClosePushL(fs);

		TInt result = file.Open(fs, sourceFileName, EFileRead | EFileStream | EFileShareAny);

		CleanupClosePushL(file);

		while(result == KErrNone)

			{

			result = file.Read(readBuffer);

			if(readBuffer.Length() == 0)

				break;

			User::LeaveIfError(import->WriteData(readBuffer));

			}

		CleanupStack::PopAndDestroy(&file); 

		User::LeaveIfError(import->WriteDataComplete());

		TInt n = import->OutputFileCountL();

		for(TInt i = 0; i < n; i++)

			{

			// get output file name

			TPtrC OutputFileName = import->OutputFileL(i).FileName();

			INFO_PRINTF2(_L("Output File Created: %S"),&OutputFileName);

			// get output file type (content or receipt)

			TOutputType outputType = import->OutputFileL(i).OutputType();

			if(outputType == EReceipt)

				{

				INFO_PRINTF1(_L("Output File is a receipt"));

				}

			else

				{

				INFO_PRINTF1(_L("Output File is content"));

				}

			// get output file mime type

			TPtrC8 OutputMimeType = import->OutputFileL(i).MimeTypeL();

			HBufC *mime = ConvertDes8toHBufC16LC(OutputMimeType );

			INFO_PRINTF2(_L("Output File Mime Type: %S"),mime);

			CleanupStack::PopAndDestroy(mime); 

			}

		CleanupStack::PopAndDestroy(&fs); 

		CleanupStack::PopAndDestroy(import); 

		}

	CleanupStack::PopAndDestroy(mySupplier); 

	CleanupStack::PopAndDestroy(header); 

	CleanupStack::PopAndDestroy(mime); 

	__UHEAP_MARKEND;

	if (TestStepResult() != EFail)

		{

		SetTestStepResult(EPass);

		}

	return TestStepResult();

	}

/* 

 * This step imports a DCF file into CAF 

 *

 */

CCafSupplierAsyncStep::~CCafSupplierAsyncStep()

	{

	}

CCafSupplierAsyncStep::CCafSupplierAsyncStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFSupplierAsyncStep);

	}

TVerdict CCafSupplierAsyncStep::doTestStepL()

	{

	SetTestStepResult(EInconclusive);

	RFs fs;

	RFile file;

	TBuf8 <128> readBuffer;

	TRequestStatus status;

	INFO_PRINTF1(_L("Asynchronous Supplier Test - Agent provides output files"));

	TPtrC outputDirectory, sourceFileName, suggestedFileName, mimeType;

	TInt expectedLeave;

	// Get parameters from INI file

	GetStringFromConfig(ConfigSection(),_L("OutputPath"),outputDirectory);

	GetStringFromConfig(ConfigSection(),_L("SourceFileName"),sourceFileName);

	GetStringFromConfig(ConfigSection(),_L("SuggestedFileName"),suggestedFileName);

	GetStringFromConfig(ConfigSection(),_L("MimeType"),mimeType);

	GetIntFromConfig(ConfigSection(),_L("LeaveResult"),expectedLeave);

	StartApparcServerL();

	__UHEAP_MARK;

	HBufC8 *mime = ConvertDes16toHBufC8LC(mimeType);

	CCafMimeHeader *header = CCafMimeHeader::NewL(mime->Des());

	CleanupStack::PushL(header);

	CSupplier *mySupplier = CSupplier::NewLC();

	mySupplier->SetOutputDirectoryL(outputDirectory);

	// ignore return value, just exercises code for CCover

	mySupplier->IsImportSupported(header->StandardMimeData(EContentType));

	CImportFile *import = NULL;

	TRAPD(leaveResult, import = mySupplier->ImportFileL(*header, suggestedFileName));

	if(leaveResult != expectedLeave)

		{

		SetTestStepResult(EFail);

		}

	if(leaveResult == KErrNone)

		{

		CleanupStack::PushL(import);

		// read the input file and pass it to the CAF

		fs.Connect();

		CleanupClosePushL(fs);

		TInt result = file.Open(fs, sourceFileName, EFileRead | EFileStream | EFileShareAny);

		CleanupClosePushL(file);

		while(result == KErrNone)

			{

			result = file.Read(readBuffer);

			if(readBuffer.Length() == 0)

				break;

			status = KRequestPending;

			import->WriteData(readBuffer,status);

			User::WaitForRequest(status);

			}

		CleanupStack::PopAndDestroy(&file); 

		status = KRequestPending;

		import->WriteDataComplete(status);

		User::WaitForRequest(status);

		TInt n = import->OutputFileCountL();

		for(TInt i = 0; i < n; i++)

			{

			// get output file name

			TPtrC OutputFileName = import->OutputFileL(i).FileName();

			INFO_PRINTF2(_L("Output File Created: %S"),&OutputFileName);

			// get output file type (content or receipt)

			TOutputType outputType = import->OutputFileL(i).OutputType();

			if(outputType == EReceipt)

				{

				INFO_PRINTF1(_L("Output File is a receipt"));

				}

			else

				{

				INFO_PRINTF1(_L("Output File is content"));

				}

			// get output file mime type

			TPtrC8 OutputMimeType = import->OutputFileL(i).MimeTypeL();

			HBufC *mime = ConvertDes8toHBufC16LC(OutputMimeType );

			INFO_PRINTF2(_L("Output File Mime Type: %S"),mime);

			CleanupStack::PopAndDestroy(mime); 

			}

		CleanupStack::PopAndDestroy(&fs); 

		CleanupStack::PopAndDestroy(import); 

		}

	CleanupStack::PopAndDestroy(mySupplier); 

	CleanupStack::PopAndDestroy(header); 

	CleanupStack::PopAndDestroy(mime); 

	__UHEAP_MARKEND;

	if (TestStepResult() != EFail)

		{

		SetTestStepResult(EPass);

		}

	return TestStepResult();

	}

/* 

 * This step imports a DCF file into CAF 

 *

 */

CCafClientOutputSupplierStep::~CCafClientOutputSupplierStep()

	{

	}

CCafClientOutputSupplierStep::CCafClientOutputSupplierStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFClientOutputSupplierStep);

	}

void CCafClientOutputSupplierStep::CheckContentMimeL(CImportFile* aImport, TDes8& aContentMime, TDesC8& aExpectedContentMime)

	{

	if(!aImport->ContentMimeTypeL(aContentMime))

		{

		//Agent can't determine the content MIME type with available data at the moment

		INFO_PRINTF1(_L("Content MIME Type can't be determined"));

		SetTestStepResult(EFail);

		return;

		}

	//If we reach here, we are expecting a correct Content MIME type 

	HBufC *mime = ConvertDes8toHBufC16LC(aContentMime);

	INFO_PRINTF2(_L("Content MIME Type: %S"), mime);

	CleanupStack::PopAndDestroy(mime);

	if(aContentMime.CompareF(aExpectedContentMime) == 0)

		{

		SetTestStepResult(EPass);

		}

	else

		{

		ERR_PRINTF1(_L("Content MIME Type doesn't match expected"));

		SetTestStepResult(EFail);

		}

	}

TVerdict CCafClientOutputSupplierStep::doTestStepL()

	{

	SetTestStepResult(EInconclusive);

	RFs fs;

	RFile file;

	TBuf8 <128> readBuffer;

	TBuf8 <255> mimetype8;

	TFileName outputFileName;

	RFile outputFile;

	CImportFile *import = NULL;

	// first output file will be a.txt

	_LIT(KOutputFileName, "C:\\something.drm");

	outputFileName.Copy(KOutputFileName);

	INFO_PRINTF1(_L("Supplier Test - Client provides output files"));

	TPtrC outputDirectory, sourceFileName, suggestedFileName, mimeType, expectedContentMime;

	TInt expectedLeave;

	TBool checkContentMime = EFalse;

	TBuf8<KMaxDataTypeLength> contentMimeType;	

	// Get parameters from INI file

	GetStringFromConfig(ConfigSection(),_L("OutputPath"),outputDirectory);

	GetStringFromConfig(ConfigSection(),_L("SourceFileName"),sourceFileName);

	GetStringFromConfig(ConfigSection(),_L("SuggestedFileName"),suggestedFileName);

	GetStringFromConfig(ConfigSection(),_L("MimeType"),mimeType);

	GetIntFromConfig(ConfigSection(),_L("LeaveResult"),expectedLeave);

	GetStringFromConfig(ConfigSection(),_L("ExpectedContentMime"),expectedContentMime);

	GetBoolFromConfig(ConfigSection(),_L("CheckContentMime"),checkContentMime);

	StartApparcServerL();

	__UHEAP_MARK;

	mimetype8.Copy(mimeType);

	// fill in meta data - just the mime type really

	CMetaDataArray *array = CMetaDataArray::NewL();

	CleanupStack::PushL(array);

	_LIT8(KContentType,"content-type");

	array->AddL(KContentType(), mimetype8);

	// create a supplier session

	CSupplier *mySupplier = CSupplier::NewL();

	CleanupStack::PushL(mySupplier);

	// check import is supported, ignore return value, just exercises code for CCover

	mySupplier->IsImportSupported(array->SearchL(KContentType()));

	// create import session

	TRAPD(leaveResult, import = mySupplier->ImportFileL(mimetype8, *array));

	if(leaveResult != expectedLeave)

		{

		SetTestStepResult(EFail);

		}

	if(leaveResult == KErrNone)

		{

		CleanupStack::PushL(import);

		// read the input file and pass it to the CAF

		fs.Connect();

		CleanupClosePushL(fs);

		TInt result = file.Open(fs, sourceFileName, EFileRead | EFileStream | EFileShareAny);

		CleanupClosePushL(file);

		TParsePtrC parse(suggestedFileName);

		TPtrC desiredOutFileName( parse.Name() );

		while(result == KErrNone)

			{

			result = file.Read(readBuffer);

			if(readBuffer.Length() == 0)

				break;

			result = import->WriteData(readBuffer);

			while(result == KErrCANewFileHandleRequired)

				{

				if(checkContentMime)

					{

					//If CheckContentMimeL failed, Client code should assume content MIME type wouldn't

					//be available until after the supply session has finished. The imported data could be

					//output to default location

					//In this test step, data are always output to default location regardless of content MIME

					//type

					TBuf8<KMaxDataTypeLength> expectedContentMime8bit;

					expectedContentMime8bit.Copy(expectedContentMime);

					CheckContentMimeL(import, contentMimeType, expectedContentMime8bit);

					//no more check needed in following iterations

					checkContentMime = EFalse;

					//At this point client should decide where to save the file based on content mime

					}

				const TInt KMaxExtLen = 28;

				TBuf<KMaxExtLen> suggestedExt;

				User::LeaveIfError(import->GetSuggestedOutputFileExtension(suggestedExt));

				outputFileName.Copy(outputDirectory);

				outputFileName.Append(desiredOutFileName);

				outputFileName.Append(suggestedExt);

				// create a new outputfile

				fs.Delete(outputFileName);

				User::LeaveIfError(outputFile.Create(fs,outputFileName, EFileShareAny  | EFileStream | EFileWrite));

				result = import->ContinueWithNewOutputFile(outputFile,outputFileName);

				outputFile.Close();

				}

			User::LeaveIfError(result);

			}

		CleanupStack::PopAndDestroy(&file); 

		result = import->WriteDataComplete();

		while(result == KErrCANewFileHandleRequired)

				{

				TFileName suggestedName;

				User::LeaveIfError(import->GetSuggestedOutputFileName(suggestedName));

				outputFileName.Copy(outputDirectory);

				outputFileName.Append(suggestedName);

				// create a new outputfile

				fs.Delete(outputFileName);

				User::LeaveIfError(outputFile.Create(fs,outputFileName, EFileShareAny  | EFileStream | EFileWrite));

				result = import->ContinueWithNewOutputFile(outputFile,outputFileName);

				outputFile.Close();

				}

		TInt n = import->OutputFileCountL();

		for(TInt i = 0; i < n; i++)

			{

			// get output file name

			TPtrC OutputFileName = import->OutputFileL(i).FileName();

			INFO_PRINTF2(_L("Output File Created: %S"),&OutputFileName);

			// get output file type (content or receipt)

			TOutputType outputType = import->OutputFileL(i).OutputType();

			if(outputType == EReceipt)

				{

				INFO_PRINTF1(_L("Output File is a receipt"));

				}

			else

				{

				INFO_PRINTF1(_L("Output File is content"));

				}

			// get output file mime type

			TPtrC8 OutputMimeType = import->OutputFileL(i).MimeTypeL();

			HBufC *mime = ConvertDes8toHBufC16LC(OutputMimeType );

			INFO_PRINTF2(_L("Output File Mime Type: %S"),mime);

			CleanupStack::PopAndDestroy(mime); 

			}

		CleanupStack::PopAndDestroy(&fs); 

		CleanupStack::PopAndDestroy(import); 

		}

	CleanupStack::PopAndDestroy(mySupplier); 

	CleanupStack::PopAndDestroy(array); 

	__UHEAP_MARKEND;

	if (TestStepResult() != EFail)

		{

		SetTestStepResult(EPass);

		}

	return TestStepResult();

	}

/* 

 * This step tests the ExternalizeL() and InternalizeL() functions for

 * CCafMimeHeader

 */

CCAFSupplierSerializeStep::~CCAFSupplierSerializeStep()

	{

	}

CCAFSupplierSerializeStep::CCAFSupplierSerializeStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFSupplierSerializeStep);

	}

TVerdict CCAFSupplierSerializeStep::doTestStepL()

	{	

	_LIT8(KDrmMime,"application/testagent.drm");

	_LIT8(KBinaryEncoding,"Binary");

	_LIT8(KOmaRightsPending, "X-Oma-Drm-Separate-Delivery");

	_LIT8(KOmaRightsPendingValue, "12");

	SetTestStepResult(EInconclusive); // Default result to EInconclusive

	__UHEAP_MARK;

	// create a CafMimeHeader with "content type:" application/testagent.drm

	CCafMimeHeader *header = CCafMimeHeader::NewL(KDrmMime());

	CleanupStack::PushL(header);

	// Add some information to the header

	header->SetStandardMimeDataL(EContentTransferEncoding, KBinaryEncoding());

	header->AddNonStandardMimeL(KOmaRightsPending(), KOmaRightsPendingValue());

	// Create a buffer stream

	CBufFlat* buf = CBufFlat::NewL(50);

	CleanupStack::PushL(buf);

	RBufWriteStream stream(*buf);

	CleanupClosePushL(stream);

	// call the stream function

	stream << *header;

	CleanupStack::PopAndDestroy(&stream);

	// Now, create an HBufC8 from the stream buf's length, and copy 

	// the stream buffer into this descriptor

	HBufC8* des = HBufC8::NewL(buf->Size());

	TPtr8 ptr(des->Des());

	buf->Read(0, ptr, buf->Size());

	// destroy the buffer

	CleanupStack::PopAndDestroy(buf);

	CleanupStack::PushL(des);

	// Now, stream a new CCafMimeHeader from the descriptor

	CCafMimeHeader* newHeader = CCafMimeHeader::NewL(KNullDesC8());

	CleanupStack::PushL(newHeader);

	RDesReadStream readstream(*des);

	CleanupClosePushL(readstream);

	readstream >> *newHeader;

	CleanupStack::PopAndDestroy(&readstream);

	// Now check that the new bitset equals the old one

	TInt result = newHeader->StandardMimeData(EContentType).Compare(KDrmMime());

	if (result != 0)

		{

		INFO_PRINTF1(_L("Content type was not copied properly during seriaization"));

		SetTestStepResult(EFail);

		}

	result = newHeader->StandardMimeData(EContentTransferEncoding).Compare(KBinaryEncoding());

	if (result != 0)

		{

		INFO_PRINTF1(_L("Content Length was not copied properly during seriaization"));

		SetTestStepResult(EFail);

		}

	if (newHeader->NonStandardMimeCount() != 1)

		{

		INFO_PRINTF1(_L("Non standard field array not copied properly during seriaization"));

		SetTestStepResult(EFail);

		}

	result = newHeader->NonStandardMimeField(0).Compare(KOmaRightsPending());

	if (result != 0)

		{

		INFO_PRINTF1(_L("Non standard field not copied properly during seriaization"));

		SetTestStepResult(EFail);

		}

	result = newHeader->NonStandardMimeData(0).Compare(KOmaRightsPendingValue());

	if (result != 0)

		{

		INFO_PRINTF1(_L("Non standard field data was not copied properly during seriaization"));

		SetTestStepResult(EFail);

		}

	CleanupStack::PopAndDestroy(3, header);

	__UHEAP_MARKEND;

	if (TestStepResult() != EFail)

		{

		SetTestStepResult(EPass);

		}

	return TestStepResult();

	}

#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY

/* 

 * Check that applications can retrieve the HTTP request headers

 */

CCAFHTTPRequestHeadersStep::~CCAFHTTPRequestHeadersStep()

	{

	}

CCAFHTTPRequestHeadersStep::CCAFHTTPRequestHeadersStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFHTTPRequestHeadersStep);

	}

void CCAFHTTPRequestHeadersStep::MHFRunL(RHTTPTransaction, const THTTPEvent&)

	{

	}

TInt CCAFHTTPRequestHeadersStep::MHFRunError(TInt, RHTTPTransaction, const THTTPEvent&)

	{

	return 0;

	}

TVerdict CCAFHTTPRequestHeadersStep::doTestStepL()

	{	

	_LIT8(Kuri, "http://www.symbian.com/");

	TPtrC8 acceptHeader;

	TInt i = 0;

	TInt result = 0;

	SetTestStepResult(EInconclusive); // Default result to EInconclusive

	THTTPHdrVal aValue;

	__UHEAP_MARK;

	CSupplier* supplier = CSupplier::NewLC();

	// Create an HTTP session 

	RHTTPSession session;

	session.OpenL();

	RStringPool pool = session.StringPool();

	// Convert the URI string into a TUri8

	TUriParser8 parser;

	parser.Parse(Kuri());

	// create an HTTP transaction

	RHTTPTransaction transaction = session.OpenTransactionL(parser, *this, pool.StringF(HTTP::EGET,RHTTPSession::GetTable()));

	RHTTPHeaders hdr = transaction.Request().GetHeaderCollection();

	// Get the request headers from the agent

	supplier->PrepareHTTPRequestHeaders(pool, hdr);

	TInt fieldParts = hdr.FieldPartsL(pool.StringF(HTTP::EAccept, RHTTPSession::GetTable()));

	if(fieldParts == 3)

		{

		for(i = 0; i < fieldParts; i++)

			{

			// loop over all accept headers make sure we find the three we expect

			User::LeaveIfError(hdr.GetField(pool.StringF(HTTP::EAccept, RHTTPSession::GetTable()), i, aValue));

			RStringF header = (RStringF) aValue;

			acceptHeader.Set(header.DesC()); 

			// Reference Test Agent - content MIME type

			if(acceptHeader.Compare(_L8("application/x-rta.drm.content")) == 0)

				{

				result |= 1;

				}

			// Reference Test Agent - content + rights MIME type

			else if(acceptHeader.Compare(_L8("application/x-rta.drm.contentrights")) == 0)

				{

				result |= 2;

				}

			// Test Agent - MIME type

			else if(acceptHeader.Compare(_L8("APPLICATION/TESTAGENT.DRM")) == 0)

				{

				result |= 4;

				}

			}

		if(result != 7)

			{

			// not all three headers were found

			INFO_PRINTF1(_L("Not all expected HTTP Accept headers were present"));

			SetTestStepResult(EFail);		

			}

		}

	else

		{

		// We were expecting three accept headers to be set

		// two from the Reference Test Agent and one from Test Agent

		INFO_PRINTF2(_L("ERROR: Only %d HTTP Accept headers were returned, expected 3"), fieldParts);

		SetTestStepResult(EFail);	

		}

	transaction.Close();

	session.Close();

	CleanupStack::PopAndDestroy(supplier);

	__UHEAP_MARKEND;

	if (TestStepResult() != EFail)

		{

		SetTestStepResult(EPass);

		}

	return TestStepResult();

	}

#endif