SingleTrackerRequestSessionTest.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 "../SingleTrackerRequestSession.h"
#include "../TrackerResponseParser.h"
#include "generated/HttpRequestSessionMock.h"
#include "generated/SingleTrackerRequestSessionDriver.h"
#include "generated/TrackerRequestSessionMock.h"
#include "Imports.cpp"

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


class SingleTrackerRequestSessionTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (SingleTrackerRequestSessionTest);
    CPPUNIT_TEST (testOpenClosedSession);
    CPPUNIT_TEST (testHttpRequestSessionGetsEstablished);
    CPPUNIT_TEST (testSendRequest);
    CPPUNIT_TEST (testRecieveResponseHttp200AndValidMessageBody);
    CPPUNIT_TEST (testRecieveResponseHttp206AndValidMessageBody);
    CPPUNIT_TEST (testHttpErrorHttp100);
    CPPUNIT_TEST (testHttpErrorHttp101);
    CPPUNIT_TEST (testHttpErrorHttp300);
    CPPUNIT_TEST (testHttpErrorHttp307);
    CPPUNIT_TEST (testHttpErrorHttp400);
    CPPUNIT_TEST (testHttpErrorHttp417);
    CPPUNIT_TEST (testHttpErrorHttp500);
    CPPUNIT_TEST (testHttpErrorHttp505);
    CPPUNIT_TEST (testTrackerErrorHttp200AndInvalidResponseBody);
    CPPUNIT_TEST (testTrackerErrorHttp200AndFailureResponseBody);
    CPPUNIT_TEST (testCloseClosedSession);
    CPPUNIT_TEST (testCloseSessionCompletelyAfterItsEstablished);
    CPPUNIT_TEST (testCloseSessionCompletelyWhileWaitingForResponse);
    CPPUNIT_TEST (testCloseSessionCompletelyAfterHandledResponseHeader);
    CPPUNIT_TEST (testCloseSessionWhileClosing);
    CPPUNIT_TEST (testAbortClosedSession);
    CPPUNIT_TEST (testAbortSessionAfterItsEstablished);
    CPPUNIT_TEST (testAbortSessionWhileWaitingForResponse);
    CPPUNIT_TEST (testAbortSessionAfterHandledResponseHeader);
    CPPUNIT_TEST (testAbortSessionWhileClosing);
    CPPUNIT_TEST (testHttpRequestSessionErrorWhileEstablishingSession);
    CPPUNIT_TEST (testHttpRequestSessionErrorAfterSessionIsEstablished);
    CPPUNIT_TEST (testHttpRequestSessionErrorWhileWaitingForResponse);
    CPPUNIT_TEST (testHttpRequestSessionErrorAfterHandledResponseHeader);
    CPPUNIT_TEST (testHttpRequestSessionErrorWhileClosing);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <HttpRequestSessionMock>                   httpRequestSession;
    auto_ptr <TrackerRequestSessionStatusMock>          sessionStatus;
    auto_ptr <SingleTrackerRequestSession>              sessionReal;
    auto_ptr <SingleTrackerRequestSessionDriver>        session;

    const Uri                                   ValidAnnounceUrl;
    const TrackerRequest                        ValidTrackerRequest;
    const Uri                                   ValidTrackerRequestUrl;
    const QByteArray                            ValidResponseBody;
    const QByteArray                            InvalidResponseBody;
    const QByteArray                            FailureResponseBody;
    const TrackerResponse                       ValidTrackerResponse;


    TrackerResponse createValidTrackerResponse() const
    {
        TrackerResponse response;
        TrackerResponseParser::parseAndLoadTrackerResponse (ValidResponseBody,
            response);
        return response;
    }

public:
    SingleTrackerRequestSessionTest();

    void setUp()
    {
        httpRequestSession.reset (new HttpRequestSessionMock());
        sessionStatus.reset (new TrackerRequestSessionStatusMock());
        sessionReal.reset (new SingleTrackerRequestSession (
            &httpRequestSession->imp, ValidAnnounceUrl, &sessionStatus->imp));
        session.reset (new SingleTrackerRequestSessionDriver (
            *sessionReal.get()));
    }

    void tearDown()
    {
        session.reset();
        sessionReal.reset();
        sessionStatus.reset();
        httpRequestSession.reset();
    }

    void testOpenClosedSession()
    {
        call (session->open())
            .willCall (httpRequestSession->open (ValidAnnounceUrl))
            .returns()
        .returns();
    }

    void stateSessionIsOpened()
    {
        testOpenClosedSession();
    }

    void testHttpRequestSessionGetsEstablished()
    {
        call (session->httpRequestSessionEstablished())
            .willCall (sessionStatus->trackerRequestSessionEstablished (
                sessionReal.get()))
            .returns()
        .returns();
    }

    void stateSessionIsEstablished()
    {
        testHttpRequestSessionGetsEstablished();
    }

    void testSendRequest()
    {
        stateSessionIsEstablished();

        call (session->sendRequest (ValidTrackerRequest))
            .willCall (httpRequestSession->get (ValidTrackerRequestUrl))
            .returns()
        .returns();
    }

    void stateWaitingForResponse()
    {
        testSendRequest();
    }


    void refHandleResponseHeaderSuccessfully (const ResponseHeader &responseHeader)
    {
        call (session->httpRequestSessionResponseHeaderRecieved (responseHeader))
        .returns();
    }


    void scenarioRecieveResponse (const ResponseHeader &responseHeader,
                                  const QByteArray &responseBody,
                                  const TrackerResponse &trackerResponse)
    {
        stateWaitingForResponse();

        refHandleResponseHeaderSuccessfully (responseHeader);

        call (session->httpRequestSessionResponseBodyRecieved (responseBody))
            .willCall (sessionStatus->trackerRequestSessionResponseRecieved (
                sessionReal.get(), trackerResponse))
            .returns()
        .returns();
    }

    void testRecieveResponseHttp200AndValidMessageBody()
    {
        scenarioRecieveResponse (ResponseHeader ("HTTP/1.1 200 OK\r\n\r\n"),
            ValidResponseBody, ValidTrackerResponse);
    }

    void testRecieveResponseHttp206AndValidMessageBody()
    {
        scenarioRecieveResponse (ResponseHeader ("HTTP/1.1 206 Partial Content\r\n\r\n"),
            ValidResponseBody, ValidTrackerResponse);
    }


    void scenarioHttpError (const ResponseHeader &responseHeader,
                            const QString &httpErrorMessage)
    {
        stateWaitingForResponse();

        call (session->httpRequestSessionResponseHeaderRecieved (responseHeader))
            .willCall (sessionStatus->trackerRequestSessionError (
                sessionReal.get(), httpErrorMessage))
            .returns()
        .returns();
    }

    void testHttpErrorHttp100()
    {
        scenarioHttpError (ResponseHeader ("HTTP/1.1 100 Continue\r\n\r\n"),
            QString ("HTTP error: 100 Continue"));
    }

    void testHttpErrorHttp101()
    {
        scenarioHttpError (ResponseHeader ("HTTP/1.1 101 Switching Protocols\r\n\r\n"),
            QString ("HTTP error: 101 Switching Protocols"));
    }

    void testHttpErrorHttp300()
    {
        scenarioHttpError (ResponseHeader ("HTTP/1.1 300 Multiple Choices\r\n\r\n"),
            QString ("HTTP error: 300 Multiple Choices"));
    }

    void testHttpErrorHttp307()
    {
        scenarioHttpError (ResponseHeader ("HTTP/1.1 307 Temporary Redirect\r\n\r\n"),
            QString ("HTTP error: 307 Temporary Redirect"));
    }

    void testHttpErrorHttp400()
    {
        scenarioHttpError (ResponseHeader ("HTTP/1.1 400 Bad Request\r\n\r\n"),
            QString ("HTTP error: 400 Bad Request"));
    }

    void testHttpErrorHttp417()
    {
        scenarioHttpError (ResponseHeader ("HTTP/1.1 417 Expectation Failed\r\n\r\n"),
            QString ("HTTP error: 417 Expectation Failed"));
    }

    void testHttpErrorHttp500()
    {
        scenarioHttpError (ResponseHeader ("HTTP/1.1 500 Internal Server Error\r\n\r\n"),
            QString ("HTTP error: 500 Internal Server Error"));
    }

    void testHttpErrorHttp505()
    {
        scenarioHttpError (ResponseHeader ("HTTP/1.1 505 HTTP Version Not Supported\r\n\r\n"),
            QString ("HTTP error: 505 HTTP Version Not Supported"));
    }


    void scenarioTrackerError (const ResponseHeader &responseHeader,
                               const QByteArray &responseBody,
                               const QString &trackerErrorMessage)
    {
        stateWaitingForResponse();

        refHandleResponseHeaderSuccessfully (responseHeader);

        call (session->httpRequestSessionResponseBodyRecieved (responseBody))
            .willCall (sessionStatus->trackerRequestSessionError (
                sessionReal.get(), trackerErrorMessage))
            .returns()
        .returns();
    }

    void testTrackerErrorHttp200AndInvalidResponseBody()
    {
        scenarioTrackerError (ResponseHeader ("HTTP/1.1 200 OK\r\n\r\n"),
            InvalidResponseBody, QString ("Tracker error: Tracker response could not be parsed"));
    }

    void testTrackerErrorHttp200AndFailureResponseBody()
    {
        scenarioTrackerError (ResponseHeader ("HTTP/1.1 200 OK\r\n\r\n"),
            FailureResponseBody, QString ("Tracker error: Unknown info_hash"));
    }

    void stateResponseHeaderHandledSuccessfully()
    {
        stateWaitingForResponse();

        refHandleResponseHeaderSuccessfully (
            ResponseHeader ("HTTP/1.1 200 OK\r\n\r\n"));
    }

    void refCloseSessionAfterHttpRequestSessionIsClosed()
    {
        call (session->httpRequestSessionClosed())
            .willCall (sessionStatus->trackerRequestSessionClosed (
                sessionReal.get()))
            .returns()
        .returns();
    }

    void refCloseEstablishedSession()
    {
        call (session->close())
            .willCall (sessionStatus->trackerRequestSessionClosing (
                sessionReal.get()))
            .returns()
            .willCall (httpRequestSession->close())
            .returns()
        .returns();
    }

    void refCloseEstablishedSessionCompletely()
    {
        refCloseEstablishedSession();
        refCloseSessionAfterHttpRequestSessionIsClosed();
    }

    void refCloseClosedOrClosingSession()
    {
        call (session->close())
        .returns();
    }

    void stateSessionIsClosing()
    {
        stateSessionIsEstablished();

        refCloseEstablishedSession();
    }

    void testCloseClosedSession()
    {
        refCloseClosedOrClosingSession();
    }

    void testCloseSessionCompletelyAfterItsEstablished()
    {
        stateSessionIsEstablished();

        refCloseEstablishedSessionCompletely();
    }

    void testCloseSessionCompletelyWhileWaitingForResponse()
    {
        stateWaitingForResponse();

        refCloseEstablishedSessionCompletely();
    }

    void testCloseSessionCompletelyAfterHandledResponseHeader()
    {
        stateResponseHeaderHandledSuccessfully();

        refCloseEstablishedSessionCompletely();
    }

    void testCloseSessionWhileClosing()
    {
        stateSessionIsClosing();

        refCloseClosedOrClosingSession();
    }

    void refAbortEstablishedSession()
    {
        call (session->abort())
            .willCall (httpRequestSession->abort())
            .returns()
            .willCall (sessionStatus->trackerRequestSessionClosed (
                sessionReal.get()))
            .returns()
        .returns();
    }

    void testAbortClosedSession()
    {
        call (session->abort())
        .returns();
    }

    void testAbortSessionAfterItsEstablished()
    {
        stateSessionIsEstablished();

        refAbortEstablishedSession();
    }

    void testAbortSessionWhileWaitingForResponse()
    {
        stateWaitingForResponse();

        refAbortEstablishedSession();
    }

    void testAbortSessionAfterHandledResponseHeader()
    {
        stateResponseHeaderHandledSuccessfully();

        refAbortEstablishedSession();
    }

    void testAbortSessionWhileClosing()
    {
        stateSessionIsClosing();

        refAbortEstablishedSession();
    }

    void refHandleHttpRequestSessionError (const QString &errorMessage)
    {
        call (session->httpRequestSessionError (errorMessage))
            .willCall (sessionStatus->trackerRequestSessionError (
                sessionReal.get(), QString ("HTTP request session error: " +
                    errorMessage)))
            .returns()
        .returns();
    }

    void testHttpRequestSessionErrorWhileEstablishingSession()
    {
        stateSessionIsOpened();

        refHandleHttpRequestSessionError (QString ("Connection failed"));
    }

    void testHttpRequestSessionErrorAfterSessionIsEstablished()
    {
        stateSessionIsEstablished();

        refHandleHttpRequestSessionError (QString ("Connection lost"));
    }

    void testHttpRequestSessionErrorWhileWaitingForResponse()
    {
        stateWaitingForResponse();

        refHandleHttpRequestSessionError (QString ("Connection lost"));
    }

    void testHttpRequestSessionErrorAfterHandledResponseHeader()
    {
        stateResponseHeaderHandledSuccessfully();

        refHandleHttpRequestSessionError (QString ("Connection lost"));
    }

    void testHttpRequestSessionErrorWhileClosing()
    {
        stateSessionIsClosing();

        refHandleHttpRequestSessionError (QString ("Closing problem"));
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(SingleTrackerRequestSessionTest);

SingleTrackerRequestSessionTest::SingleTrackerRequestSessionTest()
    : httpRequestSession(),
      sessionStatus(),
      sessionReal(),
      session(),
      ValidAnnounceUrl (Uri::fromUnencoded ("http://localhost/announce.php")),
      ValidTrackerRequest (
        ValidAnnounceUrl,
        PeerInfo ("0.0.0.0", 6881, PeerInfo::PeerId ("-CA0610-574938205849")),
        Torrent::InfoHash ("z53bf64bd05hfn2daqml"),
        4096,
        2048,
        63488,
        false),
      ValidTrackerRequestUrl (Uri::fromUnencoded (
        ValidAnnounceUrl.unencoded() +
        "?info_hash=z53bf64bd05hfn2daqml"
        "&peer_id=-CA0610-574938205849"
        "&port=6881"
        "&uploaded=4096"
        "&downloaded=2048"
        "&left=63488"
        "&compact=0"
        "&event=empty"
        "&numwant=0")),
      ValidResponseBody (
        "d"
            "8:intervali300e"
            "5:peersle"
        "e"),
      InvalidResponseBody (
        "d"
            "1:too-long-key-namei467e"
        "e"),
      FailureResponseBody (
        "d"
            "14:failure reason17:Unknown info_hash"
        "e"),
      ValidTrackerResponse (createValidTrackerResponse())
{
}

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.