AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
b3f474d620
qt5base-lts/tests/manual/qnetworkreply/main.cpp

609 lines
24 KiB
C++
Raw Normal View History

Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
/****************************************************************************
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** Copyright (C) 2016 The Qt Company Ltd.
network: add support for the SPDY protocol Currently the only supported SPDY version is 3.0. The feature needs to be enabled explicitly via QNetworkRequest::SpdyAllowedAttribute. Whether SPDY actually was used can be determined via QNetworkRequest::SpdyWasUsedAttribute from a QNetworkReply once it has been started (i.e. after the encrypted() signal has been received). Whether SPDY can be used will be determined during the SSL handshake through the TLS NPN extension (see separate commit). The following things from SPDY have not been enabled currently: * server push is not implemented, it has never been seen in the wild; in that case we just reject a stream pushed by the server, which is legit. * settings are not persisted across SPDY sessions. In practice this means that the server sends a small message upon session start telling us e.g. the number of concurrent connections. * SSL client certificates are not supported. Task-number: QTBUG-18714 [ChangeLog][QtNetwork] Added support for the SPDY protocol (version 3.0). Change-Id: I81bbe0495c24ed84e9cf8af3a9dbd63ca1e93d0d Reviewed-by: Richard J. Moore <rich@kde.org>
2014-01-22 13:54:21 +00:00
** Copyright (C) 2014 BlackBerry Limited. All rights reserved.
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** Contact: https://www.qt.io/licensing/
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
**
** This file is part of the test suite of the Qt Toolkit.
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: If1cc974286d29fd01ec6c19dd4719a67f4c3f00e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@digia.com>
2012-09-19 12:28:29 +00:00
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
Update copyright headers Qt copyrights are now in The Qt Company, so we could update the source code headers accordingly. In the same go we should also fix the links to point to qt.io. Outdated header.LGPL removed (use header.LGPL21 instead) Old header.LGPL3 renamed to header.LGPL3-COMM to match actual licensing combination. New header.LGPL-COMM taken in the use file which were using old header.LGPL3 (src/plugins/platforms/android/extract.cpp) Added new header.LGPL3 containing Commercial + LGPLv3 + GPLv2 license combination Change-Id: I6f49b819a8a20cc4f88b794a8f6726d975e8ffbe Reviewed-by: Matti Paaso <matti.paaso@theqtcompany.com>
2015-01-28 08:44:43 +00:00
** a written agreement between you and The Qt Company. For licensing terms
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: If1cc974286d29fd01ec6c19dd4719a67f4c3f00e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@digia.com>
2012-09-19 12:28:29 +00:00
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
**
** $QT_END_LICENSE$
**
****************************************************************************/
// This file contains benchmarks for QNetworkReply functions.
#include <QDebug>
#include <qtest.h>
#include <QtTest/QtTest>
#include <QtNetwork/qnetworkreply.h>
#include <QtNetwork/qnetworkrequest.h>
#include <QtNetwork/qnetworkaccessmanager.h>
QSslConfiguration: toggle on demand loading of root certs properly make sure we keep track of when we can load root certs and when we cannot (we cannot when the developer set the certs explicitly). This is implemented the same way for QSslSocket already, and needs to be duplicated because we have 2 methods for setting CA certificates: one in QSslSocket and one in QSslConfiguration. In addition, adapt the auto test which checks whether setting a default QSslConfiguration works: There is no way to set on demand loading through the API, so it should be enabled by default. Task-number: QTBUG-29103 Change-Id: I5146128aaa385dfcc0ad1e0ef81a92d9350ec5f2 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-01-14 13:43:52 +00:00
#include <QtNetwork/qsslconfiguration.h>
network tests: add manual test for uploading images to Facebook ... to have a real world test case for uploading via SSL, QHttpMultiPart (+ resetting) etc. Change-Id: I004dd6f2507776b2fb8ebe1f02625b40abff6261 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-04-11 10:20:12 +00:00
#include <QtNetwork/qhttpmultipart.h>
network tests: add manual test for auth / proxy auth This is helpful to e.g. test an NTLM proxy. The test server currently does not support NTLM; this test offers a possibility to specify a proxy server via environment variables. Change-Id: Iea94656d38424c1d932fc854d13ca15ca47cdd68 Reviewed-by: Richard J. Moore <rich@kde.org>
2014-08-04 14:32:45 +00:00
#include <QtNetwork/qauthenticator.h>
network tests: add manual test for uploading images to Facebook ... to have a real world test case for uploading via SSL, QHttpMultiPart (+ resetting) etc. Change-Id: I004dd6f2507776b2fb8ebe1f02625b40abff6261 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-04-11 10:20:12 +00:00
#include <QtCore/QJsonDocument>
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include "../../auto/network-settings.h"
Fix building of the manual tests. Adapt to API-changes, exclude network/SSL-tests for Windows. Change-Id: I80d5ef1bd81e149a2f04fa7644376a8a88b1f7b9 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-03-12 13:38:21 +00:00
#if defined(QT_BUILD_INTERNAL) && !defined(QT_NO_SSL)
QSslConfiguration: toggle on demand loading of root certs properly make sure we keep track of when we can load root certs and when we cannot (we cannot when the developer set the certs explicitly). This is implemented the same way for QSslSocket already, and needs to be duplicated because we have 2 methods for setting CA certificates: one in QSslSocket and one in QSslConfiguration. In addition, adapt the auto test which checks whether setting a default QSslConfiguration works: There is no way to set on demand loading through the API, so it should be enabled by default. Task-number: QTBUG-29103 Change-Id: I5146128aaa385dfcc0ad1e0ef81a92d9350ec5f2 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-01-14 13:43:52 +00:00
#include "private/qsslsocket_p.h"
network: add support for the SPDY protocol Currently the only supported SPDY version is 3.0. The feature needs to be enabled explicitly via QNetworkRequest::SpdyAllowedAttribute. Whether SPDY actually was used can be determined via QNetworkRequest::SpdyWasUsedAttribute from a QNetworkReply once it has been started (i.e. after the encrypted() signal has been received). Whether SPDY can be used will be determined during the SSL handshake through the TLS NPN extension (see separate commit). The following things from SPDY have not been enabled currently: * server push is not implemented, it has never been seen in the wild; in that case we just reject a stream pushed by the server, which is legit. * settings are not persisted across SPDY sessions. In practice this means that the server sends a small message upon session start telling us e.g. the number of concurrent connections. * SSL client certificates are not supported. Task-number: QTBUG-18714 [ChangeLog][QtNetwork] Added support for the SPDY protocol (version 3.0). Change-Id: I81bbe0495c24ed84e9cf8af3a9dbd63ca1e93d0d Reviewed-by: Richard J. Moore <rich@kde.org>
2014-01-22 13:54:21 +00:00
#include <QtNetwork/private/qsslsocket_openssl_p.h>
QSslConfiguration: toggle on demand loading of root certs properly make sure we keep track of when we can load root certs and when we cannot (we cannot when the developer set the certs explicitly). This is implemented the same way for QSslSocket already, and needs to be duplicated because we have 2 methods for setting CA certificates: one in QSslSocket and one in QSslConfiguration. In addition, adapt the auto test which checks whether setting a default QSslConfiguration works: There is no way to set on demand loading through the API, so it should be enabled by default. Task-number: QTBUG-29103 Change-Id: I5146128aaa385dfcc0ad1e0ef81a92d9350ec5f2 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-01-14 13:43:52 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#define BANDWIDTH_LIMIT_BYTES (1024*100)
#define TIME_ESTIMATION_SECONDS (97)
class tst_qnetworkreply : public QObject
{
Q_OBJECT
Fix sanity check of network test server Some of Qt's autotests depend on access to a test server. For each test that used the test server, tests/auto/network-settings.h created a global object to verify at startup that host lookups to the test server will succeed (and abort the test otherwise). There are two problems with that approach: First, the sanity check happens before main(), and thus before the test framework has started logging test results. This means that if the sanity check aborts the test, the failure message will not be visible in the test output if logging to a file or will cause the output to be malformed if logging to the console in XML format. Second, since Qt 4.7, the host lookup uses a class that connects to the QCoreApplication instance, which doesn't exist before main(), and this caused all tests that included network-settings.h to output an error message from QObject::connect() at the beginning of the test. Both of these problems are solved by removing the global object from network-settings.h and instead performing the sanity check in the initTestCase() function of each test. Task-number: QTBUG-22876 Change-Id: Id49c1826906327bf571686cc11527f0265e5af44 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-11-25 07:04:12 +00:00
private slots:
void initTestCase();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void limiting_data();
void limiting();
QSslConfiguration: toggle on demand loading of root certs properly make sure we keep track of when we can load root certs and when we cannot (we cannot when the developer set the certs explicitly). This is implemented the same way for QSslSocket already, and needs to be duplicated because we have 2 methods for setting CA certificates: one in QSslSocket and one in QSslConfiguration. In addition, adapt the auto test which checks whether setting a default QSslConfiguration works: There is no way to set on demand loading through the API, so it should be enabled by default. Task-number: QTBUG-29103 Change-Id: I5146128aaa385dfcc0ad1e0ef81a92d9350ec5f2 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-01-14 13:43:52 +00:00
void setSslConfiguration_data();
void setSslConfiguration();
network tests: add manual test for uploading images to Facebook ... to have a real world test case for uploading via SSL, QHttpMultiPart (+ resetting) etc. Change-Id: I004dd6f2507776b2fb8ebe1f02625b40abff6261 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-04-11 10:20:12 +00:00
void uploadToFacebook();
network: add support for the SPDY protocol Currently the only supported SPDY version is 3.0. The feature needs to be enabled explicitly via QNetworkRequest::SpdyAllowedAttribute. Whether SPDY actually was used can be determined via QNetworkRequest::SpdyWasUsedAttribute from a QNetworkReply once it has been started (i.e. after the encrypted() signal has been received). Whether SPDY can be used will be determined during the SSL handshake through the TLS NPN extension (see separate commit). The following things from SPDY have not been enabled currently: * server push is not implemented, it has never been seen in the wild; in that case we just reject a stream pushed by the server, which is legit. * settings are not persisted across SPDY sessions. In practice this means that the server sends a small message upon session start telling us e.g. the number of concurrent connections. * SSL client certificates are not supported. Task-number: QTBUG-18714 [ChangeLog][QtNetwork] Added support for the SPDY protocol (version 3.0). Change-Id: I81bbe0495c24ed84e9cf8af3a9dbd63ca1e93d0d Reviewed-by: Richard J. Moore <rich@kde.org>
2014-01-22 13:54:21 +00:00
void spdy_data();
void spdy();
void spdyMultipleRequestsPerHost();
network tests: add manual test for auth / proxy auth This is helpful to e.g. test an NTLM proxy. The test server currently does not support NTLM; this test offers a possibility to specify a proxy server via environment variables. Change-Id: Iea94656d38424c1d932fc854d13ca15ca47cdd68 Reviewed-by: Richard J. Moore <rich@kde.org>
2014-08-04 14:32:45 +00:00
void proxyAuthentication_data();
void proxyAuthentication();
void authentication();
SSL NPN negotiation: Do not abort on unmatched protocols ... but choose HTTP/1.1 and continue connecting anyhow. According to the NPN spec, actually we should choose SPDY: "In the event that the client doesn't support any of server's protocols, or the server doesn't advertise any, it SHOULD select the first protocol that it supports." However, some tested servers did not advertise anything and did not support SPDY, so blindly trying the newest protocol would fail. We are conservative in that case and choose HTTP. Task-number: QTBUG-40714 Change-Id: Ia8aaf01fea74e13d9e4416306f85f1890b25559e Reviewed-by: Richard J. Moore <rich@kde.org>
2015-02-05 13:05:21 +00:00
void npnWithEmptyList(); // QTBUG-40714
network: add support for the SPDY protocol Currently the only supported SPDY version is 3.0. The feature needs to be enabled explicitly via QNetworkRequest::SpdyAllowedAttribute. Whether SPDY actually was used can be determined via QNetworkRequest::SpdyWasUsedAttribute from a QNetworkReply once it has been started (i.e. after the encrypted() signal has been received). Whether SPDY can be used will be determined during the SSL handshake through the TLS NPN extension (see separate commit). The following things from SPDY have not been enabled currently: * server push is not implemented, it has never been seen in the wild; in that case we just reject a stream pushed by the server, which is legit. * settings are not persisted across SPDY sessions. In practice this means that the server sends a small message upon session start telling us e.g. the number of concurrent connections. * SSL client certificates are not supported. Task-number: QTBUG-18714 [ChangeLog][QtNetwork] Added support for the SPDY protocol (version 3.0). Change-Id: I81bbe0495c24ed84e9cf8af3a9dbd63ca1e93d0d Reviewed-by: Richard J. Moore <rich@kde.org>
2014-01-22 13:54:21 +00:00
protected slots:
void spdyReplyFinished(); // only used by spdyMultipleRequestsPerHost test
network tests: add manual test for auth / proxy auth This is helpful to e.g. test an NTLM proxy. The test server currently does not support NTLM; this test offers a possibility to specify a proxy server via environment variables. Change-Id: Iea94656d38424c1d932fc854d13ca15ca47cdd68 Reviewed-by: Richard J. Moore <rich@kde.org>
2014-08-04 14:32:45 +00:00
void authenticationRequiredSlot(QNetworkReply *, QAuthenticator *authenticator);
network: add support for the SPDY protocol Currently the only supported SPDY version is 3.0. The feature needs to be enabled explicitly via QNetworkRequest::SpdyAllowedAttribute. Whether SPDY actually was used can be determined via QNetworkRequest::SpdyWasUsedAttribute from a QNetworkReply once it has been started (i.e. after the encrypted() signal has been received). Whether SPDY can be used will be determined during the SSL handshake through the TLS NPN extension (see separate commit). The following things from SPDY have not been enabled currently: * server push is not implemented, it has never been seen in the wild; in that case we just reject a stream pushed by the server, which is legit. * settings are not persisted across SPDY sessions. In practice this means that the server sends a small message upon session start telling us e.g. the number of concurrent connections. * SSL client certificates are not supported. Task-number: QTBUG-18714 [ChangeLog][QtNetwork] Added support for the SPDY protocol (version 3.0). Change-Id: I81bbe0495c24ed84e9cf8af3a9dbd63ca1e93d0d Reviewed-by: Richard J. Moore <rich@kde.org>
2014-01-22 13:54:21 +00:00
network tests: add manual test for uploading images to Facebook ... to have a real world test case for uploading via SSL, QHttpMultiPart (+ resetting) etc. Change-Id: I004dd6f2507776b2fb8ebe1f02625b40abff6261 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-04-11 10:20:12 +00:00
private:
QHttpMultiPart *createFacebookMultiPart(const QByteArray &accessToken);
network: add support for the SPDY protocol Currently the only supported SPDY version is 3.0. The feature needs to be enabled explicitly via QNetworkRequest::SpdyAllowedAttribute. Whether SPDY actually was used can be determined via QNetworkRequest::SpdyWasUsedAttribute from a QNetworkReply once it has been started (i.e. after the encrypted() signal has been received). Whether SPDY can be used will be determined during the SSL handshake through the TLS NPN extension (see separate commit). The following things from SPDY have not been enabled currently: * server push is not implemented, it has never been seen in the wild; in that case we just reject a stream pushed by the server, which is legit. * settings are not persisted across SPDY sessions. In practice this means that the server sends a small message upon session start telling us e.g. the number of concurrent connections. * SSL client certificates are not supported. Task-number: QTBUG-18714 [ChangeLog][QtNetwork] Added support for the SPDY protocol (version 3.0). Change-Id: I81bbe0495c24ed84e9cf8af3a9dbd63ca1e93d0d Reviewed-by: Richard J. Moore <rich@kde.org>
2014-01-22 13:54:21 +00:00
QNetworkAccessManager m_manager;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
};
QNetworkReply *reply;
class HttpReceiver : public QObject
{
Q_OBJECT
public slots:
void finishedSlot() {
quint64 bytesPerSec = (reply->header(QNetworkRequest::ContentLengthHeader).toLongLong()) / (stopwatch.elapsed() / 1000.0);
qDebug() << "Finished HTTP(S) request with" << bytesPerSec << "bytes/sec";
QVERIFY(bytesPerSec < BANDWIDTH_LIMIT_BYTES*1.05);
QVERIFY(bytesPerSec > BANDWIDTH_LIMIT_BYTES*0.95);
timer->stop();
QTestEventLoop::instance().exitLoop();
}
void readyReadSlot() {
}
void timeoutSlot() {
reply->read(BANDWIDTH_LIMIT_BYTES).size();
}
void startTimer() {
stopwatch.start();
timer = new QTimer(this);
QObject::connect(timer, SIGNAL(timeout()), this, SLOT(timeoutSlot()));
timer->start(1000);
}
protected:
QTimer *timer;
QTime stopwatch;
};
Fix sanity check of network test server Some of Qt's autotests depend on access to a test server. For each test that used the test server, tests/auto/network-settings.h created a global object to verify at startup that host lookups to the test server will succeed (and abort the test otherwise). There are two problems with that approach: First, the sanity check happens before main(), and thus before the test framework has started logging test results. This means that if the sanity check aborts the test, the failure message will not be visible in the test output if logging to a file or will cause the output to be malformed if logging to the console in XML format. Second, since Qt 4.7, the host lookup uses a class that connects to the QCoreApplication instance, which doesn't exist before main(), and this caused all tests that included network-settings.h to output an error message from QObject::connect() at the beginning of the test. Both of these problems are solved by removing the global object from network-settings.h and instead performing the sanity check in the initTestCase() function of each test. Task-number: QTBUG-22876 Change-Id: Id49c1826906327bf571686cc11527f0265e5af44 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-11-25 07:04:12 +00:00
void tst_qnetworkreply::initTestCase()
{
network: add support for the SPDY protocol Currently the only supported SPDY version is 3.0. The feature needs to be enabled explicitly via QNetworkRequest::SpdyAllowedAttribute. Whether SPDY actually was used can be determined via QNetworkRequest::SpdyWasUsedAttribute from a QNetworkReply once it has been started (i.e. after the encrypted() signal has been received). Whether SPDY can be used will be determined during the SSL handshake through the TLS NPN extension (see separate commit). The following things from SPDY have not been enabled currently: * server push is not implemented, it has never been seen in the wild; in that case we just reject a stream pushed by the server, which is legit. * settings are not persisted across SPDY sessions. In practice this means that the server sends a small message upon session start telling us e.g. the number of concurrent connections. * SSL client certificates are not supported. Task-number: QTBUG-18714 [ChangeLog][QtNetwork] Added support for the SPDY protocol (version 3.0). Change-Id: I81bbe0495c24ed84e9cf8af3a9dbd63ca1e93d0d Reviewed-by: Richard J. Moore <rich@kde.org>
2014-01-22 13:54:21 +00:00
qRegisterMetaType<QNetworkReply *>(); // for QSignalSpy
Fix sanity check of network test server Some of Qt's autotests depend on access to a test server. For each test that used the test server, tests/auto/network-settings.h created a global object to verify at startup that host lookups to the test server will succeed (and abort the test otherwise). There are two problems with that approach: First, the sanity check happens before main(), and thus before the test framework has started logging test results. This means that if the sanity check aborts the test, the failure message will not be visible in the test output if logging to a file or will cause the output to be malformed if logging to the console in XML format. Second, since Qt 4.7, the host lookup uses a class that connects to the QCoreApplication instance, which doesn't exist before main(), and this caused all tests that included network-settings.h to output an error message from QObject::connect() at the beginning of the test. Both of these problems are solved by removing the global object from network-settings.h and instead performing the sanity check in the initTestCase() function of each test. Task-number: QTBUG-22876 Change-Id: Id49c1826906327bf571686cc11527f0265e5af44 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-11-25 07:04:12 +00:00
QVERIFY(QtNetworkSettings::verifyTestNetworkSettings());
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_qnetworkreply::limiting_data()
{
QTest::addColumn<QUrl>("url");
QTest::newRow("HTTP") << QUrl("http://" + QtNetworkSettings::serverName() + "/mediumfile");
Test for QT_NO_SSL instead of QT_NO_OPENSSL Change the ifdefs in our own code (except openssl backend) to use the new configure flag. Change-Id: I8774734771c66b22164b5fae8fdb27814ac3df7b Reviewed-by: Richard J. Moore <rich@kde.org>
2012-02-20 17:02:41 +00:00
#ifndef QT_NO_SSL
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QTest::newRow("HTTP+SSL") << QUrl("https://" + QtNetworkSettings::serverName() + "/mediumfile");
#endif
}
void tst_qnetworkreply::limiting()
{
HttpReceiver receiver;
QNetworkAccessManager manager;
QFETCH(QUrl, url);
QNetworkRequest req (url);
qDebug() << "Starting. This will take a while (around" << TIME_ESTIMATION_SECONDS << "sec).";
qDebug() << "Please check the actual bandwidth usage with a network monitor, e.g. the KDE";
qDebug() << "network plasma widget. It should be around" << BANDWIDTH_LIMIT_BYTES << "bytes/sec.";
reply = manager.get(req);
reply->ignoreSslErrors();
reply->setReadBufferSize(BANDWIDTH_LIMIT_BYTES);
QObject::connect(reply, SIGNAL(readyRead()), &receiver, SLOT(readyReadSlot()));
QObject::connect(reply, SIGNAL(finished()), &receiver, SLOT(finishedSlot()));
receiver.startTimer();
// event loop
QTestEventLoop::instance().enterLoop(TIME_ESTIMATION_SECONDS + 20);
QVERIFY(!QTestEventLoop::instance().timeout());
}
QSslConfiguration: toggle on demand loading of root certs properly make sure we keep track of when we can load root certs and when we cannot (we cannot when the developer set the certs explicitly). This is implemented the same way for QSslSocket already, and needs to be duplicated because we have 2 methods for setting CA certificates: one in QSslSocket and one in QSslConfiguration. In addition, adapt the auto test which checks whether setting a default QSslConfiguration works: There is no way to set on demand loading through the API, so it should be enabled by default. Task-number: QTBUG-29103 Change-Id: I5146128aaa385dfcc0ad1e0ef81a92d9350ec5f2 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-01-14 13:43:52 +00:00
void tst_qnetworkreply::setSslConfiguration_data()
{
QTest::addColumn<QUrl>("url");
QTest::addColumn<bool>("works");
QTest::newRow("codereview.qt-project.org") << QUrl("https://codereview.qt-project.org") << true;
QTest::newRow("test-server") << QUrl("https://" + QtNetworkSettings::serverName() + "/") << false;
}
void tst_qnetworkreply::setSslConfiguration()
{
Fix building of the manual tests. Adapt to API-changes, exclude network/SSL-tests for Windows. Change-Id: I80d5ef1bd81e149a2f04fa7644376a8a88b1f7b9 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-03-12 13:38:21 +00:00
#ifdef QT_NO_SSL
QSKIP("SSL is not enabled.");
#else
QSslConfiguration: toggle on demand loading of root certs properly make sure we keep track of when we can load root certs and when we cannot (we cannot when the developer set the certs explicitly). This is implemented the same way for QSslSocket already, and needs to be duplicated because we have 2 methods for setting CA certificates: one in QSslSocket and one in QSslConfiguration. In addition, adapt the auto test which checks whether setting a default QSslConfiguration works: There is no way to set on demand loading through the API, so it should be enabled by default. Task-number: QTBUG-29103 Change-Id: I5146128aaa385dfcc0ad1e0ef81a92d9350ec5f2 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-01-14 13:43:52 +00:00
QFETCH(QUrl, url);
QNetworkRequest request(url);
QSslConfiguration conf = request.sslConfiguration();
conf.setProtocol(QSsl::TlsV1_0); // TLS 1.0 will be used anyway, just make sure we change the configuration
request.setSslConfiguration(conf);
QNetworkAccessManager manager;
reply = manager.get(request);
QObject::connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
QTestEventLoop::instance().enterLoop(15);
QVERIFY(!QTestEventLoop::instance().timeout());
#ifdef QT_BUILD_INTERNAL
QFETCH(bool, works);
bool rootCertLoadingAllowed = QSslSocketPrivate::rootCertOnDemandLoadingSupported();
Remove remaining support for Blackberry The platform is no longer supported or actively maintained, and is in the way for improvements to the Unix event dispatcher and QProcess implementations. Change-Id: I3935488ca12e2139ea5f46068d7665a453e20526 Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2015-10-15 13:24:54 +00:00
#if defined(Q_OS_LINUX)
QSslConfiguration: toggle on demand loading of root certs properly make sure we keep track of when we can load root certs and when we cannot (we cannot when the developer set the certs explicitly). This is implemented the same way for QSslSocket already, and needs to be duplicated because we have 2 methods for setting CA certificates: one in QSslSocket and one in QSslConfiguration. In addition, adapt the auto test which checks whether setting a default QSslConfiguration works: There is no way to set on demand loading through the API, so it should be enabled by default. Task-number: QTBUG-29103 Change-Id: I5146128aaa385dfcc0ad1e0ef81a92d9350ec5f2 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-01-14 13:43:52 +00:00
QCOMPARE(rootCertLoadingAllowed, true);
#elif defined(Q_OS_MAC)
QCOMPARE(rootCertLoadingAllowed, false);
Fix assorted MSVC warnings in tests. tst_collections.cpp tst_collections.cpp(3138) : warning C4305: 'argument' : truncation from 'size_t' to 'bool' tst_collections.cpp(3190) : see reference to function template instantiation 'void testContainerTypedefs<QVector<int>>(Container)' being compiled with[Container=QVector<int>] (repeated) tst_qringbuffer.cpp(297) : warning C4267: 'argument' : conversion from 'size_t' to 'int', possible loss of data tst_qringbuffer.cpp(300) : warning C4309: '=' : truncation of constant value tst_qringbuffer.cpp(306) : warning C4267: 'argument' : conversion from 'size_t' to 'int', possible loss of data tst_qrawfont.cpp(947) : warning C4309: 'argument' : truncation of constant value tst_qsslsocket_onDemandCertificates_member.cpp(217) : warning C4189: 'rootCertLoadingAllowed' : local variable is initialized but not referenced Change-Id: I6143d4ad121088a0d5bdd6dd2637eb3641a26096 Reviewed-by: Kai Koehne <kai.koehne@theqtcompany.com>
2015-01-15 13:00:19 +00:00
#else
Q_UNUSED(rootCertLoadingAllowed)
QSslConfiguration: toggle on demand loading of root certs properly make sure we keep track of when we can load root certs and when we cannot (we cannot when the developer set the certs explicitly). This is implemented the same way for QSslSocket already, and needs to be duplicated because we have 2 methods for setting CA certificates: one in QSslSocket and one in QSslConfiguration. In addition, adapt the auto test which checks whether setting a default QSslConfiguration works: There is no way to set on demand loading through the API, so it should be enabled by default. Task-number: QTBUG-29103 Change-Id: I5146128aaa385dfcc0ad1e0ef81a92d9350ec5f2 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-01-14 13:43:52 +00:00
#endif // other platforms: undecided (Windows: depends on the version)
if (works) {
QCOMPARE(reply->error(), QNetworkReply::NoError);
} else {
QCOMPARE(reply->error(), QNetworkReply::SslHandshakeFailedError);
}
#endif
Fix building of the manual tests. Adapt to API-changes, exclude network/SSL-tests for Windows. Change-Id: I80d5ef1bd81e149a2f04fa7644376a8a88b1f7b9 Reviewed-by: Frederik Gladhorn <frederik.gladhorn@digia.com>
2013-03-12 13:38:21 +00:00
#endif // QT_NO_SSL
QSslConfiguration: toggle on demand loading of root certs properly make sure we keep track of when we can load root certs and when we cannot (we cannot when the developer set the certs explicitly). This is implemented the same way for QSslSocket already, and needs to be duplicated because we have 2 methods for setting CA certificates: one in QSslSocket and one in QSslConfiguration. In addition, adapt the auto test which checks whether setting a default QSslConfiguration works: There is no way to set on demand loading through the API, so it should be enabled by default. Task-number: QTBUG-29103 Change-Id: I5146128aaa385dfcc0ad1e0ef81a92d9350ec5f2 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-01-14 13:43:52 +00:00
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
network tests: add manual test for uploading images to Facebook ... to have a real world test case for uploading via SSL, QHttpMultiPart (+ resetting) etc. Change-Id: I004dd6f2507776b2fb8ebe1f02625b40abff6261 Reviewed-by: Richard J. Moore <rich@kde.org>
2013-04-11 10:20:12 +00:00
QHttpMultiPart *tst_qnetworkreply::createFacebookMultiPart(const QByteArray &accessToken)
{
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart accessTokenPart;
accessTokenPart.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"access_token\""));
accessTokenPart.setBody(accessToken);
multiPart->append(accessTokenPart);
QHttpPart batchPart;
batchPart.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"batch\""));
batchPart.setBody("["
" {"
" \"attached_files\" : \"image1\","
" \"body\" : \"message=&published=0\","
" \"method\" : \"POST\","
" \"relative_url\" : \"me/photos\""
" },"
" {"
" \"attached_files\" : \"image2\","
" \"body\" : \"message=&published=0\","
" \"method\" : \"POST\","
" \"relative_url\" : \"me/photos\""
" },"
" {"
" \"attached_files\" : \"image3\","
" \"body\" : \"message=&published=0\","
" \"method\" : \"POST\","
" \"relative_url\" : \"me/photos\""
" }"
"]");
multiPart->append(batchPart);
QHttpPart imagePart1;
imagePart1.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/jpg"));
imagePart1.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"image1\"; filename=\"image1.jpg\""));
QFile *file1 = new QFile(QFINDTESTDATA("../../auto/network/access/qnetworkreply/image1.jpg"));
file1->open(QIODevice::ReadOnly);
imagePart1.setBodyDevice(file1);
file1->setParent(multiPart);
multiPart->append(imagePart1);
QHttpPart imagePart2;
imagePart2.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/jpg"));
imagePart2.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"image2\"; filename=\"image2.jpg\""));
QFile *file2 = new QFile(QFINDTESTDATA("../../auto/network/access/qnetworkreply/image2.jpg"));
file2->open(QIODevice::ReadOnly);
imagePart2.setBodyDevice(file2);
file2->setParent(multiPart);
multiPart->append(imagePart2);
QHttpPart imagePart3;
imagePart3.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/jpg"));
imagePart3.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"image3\"; filename=\"image3.jpg\""));
QFile *file3 = new QFile(QFINDTESTDATA("../../auto/network/access/qnetworkreply/image3.jpg"));
file3->open(QIODevice::ReadOnly);
imagePart3.setBodyDevice(file3);
file3->setParent(multiPart);
multiPart->append(imagePart3);
return multiPart;
}
void tst_qnetworkreply::uploadToFacebook()
{
QByteArray accessToken = qgetenv("QT_FACEBOOK_ACCESS_TOKEN");
if (accessToken.isEmpty())
QSKIP("This test requires the QT_FACEBOOK_ACCESS_TOKEN environment variable to be set. "
"Do something like 'export QT_FACEBOOK_ACCESS_TOKEN=MyAccessToken'");
QElapsedTimer timer;
QNetworkAccessManager manager;
QNetworkRequest request(QUrl("https://graph.facebook.com/me/photos"));
QHttpMultiPart *multiPart = createFacebookMultiPart(accessToken);
timer.start();
QNetworkReply *reply = manager.post(request, multiPart);
multiPart->setParent(reply);
QObject::connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
QTestEventLoop::instance().enterLoop(120);
qint64 elapsed = timer.elapsed();
QVERIFY(!QTestEventLoop::instance().timeout());
qDebug() << "reply finished after" << elapsed / 1000.0 << "seconds";
QCOMPARE(reply->error(), QNetworkReply::NoError);
QByteArray content = reply->readAll();
QJsonDocument jsonDocument = QJsonDocument::fromJson(content);
QVERIFY(jsonDocument.isArray());
QJsonArray uploadStatuses = jsonDocument.array();
QVERIFY(uploadStatuses.size() > 0);
for (int a = 0; a < uploadStatuses.size(); a++) {
QJsonValue currentUploadStatus = uploadStatuses.at(a);
QVERIFY(currentUploadStatus.isObject());
QJsonObject statusObject = currentUploadStatus.toObject();
QJsonValue statusCode = statusObject.value(QLatin1String("code"));
QCOMPARE(statusCode.toVariant().toInt(), 200); // 200 OK
}
}
network: add support for the SPDY protocol Currently the only supported SPDY version is 3.0. The feature needs to be enabled explicitly via QNetworkRequest::SpdyAllowedAttribute. Whether SPDY actually was used can be determined via QNetworkRequest::SpdyWasUsedAttribute from a QNetworkReply once it has been started (i.e. after the encrypted() signal has been received). Whether SPDY can be used will be determined during the SSL handshake through the TLS NPN extension (see separate commit). The following things from SPDY have not been enabled currently: * server push is not implemented, it has never been seen in the wild; in that case we just reject a stream pushed by the server, which is legit. * settings are not persisted across SPDY sessions. In practice this means that the server sends a small message upon session start telling us e.g. the number of concurrent connections. * SSL client certificates are not supported. Task-number: QTBUG-18714 [ChangeLog][QtNetwork] Added support for the SPDY protocol (version 3.0). Change-Id: I81bbe0495c24ed84e9cf8af3a9dbd63ca1e93d0d Reviewed-by: Richard J. Moore <rich@kde.org>
2014-01-22 13:54:21 +00:00
void tst_qnetworkreply::spdy_data()
{
QTest::addColumn<QString>("host");
QTest::addColumn<bool>("setAttribute");
QTest::addColumn<bool>("enabled");
QTest::addColumn<QByteArray>("expectedProtocol");
QList<QString> hosts = QList<QString>()
<< QStringLiteral("www.google.com") // sends SPDY and 30x redirect
<< QStringLiteral("www.google.de") // sends SPDY and 200 OK
<< QStringLiteral("mail.google.com") // sends SPDY and 200 OK
<< QStringLiteral("www.youtube.com") // sends SPDY and 200 OK
<< QStringLiteral("www.dropbox.com") // no SPDY, but NPN which selects HTTP
<< QStringLiteral("www.facebook.com") // sends SPDY and 200 OK
<< QStringLiteral("graph.facebook.com") // sends SPDY and 200 OK
<< QStringLiteral("www.twitter.com") // sends SPDY and 30x redirect
<< QStringLiteral("twitter.com") // sends SPDY and 200 OK
<< QStringLiteral("api.twitter.com"); // sends SPDY and 200 OK
foreach (const QString &host, hosts) {
QByteArray tag = host.toLocal8Bit();
tag.append("-not-used");
QTest::newRow(tag)
<< QStringLiteral("https://") + host
<< false
<< false
<< QByteArray();
tag = host.toLocal8Bit();
tag.append("-disabled");
QTest::newRow(tag)
<< QStringLiteral("https://") + host
<< true
<< false
<< QByteArray();
if (host != QStringLiteral("api.twitter.com")) { // they don't offer an API over HTTP
tag = host.toLocal8Bit();
tag.append("-no-https-url");
QTest::newRow(tag)
<< QStringLiteral("http://") + host
<< true
<< true
<< QByteArray();
}
#ifndef QT_NO_OPENSSL
tag = host.toLocal8Bit();
tag.append("-enabled");
QTest::newRow(tag)
<< QStringLiteral("https://") + host
<< true
<< true
<< (host == QStringLiteral("www.dropbox.com")
? QByteArray(QSslConfiguration::NextProtocolHttp1_1)
: QByteArray(QSslConfiguration::NextProtocolSpdy3_0));
#endif // QT_NO_OPENSSL
}
}
void tst_qnetworkreply::spdy()
{
#if defined(QT_BUILD_INTERNAL) && !defined(QT_NO_SSL) && OPENSSL_VERSION_NUMBER >= 0x1000100fL && !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
m_manager.clearAccessCache();
QFETCH(QString, host);
QUrl url(host);
QNetworkRequest request(url);
QFETCH(bool, setAttribute);
QFETCH(bool, enabled);
if (setAttribute) {
request.setAttribute(QNetworkRequest::SpdyAllowedAttribute, QVariant(enabled));
}
QNetworkReply *reply = m_manager.get(request);
QObject::connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
QSignalSpy metaDataChangedSpy(reply, SIGNAL(metaDataChanged()));
QSignalSpy readyReadSpy(reply, SIGNAL(readyRead()));
QSignalSpy finishedSpy(reply, SIGNAL(finished()));
QSignalSpy finishedManagerSpy(&m_manager, SIGNAL(finished(QNetworkReply*)));
QTestEventLoop::instance().enterLoop(15);
QVERIFY(!QTestEventLoop::instance().timeout());
QFETCH(QByteArray, expectedProtocol);
Removing a few unneeded "? true : false" Change-Id: Ib13f0ddd65fe78f5559f343f2fc30756b1d3ef76 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com> Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
2014-09-09 13:18:54 +00:00
bool expectedSpdyUsed = (expectedProtocol == QSslConfiguration::NextProtocolSpdy3_0);
network: add support for the SPDY protocol Currently the only supported SPDY version is 3.0. The feature needs to be enabled explicitly via QNetworkRequest::SpdyAllowedAttribute. Whether SPDY actually was used can be determined via QNetworkRequest::SpdyWasUsedAttribute from a QNetworkReply once it has been started (i.e. after the encrypted() signal has been received). Whether SPDY can be used will be determined during the SSL handshake through the TLS NPN extension (see separate commit). The following things from SPDY have not been enabled currently: * server push is not implemented, it has never been seen in the wild; in that case we just reject a stream pushed by the server, which is legit. * settings are not persisted across SPDY sessions. In practice this means that the server sends a small message upon session start telling us e.g. the number of concurrent connections. * SSL client certificates are not supported. Task-number: QTBUG-18714 [ChangeLog][QtNetwork] Added support for the SPDY protocol (version 3.0). Change-Id: I81bbe0495c24ed84e9cf8af3a9dbd63ca1e93d0d Reviewed-by: Richard J. Moore <rich@kde.org>
2014-01-22 13:54:21 +00:00
QCOMPARE(reply->attribute(QNetworkRequest::SpdyWasUsedAttribute).toBool(), expectedSpdyUsed);
QCOMPARE(metaDataChangedSpy.count(), 1);
QCOMPARE(finishedSpy.count(), 1);
QCOMPARE(finishedManagerSpy.count(), 1);
QUrl redirectUrl = reply->header(QNetworkRequest::LocationHeader).toUrl();
QByteArray content = reply->readAll();
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QVERIFY(statusCode >= 200 && statusCode < 500);
if (statusCode == 200 || statusCode >= 400) {
QVERIFY(readyReadSpy.count() > 0);
QVERIFY(!content.isEmpty());
} else if (statusCode >= 300 && statusCode < 400) {
QVERIFY(!redirectUrl.isEmpty());
}
QSslConfiguration::NextProtocolNegotiationStatus expectedStatus =
expectedProtocol.isNull() ? QSslConfiguration::NextProtocolNegotiationNone
: QSslConfiguration::NextProtocolNegotiationNegotiated;
QCOMPARE(reply->sslConfiguration().nextProtocolNegotiationStatus(),
expectedStatus);
QCOMPARE(reply->sslConfiguration().nextNegotiatedProtocol(), expectedProtocol);
#else
QSKIP("Qt built withouth OpenSSL, or the OpenSSL version is too old");
#endif // defined(QT_BUILD_INTERNAL) && !defined(QT_NO_SSL) ...
}
void tst_qnetworkreply::spdyReplyFinished()
{
static int finishedCount = 0;
finishedCount++;
if (finishedCount == 12)
QTestEventLoop::instance().exitLoop();
}
void tst_qnetworkreply::spdyMultipleRequestsPerHost()
{
#if defined(QT_BUILD_INTERNAL) && !defined(QT_NO_SSL) && OPENSSL_VERSION_NUMBER >= 0x1000100fL && !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
QList<QNetworkRequest> requests;
requests
<< QNetworkRequest(QUrl("https://www.facebook.com"))
<< QNetworkRequest(QUrl("https://www.facebook.com/images/fb_icon_325x325.png"))
<< QNetworkRequest(QUrl("https://www.google.de"))
<< QNetworkRequest(QUrl("https://www.google.de/preferences?hl=de"))
<< QNetworkRequest(QUrl("https://www.google.de/intl/de/policies/?fg=1"))
<< QNetworkRequest(QUrl("https://www.google.de/intl/de/about.html?fg=1"))
<< QNetworkRequest(QUrl("https://www.google.de/services/?fg=1"))
<< QNetworkRequest(QUrl("https://www.google.de/intl/de/ads/?fg=1"))
<< QNetworkRequest(QUrl("https://i1.ytimg.com/li/tnHdj3df7iM/default.jpg"))
<< QNetworkRequest(QUrl("https://i1.ytimg.com/li/7Dr1BKwqctY/default.jpg"))
<< QNetworkRequest(QUrl("https://i1.ytimg.com/li/hfZhJdhTqX8/default.jpg"))
<< QNetworkRequest(QUrl("https://i1.ytimg.com/vi/14Nprh8163I/hqdefault.jpg"))
;
QList<QNetworkReply *> replies;
QList<QSignalSpy *> metaDataChangedSpies;
QList<QSignalSpy *> readyReadSpies;
QList<QSignalSpy *> finishedSpies;
QSignalSpy finishedManagerSpy(&m_manager, SIGNAL(finished(QNetworkReply*)));
foreach (QNetworkRequest request, requests) {
request.setAttribute(QNetworkRequest::SpdyAllowedAttribute, true);
QNetworkReply *reply = m_manager.get(request);
QObject::connect(reply, SIGNAL(finished()), this, SLOT(spdyReplyFinished()));
replies << reply;
QSignalSpy *metaDataChangedSpy = new QSignalSpy(reply, SIGNAL(metaDataChanged()));
metaDataChangedSpies << metaDataChangedSpy;
QSignalSpy *readyReadSpy = new QSignalSpy(reply, SIGNAL(readyRead()));
readyReadSpies << readyReadSpy;
QSignalSpy *finishedSpy = new QSignalSpy(reply, SIGNAL(finished()));
finishedSpies << finishedSpy;
}
QCOMPARE(requests.count(), replies.count());
QTestEventLoop::instance().enterLoop(15);
QVERIFY(!QTestEventLoop::instance().timeout());
QCOMPARE(finishedManagerSpy.count(), requests.count());
for (int a = 0; a < replies.count(); ++a) {
QCOMPARE(replies.at(a)->sslConfiguration().nextProtocolNegotiationStatus(),
QSslConfiguration::NextProtocolNegotiationNegotiated);
QCOMPARE(replies.at(a)->sslConfiguration().nextNegotiatedProtocol(),
QByteArray(QSslConfiguration::NextProtocolSpdy3_0));
QCOMPARE(replies.at(a)->error(), QNetworkReply::NoError);
QCOMPARE(replies.at(a)->attribute(QNetworkRequest::SpdyWasUsedAttribute).toBool(), true);
QCOMPARE(replies.at(a)->attribute(QNetworkRequest::ConnectionEncryptedAttribute).toBool(), true);
QCOMPARE(replies.at(a)->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
QByteArray content = replies.at(a)->readAll();
QVERIFY(content.count() > 0);
QCOMPARE(metaDataChangedSpies.at(a)->count(), 1);
metaDataChangedSpies.at(a)->deleteLater();
QCOMPARE(finishedSpies.at(a)->count(), 1);
finishedSpies.at(a)->deleteLater();
QVERIFY(readyReadSpies.at(a)->count() > 0);
readyReadSpies.at(a)->deleteLater();
replies.at(a)->deleteLater();
}
#else
QSKIP("Qt built withouth OpenSSL, or the OpenSSL version is too old");
#endif // defined(QT_BUILD_INTERNAL) && !defined(QT_NO_SSL) ...
}
network tests: add manual test for auth / proxy auth This is helpful to e.g. test an NTLM proxy. The test server currently does not support NTLM; this test offers a possibility to specify a proxy server via environment variables. Change-Id: Iea94656d38424c1d932fc854d13ca15ca47cdd68 Reviewed-by: Richard J. Moore <rich@kde.org>
2014-08-04 14:32:45 +00:00
void tst_qnetworkreply::proxyAuthentication_data()
{
QTest::addColumn<QUrl>("url");
QTest::newRow("http://www.google.com") << QUrl("http://www.google.com");
QTest::newRow("https://www.google.com") << QUrl("https://www.google.com");
}
void tst_qnetworkreply::proxyAuthentication()
{
QFETCH(QUrl, url);
QNetworkRequest request(url);
QNetworkAccessManager manager;
QByteArray proxyHostName = qgetenv("QT_PROXY_HOST");
QByteArray proxyPort = qgetenv("QT_PROXY_PORT");
QByteArray proxyUser = qgetenv("QT_PROXY_USER");
QByteArray proxyPassword = qgetenv("QT_PROXY_PASSWORD");
if (proxyHostName.isEmpty() || proxyPort.isEmpty() || proxyUser.isEmpty()
|| proxyPassword.isEmpty())
QSKIP("This test requires the QT_PROXY_* environment variables to be set. "
"Do something like:\n"
"export QT_PROXY_HOST=myNTLMHost\n"
"export QT_PROXY_PORT=8080\n"
"export QT_PROXY_USER='myDomain\\myUser'\n"
"export QT_PROXY_PASSWORD=myPassword\n");
QNetworkProxy proxy(QNetworkProxy::HttpProxy);
proxy.setHostName(proxyHostName);
proxy.setPort(proxyPort.toInt());
proxy.setUser(proxyUser);
proxy.setPassword(proxyPassword);
manager.setProxy(proxy);
reply = manager.get(request);
QObject::connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
QTestEventLoop::instance().enterLoop(15);
QVERIFY(!QTestEventLoop::instance().timeout());
QCOMPARE(reply->error(), QNetworkReply::NoError);
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QVERIFY(statusCode >= 200 && statusCode < 400);
}
void tst_qnetworkreply::authenticationRequiredSlot(QNetworkReply *,
QAuthenticator *authenticator)
{
QString authUser = QString::fromLocal8Bit(qgetenv("QT_AUTH_USER"));
QString authPassword = QString::fromLocal8Bit(qgetenv("QT_AUTH_PASSWORD"));
authenticator->setUser(authUser);
authenticator->setPassword(authPassword);
}
void tst_qnetworkreply::authentication()
{
QByteArray authUrl = qgetenv("QT_AUTH_URL");
if (authUrl.isEmpty())
QSKIP("This test requires the QT_AUTH_* environment variables to be set. "
"Do something like:\n"
"export QT_AUTH_URL='http://myUrl.com/myPath'\n"
"export QT_AUTH_USER='myDomain\\myUser'\n"
"export QT_AUTH_PASSWORD=myPassword\n");
QUrl url(QString::fromLocal8Bit(authUrl));
QNetworkRequest request(url);
QNetworkAccessManager manager;
QObject::connect(&manager, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)),
this, SLOT(authenticationRequiredSlot(QNetworkReply*,QAuthenticator*)));
reply = manager.get(request);
QObject::connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
QTestEventLoop::instance().enterLoop(15);
QVERIFY(!QTestEventLoop::instance().timeout());
QVERIFY2(reply->error() == QNetworkReply::NoError, reply->errorString().toLocal8Bit());
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QVERIFY(statusCode >= 200 && statusCode < 400);
}
SSL NPN negotiation: Do not abort on unmatched protocols ... but choose HTTP/1.1 and continue connecting anyhow. According to the NPN spec, actually we should choose SPDY: "In the event that the client doesn't support any of server's protocols, or the server doesn't advertise any, it SHOULD select the first protocol that it supports." However, some tested servers did not advertise anything and did not support SPDY, so blindly trying the newest protocol would fail. We are conservative in that case and choose HTTP. Task-number: QTBUG-40714 Change-Id: Ia8aaf01fea74e13d9e4416306f85f1890b25559e Reviewed-by: Richard J. Moore <rich@kde.org>
2015-02-05 13:05:21 +00:00
void tst_qnetworkreply::npnWithEmptyList() // QTBUG-40714
{
#if defined(QT_BUILD_INTERNAL) && !defined(QT_NO_SSL) && OPENSSL_VERSION_NUMBER >= 0x1000100fL && !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
// The server does not send a list of Next Protocols, so we test
// that we continue anyhow and it works
m_manager.clearAccessCache();
QUrl url(QStringLiteral("https://www.ossifrage.net/"));
QNetworkRequest request(url);
request.setAttribute(QNetworkRequest::SpdyAllowedAttribute, QVariant(true));
QNetworkReply *reply = m_manager.get(request);
QObject::connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
QTestEventLoop::instance().enterLoop(15);
QVERIFY(!QTestEventLoop::instance().timeout());
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QVERIFY(statusCode == 200);
QCOMPARE(reply->sslConfiguration().nextProtocolNegotiationStatus(),
QSslConfiguration::NextProtocolNegotiationUnsupported);
#else
QSKIP("Qt built withouth OpenSSL, or the OpenSSL version is too old");
#endif // defined(QT_BUILD_INTERNAL) && !defined(QT_NO_SSL) ...
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QTEST_MAIN(tst_qnetworkreply)
#include "main.moc"
Reference in New Issue Copy Permalink