Add unittest that tests behavior when downloading a crx fails.

chrome/browser/extensions/updater/extension_updater_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 52 matching lines @@
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 using testing::DoAll;
+using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::Mock;
 using testing::Return;
 using testing::SetArgPointee;
 using testing::_;
 
 namespace extensions {
 
 typedef ExtensionDownloaderDelegate::Error Error;
 typedef ExtensionDownloaderDelegate::PingResult PingResult;
@@ skipping 61 matching lines @@
         new content::MessageLoopRunner;
     quit_closure_ = runner->QuitClosure();
     runner->Run();
     quit_closure_.Reset();
   }
 
   void Quit() {
     quit_closure_.Run();
   }
 
+  void DelegateTo(ExtensionDownloaderDelegate* delegate) {
+    ON_CALL(*this, OnExtensionDownloadFailed(_, _, _, _))
+        .WillByDefault(Invoke(delegate,
+            &ExtensionDownloaderDelegate::OnExtensionDownloadFailed));
+    ON_CALL(*this, OnExtensionDownloadFinished(_, _, _, _, _, _, _))
+        .WillByDefault(Invoke(delegate,
+            &ExtensionDownloaderDelegate::OnExtensionDownloadFinished));
+    ON_CALL(*this, GetPingDataForExtension(_, _))
+        .WillByDefault(Invoke(delegate,
+            &ExtensionDownloaderDelegate::GetPingDataForExtension));
+    ON_CALL(*this, GetUpdateUrlData(_))
+        .WillByDefault(Invoke(delegate,
+            &ExtensionDownloaderDelegate::GetUpdateUrlData));
+    ON_CALL(*this, IsExtensionPending(_))
+        .WillByDefault(Invoke(delegate,
+            &ExtensionDownloaderDelegate::IsExtensionPending));
+    ON_CALL(*this, GetExtensionExistingVersion(_, _))
+        .WillByDefault(Invoke(delegate,
+            &ExtensionDownloaderDelegate::GetExtensionExistingVersion));

[asargent_no_longer_on_chrome, 2014/02/01 00:55:05]

ZOMG gtest

+  }
+
  private:
   base::Closure quit_closure_;
 };
 
 const int kNotificationsObserved[] = {
   chrome::NOTIFICATION_EXTENSION_UPDATING_STARTED,
   chrome::NOTIFICATION_EXTENSION_UPDATE_FOUND,
 };
 
 // A class that observes the notifications sent by the ExtensionUpdater and
@@ skipping 795 matching lines @@
     EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
     fetcher->set_url(kUpdateUrl);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(400);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunUntilIdle();
 
     Mock::VerifyAndClearExpectations(&delegate);
   }
 
-  void TestSingleExtensionDownloading(bool pending, bool retry) {
+  void TestSingleExtensionDownloading(bool pending, bool retry, bool fail) {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
     scoped_ptr<ServiceForDownloadTests> service(
         new ServiceForDownloadTests(prefs_.get()));
     ExtensionUpdater updater(service.get(), service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
                              kUpdateFrequencySecs,
                              NULL);
     updater.Start();
+    MockExtensionDownloaderDelegate delegate;
+    delegate.DelegateTo(&updater);
     ResetDownloader(
         &updater,
-        new ExtensionDownloader(&updater, service->request_context()));
+        new ExtensionDownloader(&delegate, service->request_context()));
     updater.downloader_->extensions_queue_.set_backoff_policy(
         &kNoBackoffPolicy);
 
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash;
     Version version("0.0.1");
     std::set<int> requests;
     requests.insert(0);
@@ skipping 32 matching lines @@
 
       RunUntilIdle();
       fetcher = factory.GetFetcherByID(
           ExtensionDownloader::kExtensionFetcherId);
       EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
       EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
     }
 
     fetcher->set_url(test_url);
     fetcher->set_status(net::URLRequestStatus());
-    fetcher->set_response_code(200);
-    fetcher->SetResponseFilePath(extension_file_path);
+    if (fail) {
+      fetcher->set_response_code(404);
+      EXPECT_CALL(delegate, OnExtensionDownloadFailed(id, _, _, requests));
+    } else {
+      fetcher->set_response_code(200);
+      fetcher->SetResponseFilePath(extension_file_path);
+      EXPECT_CALL(delegate, OnExtensionDownloadFinished(
+          id, _, _, _, version.GetString(), _, requests));
+    }
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     RunUntilIdle();
 
-    // Expect that ExtensionUpdater asked the mock extensions service to install
-    // a file with the test data for the right id.
-    EXPECT_EQ(id, service->extension_id());
-    base::FilePath tmpfile_path = service->install_path();
-    EXPECT_FALSE(tmpfile_path.empty());
-    EXPECT_EQ(test_url, service->download_url());
-    EXPECT_EQ(extension_file_path, tmpfile_path);
+    if (fail) {
+      // Don't expect any extension to have been installed.
+      EXPECT_TRUE(service->extension_id().empty());
+    } else {
+      // Expect that ExtensionUpdater asked the mock extensions service to
+      // install a file with the test data for the right id.
+      EXPECT_EQ(id, service->extension_id());
+      base::FilePath tmpfile_path = service->install_path();
+      EXPECT_FALSE(tmpfile_path.empty());
+      EXPECT_EQ(test_url, service->download_url());
+      EXPECT_EQ(extension_file_path, tmpfile_path);
+    }
   }
 
   // Two extensions are updated.  If |updates_start_running| is true, the
   // mock extensions service has UpdateExtension(...) return true, and
   // the test is responsible for creating fake CrxInstallers.  Otherwise,
   // UpdateExtension() returns false, signaling install failures.
   void TestMultipleExtensionDownloading(bool updates_start_running) {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
     ServiceForDownloadTests service(prefs_.get());
@@ skipping 374 matching lines @@
 
 TEST_F(ExtensionUpdaterTest, TestDetermineUpdatesPending) {
   TestDetermineUpdatesPending();
 }
 
 TEST_F(ExtensionUpdaterTest, TestMultipleManifestDownloading) {
   TestMultipleManifestDownloading();
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloading) {
-  TestSingleExtensionDownloading(false, false);
+  TestSingleExtensionDownloading(false, false, false);
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingPending) {
-  TestSingleExtensionDownloading(true, false);
+  TestSingleExtensionDownloading(true, false, false);
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingWithRetry) {
-  TestSingleExtensionDownloading(false, true);
+  TestSingleExtensionDownloading(false, true, false);
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingPendingWithRetry) {
-  TestSingleExtensionDownloading(true, true);
+  TestSingleExtensionDownloading(true, true, false);
+}
+
+TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingFailure) {
+  TestSingleExtensionDownloading(false, false, true);
+}
+
+TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingFailureWithRetry) {
+  TestSingleExtensionDownloading(false, true, true);
+}
+
+TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingFailurePending) {
+  TestSingleExtensionDownloading(true, false, true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesFail) {
   TestMultipleExtensionDownloading(false);
 }
 TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesSucceed) {
   TestMultipleExtensionDownloading(true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestManifestRetryDownloading) {
@@ skipping 175 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions