SessionTest.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 "generated/SessionDriver.h"
#include "generated/SessionMock.h" // \todo for SessionStatusMock
#include "Imports.cpp"

namespace Protocols {
namespace BitTorrent {
namespace Transfers {
namespace Testing {


class SessionTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE(SessionTest);
    CPPUNIT_TEST (testEstablishSessionSucceedsDirectly);
    CPPUNIT_TEST (testEstablishSessionSucceedsAfterOneReadyRead);
    CPPUNIT_TEST (testEstablishSessionSucceedsAfterTwoReadyRead);
    CPPUNIT_TEST (testEstablishSessionSucceedsAfterThreeReadyRead);
    CPPUNIT_TEST (testAcceptConnectionSucceedsDirectly);
    CPPUNIT_TEST (testAcceptConnectionSucceedsAfterOneReadyRead);
    CPPUNIT_TEST (testAcceptConnectionSucceedsAfterTwoReadyReads);
    CPPUNIT_TEST (testAcceptConnectionSucceedsAfterThreeReadyReads);
    //CPPUNIT_TEST (testEstablishSessionFailsDirectly);
    //CPPUNIT_TEST (testEstablishSessionFailsAfterOneReadyRead);
    //CPPUNIT_TEST (testEstablishSessionFailsAfterTwoReadyRead);
    // protocol error (e.g. fileId not matched, corrupt message header)
    //CPPUNIT_TEST (testSessionChoked);
    //CPPUNIT_TEST (testSessionUnchoked);
    //CPPUNIT_TEST (testSessionInterested);
    //CPPUNIT_TEST (testSessionNotInterested);
    //CPPUNIT_TEST (testChokeSession);
    //CPPUNIT_TEST (testUnchokeSession);
    CPPUNIT_TEST_SUITE_END();

    PeerInfo                        myPeerInfo;
    PeerInfo                        remotePeerInfo;
    FileId                          fileId;
    auto_ptr <TransportMock>        transport;
    auto_ptr <SessionStatusMock>    status;
    auto_ptr <Session>              session_real;
    auto_ptr <SessionDriver>        session;

public:
    void setUp()
    {
        // \todo set PeerInfo.nodeAddress ???
        myPeerInfo.id = QByteArray (20, '1');
        remotePeerInfo.id = QByteArray (20, '2');
        fileId = QByteArray  (20, '3');

        transport.reset (new TransportMock());
        status.reset (new SessionStatusMock());
        session_real.reset (new Session (transport->imp, status->imp,
                                         myPeerInfo));
        session.reset (new SessionDriver (*session_real.get()));
    }

    void tearDown()
    {
        session.reset();
        session_real.reset();
        status.reset();
        transport.reset();
    }

    QByteArray makeHandshakeBytes (const FileId &fileId,
                                   const PeerInfo &peerInfo)
    {
        QByteArray handshake;
        handshake.append ('\x13');
        handshake.append (QByteArray ("BitTorrent protocol"));
        handshake.append (QByteArray ("\0\0\0\0\0\0\0\0", 8));
        handshake.append (fileId);
        handshake.append (peerInfo.id);
        return handshake;
    }

    void testEstablishSessionSucceedsDirectly()
    {
        // Prepare the handshakes:
        QByteArray outHandshake = makeHandshakeBytes (fileId, myPeerInfo);
        QByteArray inHandshake = makeHandshakeBytes (fileId, remotePeerInfo);
        // We send our handshake after establishing the transport connection:
        transport->calls (session->establish (myPeerInfo, fileId))
            .willCall (status->establishingSession())
            .returns()
            .willCall (transport->write (outHandshake))
            .willReturn (true)
            .willCall (transport->read (inHandshake.length()))
            .willReturn (inHandshake)
            .willCall (status->sessionEstablished())
            .returns()
        .returns();
    }

    void scenarioEstablishSessionSucceedsAfterANumberOfReadyReads (int count)
    {
        Q_ASSERT (count > 0);
        // Prepare the handshake bytes:
        QByteArray inHandshake = makeHandshakeBytes (fileId, remotePeerInfo);
        QByteArray outHandshake = makeHandshakeBytes (fileId, myPeerInfo);
        // The transport connection is established:
        transport->calls (session->establish (myPeerInfo, fileId))
            .willCall (status->establishingSession())
            .returns()
            .willCall (transport->write (outHandshake))
            .willReturn (true)
            .willCall (transport->read (inHandshake.length()))
            .willReturn (QByteArray())
        .returns();
        // readyRead() may be called even if not all bytes are buffered:
        for (; count > 1; --count) // the last readyRead() will succeed below
        {
            transport->calls (session->readyRead())
                .willCall (transport->read (inHandshake.length()))
                .willReturn (QByteArray())
            .returns();
        }
        // some bytes have been read by transport, retry reading the handshake:
        transport->calls (session->readyRead())
            // read complete handshake directly:
            .willCall (transport->read (inHandshake.length()))
            .willReturn (inHandshake)
            // done, connection established:
            .willCall (status->sessionEstablished())
            .returns()
        .returns();
    }

    void testEstablishSessionSucceedsAfterOneReadyRead()
    {
        scenarioEstablishSessionSucceedsAfterANumberOfReadyReads (1);
    }

    void testEstablishSessionSucceedsAfterTwoReadyRead()
    {
        scenarioEstablishSessionSucceedsAfterANumberOfReadyReads (2);
    }

    void testEstablishSessionSucceedsAfterThreeReadyRead()
    {
        scenarioEstablishSessionSucceedsAfterANumberOfReadyReads (3);
    }


    void testAcceptConnectionSucceedsDirectly()
    {
        QByteArray inHandshake = makeHandshakeBytes (fileId, remotePeerInfo);
        QByteArray outHandshake = makeHandshakeBytes (fileId, myPeerInfo);

        call (session->waitRequest())
            // report status:
            .willCall (status->establishingSession())
            .returns()
            // read complete handshake directly:
            .willCall (transport->read (inHandshake.length()))
            .willReturn (inHandshake)
            .willCall (status->sessionRequestedFor (fileId))
            .returns()
        .returns();

        call (session->accept())
            // write complete handshake directly:
            .willCall (transport->write (outHandshake))
            .willReturn (true)
            // done, connection established:
            .willCall (status->sessionEstablished())
            .returns()
        .returns();
    }


    void scenarioAcceptConnectionSucceedsAfterANumberOfReadyReads (int count)
    {
        Q_ASSERT (count > 0);
        // Prepare the handshakes:
        QByteArray inHandshake = makeHandshakeBytes (fileId, remotePeerInfo);
        QByteArray outHandshake = makeHandshakeBytes (fileId, myPeerInfo);

        call (session->waitRequest())
            // report status:
            .willCall (status->establishingSession())
            .returns()
            // handshake cannot be read completely:
            .willCall (transport->read (inHandshake.length()))
            .willReturn (QByteArray())
        .returns();
        // readyRead() may be called even if not all bytes are buffered:
        for (; count > 1; --count) // the last readyRead() will succeed below
        {
            transport->calls (session->readyRead())
                .willCall (transport->read (inHandshake.length()))
                .willReturn (QByteArray())
            .returns();
        }
        // Some bytes have been read by transport, retry reading the handshake:
        transport->calls (session->readyRead())
            // read complete handshake directly:
            .willCall (transport->read (inHandshake.length()))
            .willReturn (inHandshake)
            .willCall (status->sessionRequestedFor (fileId))
            .returns()
        .returns();
        // Accept the session for the requested fileId:
        call (session->accept())
            // write complete handshake directly:
            .willCall (transport->write (outHandshake))
            .willReturn (true)
            // done, connection established:
            .willCall (status->sessionEstablished())
            .returns()
        .returns();
    }

    void testAcceptConnectionSucceedsAfterOneReadyRead()
    {
        scenarioAcceptConnectionSucceedsAfterANumberOfReadyReads (1);
    }

    void testAcceptConnectionSucceedsAfterTwoReadyReads()
    {
        scenarioAcceptConnectionSucceedsAfterANumberOfReadyReads (2);
    }

    void testAcceptConnectionSucceedsAfterThreeReadyReads()
    {
        scenarioAcceptConnectionSucceedsAfterANumberOfReadyReads (3);
    }

    // testAcceptConnectionFailsDueToInvalidHandshake()

    void stateEstablished()
    {
        testEstablishSessionSucceedsDirectly();
    }

    /*
    template <typename T>
    void scenarioSessionStateChangedByPeer (
                ExpectationPair <ExpectedFunction <void ()> > expectation)
    {
        stateEstablished();

        call (session->readyRead())
            .willCall (packetFactory->readPacket(transport->imp))
            .willReturn (SharedPointer <Packet> (new T()))
            .willCall (expectation)
            .returns()
        .returns();
    }

    void testSessionChoked()
    {
        scenarioSessionStateChangedByPeer <Choke> (status->sessionChoked());
    }

    void testSessionUnchoked()
    {
        scenarioSessionStateChangedByPeer <Unchoke> (status->sessionUnchoked());
    }

    void testSessionInterested()
    {
        scenarioSessionStateChangedByPeer <Interested>
                                            (status->sessionInterested());
    }

    void testSessionNotInterested()
    {
        scenarioSessionStateChangedByPeer <NotInterested>
                                            (status->sessionNotInterested());
    }

    void testChokeSession()
    {
        CPPUNIT_ASSERT (false);
    }

    void testUnchokeSession()
    {
        CPPUNIT_ASSERT (false);
    }
    */
};

CPPUNIT_TEST_SUITE_REGISTRATION(SessionTest);

} // namespace Testing
} // namespace Transfers
} // namespace BitTorrent
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.