SocketTransportTest.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-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 "../SocketTransport.h"
#include "generated/TransportStatusMock.h"
#include "generated/SocketBufferMock.h"
#include "generated/SocketMock.h"
#include "generated/SocketTransportDriver.h"
#include "Imports.cpp"

namespace Protocols {
namespace Generics {
namespace Testing {


class SocketTransportTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (SocketTransportTest);
    CPPUNIT_TEST (testStartConnecting);
    CPPUNIT_TEST (testConnectionEstablished);
    CPPUNIT_TEST (testConnectionRejected);
    CPPUNIT_TEST (testAbortConnectionAttempt);
    CPPUNIT_TEST (testStartDisconnecting);
    CPPUNIT_TEST (testDisconnectingCompletes);
    CPPUNIT_TEST (testAbortWhileDisconnecting);
    CPPUNIT_TEST (testConnectionDisconnectedBySocket);
    CPPUNIT_TEST (testAbortDueToSocketError);
    CPPUNIT_TEST (testSocketConnectedTwice);
    CPPUNIT_TEST (testSocketDisconnectedTwice);
    CPPUNIT_TEST (testSocketErrorTwice);
    CPPUNIT_TEST (testSocketErrorSocketDisconnected);
    CPPUNIT_TEST (testSocketDisconnectedSocketError);
    CPPUNIT_TEST (testWriteDelegatesToSocketBufferAndTriesToWriteToSocket);
    CPPUNIT_TEST (testReadsDelegateToSocketBufferThenTriesToReadMoreFromSocket);
    CPPUNIT_TEST (testPeeksDelegateToSocketBuffer);
    CPPUNIT_TEST (testCanReadCanWriteDelegateToSocketBuffer);
    CPPUNIT_TEST (testSocketReadMakesBufferToReadFromSocketAndEmitsReadyRead);
    CPPUNIT_TEST (testSocketWrittenMakesBufferToWriteToSocketAndEmitsReadyWrite);
    CPPUNIT_TEST (testSocketWrittenReadyWriteNotCalledRecursively);
    CPPUNIT_TEST (testReadyWriteNotCalledFromWrite);
    CPPUNIT_TEST (testSocketWrittenDoesNotCallTryWriteToRecursively);
    CPPUNIT_TEST (testSocketReadReadyReadNofCalledRecursively);
    CPPUNIT_TEST (testReadyReadNotCalledFromRead);
    CPPUNIT_TEST (testSocketReadDoesNotCallTryReadFromRecursively);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <SocketMock>               socket;
    auto_ptr <SocketBufferMock>         buffer;
    auto_ptr <TransportStatusMock>      status;
    auto_ptr <SocketTransport>          transport_real;
    auto_ptr <SocketTransportDriver>    transport;

public:
    SocketTransportTest()
     :  socket(), buffer(), status(), transport_real(), transport()
    {
    }

    void setUp()
    {
        socket.reset (new SocketMock);
        buffer.reset (new SocketBufferMock);
        status.reset (new TransportStatusMock);
        transport_real.reset (new SocketTransport (*socket, *buffer, *status));
        transport.reset (new SocketTransportDriver (*transport_real.get()));
    }

    void tearDown()
    {
        transport.reset();
        transport_real.reset();
        status.reset();
        buffer.reset();
        socket.reset();
    }

    void stateDisconnected()
    {
    }

    void testStartConnecting()
    {
        stateDisconnected();

        Uri connectAddress = Uri::fromUnencoded ("//127.0.0.1:1000");
        call (transport->connectToNode (connectAddress))
            .willCall (socket->connectToHost (QHostAddress ("127.0.0.1"), 1000))
            .returns()
        .returns();
    }

    void stateConnecting()
    {
        testStartConnecting();
    }

    void testConnectionEstablished()
    {
        stateConnecting();

        socket->calls (transport->socketConnected())
            .willCall (status->transportConnected (*transport))
            .returns()
        .returns();
    }

    void stateConnected()
    {
        testConnectionEstablished();
    }


    void testConnectionRejected()
    {
        stateConnecting();

        socket->calls (transport->socketError())
            .willCall (socket->abort())
                .willCall (transport->socketDisconnected())
                    .willCall (status->transportDisconnected (*transport))
                    .returns()
                .returns()
            .returns()
        .returns();
    }


    void testAbortConnectionAttempt()
    {
        stateConnecting();

        call (transport->abort())
            .willCall (socket->abort())
                .willCall (transport->socketDisconnected())
                    .willCall (status->transportDisconnected (*transport))
                    .returns()
                .returns()
            .returns()
        .returns();
    }

    void refStartDisconnecting()
    {
        call (transport->disconnectFromNode())
            .willCall (socket->disconnectFromHost())
            .returns()
        .returns();
    }

    void testStartDisconnecting()
    {
        stateConnected();
        refStartDisconnecting();
    }

    void stateDisconnecting()
    {
        testStartDisconnecting();
    }

    void testDisconnectingCompletes()
    {
        stateDisconnecting();

        socket->calls (transport->socketDisconnected())
            .willCall (status->transportDisconnected (*transport))
            .returns()
        .returns();
    }

    void testAbortWhileDisconnecting()
    {
        stateDisconnecting();

        socket->calls (transport->abort())
            .willCall (socket->abort())
                .willCall (transport->socketDisconnected())
                    .willCall (status->transportDisconnected (*transport))
                    .returns()
                .returns()
            .returns()
        .returns();
    }

    void testConnectionDisconnectedBySocket()
    {
        stateConnected();

        socket->calls (transport->socketDisconnected())
            .willCall (status->transportDisconnected (*transport))
            .returns()
        .returns();
    }

    void testAbortDueToSocketError()
    {
        stateConnected();

        socket->calls (transport->socketError())
            .willCall (socket->abort())
                .willCall (transport->socketDisconnected())
                    .willCall (status->transportDisconnected (*transport))
                    .returns()
                .returns()
            .returns()
        .returns();
    }

    void testSocketConnectedTwice()
    {
        stateConnected();

        socket->calls (transport->socketConnected())
        .returns();
    }

    void testSocketDisconnectedTwice()
    {
        stateDisconnected();

        socket->calls (transport->socketDisconnected())
        .returns();
    }

    void testSocketErrorTwice()
    {
        testAbortDueToSocketError();

        socket->calls (transport->socketError())
        .returns();
    }

    void testSocketErrorSocketDisconnected()
    {
        testAbortDueToSocketError();

        socket->calls (transport->socketDisconnected())
        .returns();
    }

    void testSocketDisconnectedSocketError()
    {
        testConnectionDisconnectedBySocket();

        socket->calls (transport->socketError())
        .returns();
    }


    void refWriteBytes (const QByteArray &bytes, bool flush, bool succeeds)
    {
        call (transport->write (bytes, flush))
            .willCall (buffer->write (bytes, flush))
            .willReturn (succeeds)
            .willCall (buffer->tryWriteTo (*socket))
            .returns()
        .willReturn (succeeds);
    }


    void testWriteDelegatesToSocketBufferAndTriesToWriteToSocket()
    {
        stateConnected();

        refWriteBytes (QByteArray ("123"), false, true);
        refWriteBytes (QByteArray(), true, true);
        refWriteBytes (QByteArray ("123"), false, false);
        refWriteBytes (QByteArray(), true, false);
    }

    void refReadsDelegateToBuffer()
    {
        call (transport->readAll())
            .willCall (buffer->readAll())
            .willReturn (QByteArray ("123"))
            .willCall (buffer->tryReadFrom (*socket))
            .returns()
        .willReturn (QByteArray ("123"));

        call (transport->readTo (QByteArray ("ee")))
            .willCall (buffer->readTo (QByteArray ("ee")))
            .willReturn (QByteArray ("123"))
            .willCall (buffer->tryReadFrom (*socket))
            .returns()
        .willReturn (QByteArray ("123"));

        call (transport->read (10))
            .willCall (buffer->read (10))
            .willReturn (QByteArray (10, '1'))
            .willCall (buffer->tryReadFrom (*socket))
            .returns()
        .willReturn (QByteArray (10, '1'));

        call (transport->readAtMost (10))
            .willCall (buffer->readAtMost (10))
            .willReturn (QByteArray (5, '1'))
            .willCall (buffer->tryReadFrom (*socket))
            .returns()
        .willReturn (QByteArray (5, '1'));
    }


    void testReadsDelegateToSocketBufferThenTriesToReadMoreFromSocket()
    {
        stateConnected();
        refReadsDelegateToBuffer();
        refStartDisconnecting();
        refReadsDelegateToBuffer();
    }

    void refPeedsDelegateToSocketBuffer()
    {
        call (transport->peekAll())
            .willCall (buffer->peekAll())
            .willReturn (QByteArray ("123"))
        .willReturn (QByteArray ("123"));

        call (transport->peekTo (QByteArray ("ee")))
            .willCall (buffer->peekTo (QByteArray ("ee")))
            .willReturn (QByteArray ("123"))
        .willReturn (QByteArray ("123"));

        call (transport->peek (10))
            .willCall (buffer->peek (10))
            .willReturn (QByteArray (10, '1'))
        .willReturn (QByteArray (10, '1'));

        call (transport->peekAtMost (10))
            .willCall (buffer->peekAtMost (10))
            .willReturn (QByteArray (5, '1'))
        .willReturn (QByteArray (5, '1'));
    }


    void testPeeksDelegateToSocketBuffer()
    {
        stateConnected();
        refPeedsDelegateToSocketBuffer();
        refStartDisconnecting();
        refPeedsDelegateToSocketBuffer();
    }

    void refCanReadDelegatesToBuffer (int count, bool canRead)
    {
        call (transport->canRead (count))
            .willCall (buffer->canRead (count))
            .willReturn (canRead)
        .willReturn (canRead);
    }

    void refCanWriteDelegatesToBuffer (int count, bool canWrite)
    {
        call (transport->canWrite (count))
            .willCall (buffer->canWrite (count))
            .willReturn (canWrite)
        .willReturn (canWrite);
    }


    void testCanReadCanWriteDelegateToSocketBuffer()
    {
        stateConnected();

        refCanReadDelegatesToBuffer (10, true);
        refCanReadDelegatesToBuffer (10, false);

        refCanWriteDelegatesToBuffer (10, true);
        refCanWriteDelegatesToBuffer (10, false);

        refStartDisconnecting();

        refCanReadDelegatesToBuffer (10, true);
        refCanReadDelegatesToBuffer (10, false);
    }

    void testSocketReadMakesBufferToReadFromSocketAndEmitsReadyRead()
    {
        stateConnected();

        call (transport->socketRead())
            .willCall (buffer->tryReadFrom (*socket))
            .returns()
            .willCall (status->transportReadyRead (*transport))
            .returns()
        .returns();
    }

    void testSocketWrittenMakesBufferToWriteToSocketAndEmitsReadyWrite()
    {
        stateConnected();

        call (transport->socketWritten())
            .willCall (buffer->tryWriteTo (*socket))
            .returns()
            .willCall (status->transportReadyWrite (*transport))
            .returns()
        .returns();
    }


    void testSocketWrittenReadyWriteNotCalledRecursively()
    {
        stateConnected();

        call (transport->socketWritten())
            .willCall (buffer->tryWriteTo (*socket))
            .returns()
            .willCall (status->transportReadyWrite (*transport))
                .willCall (transport->write (QByteArray(), true))
                    .willCall (buffer->write (QByteArray(), true))
                    .willReturn (true)
                    .willCall (buffer->tryWriteTo (*socket))
                        .willCall (transport->socketWritten())
                        .returns()
                    .returns()
                .willReturn (true)
            .returns()
        .returns();
    }


    void testReadyWriteNotCalledFromWrite()
    {
        stateConnected();

        call (transport->write (QByteArray(), true))
            .willCall (buffer->write (QByteArray(), true))
            .willReturn (true)
            .willCall (buffer->tryWriteTo (*socket))
                .willCall (transport->socketWritten())
                .returns()
            .returns()
        .willReturn (true);
    }

    void testSocketWrittenDoesNotCallTryWriteToRecursively()
    {
        stateConnected();

        call (transport->socketWritten())
            .willCall (buffer->tryWriteTo (*socket))
                .willCall (transport->socketWritten())
                .returns()
            .returns()
            .willCall (status->transportReadyWrite (*transport))
            .returns()
        .returns();
    }


    void testSocketReadReadyReadNofCalledRecursively()
    {
        stateConnected();

        call (transport->socketRead())
            .willCall (buffer->tryReadFrom (*socket))
            .returns()
            .willCall (status->transportReadyRead (*transport))
                .willCall (transport->read (0))
                    .willCall (buffer->read (0))
                    .willReturn (QByteArray())
                    .willCall (buffer->tryReadFrom (*socket))
                        .willCall (transport->socketRead())
                        .returns()
                    .returns()
                .willReturn (QByteArray())
            .returns()
        .returns();
    }


    void testReadyReadNotCalledFromRead()
    {
        stateConnected();

        call (transport->read (0))
            .willCall (buffer->read (0))
            .willReturn (QByteArray())
            .willCall (buffer->tryReadFrom (*socket))
            .returns()
        .willReturn (QByteArray());
    }

    void testSocketReadDoesNotCallTryReadFromRecursively()
    {
        stateConnected();

        call (transport->socketRead())
            .willCall (buffer->tryReadFrom (*socket))
                .willCall (transport->socketRead())
                .returns()
            .returns()
            .willCall (status->transportReadyRead (*transport))
            .returns()
        .returns();
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (SocketTransportTest);

} // namespace Testing
} // namespace Generics
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.