main-acceptance.cpp

Go to the documentation of this file.

#include "Qt.h"
#include "Utils/CalitkoMocks/TesterApplication.h"
#include "3rdParty/cppunit/extensions/TestFactoryRegistry.h"
#include "3rdParty/cppunit/ui/text/TestRunner.h"

#include "Utils/CalitkoMocks/CoCppUnit.h"
#include "Utils/CalitkoMocks/Mocks.h"
#include "Protocols/Http/ClientHttpSession.h"
#include "Protocols/Http/ClientHttpSessionFactory.h"
#include "Protocols/Http/ClientHttpSessionStatus.h"
#include "Protocols/Http/HeaderBase.h"
#include "Protocols/Http/ResponseHeader.h"
#include "Protocols/Generics/IpResolvingTransportFactory.h"
#include "Protocols/Generics/TcpTransportFactory.h"
#include "Protocols/Generics/QtNameResolver.h"

#include <iostream>

class MemoryFile : public Protocols::Http::File
{
public:
    bool write (const QByteArray &bytes, bool = true)
    {
        bytes_ += bytes;
        return true;
    }

    QByteArray bytes_;
};

using Protocols::Generics::Data;
using Protocols::Generics::IpResolvingTransportFactory;
using Protocols::Generics::TcpTransportFactory;
using Protocols::Generics::TransportFactory;
using Protocols::Generics::QtNameResolver;
using Protocols::Http::ClientHttpSession;
using Protocols::Http::ClientHttpSessionFactory;
using Protocols::Http::HeaderBase;
using Protocols::Http::ResponseHeader;
using namespace Utils::CalitkoMocks;
using Utils::Uri;

class HttpDownloader : public Protocols::Http::ClientHttpSessionFactoryStatus,
                       public Protocols::Http::ClientHttpSessionStatus
{
    ClientHttpSessionFactory    clientHttpSessionFactory_;
    ClientHttpSession           *session_;
    MemoryFile                  memoryFile;

public:
    HttpDownloader (TransportFactory *transportFactory)
     :  clientHttpSessionFactory_ (transportFactory),
        session_ (0),
        memoryFile()
    {
    }

    ~HttpDownloader()
    {
    }

    void download (const QByteArray &url)
    {
        qDebug() << "starting" << url;
        clientHttpSessionFactory_.createSession (Uri::fromUnencoded (url), this, this);
    }

    // Interface  ClientHttpSessionFactoryStatus:
    void clientHttpSessionFactorySucceeded (const Uri &uri,
                                            ClientHttpSession *session)
    {
        session_ = session;
        session_->open(); // Enables reading and writing.
        session_->get (uri, &memoryFile);
    }

    void clientHttpSessionFactoryFailed (const Uri &)
    {
        qDebug() << "FAILED to open session!";
        done();
    }

    // Interface  ClientHttpSessionStatus:
    void clientHttpSessionResponseStarted (const ResponseHeader &header)
    {
        qDebug() << "Response Header:";
        qDebug() << header.toRawBytes();
    }

    void clientHttpSessionResponseFinished (const HeaderBase &header)
    {
        qDebug() << "FINISHED";
        qDebug() << header.toRawBytes();
        qDebug() << "Response DATA:";
        std::cout.write (memoryFile.bytes_.constData(), memoryFile.bytes_.size());
        session_->close();
    }

    void clientHttpSessionInvaidResponse (const Data &)
    {
        qDebug() << "INVALID RESPONSE";
        done();
    }

    void clientHttpSessionClosing()
    {
        qDebug() << "Closing session...";
    }

    void clientHttpSessionClosed()
    {
        qDebug() << "Session closed.";
        done();
    }

private:
    void done()
    {
        if (session_ != 0)
            clientHttpSessionFactory_.destroySession (session_);
        QCoreApplication::exit(0);
    }
};

class AcceptanceEnvironment
{
public:
    QtNameResolver                  qtNameResolver;
    TcpTransportFactory             tcpTransportFactory;
};

class CalitkoApplication
{
    IpResolvingTransportFactory     ipResolvingTransportFactory_;

public:
    // Services:
    HttpDownloader      downloader;

    CalitkoApplication (AcceptanceEnvironment *);
    ~CalitkoApplication();
};

CalitkoApplication::CalitkoApplication (AcceptanceEnvironment *environment)
 :  ipResolvingTransportFactory_ (&environment->tcpTransportFactory,
                                  &environment->qtNameResolver),
    downloader (&ipResolvingTransportFactory_)
{
}

CalitkoApplication::~CalitkoApplication()
{
}

class HttpDownloadAcceptance : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (HttpDownloadAcceptance);
    CPPUNIT_TEST (testDownloadHttpResourceAtOnce);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <AcceptanceEnvironment>    environment;
    auto_ptr <CalitkoApplication>       calitko;

public:
    void setUp()
    {
        environment.reset (new AcceptanceEnvironment);
        calitko.reset (new CalitkoApplication (environment.get()));
    }

    void tearDown()
    {
        calitko.reset();
        environment.reset();
    }

    void testDownloadHttpResourceAtOnce()
    {
        //QByteArray tcpScript = "TODO";
        //environment->nameResolver->addMapping ("bzr.calitko.org",
        //                                     "123.123.123.123");
        //environment->socketFactory->addMapping ("123.123.123.123", 80,
        //                                      tcpScript);
        // \todo DownloadingService???
        HttpDownloader *downloader = &calitko->downloader;
        downloader->download ("http://bzr.calitko.org/developers/peter/");
        //downloader->download ("http://123.123.123.123/developers/peter/");
        CPPUNIT_ASSERT (TesterApplication::exec(10000) == 0);
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (HttpDownloadAcceptance);

using namespace CppUnit;

int main(int argc, char** argv)
{
    TesterApplication app (argc, argv);
    TextUi::TestRunner runner;
    TestFactoryRegistry &registry = TestFactoryRegistry::getRegistry();
    runner.addTest (registry.makeTest());
    bool wasSuccessful = runner.run ("", false);
    return !wasSuccessful;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.