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