components/precache/core/precache_fetcher_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/precache/core/precache_fetcher.h"
   6
   7 #include <list>
   8 #include <set>
   9 #include <string>
  10
  11 #include "base/basictypes.h"
  12 #include "base/bind.h"
  13 #include "base/callback.h"
  14 #include "base/command_line.h"
  15 #include "base/compiler_specific.h"
  16 #include "base/message_loop/message_loop.h"
  17 #include "components/precache/core/precache_switches.h"
  18 #include "components/precache/core/proto/precache.pb.h"
  19 #include "net/http/http_response_headers.h"
  20 #include "net/http/http_status_code.h"
  21 #include "net/url_request/test_url_fetcher_factory.h"
  22 #include "net/url_request/url_request_status.h"
  23 #include "net/url_request/url_request_test_util.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25
  26 namespace precache {
  27
  28 namespace {
  29
  30 class TestURLFetcherCallback {
  31  public:
  32   scoped_ptr<net::FakeURLFetcher> CreateURLFetcher(
  33       const GURL& url, net::URLFetcherDelegate* delegate,
  34       const std::string& response_data, net::HttpStatusCode response_code,
  35       net::URLRequestStatus::Status status) {
  36     scoped_ptr<net::FakeURLFetcher> fetcher(new net::FakeURLFetcher(
  37         url, delegate, response_data, response_code, status));
  38
  39     if (response_code == net::HTTP_OK) {
  40       scoped_refptr<net::HttpResponseHeaders> download_headers =
  41           new net::HttpResponseHeaders("");
  42       download_headers->AddHeader("Content-Type: text/html");
  43       fetcher->set_response_headers(download_headers);
  44     }
  45
  46     requested_urls_.insert(url);
  47     return fetcher.Pass();
  48   }
  49
  50   const std::multiset<GURL>& requested_urls() const {
  51     return requested_urls_;
  52   }
  53
  54  private:
  55   // Multiset with one entry for each URL requested.
  56   std::multiset<GURL> requested_urls_;
  57 };
  58
  59 class TestPrecacheDelegate : public PrecacheFetcher::PrecacheDelegate {
  60  public:
  61   TestPrecacheDelegate() : was_on_done_called_(false) {}
  62
  63   virtual void OnDone() OVERRIDE {
  64     was_on_done_called_ = true;
  65   }
  66
  67   bool was_on_done_called() const {
  68     return was_on_done_called_;
  69   }
  70
  71  private:
  72   bool was_on_done_called_;
  73 };
  74
  75 class PrecacheFetcherTest : public testing::Test {
  76  public:
  77   PrecacheFetcherTest()
  78       : request_context_(new net::TestURLRequestContextGetter(
  79             base::MessageLoopProxy::current())),
  80         factory_(NULL, base::Bind(&TestURLFetcherCallback::CreateURLFetcher,
  81                                   base::Unretained(&url_callback_))) {}
  82
  83  protected:
  84   base::MessageLoopForUI loop_;
  85   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
  86   TestURLFetcherCallback url_callback_;
  87   net::FakeURLFetcherFactory factory_;
  88   TestPrecacheDelegate precache_delegate_;
  89 };
  90
  91 const char kConfigURL[] = "http://config-url.com";
  92 const char kManfiestURLPrefix[] = "http://manifest-url-prefix.com/";
  93 const char kManifestFetchFailureURL[] =
  94     "http://manifest-url-prefix.com/"
  95     "http%253A%252F%252Fmanifest-fetch-failure.com%252F";
  96 const char kBadManifestURL[] =
  97     "http://manifest-url-prefix.com/http%253A%252F%252Fbad-manifest.com%252F";
  98 const char kGoodManifestURL[] =
  99     "http://manifest-url-prefix.com/http%253A%252F%252Fgood-manifest.com%252F";
 100 const char kResourceFetchFailureURL[] = "http://resource-fetch-failure.com";
 101 const char kGoodResourceURL[] = "http://good-resource.com";
 102 const char kForcedStartingURLManifestURL[] =
 103     "http://manifest-url-prefix.com/"
 104     "http%253A%252F%252Fforced-starting-url.com%252F";
 105
 106 TEST_F(PrecacheFetcherTest, FullPrecache) {
 107   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 108       switches::kPrecacheConfigSettingsURL, kConfigURL);
 109   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 110       switches::kPrecacheManifestURLPrefix, kManfiestURLPrefix);
 111
 112   std::list<GURL> starting_urls;
 113   starting_urls.push_back(GURL("http://manifest-fetch-failure.com"));
 114   starting_urls.push_back(GURL("http://bad-manifest.com"));
 115   starting_urls.push_back(GURL("http://good-manifest.com"));
 116   starting_urls.push_back(GURL("http://not-in-top-3.com"));
 117
 118   PrecacheConfigurationSettings config;
 119   config.set_top_sites_count(3);
 120   config.add_forced_starting_url("http://forced-starting-url.com");
 121   // Duplicate starting URL, the manifest for this should only be fetched once.
 122   config.add_forced_starting_url("http://good-manifest.com");
 123
 124   PrecacheManifest good_manifest;
 125   good_manifest.add_resource()->set_url(kResourceFetchFailureURL);
 126   good_manifest.add_resource();  // Resource with no URL, should not be fetched.
 127   good_manifest.add_resource()->set_url(kGoodResourceURL);
 128
 129   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
 130                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 131   factory_.SetFakeResponse(GURL(kManifestFetchFailureURL), "",
 132                            net::HTTP_INTERNAL_SERVER_ERROR,
 133                            net::URLRequestStatus::FAILED);
 134   factory_.SetFakeResponse(GURL(kBadManifestURL), "bad protobuf", net::HTTP_OK,
 135                            net::URLRequestStatus::SUCCESS);
 136   factory_.SetFakeResponse(GURL(kGoodManifestURL),
 137                            good_manifest.SerializeAsString(), net::HTTP_OK,
 138                            net::URLRequestStatus::SUCCESS);
 139   factory_.SetFakeResponse(GURL(kResourceFetchFailureURL),
 140                            "", net::HTTP_INTERNAL_SERVER_ERROR,
 141                            net::URLRequestStatus::FAILED);
 142   factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
 143                            net::URLRequestStatus::SUCCESS);
 144   factory_.SetFakeResponse(GURL(kForcedStartingURLManifestURL),
 145                            PrecacheManifest().SerializeAsString(), net::HTTP_OK,
 146                            net::URLRequestStatus::SUCCESS);
 147
 148   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
 149                                    &precache_delegate_);
 150   precache_fetcher.Start();
 151
 152   base::MessageLoop::current()->RunUntilIdle();
 153
 154   std::multiset<GURL> expected_requested_urls;
 155   expected_requested_urls.insert(GURL(kConfigURL));
 156   expected_requested_urls.insert(GURL(kManifestFetchFailureURL));
 157   expected_requested_urls.insert(GURL(kBadManifestURL));
 158   expected_requested_urls.insert(GURL(kGoodManifestURL));
 159   expected_requested_urls.insert(GURL(kResourceFetchFailureURL));
 160   expected_requested_urls.insert(GURL(kGoodResourceURL));
 161   expected_requested_urls.insert(GURL(kForcedStartingURLManifestURL));
 162
 163   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 164
 165   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 166 }
 167
 168 TEST_F(PrecacheFetcherTest, ConfigFetchFailure) {
 169   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 170       switches::kPrecacheConfigSettingsURL, kConfigURL);
 171
 172   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 173
 174   factory_.SetFakeResponse(GURL(kConfigURL), "",
 175                            net::HTTP_INTERNAL_SERVER_ERROR,
 176                            net::URLRequestStatus::FAILED);
 177
 178   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
 179                                    &precache_delegate_);
 180   precache_fetcher.Start();
 181
 182   base::MessageLoop::current()->RunUntilIdle();
 183
 184   std::multiset<GURL> expected_requested_urls;
 185   expected_requested_urls.insert(GURL(kConfigURL));
 186   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 187
 188   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 189 }
 190
 191 TEST_F(PrecacheFetcherTest, BadConfig) {
 192   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 193       switches::kPrecacheConfigSettingsURL, kConfigURL);
 194
 195   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 196
 197   factory_.SetFakeResponse(GURL(kConfigURL), "bad protobuf", net::HTTP_OK,
 198                            net::URLRequestStatus::SUCCESS);
 199
 200   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
 201                                    &precache_delegate_);
 202   precache_fetcher.Start();
 203
 204   base::MessageLoop::current()->RunUntilIdle();
 205
 206   std::multiset<GURL> expected_requested_urls;
 207   expected_requested_urls.insert(GURL(kConfigURL));
 208   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 209
 210   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 211 }
 212
 213 TEST_F(PrecacheFetcherTest, Cancel) {
 214   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 215       switches::kPrecacheConfigSettingsURL, kConfigURL);
 216
 217   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 218
 219   PrecacheConfigurationSettings config;
 220   config.set_top_sites_count(1);
 221
 222   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
 223                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 224
 225   scoped_ptr<PrecacheFetcher> precache_fetcher(new PrecacheFetcher(
 226       starting_urls, request_context_.get(), &precache_delegate_));
 227   precache_fetcher->Start();
 228
 229   // Destroy the PrecacheFetcher to cancel precaching. This should not cause
 230   // OnDone to be called on the precache delegate.
 231   precache_fetcher.reset();
 232
 233   base::MessageLoop::current()->RunUntilIdle();
 234
 235   std::multiset<GURL> expected_requested_urls;
 236   expected_requested_urls.insert(GURL(kConfigURL));
 237   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 238
 239   EXPECT_FALSE(precache_delegate_.was_on_done_called());
 240 }
 241
 242 #if defined(PRECACHE_CONFIG_SETTINGS_URL)
 243
 244 // If the default precache configuration settings URL is defined, then test that
 245 // it works with the PrecacheFetcher.
 246 TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultConfigSettingsURL) {
 247   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 248
 249   PrecacheConfigurationSettings config;
 250   config.set_top_sites_count(0);
 251
 252   factory_.SetFakeResponse(GURL(PRECACHE_CONFIG_SETTINGS_URL),
 253                            config.SerializeAsString(), net::HTTP_OK,
 254                            net::URLRequestStatus::SUCCESS);
 255
 256   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
 257                                    &precache_delegate_);
 258   precache_fetcher.Start();
 259
 260   base::MessageLoop::current()->RunUntilIdle();
 261
 262   std::multiset<GURL> expected_requested_urls;
 263   expected_requested_urls.insert(GURL(PRECACHE_CONFIG_SETTINGS_URL));
 264   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 265
 266   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 267 }
 268
 269 #endif  // PRECACHE_CONFIG_SETTINGS_URL
 270
 271 #if defined(PRECACHE_MANIFEST_URL_PREFIX)
 272
 273 // If the default precache manifest URL prefix is defined, then test that it
 274 // works with the PrecacheFetcher.
 275 TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultManifestURLPrefix) {
 276   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 277       switches::kPrecacheConfigSettingsURL, kConfigURL);
 278
 279   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 280
 281   PrecacheConfigurationSettings config;
 282   config.set_top_sites_count(1);
 283
 284   GURL manifest_url(PRECACHE_MANIFEST_URL_PREFIX
 285                     "http%253A%252F%252Fstarting-url.com%252F");
 286
 287   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
 288                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 289   factory_.SetFakeResponse(manifest_url, PrecacheManifest().SerializeAsString(),
 290                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 291
 292   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
 293                                    &precache_delegate_);
 294   precache_fetcher.Start();
 295
 296   base::MessageLoop::current()->RunUntilIdle();
 297
 298   std::multiset<GURL> expected_requested_urls;
 299   expected_requested_urls.insert(GURL(kConfigURL));
 300   expected_requested_urls.insert(manifest_url);
 301   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 302
 303   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 304 }
 305
 306 #endif  // PRECACHE_MANIFEST_URL_PREFIX
 307
 308 }  // namespace
 309
 310 }  // namespace precache