/*

* Copyright (c) 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:

*

*/

#include "ut_logsdbconnector.h"

#include "logsdbconnector.h"

#include "logsevent.h"

#include "logsmodel.h"

#include "logsreader.h"

#include "logscommondata.h"

#include <QtTest/QtTest>

Q_DECLARE_METATYPE(QList<int>)

#define LOGS_TEST_CREATE_EVENT_WITHOUT_IDX(eventName, id, eventState ) \

LogsEvent* eventName = new LogsEvent; \

eventName->setLogId(id);\

eventName->setIsInView(true); \

eventName->mEventState = eventState; \

mDbConnector->mEvents.insert(id, eventName)

#define LOGS_TEST_CREATE_EVENT(eventName, index, eventState ) \

LogsEvent* eventName = new LogsEvent; \

eventName->setIndex(index); \

eventName->setLogId(index);\

eventName->setIsInView(true); \

eventName->mEventState = eventState; \

mDbConnector->mEvents.insert(index, eventName)

#define ADD_EVENT_WITH_ID( arr, id ) \

{\

LogsEvent* ev = new LogsEvent;\

ev->setLogId(id);\

arr.append(ev);\

}

#define ADD_EVENT_WITH_ID_2( arr, id ) \

{\

LogsEvent ev;\

ev.setLogId(id);\

arr.append(ev);\

}

void UT_LogsDbConnector::initTestCase()

{

}

void UT_LogsDbConnector::cleanupTestCase()

{

}

void UT_LogsDbConnector::init()

{

    mDbConnector = new LogsDbConnector(mEvents);

}

void UT_LogsDbConnector::cleanup()

{

    delete mDbConnector;

    mDbConnector = 0;

}

void UT_LogsDbConnector::testConstructor()

{

    QVERIFY( mDbConnector );

}

void UT_LogsDbConnector::testInit()

{

    QVERIFY( !mDbConnector->mLogsRemove );

    QVERIFY( mDbConnector->init() == 0 );

    QVERIFY( mDbConnector->mReader );

    QVERIFY( mDbConnector->mLogsRemove );

    QVERIFY( mDbConnector->mLogEventStrings.iFetched.length() > 0 );

    QVERIFY( !mDbConnector->mCompressionEnabled );

    QVERIFY( LogsCommonData::getInstance().maxReadSize() == logsReadSizeUndefined );

    // Resource control enabled

    LogsDbConnector* connector = new LogsDbConnector(mEvents, false, true);

    QVERIFY( connector->init() == 0 );

    QVERIFY( connector->mReader );

    QVERIFY( connector->mLogsRemove );

    QVERIFY( connector->mCompressionEnabled );

    QVERIFY( LogsCommonData::getInstance().maxReadSize() == logsReadSizeCompressEnabled );

    QCOMPARE( LogsCommonData::getInstance().telNumMatchLen(), logsDefaultMatchLength + 2 );

    delete connector;

    // Match len not found, default is used

    connector = new LogsDbConnector(mEvents);

    QVERIFY( connector->init() == 0 );

    QVERIFY( connector->mReader );

    QVERIFY( connector->mLogsRemove );

    QCOMPARE( LogsCommonData::getInstance().telNumMatchLen(), logsDefaultMatchLength );

}

void  UT_LogsDbConnector::testClearList()

{

    QVERIFY( !mDbConnector->mLogsRemove );

    QVERIFY( !mDbConnector->clearList(LogsModel::TypeLogsClearAll) );

    mDbConnector->init();

    QVERIFY( mDbConnector->mLogsRemove );

    QVERIFY( mDbConnector->clearList(LogsModel::TypeLogsClearAll) );

}

void UT_LogsDbConnector::testClearEvents()

{

    QVERIFY( !mDbConnector->mLogsRemove );

    QList<LogsEvent*> events;

    ADD_EVENT_WITH_ID(events, 1);

    QVERIFY( !mDbConnector->clearEvents(events) ); // sync

    mDbConnector->init();

    QVERIFY( mDbConnector->mLogsRemove );

    mDbConnector->clearEvents(events); 

    QVERIFY( mDbConnector->mReader->mLocked );

    QVERIFY( !mDbConnector->clearEvents(events) ); // Already clearing

    QVERIFY( mDbConnector->mReader->mLocked );

    qDeleteAll(events);

    // Remove completed or removeError causes read lock release

    mDbConnector->removeCompleted();

    QVERIFY( !mDbConnector->mReader->mLocked );

    mDbConnector->mReader->mLocked = true;

    mDbConnector->logsRemoveErrorOccured(-1);

    QVERIFY( !mDbConnector->mReader->mLocked );

}

void UT_LogsDbConnector::testMarkEventsSeen()

{

    QList<LogsEvent*> events;

    QSignalSpy spy( mDbConnector, SIGNAL(markingCompleted(int)) );

    // Not ready

    mDbConnector->mEventsSeen.clear();

    mDbConnector->markEventsSeen(events);

    QVERIFY( mDbConnector->mEventsSeen.count() == 0 );

    // No events

    mDbConnector->init();

    mDbConnector->markEventsSeen(events);

    QVERIFY( mDbConnector->mEventsSeen.count() == 0 );

    // Marking missed as seen (one is already seen)

    LOGS_TEST_CREATE_EVENT(event, 0, LogsEvent::EventAdded );

    event->setDirection(LogsEvent::DirMissed);

    LOGS_TEST_CREATE_EVENT(event2, 1, LogsEvent::EventAdded );

    event2->setDirection(LogsEvent::DirMissed);

    LOGS_TEST_CREATE_EVENT(event3, 2, LogsEvent::EventAdded );

    event3->setDirection(LogsEvent::DirMissed);

    ADD_EVENT_WITH_ID(events, 0);

    ADD_EVENT_WITH_ID(events, 1);

    QVERIFY( mDbConnector->markEventsSeen(events) );

    QVERIFY( mDbConnector->mEventsSeen.count() == 2 );

    QVERIFY( mDbConnector->mReader->mCurrentEventId == 0 ); // Started modifying

    // Trying to clear missed again, id is appended to mark list, old modifying process in ongoing

    // and is not interrupted

    ADD_EVENT_WITH_ID(events, 2);

    QVERIFY( !mDbConnector->markEventsSeen(events) );

    QVERIFY( mDbConnector->mEventsSeen.count() == 3 );

    QVERIFY( mDbConnector->mReader->mCurrentEventId == 0 ); // Modifying still previous

    // Completed previous modifying, next one in queue is modified

    mDbConnector->mReader->Cancel();

    mDbConnector->eventModifyingCompleted();

    QVERIFY( mDbConnector->mEventsSeen.count() == 2 );

    QVERIFY( mDbConnector->mReader->mCurrentEventId == 1 ); // Started modifying next one

    QVERIFY( spy.count() == 0 ); // Not yet totally completed

    // Last pending gets completed

    mDbConnector->mEventsSeen.takeLast(); // Now only one pending left

    mDbConnector->eventModifyingCompleted();

    QVERIFY( mDbConnector->mEventsSeen.count() == 0 );

    QVERIFY( spy.count() == 1 ); // Completion was signaled with err 0

    QVERIFY( spy.takeFirst().at(0).toInt() == 0 );

    // Clearing all, ids are not appended as those are already in modification list

    mDbConnector->mEventsSeen.clear();

    ADD_EVENT_WITH_ID_2(mDbConnector->mEventsSeen, 0);

    ADD_EVENT_WITH_ID_2(mDbConnector->mEventsSeen, 1);

    ADD_EVENT_WITH_ID_2(mDbConnector->mEventsSeen, 2);

    QVERIFY( !mDbConnector->markEventsSeen(events) );

    QVERIFY( mDbConnector->mEventsSeen.count() == 3 );

    // Marked events contains merged duplicates which will be handled same way

    // as any other event

    mDbConnector->mEventsSeen.clear();

    qDeleteAll(events);

    events.clear();

    ADD_EVENT_WITH_ID(events, 8);

    ADD_EVENT_WITH_ID(events, 9);

    ADD_EVENT_WITH_ID_2( events.at(0)->mergedDuplicates(), 88 );

    ADD_EVENT_WITH_ID_2( events.at(0)->mergedDuplicates(), 9 ); // already exists in main event list

    QVERIFY( !mDbConnector->markEventsSeen(events) );

    QVERIFY( mDbConnector->mEventsSeen.count() == 3 );

    QVERIFY( mDbConnector->mEventsSeen.at(0).logId() == 8 );

    QVERIFY( mDbConnector->mEventsSeen.at(1).logId() == 88 );

    QVERIFY( mDbConnector->mEventsSeen.at(2).logId() == 9 );

    qDeleteAll(events);

}

void UT_LogsDbConnector::testReadDuplicates()

{

    QSignalSpy spy( mDbConnector, SIGNAL(duplicatesRead()) );

    // Not ready

    QVERIFY( mDbConnector->readDuplicates(2) != 0 );

    // Previous results are cleared when starting ok

    LogsEvent* event = new LogsEvent;

    mDbConnector->mDuplicatedEvents.append(event);

    mDbConnector->init();

    mDbConnector->readDuplicates(2);

    QVERIFY( mDbConnector->mDuplicatedEvents.count() == 0 );

    // Completes

    LogsEvent* event2 = new LogsEvent;

    LogsEvent* event3 = new LogsEvent;

    QList<LogsEvent*> duplicates;

    duplicates.append(event2);

    duplicates.append(event3);

    mDbConnector->duplicatesReadingCompleted(duplicates);

    QVERIFY( mDbConnector->mDuplicatedEvents.count() == 2 );

    QVERIFY( spy.count() == 1 );

    // Client reads those events

    QList<LogsEvent*> takenEvents = mDbConnector->takeDuplicates();

    QVERIFY( mDbConnector->mDuplicatedEvents.count() == 0 );

    QVERIFY( takenEvents.count() == 2 );

}

void UT_LogsDbConnector::testStart()

{

    // No reader, starting fails

    QVERIFY( mDbConnector->start() == -1 );

    // Starting ok

    mDbConnector->init();

    QVERIFY( mDbConnector->start() == 0 );

}

void UT_LogsDbConnector::testReadCompleted()

{

    qRegisterMetaType< QList<int> >("QList<int>");

    QSignalSpy spyAdded(mDbConnector, SIGNAL(dataAdded(QList<int>)));

    QSignalSpy spyRemoved(mDbConnector, SIGNAL(dataRemoved(QList<int>)));

    QSignalSpy spyUpdated(mDbConnector, SIGNAL(dataUpdated(QList<int>)));

    QSignalSpy spyReset(mDbConnector, SIGNAL(dataReset()));

    // No events, no signal

    mDbConnector->readCompleted();

    QVERIFY( spyAdded.count() == 0 );

    QVERIFY( spyRemoved.count() == 0 );

    QVERIFY( spyUpdated.count() == 0 );

    QVERIFY( spyReset.count() == 0 );

    // Events exists, their indexes are signaled, indexes are assigned at this phase

    LOGS_TEST_CREATE_EVENT_WITHOUT_IDX(event, 0, LogsEvent::EventAdded );

    QCOMPARE( event->index(), -1 );

    mDbConnector->readCompleted();

    QCOMPARE( event->index(), 0 );

    QVERIFY( spyAdded.count() == 1 );

    QList<int> addedIndexes = qvariant_cast< QList<int> >(spyAdded.at(0).at(0));

    QVERIFY( addedIndexes.count() == 1 );

    QVERIFY( addedIndexes.at(0) == 0 );

    QVERIFY( spyRemoved.count() == 0 );

    QVERIFY( spyUpdated.count() == 0 );

    QVERIFY( spyReset.count() == 0 );

    QVERIFY( mDbConnector->mEvents.count() == 1 );

    QVERIFY( mEvents.count() == 1 );

    // 2 more events added, their indexes are signaled

    event->mEventState = LogsEvent::EventNotUpdated;

    LOGS_TEST_CREATE_EVENT_WITHOUT_IDX(event2, 0, LogsEvent::EventAdded );

    LOGS_TEST_CREATE_EVENT_WITHOUT_IDX(event3, 1, LogsEvent::EventAdded );

    mDbConnector->readCompleted();

    QCOMPARE( event2->index(), 0 );

    QCOMPARE( event3->index(), 1 );

    QCOMPARE( event->index(), 2 );

    QVERIFY( spyAdded.count() == 2 );

    QList<int> addedIndexes2 = qvariant_cast< QList<int> >(spyAdded.at(1).at(0));

    QVERIFY( addedIndexes2.count() == 2 );

    QVERIFY( addedIndexes2.at(0) == 0 );

    QVERIFY( addedIndexes2.at(1) == 1 );

    QVERIFY( spyRemoved.count() == 0 );

    QVERIFY( spyUpdated.count() == 0 );

    QVERIFY( spyReset.count() == 0 );

    QVERIFY( mDbConnector->mEvents.count() == 3 );

    QVERIFY( mEvents.count() == 3 );

    // One of the events updated (index 1)

    event->mEventState = LogsEvent::EventNotUpdated;

    event2->mEventState = LogsEvent::EventNotUpdated;

    event3->mEventState = LogsEvent::EventUpdated;

    mDbConnector->readCompleted(); 

    QVERIFY( spyAdded.count() == 2 );

    QVERIFY( spyRemoved.count() == 0 );

    QVERIFY( spyUpdated.count() == 1 );

    QVERIFY( spyReset.count() == 0 );

    QList<int> updatedIndexes = qvariant_cast< QList<int> >(spyUpdated.at(0).at(0));

    QVERIFY( updatedIndexes.count() == 1 );

    QVERIFY( updatedIndexes.at(0) == 1 );

    QVERIFY( mDbConnector->mEvents.count() == 3 );

    QVERIFY( mEvents.count() == 3 );

    // One of the events removed (index 2)

    event->setIsInView(false);

    event3->mEventState = LogsEvent::EventNotUpdated;

    mDbConnector->readCompleted();

    QVERIFY( spyAdded.count() == 2 );

    QVERIFY( spyRemoved.count() == 1 );

    QVERIFY( spyUpdated.count() == 1 );

    QVERIFY( spyReset.count() == 0 );

    QList<int> removedIndexes = qvariant_cast< QList<int> >(spyRemoved.at(0).at(0));

    QVERIFY( removedIndexes.count() == 1 );

    QVERIFY( removedIndexes.at(0) == 2 ); // index 2

    QVERIFY( mDbConnector->mEvents.count() == 2 );

    QVERIFY( mEvents.count() == 2 );

    // Event added and removed, reset should be signaled

    mDbConnector->mEvents.at(0)->mEventState = LogsEvent::EventAdded;

    mDbConnector->mEvents.at(1)->mIsInView = false;

    mDbConnector->readCompleted();

    QVERIFY( spyAdded.count() == 2 );

    QVERIFY( spyRemoved.count() == 1 );

    QVERIFY( spyUpdated.count() == 1 );

    QVERIFY( spyReset.count() == 1 );

    QVERIFY( mDbConnector->mEvents.count() == 1 );

    QVERIFY( mEvents.count() == 1 );

    QVERIFY( mDbConnector->init() == 0 );

    QVERIFY( mDbConnector->start() == 0 );

    QVERIFY( mDbConnector->mReader->mLogViewRecent != 0 );

    mDbConnector->mCompressionEnabled = true;

    mDbConnector->readCompleted();

}

void UT_LogsDbConnector::testErrorOccurred()

{

    // If pending event modifying, completion is signaled

    QSignalSpy spy( mDbConnector, SIGNAL(markingCompleted(int)) );

    ADD_EVENT_WITH_ID_2(mDbConnector->mEventsSeen, 0);

    ADD_EVENT_WITH_ID_2(mDbConnector->mEventsSeen, 1);

    mDbConnector->errorOccurred(-3);

    QVERIFY( spy.count() == 1 ); // Completion was signaled with err -3

    QVERIFY( spy.takeFirst().at(0).toInt() == -3 );

    QVERIFY( mDbConnector->mEventsSeen.count() == 0 );

}

void UT_LogsDbConnector::testUpdateDetails()

{

    QSignalSpy spyUpdated(mDbConnector, SIGNAL(dataUpdated(QList<int>)));

    QVERIFY( !mDbConnector->mReader );

    QVERIFY( mDbConnector->updateDetails(false) == -1 );

    QVERIFY( spyUpdated.count() == 0 );

    mDbConnector->init();

    QVERIFY( mDbConnector->mReader );

    LOGS_TEST_CREATE_EVENT(event, 0, LogsEvent::EventUpdated );

    QVERIFY( mDbConnector->updateDetails(false) == 0 );

    QVERIFY( spyUpdated.count() == 0 ); // Will happen asynchronously

}

void UT_LogsDbConnector::testRefreshData()

{

    QVERIFY( mDbConnector->refreshData() != 0 );

    // Resource control enabled, no reader

    mDbConnector->mResourceControl = true;

    QVERIFY( mDbConnector->refreshData() == 0 );

    // Reader exists, not compressed before, nothing done

    mDbConnector->init();

    mDbConnector->mCompressionEnabled = false;

    QVERIFY( mDbConnector->refreshData() == 0 );

    QVERIFY( !mDbConnector->mReader->IsActive() );

    QVERIFY( LogsCommonData::getInstance().maxReadSize() == logsReadSizeUndefined );

    // Reader exists, compressed before, reading started

    mDbConnector->mCompressionEnabled = true;

    QVERIFY( mDbConnector->refreshData() == 0 );

    QVERIFY( mDbConnector->mReader->IsActive() );

    QVERIFY( !mDbConnector->mCompressionEnabled );

    QVERIFY( LogsCommonData::getInstance().maxReadSize() == logsReadSizeUndefined );

    // Reading not started again as already active

    LogsCommonData::getInstance().configureReadSize(30, LogsEvent::DirUndefined);

    mDbConnector->mCompressionEnabled = true;

    QVERIFY( mDbConnector->refreshData() == 0 );

    QVERIFY( mDbConnector->mReader->IsActive() );

    QVERIFY( !mDbConnector->mCompressionEnabled );

    QVERIFY( LogsCommonData::getInstance().maxReadSize() == logsReadSizeUndefined );

}

void UT_LogsDbConnector::testCompressData()

{

    qRegisterMetaType< QList<int> >("QList<int>");

    QSignalSpy spyRemoved(mDbConnector, SIGNAL(dataRemoved(QList<int>)));

    QVERIFY( mDbConnector->compressData() != 0 );

    // Reader exists, zero events, nothing really done

    mDbConnector->mResourceControl = true;

    mDbConnector->init();

    mDbConnector->mCompressionEnabled = false;

    QVERIFY( mDbConnector->compressData() == 0 );

    QVERIFY( mDbConnector->mCompressionEnabled );

    QVERIFY( LogsCommonData::getInstance().maxReadSize() == logsReadSizeCompressEnabled );

    QVERIFY( spyRemoved.count() == 1 );

    QList<int> removedIndexes = qvariant_cast< QList<int> >(spyRemoved.at(0).at(0));

    QVERIFY( removedIndexes.count() == 0 );

    // Less events than compression limit is, nothing really done

    int numEvents = 3;

    for ( int i = 0; i < numEvents; i++ ){

        LOGS_TEST_CREATE_EVENT(event, i, LogsEvent::EventAdded );

    }

    mDbConnector->mCompressionEnabled = false;

    QVERIFY( mDbConnector->compressData() == 0 );

    QVERIFY( mDbConnector->mCompressionEnabled );

    QVERIFY( LogsCommonData::getInstance().maxReadSize() == logsReadSizeCompressEnabled );

    QVERIFY( spyRemoved.count() == 2 );

    QList<int> removedIndexes2 = qvariant_cast< QList<int> >(spyRemoved.at(1).at(0));

    QVERIFY( removedIndexes2.count() == 0 );

    QVERIFY( mDbConnector->mModelEvents.count() == numEvents );

    // More events than compression limit is, extra events removed

    int numEventsMoreThanCompressLimit = ( numEvents + logsReadSizeCompressEnabled );

    for ( int i = numEvents; i < numEventsMoreThanCompressLimit; i++ ){

       LOGS_TEST_CREATE_EVENT(event, i, LogsEvent::EventAdded );

    }

    mDbConnector->mCompressionEnabled = false;

    QVERIFY( mDbConnector->compressData() == 0 );

    QVERIFY( mDbConnector->mCompressionEnabled );

    QVERIFY( LogsCommonData::getInstance().maxReadSize() == logsReadSizeCompressEnabled );

    QVERIFY( spyRemoved.count() == 3 );

    QList<int> removedIndexes3 = qvariant_cast< QList<int> >(spyRemoved.at(2).at(0));

    QVERIFY( removedIndexes3.count() == numEvents );

    // Check indexes of those removed events (3 oldest events)

    QVERIFY( removedIndexes3.at(0) == ( numEventsMoreThanCompressLimit - 3 ) ); 

    QVERIFY( removedIndexes3.at(1) == ( numEventsMoreThanCompressLimit - 2) );

    QVERIFY( removedIndexes3.at(2) == ( numEventsMoreThanCompressLimit - 1 ) );

    QVERIFY( mDbConnector->mModelEvents.count() == logsReadSizeCompressEnabled );

}