// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "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:
// Brief description of test harness:
// Tests SSL/TLS functionality in SMTS
// Input files required to run test harness:
// The following files should be copied to <drive>:\msgtest\smts\scripts
// t_smtsTlsNotSupported.scr
// t_smtsTlsTempFail.scr
// t_smtsTlsOk.scr
// t_smtsTlsSyntaxError.scr
// t_smtsTlsNoServices.scr
// t_smtsTlsRefused.scr
// t_smtsTlsStopResponding.scr
// t_smtsTlsNewSession.scr
// Output files produced by running test harness:
// <DRIVE>:\msglogs\T_SMTSSECURESOCKETS.<PLATFORM>.<VARIANT>.LOG.txt
// Description of how to build test harness:
// cd \messaging\msg\smts\
// bldmake bldfiles
// abld test build t_SMTSSECURESOCKETS
// Description of how to run test harness:
// The following instructions are the same for all platforms:
// 2. Build the test utilities:
// cd \messaging\msg\testutils\group\
// bldmake bldfiles
// abld build
// WINS running instructions:
// 1. \epoc32\release\wins\<VARIANT>\T_SMTSSECURESOCKETS.exe can be used at the command prompt
// or executable can be run from Windows Explorer.
// All other platform running instructions:
// 1. Copy \epoc32\release\<PLATFORM>\<VARIANT>\T_SMTSSECURESOCKETS.exe onto the other platform
// 2. Copy \epoc32\release\<PLATFORM>\<VARIANT>\MSVTESTUTILS.DLL into 
// <DRIVE>:\system\libs on the other platform
// 3. Copy \epoc32\release\<PLATFORM>\<VARIANT>\EMAILTESTUTILS.DLL into 
// <DRIVE>:\system\libs on the other platform
// 4. Copy \epoc32\wins\c\msgtest\smts\scripts\*.scr to
// <DRIVE>:\msgtest\smts\scripts\
// Note that this drive should be a CF card as the test files are large
// 5. Run T_SMTSSECURESOCKETS.exe on the other platform with the CF card
// 
//

#include "emailtestutils.h"
#include "scripttestutils.h"
#include <cemailaccounts.h>

_LIT(KSmtsTest, "Testing SMTS secure connection with script files");
_LIT(KSmtsComponent,"SMTS");

// Script Files for the Tests
_LIT(KTest1ScriptFile,	"scripts\\t_smtsTlsNotSupported.scr");
_LIT(KTest1Desc,		"Test 1 connects to a server which doesn't support SSLTLS.");
_LIT(KTest1Result,		"Test 1 should finish with -246 (SMTP TLS Negotiate Failed).");

_LIT(KTest2ScriptFile,	"scripts\\t_smtsTlsTempFail.scr");
_LIT(KTest2Desc,		"Test 2 connects to a server which supports SSLTLS, but TLS is not available due to temporary reason.");
_LIT(KTest2Result,		"Test 2 should finish with -185 (SSL TLS Negotiate Failed).");

_LIT(KTest3ScriptFile,	"scripts\\t_smtsTlsOk.scr");
_LIT(KTest3Desc,		"Test 3 connects to a server which supports SSLTLS.");
_LIT(KTest3Result,		"Test 3 should complete with no error.");

_LIT(KTest4ScriptFile,	"scripts\\t_smtsTlsSyntaxError.scr");
_LIT(KTest4Desc,		"Test 4 connects to a server which supports SSLTLS, but returns an Error.");
_LIT(KTest4Result,		"Test 4 should finish with -185 (SSL TLS Negotiate Failed).");

_LIT(KTest5ScriptFile,	"scripts\\t_smtsTlsNoServices.scr");
_LIT(KTest5Desc,		"Test 5 connects to a server which supports SSLTLS, starts TLS, but the server returns no supported services.");
_LIT(KTest5Result,		"Test 5 should finish with -185 (SSL TLS Negotiate Failed).");

_LIT(KTest6ScriptFile,	"scripts\\t_smtsTlsRefused.scr");
_LIT(KTest6Desc,		"Test 6 connects to a server which supports SSLTLS, but then refuses connection, due to lack of security");
_LIT(KTest6Result,		"Test 6 should finish with -244 (SMTP Login Refused).");

_LIT(KTest8ScriptFile,	"scripts\\t_smtsTlsNewSession.scr");
_LIT(KTest8Desc,		"Test 8 - After TLS handshake, the server tries to start new session, by returning STARTTLS");
_LIT(KTest8Result,		"Test 8 should complete with no error, as MTM ignores this command.");

RTest test(KSmtsTest);

LOCAL_D CTrapCleanup* theCleanup;
LOCAL_D CEmailTestUtils* testUtils; 
LOCAL_D TMsvId smtpService;
LOCAL_D CBaseServerMtm* serverMtm;
LOCAL_D TInt testError;


// Class to hold the data required for a Test
class TTestData
	{
	public:
		TInt		iTestNumber;
		TBuf<50>	iTestFile;
		TBuf<200>	iTestDescription;
		TBuf<200>	iTestResult;
	};


LOCAL_C TInt TestSendingMessagesL()
	{
	testError = 0;

	CTestActive* testActive = new (ELeave) CTestActive();
	CleanupStack::PushL(testActive);

	CMsvEntrySelection* sendSel = new(ELeave) CMsvEntrySelection();
	CleanupStack::PushL(sendSel);

	testUtils->iServerEntry->SetEntry(KMsvGlobalOutBoxIndexEntryId);
	User::LeaveIfError(testUtils->iServerEntry->GetChildren(*sendSel));
	TInt count=sendSel->Count();
	if (!count)
		{
		testUtils->WriteComment(_L("\t No messages to send in the outbox"));
		CleanupStack::PopAndDestroy(2); //testActive, sendsel
		testError = KErrNotFound;
		}
	else
		{

		serverMtm->CopyFromLocalL(*sendSel,smtpService, testActive->iStatus);

		testActive->StartL();
		CActiveScheduler::Start();
 		TImSmtpProgress temp;	
		TPckgC<TImSmtpProgress> paramPack(temp);

		const TDesC8& progBuf =serverMtm->Progress();
		paramPack.Set(progBuf);
		TImSmtpProgress progress=paramPack();	
		CleanupStack::PopAndDestroy(2); //testActive, sendsel
		testError = progress.Error();
		}

	return testError;
	}

LOCAL_C void ClosedownL()
	{
	testUtils->TestHarnessCompleted();
	CleanupStack::PopAndDestroy(2);  //testUtils, ischeduler
	}

LOCAL_C void ResetSettingsL(TBool aSecureSocket)
	{
	_LIT(KSmtpServer, "smtp.demon.co.uk");
	_LIT(KSmtpEmailAlias, "SMTP STARTTLS");
	_LIT(KSmtpEmailAddress, "<a@b>");

	// Overwrite the setings with test code one.  Don't want the default settings.
	CImSmtpSettings* settings = new(ELeave) CImSmtpSettings();
	CleanupStack::PushL(settings);
	
	CEmailAccounts* accounts = CEmailAccounts::NewLC();
	
	TSmtpAccount smtpAccountId;
	accounts->GetSmtpAccountL(smtpService,smtpAccountId); 
	accounts->LoadSmtpSettingsL(smtpAccountId, *settings);

	settings->SetServerAddressL(KSmtpServer);
	settings->SetEmailAliasL(KSmtpEmailAlias);
	settings->SetEmailAddressL(KSmtpEmailAddress);
	settings->SetReplyToAddressL(KSmtpEmailAddress);
	settings->SetBodyEncoding(EMsgOutboxMIME);
	settings->SetReceiptAddressL(KSmtpEmailAddress);
	settings->SetSecureSockets(aSecureSocket);
	settings->SetPort(25);
	
	accounts->SaveSmtpSettingsL(smtpAccountId, *settings);

	CleanupStack::PopAndDestroy(2, settings); //settings, store/accounts
	}

LOCAL_C void InitL()
	{
	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install( scheduler );

	testUtils = CEmailTestUtils::NewLC(test);
	testUtils->WriteComment(KSmtsTest);

	testUtils->CleanMessageFolderL();
	testUtils->ClearEmailAccountsL();
	
	testUtils->GoClientSideL();
 	
	smtpService = testUtils->CreateSmtpServiceL();
	ResetSettingsL(ETrue);
	CleanupStack::PopAndDestroy(testUtils);
	testUtils = CEmailTestUtils::NewLC(test, ETuGoServerSide);
	testUtils->InstantiateSmtpServerMtmL();
	serverMtm=testUtils->iSmtpServerMtm;
	testUtils->WriteComment(_L("Smtp server created"));
	}

LOCAL_C void CreateMsgToSendL()
// Create a message to send & place it in the outbox
	{
	TParse scriptFile;
	_LIT(KSmtsRfcFile, "RFC822\\rfc82201.txt");
	testUtils->ResolveFile(KSmtsComponent, KSmtsRfcFile, scriptFile);
	testUtils->CreateMessageL(scriptFile.FullName(), smtpService, KMsvGlobalOutBoxIndexEntryId);
	testUtils->WriteComment(_L(" Message created in the outbox"));
	testUtils->WriteComment(_L("\nPerforming Tests\n"));
	}


LOCAL_C void RunTestL(TTestData& aTestData)
	{
	// Add a blank line to the Log file before the new Test
	_LIT(KBlankLine, "");
	testUtils->WriteComment(KBlankLine);

	TParse scriptFile;
	testUtils->ResolveFile(KSmtsComponent, aTestData.iTestFile, scriptFile);
	testUtils->CopyScriptFileL(scriptFile.FullName(), _L("25"));
	testUtils->TestStart(aTestData.iTestNumber);
	testUtils->WriteComment(aTestData.iTestDescription);
	testUtils->WriteComment(aTestData.iTestResult);
	
	// Run the Test & check the error
	TestSendingMessagesL();
	}


LOCAL_C void RunAllTestsL()
	{
	
	//	Create a Message to Send
	CreateMsgToSendL();

	//-------------------------------
	//	Test 1 - TLS Not Supported
	//-------------------------------
	TTestData testData;
	testData.iTestNumber = 1;
	testData.iTestFile = KTest1ScriptFile;
	testData.iTestDescription = KTest1Desc;
	testData.iTestResult = KTest1Result;
	RunTestL(testData);
	testError=(testError==-246)? 0 : testError;
	testUtils->TestFinish(testData.iTestNumber, testError);

	//-----------------------------------------------------------------
	//	Test 2 - TLS Not Available due to Temp Reason (ie 454 responce)
	//-----------------------------------------------------------------
	testData.iTestNumber = 2;
	testData.iTestFile = KTest2ScriptFile;
	testData.iTestDescription = KTest2Desc;
	testData.iTestResult = KTest2Result;
	RunTestL(testData);
	testError=(testError==-185)? 0 : testError;
	testUtils->TestFinish(testData.iTestNumber, testError);

	//------------------------------------------------------
	//	Test 3 - TLS Supported & Msg Sent (ie 220 responce)
	//------------------------------------------------------
	testData.iTestNumber = 3;
	testData.iTestFile = KTest3ScriptFile;
	testData.iTestDescription = KTest3Desc;
	testData.iTestResult = KTest3Result;
	RunTestL(testData);
	testError=(testError==0)? 0 : testError;
	testUtils->TestFinish(testData.iTestNumber, testError);

	//	Create a Message to Send, as the previous one was sent by Test 3
	CreateMsgToSendL();

	//---------------------------------------------
	//	Test 4 - TLS Syntax Error (ie 501 responce)
	//---------------------------------------------
	testData.iTestNumber = 4;
	testData.iTestFile = KTest4ScriptFile;
	testData.iTestDescription = KTest4Desc;
	testData.iTestResult = KTest4Result;
	RunTestL(testData);
	testError=(testError==-185)? 0 : testError;
	testUtils->TestFinish(testData.iTestNumber, testError);

	//--------------------------------------------------------------------------------------
	//	Test 5 - No Supported Services (After Handshake, Server sends no Supported Services)
	//--------------------------------------------------------------------------------------
	testData.iTestNumber = 5;
	testData.iTestFile = KTest5ScriptFile;
	testData.iTestDescription = KTest5Desc;
	testData.iTestResult = KTest5Result;
	RunTestL(testData);
	testError=(testError==-185)? 0 : testError;
	testUtils->TestFinish(testData.iTestNumber, testError);

	//----------------------------------------
	//	Test 6 - TLS Refusal (ie 554 responce)
	//----------------------------------------
	testData.iTestNumber = 6;
	testData.iTestFile = KTest6ScriptFile;
	testData.iTestDescription = KTest6Desc;
	testData.iTestResult = KTest6Result;
	RunTestL(testData);
	testError=(testError==-244)? 0 : testError;
	testUtils->TestFinish(testData.iTestNumber, testError);

	//----------------------------------------
	//	Test 7 - Server Stops Responding
	//----------------------------------------
/*	testData.iTestNumber = 7;
	testData.iTestFile = KTest7ScriptFile;
	testData.iTestDescription = KTest7Desc;
	testData.iTestResult = KTest7Result;
	RunTestL(testData);*/

	//--------------------------------------------------------------------------
	//	Test 8 - Session Already Active (Server sends STARTTLS after handshake)
	//--------------------------------------------------------------------------
	testData.iTestNumber = 8;
	testData.iTestFile = KTest8ScriptFile;
	testData.iTestDescription = KTest8Desc;
	testData.iTestResult = KTest8Result;
	RunTestL(testData);
	testError=(testError==0)? 0 : testError;
	testUtils->TestFinish(testData.iTestNumber, testError);
	}


LOCAL_C void doMainL()
	{
	InitL();
	testUtils->iServerEntry->SetEntry(smtpService);

	// Set the Setting to use Secure Sockets & Run the Tests
	_LIT(KSecurityOn, "------Set Security On------");
	testUtils->WriteComment(KSecurityOn);
	RunAllTestsL();

	// End of the Tests
	ClosedownL();
	}


GLDEF_C TInt E32Main()
	{	
	__UHEAP_MARK;
	test.Start(_L("T_SMTSSECURESOCKETS Test SMTP server MTM secure connection"));
	theCleanup=CTrapCleanup::New();
	TRAPD(ret,doMainL());		
	test(ret==KErrNone);
	delete theCleanup;	
	test.End();
	test.Close();
	__UHEAP_MARKEND;
	User::Heap().Check();
	return(KErrNone);
	}