/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include "private/qhttpnetworkconnection_p.h"

#include "private/qnoncontiguousbytedevice_p.h"

#include <QAuthenticator>

#include "../network-settings.h"

class tst_QHttpNetworkConnection: public QObject

{

    Q_OBJECT

public:

    tst_QHttpNetworkConnection();

public Q_SLOTS:

    void finishedReply();

    void finishedWithError(QNetworkReply::NetworkError errorCode, const QString &detail);

    void challenge401(const QHttpNetworkRequest &request, QAuthenticator *authenticator, const QHttpNetworkConnection *connection);

#ifndef QT_NO_OPENSSL

    void sslErrors(const QList<QSslError> &errors);

#endif

private:

    bool finishedCalled;

    bool finishedWithErrorCalled;

    QNetworkReply::NetworkError netErrorCode;

private Q_SLOTS:

    void init();

    void cleanup();

    void initTestCase();

    void cleanupTestCase();

    void options_data();

    void options();

    void get_data();

    void get();

    void head_data();

    void head();

    void post_data();

    void post();

    void put_data();

    void put();

    void _delete_data();

    void _delete();

    void trace_data();

    void trace();

    void _connect_data();

    void _connect();

#ifndef QT_NO_COMPRESS

    void compression_data();

    void compression();

#endif

#ifndef QT_NO_OPENSSL

    void ignoresslerror_data();

    void ignoresslerror();

#endif

#ifdef QT_NO_OPENSSL

    void nossl_data();

    void nossl();

#endif

    void get401_data();

    void get401();

    void getMultiple_data();

    void getMultiple();

    void getMultipleWithPipeliningAndMultiplePriorities();

    void getMultipleWithPriorities();

    void getEmptyWithPipelining();

};

tst_QHttpNetworkConnection::tst_QHttpNetworkConnection()

{

    Q_SET_DEFAULT_IAP

}

void tst_QHttpNetworkConnection::initTestCase()

{

}

void tst_QHttpNetworkConnection::cleanupTestCase()

{

}

void tst_QHttpNetworkConnection::init()

{

}

void tst_QHttpNetworkConnection::cleanup()

{

}

void tst_QHttpNetworkConnection::options_data()

{

    // not tested yet

}

void tst_QHttpNetworkConnection::options()

{

    QEXPECT_FAIL("", "not tested yet", Continue);

    QVERIFY(false);

}

void tst_QHttpNetworkConnection::head_data()

{

    QTest::addColumn<QString>("protocol");

    QTest::addColumn<QString>("host");

    QTest::addColumn<QString>("path");

    QTest::addColumn<ushort>("port");

    QTest::addColumn<bool>("encrypt");

    QTest::addColumn<int>("statusCode");

    QTest::addColumn<QString>("statusString");

    QTest::addColumn<int>("contentLength");

    QTest::newRow("success-internal") << "http://" << QtNetworkSettings::serverName() << "/qtest/rfc3252.txt" << ushort(80) << false << 200 << "OK" << 25962;

    QTest::newRow("success-external") << "http://" << "www.ietf.org" << "/rfc/rfc3252.txt" << ushort(80) << false << 200 << "OK" << 25962;

    QTest::newRow("failure-path") << "http://" << QtNetworkSettings::serverName() << "/t" << ushort(80) << false << 404 << "Not Found" << -1;

    QTest::newRow("failure-protocol") << "" << QtNetworkSettings::serverName() << "/qtest/rfc3252.txt" << ushort(80) << false << 400 << "Bad Request" << -1;

}

void tst_QHttpNetworkConnection::head()

{

    QFETCH(QString, protocol);

    QFETCH(QString, host);

    QFETCH(QString, path);

    QFETCH(ushort, port);

    QFETCH(bool, encrypt);

    QFETCH(int, statusCode);

    QFETCH(QString, statusString);

    QFETCH(int, contentLength);

    QHttpNetworkConnection connection(host);

    QCOMPARE(connection.port(), port);

    QCOMPARE(connection.hostName(), host);

    if (encrypt)

        connection.enableEncryption();

    QCOMPARE(connection.isEncrypted(), encrypt);

    QHttpNetworkRequest request(protocol + host + path, QHttpNetworkRequest::Head);

    QHttpNetworkReply *reply = connection.sendRequest(request);

    QTime stopWatch;

    stopWatch.start();

    do {

        QCoreApplication::instance()->processEvents();

        if (stopWatch.elapsed() >= 30000)

            break;

    } while (!reply->isFinished());

    QCOMPARE(reply->statusCode(), statusCode);

    QCOMPARE(reply->reasonPhrase(), statusString);

    // only check it if it is set

    if (reply->contentLength() != -1)

        QCOMPARE(reply->contentLength(), qint64(contentLength));

    QVERIFY(reply->isFinished());

    delete reply;

}

void tst_QHttpNetworkConnection::get_data()

{

    QTest::addColumn<QString>("protocol");

    QTest::addColumn<QString>("host");

    QTest::addColumn<QString>("path");

    QTest::addColumn<ushort>("port");

    QTest::addColumn<bool>("encrypt");

    QTest::addColumn<int>("statusCode");

    QTest::addColumn<QString>("statusString");

    QTest::addColumn<int>("contentLength");

    QTest::addColumn<int>("downloadSize");

    QTest::newRow("success-internal") << "http://" << QtNetworkSettings::serverName() << "/qtest/rfc3252.txt" << ushort(80) << false << 200 << "OK" << 25962 << 25962;

    QTest::newRow("success-external") << "http://" << "www.ietf.org" << "/rfc/rfc3252.txt" << ushort(80) << false << 200 << "OK" << 25962 << 25962;

    QTest::newRow("failure-path") << "http://" << QtNetworkSettings::serverName() << "/t" << ushort(80) << false << 404 << "Not Found" << -1 << 997 + QtNetworkSettings::serverName().size();

    QTest::newRow("failure-protocol") << "" << QtNetworkSettings::serverName() << "/qtest/rfc3252.txt" << ushort(80) << false << 400 << "Bad Request" << -1 << 930 + QtNetworkSettings::serverName().size();

}

void tst_QHttpNetworkConnection::get()

{

    QFETCH(QString, protocol);

    QFETCH(QString, host);

    QFETCH(QString, path);

    QFETCH(ushort, port);

    QFETCH(bool, encrypt);

    QFETCH(int, statusCode);

    QFETCH(QString, statusString);

    QFETCH(int, contentLength);

    QFETCH(int, downloadSize);

    QHttpNetworkConnection connection(host);

    QCOMPARE(connection.port(), port);

    QCOMPARE(connection.hostName(), host);

    if (encrypt)

        connection.enableEncryption();

    QCOMPARE(connection.isEncrypted(), encrypt);

    QHttpNetworkRequest request(protocol + host + path);

    QHttpNetworkReply *reply = connection.sendRequest(request);

    QTime stopWatch;

    stopWatch.start();

    forever {

        QCoreApplication::instance()->processEvents();

        if (reply->bytesAvailable())

            break;

        if (stopWatch.elapsed() >= 30000)

            break;

    }

    QCOMPARE(reply->statusCode(), statusCode);

    QCOMPARE(reply->reasonPhrase(), statusString);

    // only check it if it is set

    if (reply->contentLength() != -1)

        QCOMPARE(reply->contentLength(), qint64(contentLength));

    stopWatch.start();

    QByteArray ba;

    do {

        QCoreApplication::instance()->processEvents();

        while (reply->bytesAvailable())

            ba += reply->readAny();

        if (stopWatch.elapsed() >= 30000)

            break;

    } while (!reply->isFinished());

    QVERIFY(reply->isFinished());

    QCOMPARE(ba.size(), downloadSize);

    delete reply;

}

void tst_QHttpNetworkConnection::finishedReply()

{

    finishedCalled = true;

}

void tst_QHttpNetworkConnection::finishedWithError(QNetworkReply::NetworkError errorCode, const QString &detail)

{

    Q_UNUSED(detail)

    finishedWithErrorCalled = true;

    netErrorCode = errorCode;

}

void tst_QHttpNetworkConnection::put_data()

{

    QTest::addColumn<QString>("protocol");

    QTest::addColumn<QString>("host");

    QTest::addColumn<QString>("path");

    QTest::addColumn<ushort>("port");

    QTest::addColumn<bool>("encrypt");

    QTest::addColumn<QString>("data");

    QTest::addColumn<bool>("succeed");

    QTest::newRow("success-internal") << "http://" << QtNetworkSettings::serverName() << "/dav/file1.txt" << ushort(80) << false << "Hello World\nEnd of file\n"<<true;

    QTest::newRow("fail-internal") << "http://" << QtNetworkSettings::serverName() << "/dav2/file1.txt" << ushort(80) << false << "Hello World\nEnd of file\n"<<false;

    QTest::newRow("fail-host") << "http://" << "fluke-nosuchhost.troll.no" << "/dav2/file1.txt" << ushort(80) << false << "Hello World\nEnd of file\n"<<false;

}

void tst_QHttpNetworkConnection::put()

{

    QFETCH(QString, protocol);

    QFETCH(QString, host);

    QFETCH(QString, path);

    QFETCH(ushort, port);

    QFETCH(bool, encrypt);

    QFETCH(QString, data);

    QFETCH(bool, succeed);

    QHttpNetworkConnection connection(host);

    QCOMPARE(connection.port(), port);

    QCOMPARE(connection.hostName(), host);

    if (encrypt)

        connection.enableEncryption();

    QCOMPARE(connection.isEncrypted(), encrypt);

    QHttpNetworkRequest request(protocol + host + path, QHttpNetworkRequest::Put);

    QByteArray array = data.toLatin1();

    QNonContiguousByteDevice *bd = QNonContiguousByteDeviceFactory::create(&array);

    bd->setParent(this);

    request.setUploadByteDevice(bd);

    finishedCalled = false;

    finishedWithErrorCalled = false;

    QHttpNetworkReply *reply = connection.sendRequest(request);

    connect(reply, SIGNAL(finished()), SLOT(finishedReply()));

    connect(reply, SIGNAL(finishedWithError(QNetworkReply::NetworkError, const QString &)),

        SLOT(finishedWithError(QNetworkReply::NetworkError, const QString &)));

    connect(&connection, SIGNAL(error(QNetworkReply::NetworkError, const QString &)),

        SLOT(finishedWithError(QNetworkReply::NetworkError, const QString &)));

    QTime stopWatch;

    stopWatch.start();

    do {

        QCoreApplication::instance()->processEvents();

        if (stopWatch.elapsed() >= 30000)

            break;

    } while (!reply->isFinished() && !finishedCalled && !finishedWithErrorCalled);

    if (reply->isFinished()) {

        QByteArray ba;

        while (reply->bytesAvailable())

            ba += reply->readAny();

    } else if(finishedWithErrorCalled) {

        if(!succeed) {

            delete reply;

            return;

        } else {

            QFAIL("Error in PUT");

        }

    } else {

        QFAIL("PUT timed out");

    }

    int status = reply->statusCode();

    if (status != 200 && status != 201 && status != 204) {

        if (succeed) {

            qDebug()<<"PUT failed, Status Code:" <<status;

            QFAIL("Error in PUT");

        }

    } else {

        if (!succeed) {

            qDebug()<<"PUT Should fail, Status Code:" <<status;

            QFAIL("Error in PUT");

        }

    }

    delete reply;

}

void tst_QHttpNetworkConnection::post_data()

{

    QTest::addColumn<QString>("protocol");

    QTest::addColumn<QString>("host");

    QTest::addColumn<QString>("path");

    QTest::addColumn<ushort>("port");

    QTest::addColumn<bool>("encrypt");

    QTest::addColumn<QString>("data");

    QTest::addColumn<int>("statusCode");

    QTest::addColumn<QString>("statusString");

    QTest::addColumn<int>("contentLength");

    QTest::addColumn<int>("downloadSize");

    QTest::newRow("success-internal") << "http://" << QtNetworkSettings::serverName() << "/qtest/cgi-bin/echo.cgi" << ushort(80) << false << "7 bytes" << 200 << "OK" << 7 << 7;

    QTest::newRow("failure-internal") << "http://" << QtNetworkSettings::serverName() << "/t" << ushort(80) << false << "Hello World" << 404 << "Not Found" << -1 << 997 + QtNetworkSettings::serverName().size();

}

void tst_QHttpNetworkConnection::post()

{

    QFETCH(QString, protocol);

    QFETCH(QString, host);

    QFETCH(QString, path);

    QFETCH(ushort, port);

    QFETCH(bool, encrypt);

    QFETCH(QString, data);

    QFETCH(int, statusCode);

    QFETCH(QString, statusString);

    QFETCH(int, contentLength);

    QFETCH(int, downloadSize);

    QHttpNetworkConnection connection(host);

    QCOMPARE(connection.port(), port);

    QCOMPARE(connection.hostName(), host);

    if (encrypt)

        connection.enableEncryption();

    QCOMPARE(connection.isEncrypted(), encrypt);

    QHttpNetworkRequest request(protocol + host + path, QHttpNetworkRequest::Post);

    QByteArray array = data.toLatin1();

    QNonContiguousByteDevice *bd = QNonContiguousByteDeviceFactory::create(&array);

    bd->setParent(this);

    request.setUploadByteDevice(bd);

    QHttpNetworkReply *reply = connection.sendRequest(request);

    QTime stopWatch;

    stopWatch.start();

    forever {

        QCoreApplication::instance()->processEvents();

        if (reply->bytesAvailable())

            break;

        if (stopWatch.elapsed() >= 30000)

            break;

    }

    QCOMPARE(reply->statusCode(), statusCode);

    QCOMPARE(reply->reasonPhrase(), statusString);

    qint64 cLen = reply->contentLength();

    if (cLen==-1) {

        // HTTP 1.1 server may respond with chunked encoding and in that

        // case contentLength is not present in reply -> verify that it is the case

        QByteArray transferEnc = reply->headerField("Transfer-Encoding");

        QCOMPARE(transferEnc, QByteArray("chunked"));

    } else {

        QCOMPARE(cLen, qint64(contentLength));

    }

    stopWatch.start();

    QByteArray ba;

    do {

        QCoreApplication::instance()->processEvents();

        while (reply->bytesAvailable())

            ba += reply->readAny();

        if (stopWatch.elapsed() >= 30000)

            break;

    } while (!reply->isFinished());

    QVERIFY(reply->isFinished());

    QCOMPARE(ba.size(), downloadSize);

    delete reply;

}

void tst_QHttpNetworkConnection::_delete_data()

{

    // not tested yet

}

void tst_QHttpNetworkConnection::_delete()

{

    QEXPECT_FAIL("", "not tested yet", Continue);

    QVERIFY(false);

}

void tst_QHttpNetworkConnection::trace_data()

{

    // not tested yet

}

void tst_QHttpNetworkConnection::trace()

{

    QEXPECT_FAIL("", "not tested yet", Continue);

    QVERIFY(false);

}

void tst_QHttpNetworkConnection::_connect_data()

{

    // not tested yet

}

void tst_QHttpNetworkConnection::_connect()

{

    QEXPECT_FAIL("", "not tested yet", Continue);

    QVERIFY(false);

}

void tst_QHttpNetworkConnection::challenge401(const QHttpNetworkRequest &request,

                                                        QAuthenticator *authenticator,

                                                        const QHttpNetworkConnection *connection)

{

    Q_UNUSED(request)

    Q_UNUSED(connection)

    QHttpNetworkConnection *c = qobject_cast<QHttpNetworkConnection*>(sender());

    if (connection) {

        QVariant val = c->property("setCredentials");

        if (val.toBool()) {

            QVariant user = c->property("username");

            QVariant password = c->property("password");

            authenticator->setUser(user.toString());

            authenticator->setPassword(password.toString());

            c->setProperty("setCredentials", false);

        }

    }

}

void tst_QHttpNetworkConnection::get401_data()

{

    QTest::addColumn<QString>("protocol");

    QTest::addColumn<QString>("host");

    QTest::addColumn<QString>("path");

    QTest::addColumn<ushort>("port");

    QTest::addColumn<bool>("encrypt");

    QTest::addColumn<bool>("setCredentials");

    QTest::addColumn<QString>("username");

    QTest::addColumn<QString>("password");

    QTest::addColumn<int>("statusCode");

    QTest::newRow("no-credentials") << "http://" << QtNetworkSettings::serverName() << "/qtest/rfcs-auth/index.html" << ushort(80) << false << false << "" << ""<<401;

    QTest::newRow("invalid-credentials") << "http://" << QtNetworkSettings::serverName() << "/qtest/rfcs-auth/index.html" << ushort(80) << false << true << "test" << "test"<<401;