SingleHostClientHttpSessionTest.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 "../SingleHostClientHttpSession.h"
#include "../BodyEnd.h"
#include "../RequestHeader.h"
#include "../ResponseHeader.h"
#include "generated/SingleHostClientHttpSessionDriver.h"
#include "generated/ClientHttpSessionMock.h" // \todo for FileMock
#include "generated/ClientHttpSessionStatusMock.h"
#include "Imports.cpp"

namespace Protocols {
namespace Http {
namespace Testing {


class SingleHostClientHttpSessionTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (SingleHostClientHttpSessionTest);
    CPPUNIT_TEST (testCreateRequestHeaderFromUriWithPathWithoutQuery);
    CPPUNIT_TEST (testCreateRequestHeaderFromUriWithPathWithQuery);
    CPPUNIT_TEST (testCreateRequestHeaderFromUriWithoutPathWithoutQuery);
    CPPUNIT_TEST (testCreateRequestHeaderFromUriWithoutPathWithQueryWithPort);
    CPPUNIT_TEST (testOpenHttpSessionOpensTheUnderlyingSession);
    CPPUNIT_TEST (testCloseHttpSessionClosesTheUnderlyingSession);
    CPPUNIT_TEST (testAbortHttpSessionAbortsTheUnderlyingSession);
    CPPUNIT_TEST (testSendGetRequestHeader);
    CPPUNIT_TEST (testReceiveResponseHeaderForGetRequest);
    CPPUNIT_TEST (testReceiveResponseBodyChunk);
    CPPUNIT_TEST (testReceiveBodyEnd);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <FileMock>                             outFile;
    auto_ptr <SessionMock>                          session;
    auto_ptr <ClientHttpSessionStatusMock>          status;
    auto_ptr <SingleHostClientHttpSession>          httpSessionReal;
    auto_ptr <SingleHostClientHttpSessionDriver>    httpSession;

    const Uri                                       uri;

public:
    SingleHostClientHttpSessionTest()
     :  uri (Uri::fromUnencoded ("http://www.calitko.org"))
    {
    }

    void setUp()
    {
        outFile.reset (new FileMock);
        session.reset (new SessionMock);
        status.reset (new ClientHttpSessionStatusMock);
        httpSessionReal.reset (new SingleHostClientHttpSession
                                    (*status, *session));
        httpSession.reset (new SingleHostClientHttpSessionDriver
                                    (*httpSessionReal));
    }

    void tearDown()
    {
        httpSession.reset();
        httpSessionReal.reset();
        status.reset();
        session.reset();
        outFile.reset();
    }

    void refCreateRequestHeader (const QByteArray &unencodedUri,
                                 const QByteArray &httpMethod,
                                 const QByteArray &path,
                                 const QByteArray &host)
    {
        RequestHeader request = SingleHostClientHttpSession::createRequestHeader
            (httpMethod, Uri::fromUnencoded (unencodedUri));

        RequestHeader referenceRequest (httpMethod, path, 1, 1);
        referenceRequest.addFieldValue ("Host", host);

        CPPUNIT_ASSERT (request == referenceRequest);
    }

    void testCreateRequestHeaderFromUriWithPathWithoutQuery()
    {
        refCreateRequestHeader ("http://www.calitko.org/test me",
                                "GET", "/test%20me", "www.calitko.org");
    }

    void testCreateRequestHeaderFromUriWithPathWithQuery()
    {
        refCreateRequestHeader ("http://www.calitko.org/test me?s=p&k",
                                "POST", "/test%20me?s=p&k", "www.calitko.org");
    }

    void testCreateRequestHeaderFromUriWithoutPathWithoutQuery()
    {
        refCreateRequestHeader ("http://www.calitko.org",
                                "PUT", "/", "www.calitko.org");
    }

    void testCreateRequestHeaderFromUriWithoutPathWithQueryWithPort()
    {
        refCreateRequestHeader ("http://www.calitko.org:8080?myquery",
                                "HEAD", "/?myquery", "www.calitko.org:8080");
    }

    void testOpenHttpSessionOpensTheUnderlyingSession()
    {
        call (httpSession->open())
            .willCall (session->open())
            .returns()
        .returns();
    }

    void testCloseHttpSessionClosesTheUnderlyingSession()
    {
        call (httpSession->close())
            .willCall (session->close())
                .willCall (httpSession->sessionClosing (*session))
                    .willCall (status->clientHttpSessionClosing())
                    .returns()
                .returns()
            .returns()
        .returns();

        session->calls (httpSession->sessionClosed (*session))
            .willCall (status->clientHttpSessionClosed())
            .returns()
        .returns();
    }

    void testAbortHttpSessionAbortsTheUnderlyingSession()
    {
        call (httpSession->abort())
            .willCall (session->abort())
                .willCall (httpSession->sessionClosed (*session))
                    .willCall (status->clientHttpSessionClosed())
                    .returns()
                .returns()
            .returns()
        .returns();
    }

    void refSendGetRequest (const Uri &uri)
    {
        RequestHeader getRequest =
            SingleHostClientHttpSession::createRequestHeader ("GET", uri);
        getRequest.setFieldValue ("Content-Length", "0");

        call (httpSession->get (uri, *outFile))
            .willCall (session->send (getRequest))
            .returns()
        .returns();
    }

    void testSendGetRequestHeader()
    {
        refSendGetRequest (uri);
    }

    void refReceiveResponseHeader (const ResponseHeader &response)
    {
        session->calls (httpSession->sessionReceivedData (*session, response))
            .willCall (status->clientHttpSessionResponseStarted (response))
            .returns()
        .returns();
    }

    void testReceiveResponseHeaderForGetRequest()
    {
        ResponseHeader getResponse (200, "OK", 1, 1);
        getResponse.setFieldValue ("Content-Length", "0");

        refSendGetRequest (uri);
        refReceiveResponseHeader (getResponse);
    }

    void refReceiveResponseBodyChunk (const RawData &chunk)
    {
        session->calls (httpSession->sessionReceivedData (*session, chunk))
            .willCall (outFile->write (chunk.toRawBytes()))
            .willReturn (true) // \todo test false -> status->errorX()
        .returns();
    }

    void testReceiveResponseBodyChunk()
    {
        RawData chunk (QByteArray (20, '1'));
        refSendGetRequest (uri);
        refReceiveResponseBodyChunk (chunk);
    }

    void refReceiveBodyEnd (const BodyEnd &bodyEnd)
    {
        session->calls (httpSession->sessionReceivedData (*session, bodyEnd))
            .willCall (status->clientHttpSessionResponseFinished (bodyEnd))
            .returns()
        .returns();
    }

    void testReceiveBodyEnd()
    {
        BodyEnd bodyEnd;
        bodyEnd.setFieldValue ("header-name", "value");

        refSendGetRequest (uri);
        refReceiveBodyEnd (bodyEnd);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (SingleHostClientHttpSessionTest);

} // namespace Testing
} // namespace Http
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.