// 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 "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:
// T_ImapNewMsgDuringSyncIdleCancel.cpp
// The server waits for the idle read to be cancelled by the sync command, and then sends a '* 2 EXISTS' command to indicate that
// a new message has arrived.
// 2. The client connects to the server, requests a sync and a populate.
// 3. Client / server interact to complete the sync and populate. One message is fetched.
// 4. The client requests a full sync (causing the idle read cancel).
// 5. The server indicates a new message has arrived
// 6. Client / server interact to complete the full sync. The new message is fetched
// 7. The client requests a full sync (causing the idle read cancel).
// 8. The server indicates a new message has arrived
// 9. Client / server interact to complete the full sync. The new message is fetched
// 10. The client disconnects.
// 
//

/**
 @SYMTestCaseID DEF067159
 @SYMTestType UT
 @SYMTestPriority High
 @SYMDEF DEF067159
 @SYMTestCaseDesc IMAP spoof server test that checks that a new message indication is correctly handled if idle read is being cancelled during a sync
 @SYMTestActions 1. The Server is started and listens on port 143.
 @SYMTestExpectedResults Client should have fetched three messages
*/

#include "T_ImapNewMsgDuringSyncIdleCancelClient.h"

#include <mtclbase.h>
#include <mtclreg.h>
#include <miutset.h>
#include <imapset.h>
#include <smtpset.h>
#include <iapprefs.h>
#include <imapcmds.h>

_LIT(KLoopbackAddress,"127.0.0.1");

void TDummySessionObserver::HandleSessionEventL(TMsvSessionEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)
	{
	}
	
CImapNewMsgDuringSyncIdleCancelClient::CImapNewMsgDuringSyncIdleCancelClient(MImapTestEventHandler* aOwner)
 : CActive(EPriorityStandard), iOwner(aOwner)
	{
	CActiveScheduler::Add(this);
	}

EXPORT_C CImapNewMsgDuringSyncIdleCancelClient* CImapNewMsgDuringSyncIdleCancelClient::NewL(MImapTestEventHandler* aOwner)
	{
	CImapNewMsgDuringSyncIdleCancelClient* self = NewLC(aOwner);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CImapNewMsgDuringSyncIdleCancelClient* CImapNewMsgDuringSyncIdleCancelClient::NewLC(MImapTestEventHandler* aOwner)
	{
	CImapNewMsgDuringSyncIdleCancelClient* self = new(ELeave) CImapNewMsgDuringSyncIdleCancelClient(aOwner);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}
	
CImapNewMsgDuringSyncIdleCancelClient::~CImapNewMsgDuringSyncIdleCancelClient()
	{
	Cancel();
	delete iMsvOperation;	
	delete iSelection;
	delete iClientMtm;
	delete iClientRegistry;	
	delete iSession;
	delete iSessionObserver;
	delete iAccounts;
	}
	
	
void CImapNewMsgDuringSyncIdleCancelClient::ConstructL()
	{
	// create an account
	iAccounts = CEmailAccounts::NewL();	
	CreateImapAccountL();
	// Session observer. Needed to create a session
	iSessionObserver = new (ELeave) TDummySessionObserver;
	// Session. Needed to create a client registry.
	iSession=CMsvSession::OpenSyncL(*iSessionObserver);
	// Client registry. Needed to get the MTM component
	iClientRegistry=CClientMtmRegistry::NewL(*iSession,KMsvDefaultTimeoutMicroSeconds32);
	// get the client mtm
	iClientMtm=iClientRegistry->NewMtmL(KUidMsgTypeIMAP4);	
	
	// Load the serial comms device drivers.  If this is not done,
	// connecting via NT-RAS returns KErrNotFound (-1).
	TInt driverErr;
	driverErr=User::LoadPhysicalDevice(PDD_NAME);
	if (driverErr!=KErrNone && driverErr!=KErrAlreadyExists)
		User::Leave(driverErr);
	driverErr=User::LoadLogicalDevice(LDD_NAME);
	if (driverErr!=KErrNone && driverErr!=KErrAlreadyExists)
		User::Leave(driverErr);
	}
	
TImapAccount CImapNewMsgDuringSyncIdleCancelClient::GetImapAccount()
	{
	return iImapAccount;
	}
	
void CImapNewMsgDuringSyncIdleCancelClient::CreateImapAccountL()
	{
	// create objects and initialise with the defaults
	CImImap4Settings* imap4Settings=new(ELeave)CImImap4Settings;
	CleanupStack::PushL(imap4Settings);
	CImSmtpSettings* smtpSettings=new(ELeave)CImSmtpSettings;
	CleanupStack::PushL(smtpSettings);
	CImIAPPreferences* imapIap = CImIAPPreferences::NewLC();
	CImIAPPreferences* smtpIap = CImIAPPreferences::NewLC();
	
	iAccounts->PopulateDefaultImapSettingsL(*imap4Settings, *imapIap);
	iAccounts->PopulateDefaultSmtpSettingsL(*smtpSettings, *smtpIap);
	
	// override some of the defaults
	imap4Settings->SetPasswordL(_L8("roberth"));
	imap4Settings->SetLoginNameL(_L8("roberth"));
	imap4Settings->SetServerAddressL(KLoopbackAddress);
	imap4Settings->SetFolderPathL(_L8(""));
	imap4Settings->SetSynchronise(EUseLocal);
	
	// create the account
	iImapAccount = iAccounts->CreateImapAccountL(_L("TestAccount"), *imap4Settings, *imapIap, EFalse);
	TSmtpAccount smtpAccount;
	smtpAccount = iAccounts->CreateSmtpAccountL(iImapAccount, *smtpSettings, *smtpIap, EFalse);

	// clean up
	CleanupStack::PopAndDestroy(smtpIap);
	CleanupStack::PopAndDestroy(imapIap);	
	CleanupStack::PopAndDestroy(smtpSettings);
	CleanupStack::PopAndDestroy(imap4Settings); 
	}

void CImapNewMsgDuringSyncIdleCancelClient::StartL()
	{
	
	// we are to collect the whole email: the next operation will be to fetch it
	iNextStep = ESync1;
	iSelection = new (ELeave) CMsvEntrySelection;
	TPckg<MMsvImapConnectionObserver*> param(this);
	// select the imap service entry
	iSelection->AppendL(iImapAccount.iImapService);
	// make the service entry the current context
	iClientMtm->SwitchCurrentEntryL(iImapAccount.iImapService);
	// sync the account
	iMsvOperation = iClientMtm->InvokeAsyncFunctionL(KIMAP4MTMConnectAndSyncCompleteAfterFullSync,*iSelection,param,iStatus);
	SetActive();
	}
	
void CImapNewMsgDuringSyncIdleCancelClient::DoCancel()
	{	
	__ASSERT_DEBUG(iMsvOperation!=NULL, User::Panic(_L("CImapNewMsgDuringSyncIdleCancelClient"), -3));
	iMsvOperation->Cancel();
	}

void CImapNewMsgDuringSyncIdleCancelClient::RunL()
	{
	TPckg<MMsvImapConnectionObserver*> param(this);
	
	switch(iNextStep)
		{
		case ESync1:
			{
			// First step is to do a full sync. This will cause the cancel idle to be sent, at
			// which point the spoof server will respond to indicate a new message has been
			// received. Without the defect fix, this step will panic.
			iNextStep=ESync2;
			delete iMsvOperation;
			iMsvOperation=NULL;
			iMsvOperation = iClientMtm->InvokeAsyncFunctionL(KIMAP4MTMFullSync, *iSelection, param, iStatus);
			SetActive();
			break;
			}

		case ESync2:
			{
			// Try to do another full sync. As before, this will cause the cancel idle to be
			// sent, at which point the spoof server will respond to indicate a new message
			// has been received.
			// This step is used to make sure that we have left the session state machine in
			// the correct state after the first step so that further operations can be
			// performed. It also makes it easy to spot when the test fails as for a failure,
			// the panic in the first step will mean only 2 messages are downloaded, whereas
			// for the successful case, 3 messages will be downloaded.
			iNextStep=EDisconnect;
			delete iMsvOperation;
			iMsvOperation=NULL;
			iMsvOperation = iClientMtm->InvokeAsyncFunctionL(KIMAP4MTMFullSync, *iSelection, param, iStatus);
			SetActive();
			break;
			}

		case EDisconnect:
			{
			// We have finished, so do a disconnect
			iNextStep=EComplete;
			delete iMsvOperation;
			iMsvOperation=NULL;
			iMsvOperation = iClientMtm->InvokeAsyncFunctionL(KIMAP4MTMDisconnect,*iSelection,param,iStatus);
			SetActive();
			break;
			}

		case EComplete:
			{
			// inform the owning object that the process is complete
			iOwner->TestComplete(KErrNone);
			break;
			}

		default:
			{
			__ASSERT_DEBUG(0, User::Panic(_L("CImapNewMsgDuringSyncIdleCancelClient unknown state"), KErrUnknown));
			break;			
			}
		}
	}
	
TInt CImapNewMsgDuringSyncIdleCancelClient::RunError(TInt aError)
	{
	iOwner->TestComplete(aError);
	return KErrNone;
	}
	
void CImapNewMsgDuringSyncIdleCancelClient::HandleImapConnectionEvent(TImapConnectionEvent /*aConnectionState*/)
	{
	// this method does nothing
	}