AU: When server dies, don't retry forever

http_fetcher_unittest.cc

 // Copyright (c) 2009 The Chromium OS 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 <unistd.h>
 #include <string>
 #include <vector>
 #include <base/scoped_ptr.h>
 #include <glib.h>
 #include <gtest/gtest.h>
@@ skipping 88 matching lines @@
     }
     free(argv[0]);
     return;
   }
   ~PythonHttpServer() {
     if (!started_)
       return;
     // request that the server exit itself
     LOG(INFO) << "running wget to exit";
     int rc = system((string("wget -t 1 --output-document=/dev/null ") +
-                    LocalServerUrlForPath("/quitquitquit")).c_str());
+                     LocalServerUrlForPath("/quitquitquit")).c_str());
     LOG(INFO) << "done running wget to exit";
     if (validate_quit_)
       EXPECT_EQ(0, rc);
     waitpid(pid_, NULL, 0);
   }
   GPid pid_;
   bool started_;
   bool validate_quit_;
 };
 
@@ skipping 47 matching lines @@
 };
 
 gboolean StartTransfer(gpointer data) {
   StartTransferArgs *args = reinterpret_cast<StartTransferArgs*>(data);
   args->http_fetcher->BeginTransfer(args->url);
   return FALSE;
 }
 }  // namespace {}
 
 TYPED_TEST(HttpFetcherTest, SimpleTest) {
-  GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
+  GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   {
     HttpFetcherTestDelegate delegate;
     delegate.loop_ = loop;
     scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher());
     fetcher->set_delegate(&delegate);
 
     typename TestFixture::HttpServer server;
     ASSERT_TRUE(server.started_);
 
     StartTransferArgs start_xfer_args = {fetcher.get(), this->SmallUrl()};
 
     g_timeout_add(0, StartTransfer, &start_xfer_args);
     g_main_loop_run(loop);
   }
   g_main_loop_unref(loop);
 }
 
 TYPED_TEST(HttpFetcherTest, SimpleBigTest) {
-  GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
+  GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   {
     HttpFetcherTestDelegate delegate;
     delegate.loop_ = loop;
     scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher());
     fetcher->set_delegate(&delegate);
 
     typename TestFixture::HttpServer server;
     ASSERT_TRUE(server.started_);
 
     StartTransferArgs start_xfer_args = {fetcher.get(), this->BigUrl()};
@@ skipping 32 matching lines @@
 gboolean UnpausingTimeoutCallback(gpointer data) {
   PausingHttpFetcherTestDelegate *delegate =
       reinterpret_cast<PausingHttpFetcherTestDelegate*>(data);
   if (delegate->paused_)
     delegate->Unpause();
   return TRUE;
 }
 }  // namespace {}
 
 TYPED_TEST(HttpFetcherTest, PauseTest) {
-  GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
+  GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   {
     PausingHttpFetcherTestDelegate delegate;
     scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher());
     delegate.paused_ = false;
     delegate.loop_ = loop;
     delegate.fetcher_ = fetcher.get();
     fetcher->set_delegate(&delegate);
 
     typename TestFixture::HttpServer server;
     ASSERT_TRUE(server.started_);
@@ skipping 39 matching lines @@
     delegate->TerminateTransfer();
     return TRUE;
   } else {
     delegate->EndLoop();
     return FALSE;
   }
 }
 }  // namespace {}
 
 TYPED_TEST(HttpFetcherTest, AbortTest) {
-  GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
+  GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   {
     AbortingHttpFetcherTestDelegate delegate;
     scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher());
     delegate.once_ = true;
     delegate.loop_ = loop;
     delegate.fetcher_ = fetcher.get();
     fetcher->set_delegate(&delegate);
 
     typename TestFixture::HttpServer server;
     this->IgnoreServerAborting(&server);
@@ skipping 22 matching lines @@
     g_main_loop_quit(loop_);
   }
   string data;
   GMainLoop* loop_;
 };
 }  // namespace {}
 
 TYPED_TEST(HttpFetcherTest, FlakyTest) {
   if (this->IsMock())
     return;
-  GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
+  GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   {
     FlakyHttpFetcherTestDelegate delegate;
     delegate.loop_ = loop;
     scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher());
     fetcher->set_delegate(&delegate);
 
     typename TestFixture::HttpServer server;
     ASSERT_TRUE(server.started_);
 
     StartTransferArgs start_xfer_args = {
       fetcher.get(),
       LocalServerUrlForPath("/flaky")
     };
 
     g_timeout_add(0, StartTransfer, &start_xfer_args);
     g_main_loop_run(loop);
 
     // verify the data we get back
     ASSERT_EQ(100000, delegate.data.size());
     for (int i = 0; i < 100000; i += 10) {
       // Assert so that we don't flood the screen w/ EXPECT errors on failure.
       ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij");
     }
   }
   g_main_loop_unref(loop);
 }
 
+namespace {
+class FailureHttpFetcherTestDelegate : public HttpFetcherDelegate {
+ public:
+  FailureHttpFetcherTestDelegate() : loop_(NULL), server_(NULL) {}
+  virtual void ReceivedBytes(HttpFetcher* fetcher,
+                             const char* bytes, int length) {
+    if (server_) {
+      LOG(INFO) << "Stopping server";
+      delete server_;
+      LOG(INFO) << "server stopped";
+      server_ = NULL;
+    }
+  }
+  virtual void TransferComplete(HttpFetcher* fetcher, bool successful) {
+    EXPECT_FALSE(successful);
+    g_main_loop_quit(loop_);
+  }
+  GMainLoop* loop_;
+  PythonHttpServer* server_;
+};
+}  // namespace {}
+
+
+TYPED_TEST(HttpFetcherTest, FailureTest) {
+  if (this->IsMock())
+    return;
+  GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
+  {
+    FailureHttpFetcherTestDelegate delegate;
+    delegate.loop_ = loop;
+    scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher());
+    fetcher->set_delegate(&delegate);
+
+    StartTransferArgs start_xfer_args = {
+      fetcher.get(),
+      LocalServerUrlForPath(this->SmallUrl())
+    };
+
+    g_timeout_add(0, StartTransfer, &start_xfer_args);
+    g_main_loop_run(loop);
+
+    // Exiting and testing happens in the delegate
+  }
+  g_main_loop_unref(loop);
+}
+
+TYPED_TEST(HttpFetcherTest, ServerDiesTest) {
+  if (this->IsMock())
+    return;
+  GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
+  {
+    FailureHttpFetcherTestDelegate delegate;
+    delegate.loop_ = loop;
+    delegate.server_ = new PythonHttpServer;
+    scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher());
+    fetcher->set_delegate(&delegate);
+
+    StartTransferArgs start_xfer_args = {
+      fetcher.get(),
+      LocalServerUrlForPath("/flaky")
+    };
+
+    g_timeout_add(0, StartTransfer, &start_xfer_args);
+    g_main_loop_run(loop);
+
+    // Exiting and testing happens in the delegate
+  }
+  g_main_loop_unref(loop);
+}
+
 }  // namespace chromeos_update_engine