IpResolvingTransportFactoryTest.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 "../IpResolvingTransportFactory.h"
#include "generated/IpResolvingTransportFactoryDriver.h"
#include "generated/NameResolverMock.h"
#include "generated/TransportFactoryMock.h"
#include "generated/TransportFactoryStatusMock.h"
#include "generated/TransportMock.h"
#include "Imports.cpp"

namespace Protocols {
namespace Generics {
namespace Testing {


class IpResolvingTransportFactoryTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (IpResolvingTransportFactoryTest);
    CPPUNIT_TEST (testNoResolutionNecessaryJustDelegateToTheOtherFactory);
    CPPUNIT_TEST (testStartNameResolutionWhenUriIsNotIpAddressButNoNamesFound);
    CPPUNIT_TEST (testCreateTransportWithNameResolutionOtherFactoryFails);
    CPPUNIT_TEST (testCreateTransportWithNameResolutionOtherFactorySucceeds);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <NameResolverMock>                     nameResolver;
    auto_ptr <TransportFactoryStatusMock>           status;
    auto_ptr <TransportMock>                        transport;
    auto_ptr <TransportFactoryMock>                 otherFactory;
    auto_ptr <IpResolvingTransportFactory>          factoryReal;
    auto_ptr <IpResolvingTransportFactoryDriver>    factory;

    const Uri                                       notIpAddressUri;
    const QList <QHostAddress>                      noAddresses;
    const QList <QHostAddress>                      singleAddress;

public:
    IpResolvingTransportFactoryTest()
     :  notIpAddressUri (Uri::fromUnencoded ("tcp://www.calitko.org")),
        noAddresses(),
        singleAddress (QList <QHostAddress>() += QHostAddress ("123.1.2.3"))
    {
    }

    void setUp()
    {
        nameResolver.reset (new NameResolverMock);
        status.reset (new TransportFactoryStatusMock);
        transport.reset (new TransportMock);
        otherFactory.reset (new TransportFactoryMock);
        factoryReal.reset (new IpResolvingTransportFactory (*otherFactory,
                                                            *nameResolver));
        factory.reset (new IpResolvingTransportFactoryDriver (*factoryReal));
    }

    void tearDown()
    {
        factory.reset();
        factoryReal.reset();
        otherFactory.reset();
        transport.reset();
        status.reset();
        nameResolver.reset();
    }

    void testNoResolutionNecessaryJustDelegateToTheOtherFactory()
    {
        Uri ipAddressUri = Uri::fromUnencoded ("tcp://127.0.0.1:22");
        call (factory->createTransport (ipAddressUri, *status))
            .willCall (otherFactory->createTransport (ipAddressUri, *status))
            .returns()
        .returns();
    }

    void refCreateTransportStartsNameResolution (const Uri &uri)
    {
        QByteArray hostName = uri.host();
        call (factory->createTransport (uri, *status))
            .willCall (nameResolver->resolveName (hostName, *factory))
            .returns()
        .returns();
    }

    void refNameResolutionFails (const Uri &uri)
    {
        QByteArray hostName = uri.host();
        nameResolver->calls (factory->nameResolverResolvedName (hostName,
                                                                noAddresses))
            .willCall (status->transportFactoryFailed (uri))
            .returns()
        .returns();
    }

    // \todo make a static member in the class under test?
    Uri createResolvedUri (const Uri &uri,
                            const QList <QHostAddress> &addresses)
    {
        Uri resolvedUri = uri;
        // \todo Implement Uri::setHost() and Uri::setPort() and Uri::setUserInfo()
        resolvedUri.setAuthority (uri.userInfo(),
                                  addresses.first().toString().toLatin1(),
                                  uri.port());
        return resolvedUri;
    }

    void refNameResolved (const Uri &uri, const QList <QHostAddress> &addresses)
    {
        QByteArray hostName = uri.host();
        Uri resolvedUri = createResolvedUri (uri, addresses);

        nameResolver->calls (factory->nameResolverResolvedName (hostName,
                                                                addresses))
            .willCall (otherFactory->createTransport (resolvedUri, *factory))
            .returns()
        .returns();
    }

    void refOtherFactoryFails (const Uri &uri,
                               const QList <QHostAddress> &addresses)
    {
        Uri resolvedUri = createResolvedUri (uri, addresses);
        otherFactory->calls (factory->transportFactoryFailed (resolvedUri))
            .willCall (status->transportFactoryFailed (uri))
            .returns()
        .returns();
    }

    void refOtherFactorySucceeds (const Uri &uri,
                                  const QList <QHostAddress> &addresses)
    {
        Uri resolvedUri = createResolvedUri (uri, addresses);

        otherFactory->calls (factory->transportFactorySucceeded (resolvedUri,
                                                                 *transport))
            .willCall (status->transportFactorySucceeded (uri, *transport))
            .returns()
        .returns();
    }

    void refDestroyTransport()
    {
        call (factory->destroyTransport (*transport))
            .willCall (otherFactory->destroyTransport (*transport))
            .returns()
        .returns();
    }

    void testStartNameResolutionWhenUriIsNotIpAddressButNoNamesFound()
    {
        refCreateTransportStartsNameResolution (notIpAddressUri);
        refNameResolutionFails (notIpAddressUri);
    }

    void testCreateTransportWithNameResolutionOtherFactoryFails()
    {
        refCreateTransportStartsNameResolution (notIpAddressUri);
        refNameResolved (notIpAddressUri, singleAddress);
        refOtherFactoryFails (notIpAddressUri, singleAddress);
    }

    void testCreateTransportWithNameResolutionOtherFactorySucceeds()
    {
        refCreateTransportStartsNameResolution (notIpAddressUri);
        refNameResolved (notIpAddressUri, singleAddress);
        refOtherFactorySucceeds (notIpAddressUri, singleAddress);
        refDestroyTransport();
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (IpResolvingTransportFactoryTest);

} // namespace Testing
} // namespace Generics
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.