TrackerManagerImplTest.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 "../TrackerManagerImpl.h"
#include "../TrackerRequest.h"
#include "../TrackerRequestSession.h"
#include "../TrackerRequestSessionFactory.h"
#include "../TrackerResponse.h"
#include "../TrackerResponseParser.h"
#include "generated/TrackerRequestSessionMock.h"
#include "generated/TrackerRequestSessionFactoryMock.h"
#include "generated/TrackerManagerMock.h"
#include "generated/TrackerManagerImplMock.h"
#include "generated/TrackerManagerImplDriver.h"
#include "Imports.cpp"

namespace Protocols {
namespace BitTorrent {
namespace Trackers {
namespace Testing {


class TrackerManagerImplTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (TrackerManagerImplTest);
    CPPUNIT_TEST (testStartTrackerManager);
    CPPUNIT_TEST (testSessionErrorWhileWaitingForSessionEstablishment);
    CPPUNIT_TEST (testSessionEstablishedWhileWaitingForSessionEstablishment);
    CPPUNIT_TEST (testResponseRecievedWhileWaitingForResponse);
    CPPUNIT_TEST (testUpdateTimeHasCome);
    CPPUNIT_TEST (testStopStoppedTrackerManager);
    CPPUNIT_TEST (testStopTrackerManagerWhileWaitingForSessionEstablishment);
    CPPUNIT_TEST (testStopTrackerManagerAfterRecievedResponse);
    CPPUNIT_TEST (testSessionClosingWhileWhileWaitingForResponse);
    CPPUNIT_TEST (testSessionClosingAfterRecievedResponse);
    CPPUNIT_TEST (testSessionClosedWhileWhileWaitingForResponse);
    CPPUNIT_TEST (testSessionClosedAfterRecievedResponse);
    CPPUNIT_TEST (testSessionClosedAfterStartedTrackerManagerIsStopped);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <TimerMock>                        timer;
    auto_ptr <TrackerRequestSessionMock>        trackerRequestSession;
    auto_ptr <TrackerRequestSessionFactoryMock> trackerRequestSessionFactory;
    auto_ptr <TrackerManagerStatusMock>         trackerManagerStatus;
    auto_ptr <TrackerManagerImpl>               trackerManagerReal;
    auto_ptr <TrackerManagerImplDriver>         trackerManager;

    Torrent                                     torrent;
    TrackerRequest                              trackerRequest;
    TrackerRequest                              updateTrackerRequest;
    TrackerResponse                             trackerResponse;
    QString                                     errorMessage;

public:
    TrackerManagerImplTest();

    void setUp()
    {
        timer.reset (new TimerMock());
        trackerRequestSession.reset (new TrackerRequestSessionMock());
        trackerRequestSessionFactory.reset (
            new TrackerRequestSessionFactoryMock());
        trackerManagerStatus.reset (new TrackerManagerStatusMock());
        trackerManagerReal.reset (new TrackerManagerImpl (
            &trackerRequestSessionFactory->imp,
            &timer->imp,
            &trackerManagerStatus->imp));
        trackerManager.reset (new TrackerManagerImplDriver (
            *trackerManagerReal.get()));
    }

    void tearDown()
    {
        trackerManager.reset();
        trackerManagerReal.reset();
        trackerManagerStatus.reset();
        trackerRequestSessionFactory.reset();
        trackerRequestSession.reset();
        timer.reset();
    }

    void testStartTrackerManager()
    {
        call (trackerManager->start (torrent))
            .willCall (trackerRequestSessionFactory->createSession (torrent))
            .willReturn (&trackerRequestSession->imp)
            .willCall (trackerRequestSession->open())
            .returns()
        .returns();
    }

    void stateWaitingForSessionEstablishment()
    {
        testStartTrackerManager();
    }

    void testSessionErrorWhileWaitingForSessionEstablishment()
    {
        stateWaitingForSessionEstablishment();

        call (trackerManager->trackerRequestSessionFactorySessionError (
            &trackerRequestSession->imp, errorMessage))
            .willCall (trackerManagerStatus->trackerManagerError (
                errorMessage))
            .returns()
        .returns();
    }

    void refHandleSessionEstablishment()
    {
        call (trackerManager->trackerRequestSessionFactorySessionEstablished (
            &trackerRequestSession->imp))
            .willCall (trackerRequestSession->sendRequest (trackerRequest))
            .returns()
        .returns();
    }

    void testSessionEstablishedWhileWaitingForSessionEstablishment()
    {
        stateWaitingForSessionEstablishment();

        refHandleSessionEstablishment();
    }

    void stateWaitingForResponse()
    {
        testSessionEstablishedWhileWaitingForSessionEstablishment();
    }

    void refHandleResponseReception()
    {
        call (trackerManager->trackerRequestSessionFactoryResponseRecieved (
            &trackerRequestSession->imp, trackerResponse))
            .willCall (timer->stop())
            .returns()
            .willCall (timer->start (0, trackerResponse.interval()))
            .returns()
            .willCall (trackerManagerStatus->trackerManagerFoundPeers (
                trackerResponse.peers()))
            .returns()
        .returns();
    }

    void testResponseRecievedWhileWaitingForResponse()
    {
        stateWaitingForResponse();

        refHandleResponseReception();
    }

    void stateResponseRecieved()
    {
        testResponseRecievedWhileWaitingForResponse();
    }

    void testUpdateTimeHasCome()
    {
        stateResponseRecieved();

        call (trackerManager->updateTime())
            .willCall (timer->stop())
            .returns()
            .willCall (trackerRequestSession->sendRequest (updateTrackerRequest))
            .returns()
            .willCall (timer->start (0, trackerResponse.interval()))
            .returns()
        .returns();
    }

    void testStopStoppedTrackerManager()
    {
        call (trackerManager->stop())
            .willCall (timer->stop())
            .returns()
        .returns();
    }

    void refStopStartedTrackerManager()
    {
        call (trackerManager->stop())
            .willCall (timer->stop())
            .returns()
            .willCall (trackerRequestSession->close())
            .returns()
        .returns();
    }

    void testStopTrackerManagerWhileWaitingForSessionEstablishment()
    {
        stateWaitingForSessionEstablishment();

        refStopStartedTrackerManager();
    }


    void testStopTrackerManagerAfterRecievedResponse()
    {
        stateResponseRecieved();

        refStopStartedTrackerManager();
    }

    void refHandleSessionClosing()
    {
        call (trackerManager->trackerRequestSessionFactorySessionClosing (
            &trackerRequestSession->imp))
            .willCall (timer->stop())
            .returns()
        .returns();
    }

    void testSessionClosingWhileWhileWaitingForResponse()
    {
        stateWaitingForResponse();

        refHandleSessionClosing();
    }

    void testSessionClosingAfterRecievedResponse()
    {
        stateResponseRecieved();

        refHandleSessionClosing();
    }

    void refHandleSessionClosed()
    {
        call (trackerManager->trackerRequestSessionFactorySessionClosed (
            &trackerRequestSession->imp))
            .willCall (timer->stop())
            .returns()
            .willCall (trackerRequestSessionFactory->destroySession (
                &trackerRequestSession->imp))
            .returns()
        .returns();
    }

    void testSessionClosedWhileWhileWaitingForResponse()
    {
        stateWaitingForResponse();

        refHandleSessionClosed();
    }

    void testSessionClosedAfterRecievedResponse()
    {
        stateResponseRecieved();

        refHandleSessionClosed();
    }

    void stateStoppedAfterStarted()
    {
        testStopTrackerManagerWhileWaitingForSessionEstablishment();
    }

    void testSessionClosedAfterStartedTrackerManagerIsStopped()
    {
        stateStoppedAfterStarted();

        refHandleSessionClosed();
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(TrackerManagerImplTest);

TrackerManagerImplTest::TrackerManagerImplTest()
    : timer(), trackerRequestSession(), trackerRequestSessionFactory(),
      trackerManagerStatus(), trackerManagerReal(), trackerManager(),
      torrent(),
      trackerRequest (
        Uri::fromUnencoded ("http://localhost/announce.php"),
        PeerInfo ("1.2.3.4", 6881, PeerInfo::PeerId ("-CA0610-574938205849")),
        Torrent::InfoHash ("z53bf64bd05hfn2daqml"),
        4096,
        2048,
        63488,
        false,
        TrackerRequest::Empty,
        0,
        QByteArray(),
        QByteArray()),
      updateTrackerRequest  (
        Uri::fromUnencoded ("http://localhost/announce.php"),
        PeerInfo ("1.2.3.4", 6881, PeerInfo::PeerId ("-CA0610-574938205849")),
        Torrent::InfoHash ("z53bf64bd05hfn2daqml"),
        4096,
        2048,
        63488,
        false,
        TrackerRequest::Empty,
        0,
        QByteArray(),
        QByteArray ("x64gd0c8f1cz5dusm4gd")),
      trackerResponse(),
      errorMessage ("Error")
{
    // trackerResponse
    const QByteArray rawResponseData (
        "d"
            "8:intervali360e"
            "10:tracker id20:x64gd0c8f1cz5dusm4gd"
            "5:peersle"
        "e");
    bool loadedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
        rawResponseData, trackerResponse);
    CPPUNIT_ASSERT (loadedOk);
}

} // namespace Testing
} // namespace Trackers
} // namespace BitTorrent
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.