TransferTest.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 "../Transfer.h"
#include "generated/PacketProcessorMock.h"
#include "generated/TransferDriver.h"
#include "generated/TransferMock.h" // \todo remove after all interfaces get their own module
#include "generated/TransferSessionMock.h"
#include "Imports.cpp"

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


class TransferTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE(TransferTest);
    CPPUNIT_TEST (testStartTransferForTorrent);
    CPPUNIT_TEST (testPeersReturnedFromTrackerAddedToSessionManager);
    CPPUNIT_TEST (testEstablishedSessionAllPacketProcessorsAreNotified);
    CPPUNIT_TEST (testIncomingPacketForwardedToAllPacketProcessors);
    CPPUNIT_TEST (testOutgoingPacketForwardedToAllPacketProcessors);
    CPPUNIT_TEST (testClosingSessionDoesNothing);
    CPPUNIT_TEST (testClosedSessionAllPacketProcessorsAreNotified);
    CPPUNIT_TEST (testStopTransfer);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <TrackerManagerMock>   trackerManager;
    auto_ptr <SessionManagerMock>   sessionManager;
    auto_ptr <PacketProcessorMock>  choker;
    auto_ptr <PacketProcessorMock>  pieceRequester;
    auto_ptr <PacketProcessorMock>  pieceProvider;
    auto_ptr <Transfer>             transferReal;
    auto_ptr <TransferDriver>       transfer;

    const QList <PeerInfo>          peers;
    const PeerInfo::PeerId          peerId;
    const Packet                    packet;
    auto_ptr <TransferSessionMock>  session;

public:
    TransferTest();

    void setUp()
    {
        trackerManager.reset (new TrackerManagerMock());
        sessionManager.reset (new SessionManagerMock());
        choker.reset (new PacketProcessorMock());
        pieceRequester.reset (new PacketProcessorMock());
        pieceProvider.reset (new PacketProcessorMock());
        QList <PacketProcessor *> packetProcessors;
        packetProcessors.append (*choker);
        packetProcessors.append (*pieceRequester);
        packetProcessors.append (*pieceProvider);
        transferReal.reset (new Transfer(*trackerManager, *sessionManager,
                                         packetProcessors));
        transfer.reset (new TransferDriver (*transferReal.get()));
        session.reset (new TransferSessionMock());
    }

    void tearDown()
    {
        transfer.reset();
        transferReal.reset();
        pieceProvider.reset();
        pieceRequester.reset();
        choker.reset();
        sessionManager.reset();
        trackerManager.reset();
        session.reset();
    }

    void testStartTransferForTorrent()
    {
        Torrent torrent;

        call (transfer->start (torrent))
            .willCall (trackerManager->start (torrent.announce()))
            .returns()
            .willCall (sessionManager->start())
            .returns()
        .returns();
    }

    void stateTransferStarted()
    {
        testStartTransferForTorrent();
    }

    void testPeersReturnedFromTrackerAddedToSessionManager()
    {
        call (transfer->trackerManagerFoundPeers (peers))
            .willCall (sessionManager->addPeers (peers))
            .returns()
        .returns();
    }

    void testEstablishedSessionAllPacketProcessorsAreNotified()
    {
        call (transfer->sessionManagerEstablishedSession (*session))
            .willCall (choker->openedSession (*session))
            .returns()
            .willCall (pieceRequester->openedSession (*session))
            .returns()
            .willCall (pieceProvider->openedSession (*session))
            .returns()
        .returns();
    }

    void testIncomingPacketForwardedToAllPacketProcessors()
    {
        call (transfer->transferSessionReceivedPacket (*session, packet))
            .willCall (choker->incomingPacket (*session, packet))
            .returns()
            .willCall (pieceRequester->incomingPacket (*session, packet))
            .returns()
            .willCall (pieceProvider->incomingPacket (*session, packet))
            .returns()
        .returns();
    }

    void testOutgoingPacketForwardedToAllPacketProcessors()
    {
        call (transfer->transferSessionSendingPacket (*session, packet))
            .willCall (choker->outgoingPacket (*session, packet))
            .returns()
            .willCall (pieceRequester->outgoingPacket (*session, packet))
            .returns()
            .willCall (pieceProvider->outgoingPacket (*session, packet))
            .returns()
        .returns();
    }

    void testClosingSessionDoesNothing()
    {
        call (transfer->transferSessionClosing (*session))
        .returns();
    }

    void testClosedSessionAllPacketProcessorsAreNotified()
    {
        call (transfer->transferSessionClosed (*session))
            .willCall (choker->closedSession (*session))
            .returns()
            .willCall (pieceRequester->closedSession (*session))
            .returns()
            .willCall (pieceProvider->closedSession (*session))
            .returns()
            .willCall (sessionManager->closedSession (*session))
            .returns()
        .returns();
    }

    void testStopTransfer()
    {
        call (transfer->stop())
            .willCall (trackerManager->stop())
            .returns()
            .willCall (sessionManager->stop())
            .returns()
        .returns();
    }
};

TransferTest::TransferTest()
 :  trackerManager(), sessionManager(), choker(), pieceRequester(),
    pieceProvider(), transferReal(), transfer(), peers(), peerId(), packet(),
    session()
{
}

CPPUNIT_TEST_SUITE_REGISTRATION(TransferTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.