GenericSessionTest.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "../BadPacket.h"
#include "generated/DataSerializerMock.h"
#include "generated/DataQueueMock.h"
#include "generated/GenericSessionDriver.h"
#include "generated/SessionMock.h"
#include "generated/SessionStatusMock.h"
#include "generated/TransportMock.h"
#include "Imports.cpp"

namespace Protocols {
namespace Generics {
namespace Testing {

class DataChecker
{
    Data        data;
    Transport   &transport;

public:
    DataChecker (const Data &d, Transport *t) : data (d), transport (*t) {}

    typedef bool (Function) (Data &, Transport *);

    bool check (Data &d, Transport *t)
    {
        if (t != &transport)
            return false;
        d = data;
        return true;
    }
};


class GenericSessionTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE(GenericSessionTest);
    CPPUNIT_TEST (testOpenSessionStartsReading);
    CPPUNIT_TEST (testSentDataSerializedDirectly);
    CPPUNIT_TEST (testSentDataCannotBeSerializedMustBeQueued);
    CPPUNIT_TEST (testSentDataIsBufferedDirectly);
    CPPUNIT_TEST (testSentTwoDatasThatGetQueued);
    CPPUNIT_TEST (testWriteQueuedDataOnReadyWrite);
    CPPUNIT_TEST (testWriteTwoQueuedDatasOnReadyWrite);
    CPPUNIT_TEST (testWriteQueuedDataOnReadyWriteFails);
    CPPUNIT_TEST (testWriteTwoQueuedDatasOnReadyWriteSecondFails);
    CPPUNIT_TEST (testCannotReadPacketOnReadyRead);
    CPPUNIT_TEST (testReadTwoPacketsOnReadyRead);
    CPPUNIT_TEST (testCloseSessionDisconnectsTransportOnlyIfNothingToWrite);
    CPPUNIT_TEST (testCloseSessionDisconnectsTransportOnlyAfterQueueGetsEmpty);
    CPPUNIT_TEST (testAbortSessionAbortsTransportAndClosesSession);
    CPPUNIT_TEST (testCloseSessionFromSessionDataReceivedNotificationDisconnectDeferred);
    CPPUNIT_TEST (testAbortSessionFromSessionDataReceivedNotification);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <TransportMock>                transport;
    auto_ptr <DataSerializerMock>           serializer;
    auto_ptr <SessionStatusMock>            status;
    auto_ptr <DataQueueMock>                queue;
    auto_ptr <GenericSession>               sessionReal;
    auto_ptr <GenericSessionDriver>         session;

    const Data                              data1;
    const Data                              data2;

public:
    GenericSessionTest()
     :  transport(), serializer(), status(), queue(), sessionReal(), session(),
        data1 (BadPacket ("header1", "payload1")),
        data2 (BadPacket ("header2", "payload2"))
    {
    }

    void setUp()
    {
        transport.reset (new TransportMock);
        serializer.reset (new DataSerializerMock);
        status.reset (new SessionStatusMock);
        queue.reset (new DataQueueMock);
        sessionReal.reset (new GenericSession (*transport,
                                               *serializer,
                                               *queue,
                                               *status));
        session.reset (new GenericSessionDriver (*sessionReal.get()));
    }

    void tearDown()
    {
        session.reset();
        sessionReal.reset();
        status.reset();
        queue.reset();
        serializer.reset();
        transport.reset();
    }


    void testOpenSessionStartsReading()
    {
        call (session->open())
            //.willCall (status->sessionOpened (*session))
            //.returns()
            .willCall (serializer->read (checker (DataChecker (data1, *transport))))
            .willReturn (false)
        .returns();
    }

    void stateSessionOpened()
    {
        testOpenSessionStartsReading();
    }

    void refSentDataSerializedDirectly (const Data &data)
    {
        call (session->send (data))
            .willCall (status->sessionSendingData (*session, data))
            .returns()
            .willCall (queue->isEmpty())
            .willReturn (true)
            .willCall (serializer->write (data, *transport))
            .willReturn (true)
        .returns();
    }

    void testSentDataSerializedDirectly()
    {
        stateSessionOpened();
        refSentDataSerializedDirectly (data1);
    }

    void refSentDataCannotBeSerializedMustBeQueued (const Data &data)
    {
        call (session->send (data))
            .willCall (status->sessionSendingData (*session, data))
            .returns()
            .willCall (queue->isEmpty())
            .willReturn (true)
            .willCall (serializer->write (data, *transport))
            .willReturn (false)
            .willCall (queue->enqueue (data))
            .returns()
        .returns();
    }

    void testSentDataCannotBeSerializedMustBeQueued()
    {
        stateSessionOpened();
        refSentDataCannotBeSerializedMustBeQueued (data1);
    }


    void refSentDataIsBufferedDirectly (const Data &data)
    {
        call (session->send (data))
            .willCall (status->sessionSendingData (*session, data))
            .returns()
            .willCall (queue->isEmpty())
            .willReturn (false)
            .willCall (queue->enqueue (data))
            .returns()
        .returns();
    }

    void testSentDataIsBufferedDirectly()
    {
        stateSessionOpened();
        refSentDataIsBufferedDirectly (data1);
    }

    void testSentTwoDatasThatGetQueued()
    {
        stateSessionOpened();
        refSentDataIsBufferedDirectly (data1);
        refSentDataIsBufferedDirectly (data2);
    }

    void refWriteQueuedDatasOnReadyWrite (const QList <Data> &datas)
    {
        CallDriver <BoundFunction <GenericSession, void (Transport*)> > foo =
            call (session->transportReadyWrite (*transport));

        bool wroteAll = true;
        foreach (const Data &data, datas) {
            foo
                .willCall (queue->isEmpty())
                .willReturn (false)
                .willCall (queue->next())
                .willReturn (data);
            if (data != Data()) {
            foo .willCall (serializer->write (data, *transport))
                .willReturn (true)
                .willCall (queue->dequeue())
                .returns();
            } else {
            foo .willCall (serializer->write (data, *transport))
                .willReturn (false);
                wroteAll = false;
                break; // Don't write any more.
            }
        }
        if (wroteAll) {
            // Stop writing when the queue gets empty.
            foo
                .willCall (queue->isEmpty())
                .willReturn (true);
        }
        foo.returns();
    }

    void testWriteQueuedDataOnReadyWrite()
    {
        stateSessionOpened();
        refWriteQueuedDatasOnReadyWrite (QList <Data>() += data1);
    }

    void testWriteTwoQueuedDatasOnReadyWrite()
    {
        stateSessionOpened();
        refWriteQueuedDatasOnReadyWrite ((QList <Data>() += data1) += data2);
    }

    void testWriteQueuedDataOnReadyWriteFails()
    {
        stateSessionOpened();
        refWriteQueuedDatasOnReadyWrite (QList <Data>() += Data());
    }

    void testWriteTwoQueuedDatasOnReadyWriteSecondFails()
    {
        stateSessionOpened();
        refWriteQueuedDatasOnReadyWrite ((QList <Data>() += data1) += Data());
    }

    void refReadDatasOnReadyRead (const QList <Data> &datas)
    {
        CallDriver <BoundFunction <GenericSession, void (Transport*)> > foo =
            call (session->transportReadyRead (*transport));

        foreach (const Data &data, datas) {
            foo
                .willCall (serializer->read (
                                checker (DataChecker (data, *transport))))
                .willReturn (true)
                .willCall (status->sessionReceivedData (*session, data))
                .returns();
        }
        // Cannot ready any more Data objects:
        Data data;
        foo
            .willCall (serializer->read (
                                checker (DataChecker (data, *transport))))
            .willReturn (false)
        .returns();
    }

    void testCannotReadPacketOnReadyRead()
    {
        stateSessionOpened();
        refReadDatasOnReadyRead (QList <Data>());
    }

    void testReadTwoPacketsOnReadyRead()
    {
        stateSessionOpened();
        refReadDatasOnReadyRead ((QList <Data>() += data1) += data2);
    }

    void refCloseSessionDisconnectsTransportImmediately()
    {
        call (session->close())
            .willCall (queue->isEmpty())
            .willReturn (true)
            .willCall (status->sessionClosing (*session))
            .returns()
            .willCall (transport->disconnectFromNode())
            .returns()
        .returns();
    }

    void refCloseSessionDoesNotDisconnectTransportWhenQueueIsNotEmpty()
    {
        call (session->close())
            .willCall (queue->isEmpty())
            .willReturn (false)
            .willCall (status->sessionClosing (*session))
            .returns()
        .returns();
    }

    void refTransportDisconnectedClosesTheSessionCompletely()
    {
        call (session->transportDisconnected (*transport))
            .willCall (status->sessionClosed (*session))
            .returns()
        .returns();
    }

    void refTransportReadyWriteDisconnectsTransportWhenEmptyQueueAndClosing()
    {
        call (session->transportReadyWrite (*transport))
            // take data1 from queue:
            .willCall (queue->isEmpty())
            .willReturn (true)
            // connection was closing, buffer is now empty, disconnect:
            .willCall (transport->disconnectFromNode())
            .returns()
        .returns();
    }

    void testCloseSessionDisconnectsTransportOnlyIfNothingToWrite()
    {
        stateSessionOpened();
        refCloseSessionDisconnectsTransportImmediately();
        refTransportDisconnectedClosesTheSessionCompletely();
    }

    void testCloseSessionDisconnectsTransportOnlyAfterQueueGetsEmpty()
    {
        stateSessionOpened();
        refCloseSessionDoesNotDisconnectTransportWhenQueueIsNotEmpty();
        refTransportReadyWriteDisconnectsTransportWhenEmptyQueueAndClosing();
        refTransportDisconnectedClosesTheSessionCompletely();
    }

    void testAbortSessionAbortsTransportAndClosesSession()
    {
        call (session->abort())
            .willCall (status->sessionClosing (*session))
            //.willCall (queue.clear())
            //.returns()
            .returns()
            .willCall (transport->abort())
                .willCall (session->transportDisconnected (*transport))
                    .willCall (status->sessionClosed (*session))
                    .returns()
                .returns()
            .returns()
        .returns();
    }


    void testCloseSessionFromSessionDataReceivedNotificationDisconnectDeferred()
    {
        stateSessionOpened();

        call (session->transportReadyRead (*transport))
            .willCall (serializer->read (
                            checker (DataChecker (data1, *transport))))
            .willReturn (true)
            .willCall (status->sessionReceivedData (*session, data1))
                .willCall (session->close())
                    .willCall (status->sessionClosing (*session))
                    .returns()
                    .willCall (queue->isEmpty())
                    .willReturn (false)
                .returns()
            .returns()
            .willCall (serializer->read (
                            checker (DataChecker (Data(), *transport))))
            .willReturn (false)
        .returns();
    }

    void testAbortSessionFromSessionDataReceivedNotification()
    {
        stateSessionOpened();

        call (session->transportReadyRead (*transport))
            .willCall (serializer->read (
                            checker (DataChecker (data1, *transport))))
            .willReturn (true)
            .willCall (status->sessionReceivedData (*session, data1))
                .willCall (session->abort())
                    .willCall (status->sessionClosing (*session))
                    //.willCall (queue.clear())
                    //.returns()
                    .returns()
                    .willCall (transport->abort())
                        .willCall (session->transportDisconnected (*transport))
                            .willCall (status->sessionClosed (*session))
                            .returns()
                        .returns()
                    .returns()
                .returns()
            .returns()
        .returns();
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (GenericSessionTest);

} // Testing;
} // Generics;
} // Protocols;

Copyright © 2006 Peter Dimov.
Powered by Doxygen.