ClientHttpSessionFactoryTest.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 "../ClientHttpSessionFactory.h"
#include "../CompositeSingleHostClientHttpSession.h"
#include "generated/ClientHttpSessionFactoryDriver.h"
#include "generated/ClientHttpSessionFactoryMock.h" // \todo for ClientHttpSessionFactoryStatusMock
#include "generated/ClientHttpSessionStatusMock.h"
#include "Imports.cpp"

namespace Protocols {
namespace Http {
namespace Testing {

// \todo can we refactor that away?
class SessionCreatedChecker
{
    Uri uri_;

public:
    static ClientHttpSession *checkedHttpSession;

    SessionCreatedChecker (const Uri &uri)
    : uri_ (uri) {}

    typedef void (Function) (const Uri &, ClientHttpSession *);

    bool check (const Uri &uri, ClientHttpSession *httpSession)
    {
        checkedHttpSession = httpSession;
        CPPUNIT_ASSERT (uri_ == uri);
        CPPUNIT_ASSERT (httpSession != 0);
        CPPUNIT_ASSERT (typeid (CompositeSingleHostClientHttpSession) ==
                            typeid (*httpSession));
        return true;
    }
};

using Generics::TransportStatus; // \todo remove after refactoring the hacks
class AnyPointer
{
public:
    typedef void (Function) (TransportStatus *);

    bool check (TransportStatus *)
    {
        return true;
    }
};

ClientHttpSession * SessionCreatedChecker::checkedHttpSession = 0;


class ClientHttpSessionFactoryTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (ClientHttpSessionFactoryTest);
    CPPUNIT_TEST (testConvertHttpUriOnlyWithSchemeAndHostToTcpUri);
    CPPUNIT_TEST (testConvertHttpUriOnlyWithAllFieldsToTcpUri);
    CPPUNIT_TEST (testConvertHttpUriWithoutSchemeReturnsNullUri);
    CPPUNIT_TEST (testCreateClientHttpSessionFromTransportThenDestroyThem);
    CPPUNIT_TEST (testCreateClientHttpSessionForUriSucceedsAndDestroyThem);
    CPPUNIT_TEST (testCreateClientHttpSessionForUriFails);
    CPPUNIT_TEST (testCreateClientHttpSessionForUriFailsSynchronously);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <TransportFactoryMock>                 transportFactory;
    auto_ptr <TransportMock>                        transport;
    auto_ptr <ClientHttpSessionStatusMock>          httpSessionStatus;
    auto_ptr <ClientHttpSessionFactoryStatusMock>   factoryStatus;
    auto_ptr <ClientHttpSessionFactory>             factoryReal;
    auto_ptr <ClientHttpSessionFactoryDriver>       factory;

    const Uri                                       uri;
    const Uri                                       uriForTransport;
    const Uri                                       uriAllFields;
    const Uri                                       uriAllFieldsForTransport;
    const Uri                                       badUri;
    const Uri                                       badUriForTransport;

public:
    ClientHttpSessionFactoryTest()
     :  uri (Uri::fromUnencoded ("http://www.calitko.org")),
        uriForTransport (
            Uri::fromUnencoded ("tcp://www.calitko.org:80?rb=8192&wb=8192")),
        uriAllFields (
            Uri::fromUnencoded ("http://u:p@www.calitko.org:45/p?aha=&a#f")),
        uriAllFieldsForTransport (
            Uri::fromUnencoded ("tcp://www.calitko.org:45?rb=8192&wb=8192")),
        badUri (Uri::fromUnencoded ("//www.calitko.org")),
        badUriForTransport()
    {
    }

    void setUp()
    {
        transportFactory.reset (new TransportFactoryMock);
        transport.reset (new TransportMock);
        httpSessionStatus.reset (new ClientHttpSessionStatusMock);
        factoryStatus.reset (new ClientHttpSessionFactoryStatusMock);
        factoryReal.reset (new ClientHttpSessionFactory
                                (*transportFactory));
        factory.reset (new ClientHttpSessionFactoryDriver (*factoryReal));

        // In all tests transport->setTransportStatus() should be called at
        // least once:
        // \todo That looks ugly... Once we implement custom checkers for
        // for return values and constrains for parameters, we could integrate
        // this check back in the individual test but now we just save us
        // some unnecessary duplication of ugly code:
        ExpectationPair <ExpectedFunction <void (TransportStatus *)> >
            expectation = transport->setTransportStatus (checker (AnyPointer()));
        expectation.list.add (expectation.function);
    }

    void tearDown()
    {
        factory.reset();
        factoryReal.reset();
        factoryStatus.reset();
        httpSessionStatus.reset();
        transport.reset();
        transportFactory.reset();
    }

    void scenarioMakeTransportUri (const Uri &httpUri,
                                   const Uri &expectedTransportUri)
    {
        Uri transportUri = ClientHttpSessionFactory::makeTransportUri (httpUri);
        CPPUNIT_ASSERT (expectedTransportUri == transportUri);
    }

    void testConvertHttpUriOnlyWithSchemeAndHostToTcpUri()
    {
        scenarioMakeTransportUri (uri, uriForTransport);
    }

    void testConvertHttpUriOnlyWithAllFieldsToTcpUri()
    {
        scenarioMakeTransportUri (uriAllFields, uriAllFieldsForTransport);
    }

    void testConvertHttpUriWithoutSchemeReturnsNullUri()
    {
        scenarioMakeTransportUri (badUri, badUriForTransport);
    }

    ClientHttpSession * refCreateSessionFromTransport()
    {
        ClientHttpSession *httpSession =
            factoryReal->createSession (*transport, *httpSessionStatus);
        CPPUNIT_ASSERT (httpSession != 0);
        CPPUNIT_ASSERT (typeid (CompositeSingleHostClientHttpSession) ==
                            typeid (*httpSession));
        return httpSession;
    }

    void refCreateSessionFromUri (const Uri &uri)
    {
        Uri transportUri = ClientHttpSessionFactory::makeTransportUri (uri);
        call (factory->createSession (uri, *httpSessionStatus, *factoryStatus))
            .willCall (transportFactory->createTransport (transportUri,
                                                          *factory))
            .returns()
        .returns();
    }

    void refSessionCreatedFromUriAsynchronously (const Uri &uri)
    {
        Uri transportUri = ClientHttpSessionFactory::makeTransportUri (uri);
        transportFactory->calls (factory->transportFactorySucceeded
                                        (transportUri, *transport))
            .willCall (factoryStatus->clientHttpSessionFactorySucceeded
                                    (checker (SessionCreatedChecker (uri))))
            .returns()
        .returns();
    }

    void refSessionNotCreatedFromUriAsynchronously (const Uri &uri)
    {
        Uri transportUri = ClientHttpSessionFactory::makeTransportUri (uri);
        transportFactory->calls (factory->transportFactoryFailed (transportUri))
            .willCall (factoryStatus->clientHttpSessionFactoryFailed (uri))
            .returns()
        .returns();
    }

    void refDestroySession (ClientHttpSession *httpSession)
    {
        call (factory->destroySession (httpSession))
            .willCall (transportFactory->destroyTransport (*transport))
            .returns()
        .returns();
    }

    void testCreateClientHttpSessionFromTransportThenDestroyThem()
    {
        ClientHttpSession *httpSession = refCreateSessionFromTransport();
        refDestroySession (httpSession);
    }

    void testCreateClientHttpSessionForUriSucceedsAndDestroyThem()
    {
        refCreateSessionFromUri (uri);
        refSessionCreatedFromUriAsynchronously (uri);
        refDestroySession (SessionCreatedChecker::checkedHttpSession);
    }

    void testCreateClientHttpSessionForUriFails()
    {
        refCreateSessionFromUri (uri);
        refSessionNotCreatedFromUriAsynchronously (uri);
    }

    void testCreateClientHttpSessionForUriFailsSynchronously()
    {
        call (factory->createSession (badUri, *httpSessionStatus,
                                      *factoryStatus))
            .willCall (factoryStatus->clientHttpSessionFactoryFailed (badUri))
            .returns()
        .returns();
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (ClientHttpSessionFactoryTest);

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

Copyright © 2006 Peter Dimov.
Powered by Doxygen.