57 #include <QtNetwork/QAbstractNetworkCache>

   202     void ioGetFromHttpWithCache_data();

   203     void ioGetFromHttpWithCache();

   259 

   260     void httpReUsingConnectionSequential_data();

   261     void httpReUsingConnectionSequential();

   262     void httpReUsingConnectionFromFinishedSlot_data();

   263     void httpReUsingConnectionFromFinishedSlot();

   264 

   265     void httpRecursiveCreation();

   322 

   323 // Does not work for POST/PUT!

   328     QTcpSocket *client; // always the last one that was received

   401 

   402 class MyMemoryCache: public QAbstractNetworkCache

   403 {

   404 public:

   405     typedef QPair<QNetworkCacheMetaData, QByteArray> CachedContent;

   406     typedef QHash<QByteArray, CachedContent> CacheData;

   407     CacheData cache;

   408 

   409     MyMemoryCache(QObject *parent) : QAbstractNetworkCache(parent) {}

   410 

   411     QNetworkCacheMetaData metaData(const QUrl &url)

   412     {

   413         return cache.value(url.toEncoded()).first;

   414     }

   415 

   416     void updateMetaData(const QNetworkCacheMetaData &metaData)

   417     {

   418         cache[metaData.url().toEncoded()].first = metaData;

   419     }

   420 

   421     QIODevice *data(const QUrl &url)

   422     {

   423         CacheData::ConstIterator it = cache.find(url.toEncoded());

   424         if (it == cache.constEnd())

   425             return 0;

   426         QBuffer *io = new QBuffer(this);

   427         io->setData(it->second);

   428         io->open(QIODevice::ReadOnly);

   429         io->seek(0);

   430         return io;

   431     }

   432 

   433     bool remove(const QUrl &url)

   434     {

   435         cache.remove(url.toEncoded());

   436         return true;

   437     }

   438 

   439     qint64 cacheSize() const

   440     {

   441         qint64 total = 0;

   442         foreach (const CachedContent &entry, cache)

   443             total += entry.second.size();

   444         return total;

   445     }

   446 

   447     QIODevice *prepare(const QNetworkCacheMetaData &)

   448     { Q_ASSERT(0 && "Should not have tried to add to the cache"); return 0; }

   449     void insert(QIODevice *)

   450     { Q_ASSERT(0 && "Should not have tried to add to the cache"); }

   451 

   452     void clear() { cache.clear(); }

   453 };

   454 Q_DECLARE_METATYPE(MyMemoryCache::CachedContent)

   455 Q_DECLARE_METATYPE(MyMemoryCache::CacheData)

   840     manager.setCache(0);

  1538     QVERIFY(reply->isFinished()); // a file should immediatly be done

  2052 

  2053     QTest::newRow("immediate disconnect") << QByteArray("") << true;

  2054     QTest::newRow("justHalfStatus+disconnect") << QByteArray("HTTP/1.1") << true;

  2055     QTest::newRow("justStatus+disconnect") << QByteArray("HTTP/1.1 200 OK\r\n") << true;

  2056     QTest::newRow("justStatusAndHalfHeaders+disconnect") << QByteArray("HTTP/1.1 200 OK\r\nContent-L") << true;

  2075 }

  2076 

  2077 void tst_QNetworkReply::ioGetFromHttpWithCache_data()

  2078 {

  2079     qRegisterMetaType<MyMemoryCache::CachedContent>();

  2080     QTest::addColumn<QByteArray>("dataToSend");

  2081     QTest::addColumn<QString>("body");

  2082     QTest::addColumn<MyMemoryCache::CachedContent>("cachedReply");

  2083     QTest::addColumn<int>("cacheMode");

  2084     QTest::addColumn<bool>("loadedFromCache");

  2085     QTest::addColumn<bool>("networkUsed");

  2086 

  2087     QByteArray reply200 =

  2088             "HTTP/1.0 200\r\n"

  2089             "Connection: keep-alive\r\n"

  2090             "Content-Type: text/plain\r\n"

  2091             "Cache-control: no-cache\r\n"

  2092             "Content-length: 8\r\n"

  2093             "\r\n"

  2094             "Reloaded";

  2095     QByteArray reply304 =

  2096             "HTTP/1.0 304 Use Cache\r\n"

  2097             "Connection: keep-alive\r\n"

  2098             "\r\n";

  2099 

  2100     QTest::newRow("not-cached,always-network")

  2101             << reply200 << "Reloaded" << MyMemoryCache::CachedContent() << int(QNetworkRequest::AlwaysNetwork) << false << true;

  2102     QTest::newRow("not-cached,prefer-network")

  2103             << reply200 << "Reloaded" << MyMemoryCache::CachedContent() << int(QNetworkRequest::PreferNetwork) << false << true;

  2104     QTest::newRow("not-cached,prefer-cache")

  2105             << reply200 << "Reloaded" << MyMemoryCache::CachedContent() << int(QNetworkRequest::PreferCache) << false << true;

  2106 

  2107     QDateTime present = QDateTime::currentDateTime().toUTC();

  2108     QDateTime past = present.addSecs(-3600);

  2109     QDateTime future = present.addSecs(3600);

  2110     static const char dateFormat[] = "ddd, dd MMM yyyy hh:mm:ss 'GMT'";

  2111 

  2112     QNetworkCacheMetaData::RawHeaderList rawHeaders;

  2113     MyMemoryCache::CachedContent content;

  2114     content.second = "Not-reloaded";

  2115     content.first.setLastModified(past);

  2116 

  2117     //

  2118     // Set to expired

  2119     //

  2120     rawHeaders.clear();

  2121     rawHeaders << QNetworkCacheMetaData::RawHeader("Date", QLocale::c().toString(past, dateFormat).toLatin1())

  2122             << QNetworkCacheMetaData::RawHeader("Cache-control", "max-age=0"); // isn't used in cache loading

  2123     content.first.setRawHeaders(rawHeaders);

  2124     content.first.setLastModified(past);

  2125 

  2126     QTest::newRow("expired,200,prefer-network")

  2127             << reply200 << "Reloaded" << content << int(QNetworkRequest::PreferNetwork) << false << true;

  2128     QTest::newRow("expired,200,prefer-cache")

  2129             << reply200 << "Reloaded" << content << int(QNetworkRequest::PreferCache) << false << true;

  2130 

  2131     QTest::newRow("expired,304,prefer-network")

  2132             << reply304 << "Not-reloaded" << content << int(QNetworkRequest::PreferNetwork) << true << true;

  2133     QTest::newRow("expired,304,prefer-cache")

  2134             << reply304 << "Not-reloaded" << content << int(QNetworkRequest::PreferCache) << true << true;

  2135 

  2136     //

  2137     // Set to not-expired

  2138     //

  2139     rawHeaders.clear();

  2140     rawHeaders << QNetworkCacheMetaData::RawHeader("Date", QLocale::c().toString(past, dateFormat).toLatin1())

  2141             << QNetworkCacheMetaData::RawHeader("Cache-control", "max-age=7200"); // isn't used in cache loading

  2142     content.first.setRawHeaders(rawHeaders);

  2143     content.first.setExpirationDate(future);

  2144 

  2145     QTest::newRow("not-expired,200,always-network")

  2146             << reply200 << "Reloaded" << content << int(QNetworkRequest::AlwaysNetwork) << false << true;

  2147     QTest::newRow("not-expired,200,prefer-network")

  2148             << reply200 << "Not-reloaded" << content << int(QNetworkRequest::PreferNetwork) << true << false;

  2149     QTest::newRow("not-expired,200,prefer-cache")

  2150             << reply200 << "Not-reloaded" << content << int(QNetworkRequest::PreferCache) << true << false;

  2151     QTest::newRow("not-expired,200,always-cache")

  2152             << reply200 << "Not-reloaded" << content << int(QNetworkRequest::AlwaysCache) << true << false;

  2153 

  2154     QTest::newRow("not-expired,304,prefer-network")

  2155             << reply304 << "Not-reloaded" << content << int(QNetworkRequest::PreferNetwork) << true << false;

  2156     QTest::newRow("not-expired,304,prefer-cache")

  2157             << reply304 << "Not-reloaded" << content << int(QNetworkRequest::PreferCache) << true << false;

  2158     QTest::newRow("not-expired,304,always-cache")

  2159             << reply304 << "Not-reloaded" << content << int(QNetworkRequest::AlwaysCache) << true << false;

  2160 

  2161     //

  2162     // Set must-revalidate now

  2163     //

  2164     rawHeaders.clear();

  2165     rawHeaders << QNetworkCacheMetaData::RawHeader("Date", QLocale::c().toString(past, dateFormat).toLatin1())

  2166             << QNetworkCacheMetaData::RawHeader("Cache-control", "max-age=7200, must-revalidate"); // must-revalidate is used

  2167     content.first.setRawHeaders(rawHeaders);

  2168 

  2169     QTest::newRow("must-revalidate,200,always-network")

  2170             << reply200 << "Reloaded" << content << int(QNetworkRequest::AlwaysNetwork) << false << true;

  2171     QTest::newRow("must-revalidate,200,prefer-network")

  2172             << reply200 << "Reloaded" << content << int(QNetworkRequest::PreferNetwork) << false << true;

  2173     QTest::newRow("must-revalidate,200,prefer-cache")

  2174             << reply200 << "Not-reloaded" << content << int(QNetworkRequest::PreferCache) << true << false;

  2175     QTest::newRow("must-revalidate,200,always-cache")

  2176             << reply200 << "Not-reloaded" << content << int(QNetworkRequest::AlwaysCache) << true << false;

  2177 

  2178     QTest::newRow("must-revalidate,304,prefer-network")

  2179             << reply304 << "Not-reloaded" << content << int(QNetworkRequest::PreferNetwork) << true << true;

  2180     QTest::newRow("must-revalidate,304,prefer-cache")

  2181             << reply304 << "Not-reloaded" << content << int(QNetworkRequest::PreferCache) << true << false;

  2182     QTest::newRow("must-revalidate,304,always-cache")

  2183             << reply304 << "Not-reloaded" << content << int(QNetworkRequest::AlwaysCache) << true << false;

  2184 }

  2185 

  2186 void tst_QNetworkReply::ioGetFromHttpWithCache()

  2187 {

  2188     QFETCH(QByteArray, dataToSend);

  2189     MiniHttpServer server(dataToSend);

  2190     server.doClose = false;

  2191 

  2192     MyMemoryCache *memoryCache = new MyMemoryCache(&manager);

  2193     manager.setCache(memoryCache);

  2194 

  2195     QFETCH(MyMemoryCache::CachedContent, cachedReply);

  2196     QUrl url = "http://localhost:" + QString::number(server.serverPort());

  2197     cachedReply.first.setUrl(url);

  2198     if (!cachedReply.second.isNull())

  2199         memoryCache->cache.insert(url.toEncoded(), cachedReply);

  2200 

  2201     QFETCH(int, cacheMode);

  2202     QNetworkRequest request(url);

  2203     request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, cacheMode);

  2204     request.setAttribute(QNetworkRequest::CacheSaveControlAttribute, false);

  2205     QNetworkReplyPtr reply = manager.get(request);

  2206 

  2207     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));

  2208     QTestEventLoop::instance().enterLoop(10);

  2209     QVERIFY(!QTestEventLoop::instance().timeout());

  2210 

  2211     QTEST(reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool(), "loadedFromCache");

  2212     QTEST(server.totalConnections > 0, "networkUsed");

  2213     QFETCH(QString, body);

  2214     QCOMPARE(reply->readAll().constData(), qPrintable(body));

  3806 void tst_QNetworkReply::httpReUsingConnectionSequential_data()

  3807 {

  3808     QTest::addColumn<bool>("doDeleteLater");

  3809     QTest::newRow("deleteLater") << true;

  3810     QTest::newRow("noDeleteLater") << false;

  3811 }

  3812 

  3813 void tst_QNetworkReply::httpReUsingConnectionSequential()

  3814 {

  3815     QFETCH(bool, doDeleteLater);

  3816 

  3817     QByteArray response("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");

  3818     MiniHttpServer server(response);

  3819     server.multiple = true;

  3820     server.doClose = false;

  3821 

  3822     QUrl url;

  3823     url.setScheme("http");

  3824     url.setPort(server.serverPort());

  3825     url.setHost("127.0.0.1");

  3826     // first request

  3827     QNetworkReply* reply1 = manager.get(QNetworkRequest(url));

  3828     connect(reply1, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));

  3829     QTestEventLoop::instance().enterLoop(2);

  3830     QVERIFY(!QTestEventLoop::instance().timeout());

  3831     QVERIFY(!reply1->error());

  3832     int reply1port = server.client->peerPort();

  3833 

  3834     if (doDeleteLater)

  3835         reply1->deleteLater();

  3836 

  3837     // finished received, send the next one

  3838     QNetworkReply*reply2 = manager.get(QNetworkRequest(url));

  3839     connect(reply2, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));

  3840     QTestEventLoop::instance().enterLoop(2);

  3841     QVERIFY(!QTestEventLoop::instance().timeout());

  3842     QVERIFY(!reply2->error());

  3843     int reply2port = server.client->peerPort(); // should still be the same object

  3844 

  3845     QVERIFY(reply1port > 0);

  3846     QCOMPARE(server.totalConnections, 1);

  3847     QCOMPARE(reply2port, reply1port);

  3848 

  3849     if (!doDeleteLater)

  3850         reply1->deleteLater(); // only do it if it was not done earlier

  3851     reply2->deleteLater();

  3852 }

  3853 

  3854 class HttpReUsingConnectionFromFinishedSlot : public QObject {

  3855     Q_OBJECT;

  3856 public:

  3857     QNetworkReply* reply1;

  3858     QNetworkReply* reply2;

  3859     QUrl url;

  3860     QNetworkAccessManager manager;

  3861 public slots:

  3862     void finishedSlot() {

  3863         QVERIFY(!reply1->error());

  3864 

  3865         QFETCH(bool, doDeleteLater);

  3866         if (doDeleteLater) {

  3867             reply1->deleteLater();

  3868             reply1 = 0;

  3869         }

  3870 

  3871         // kick off 2nd request and exit the loop when it is done

  3872         reply2 = manager.get(QNetworkRequest(url));

  3873         reply2->setParent(this);

  3874         connect(reply2, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));

  3875     }

  3876 };

  3877 

  3878 void tst_QNetworkReply::httpReUsingConnectionFromFinishedSlot_data()

  3879 {

  3880     httpReUsingConnectionSequential_data();

  3881 }

  3882 

  3883 void tst_QNetworkReply::httpReUsingConnectionFromFinishedSlot()

  3884 {

  3885     QByteArray response("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");

  3886     MiniHttpServer server(response);

  3887     server.multiple = true;

  3888     server.doClose = false;

  3889 

  3890     HttpReUsingConnectionFromFinishedSlot helper;

  3891     helper.reply1 = 0;

  3892     helper.reply2 = 0;

  3893     helper.url.setScheme("http");

  3894     helper.url.setPort(server.serverPort());

  3895     helper.url.setHost("127.0.0.1");

  3896 

  3897     // first request

  3898     helper.reply1 = helper.manager.get(QNetworkRequest(helper.url));

  3899     helper.reply1->setParent(&helper);

  3900     connect(helper.reply1, SIGNAL(finished()), &helper, SLOT(finishedSlot()));

  3901     QTestEventLoop::instance().enterLoop(4);

  3902     QVERIFY(!QTestEventLoop::instance().timeout());

  3903 

  3904     QVERIFY(helper.reply2);

  3905     QVERIFY(!helper.reply2->error());

  3906 

  3907     QCOMPARE(server.totalConnections, 1);

  3908 }

  3909 

  3910 class HttpRecursiveCreationHelper : public QObject {

  3911     Q_OBJECT

  3912 public:

  3913 

  3914     HttpRecursiveCreationHelper():

  3915             QObject(0),

  3916             requestsStartedCount_finished(0),

  3917             requestsStartedCount_readyRead(0),

  3918             requestsFinishedCount(0)

  3919     {

  3920     }

  3921     QNetworkAccessManager manager;

  3922     int requestsStartedCount_finished;

  3923     int requestsStartedCount_readyRead;

  3924     int requestsFinishedCount;

  3925 public slots:

  3926     void finishedSlot() {

  3927         requestsFinishedCount++;

  3928 

  3929         QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());

  3930         QVERIFY(!reply->error());

  3931         QVERIFY(reply->bytesAvailable() == 27906);

  3932 

  3933         if (requestsFinishedCount == 60) {

  3934             QTestEventLoop::instance().exitLoop();

  3935             return;

  3936         }

  3937 

  3938         if (requestsStartedCount_finished < 30) {

  3939             startOne();

  3940             requestsStartedCount_finished++;

  3941         }

  3942 

  3943         reply->deleteLater();

  3944     }

  3945     void readyReadSlot() {

  3946         QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());

  3947         QVERIFY(!reply->error());

  3948 

  3949         if (requestsStartedCount_readyRead < 30 && reply->bytesAvailable() > 27906/2) {

  3950             startOne();

  3951             requestsStartedCount_readyRead++;

  3952         }

  3953     }

  3954     void startOne() {

  3955         QUrl url = "http://" + QtNetworkSettings::serverName() + "/gif/fluke.gif";

  3956         QNetworkRequest request(url);

  3957         QNetworkReply *reply = manager.get(request);

  3958         reply->setParent(this);

  3959         connect(reply, SIGNAL(finished()), this, SLOT(finishedSlot()));

  3960         connect(reply, SIGNAL(readyRead()), this, SLOT(readyReadSlot()));

  3961     }

  3962 };

  3963 

  3964 void tst_QNetworkReply::httpRecursiveCreation()

  3965 {

  3966     // this test checks if creation of new requests to the same host properly works

  3967     // from readyRead() and finished() signals

  3968     HttpRecursiveCreationHelper helper;

  3969     helper.startOne();

  3970     QTestEventLoop::instance().enterLoop(30);

  3971     QVERIFY(!QTestEventLoop::instance().timeout());

  3972 }

  3973