AU: Update status to DOWNLOADING only after receiving some bytes from server.

download_action_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 <string>
 #include <vector>
 #include <glib.h>
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include "update_engine/action_pipe.h"
 #include "update_engine/download_action.h"
 #include "update_engine/mock_http_fetcher.h"
 #include "update_engine/omaha_hash_calculator.h"
 #include "update_engine/test_utils.h"
 #include "update_engine/utils.h"
 
 namespace chromeos_update_engine {
 
 using std::string;
 using std::vector;
+using testing::_;
+using testing::AtLeast;
+using testing::InSequence;
 
 class DownloadActionTest : public ::testing::Test { };
 
 namespace {
+class DownloadActionDelegateMock : public DownloadActionDelegate {
+ public:
+  MOCK_METHOD1(SetDownloadStatus, void(bool active));
+  MOCK_METHOD2(BytesReceived, void(uint64_t bytes_received, uint64_t total));
+};
+
 class DownloadActionTestProcessorDelegate : public ActionProcessorDelegate {
  public:
   explicit DownloadActionTestProcessorDelegate(ActionExitCode expected_code)
       : loop_(NULL),
         processing_done_called_(false),
         expected_code_(expected_code) {}
   virtual ~DownloadActionTestProcessorDelegate() {
     EXPECT_TRUE(processing_done_called_);
   }
   virtual void ProcessingDone(const ActionProcessor* processor,
@@ skipping 32 matching lines @@
   GMainLoop *loop;
   ActionProcessor *processor;
 };
 
 gboolean StartProcessorInRunLoop(gpointer data) {
   ActionProcessor *processor = reinterpret_cast<ActionProcessor*>(data);
   processor->StartProcessing();
   return FALSE;
 }
 
-void TestWithData(const vector<char>& data, bool hash_test) {
+void TestWithData(const vector<char>& data,
+                  bool hash_test,
+                  bool use_download_delegate) {
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   // TODO(adlr): see if we need a different file for build bots
   ScopedTempFile output_temp_file;
   DirectFileWriter writer;
 
   // takes ownership of passed in HttpFetcher
   string hash = hash_test ?
       OmahaHashCalculator::OmahaHashOfString("random string") :
       OmahaHashCalculator::OmahaHashOfData(data);
   InstallPlan install_plan(true,
                            "",
                            0,
                            hash,
                            output_temp_file.GetPath(),
                            "");
   ObjectFeederAction<InstallPlan> feeder_action;
   feeder_action.set_obj(install_plan);
   DownloadAction download_action(new MockHttpFetcher(&data[0],
                                                      data.size()));
   download_action.SetTestFileWriter(&writer);
   BondActions(&feeder_action, &download_action);
-
+  DownloadActionDelegateMock download_delegate;
+  if (use_download_delegate) {
+    InSequence s;
+    download_action.set_delegate(&download_delegate);
+    EXPECT_CALL(download_delegate, SetDownloadStatus(true)).Times(1);
+    EXPECT_CALL(download_delegate, BytesReceived(_, _)).Times(AtLeast(1));
+    EXPECT_CALL(download_delegate, SetDownloadStatus(false)).Times(1);
+  }
   DownloadActionTestProcessorDelegate delegate(
       hash_test ? kActionCodeDownloadHashMismatchError : kActionCodeSuccess);
   delegate.loop_ = loop;
   delegate.expected_data_ = data;
   delegate.path_ = output_temp_file.GetPath();
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&download_action);
 
   g_timeout_add(0, &StartProcessorInRunLoop, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
 }
 }  // namespace {}
 
 TEST(DownloadActionTest, SimpleTest) {
   vector<char> small;
   const char* foo = "foo";
   small.insert(small.end(), foo, foo + strlen(foo));
-  TestWithData(small, false);
+  TestWithData(small, false, true);
 }
 
 TEST(DownloadActionTest, LargeTest) {
   vector<char> big(5 * kMockHttpFetcherChunkSize);
   char c = '0';
   for (unsigned int i = 0; i < big.size(); i++) {
     big[i] = c;
     if ('9' == c)
       c = '0';
     else
       c++;
   }
-  TestWithData(big, false);
+  TestWithData(big, false, true);
 }
 
 TEST(DownloadActionTest, BadHashTest) {
   vector<char> small;
   const char* foo = "foo";
   small.insert(small.end(), foo, foo + strlen(foo));
-  TestWithData(small, true);
+  TestWithData(small, true, true);
+}
+
+TEST(DownloadActionTest, NoDownloadDelegateTest) {
+  vector<char> small;
+  const char* foo = "foofoo";
+  small.insert(small.end(), foo, foo + strlen(foo));
+  TestWithData(small, false, false);
 }
 
 namespace {
 class TerminateEarlyTestProcessorDelegate : public ActionProcessorDelegate {
  public:
   void ProcessingStopped(const ActionProcessor* processor) {
     ASSERT_TRUE(loop_);
     g_main_loop_quit(loop_);
   }
   GMainLoop *loop_;
 };
 
 gboolean TerminateEarlyTestStarter(gpointer data) {
   ActionProcessor *processor = reinterpret_cast<ActionProcessor*>(data);
   processor->StartProcessing();
   CHECK(processor->IsRunning());
   processor->StopProcessing();
   return FALSE;
 }
 
-}  // namespace {}
-
-TEST(DownloadActionTest, TerminateEarlyTest) {
+void TestTerminateEarly(bool use_download_delegate) {
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   vector<char> data(kMockHttpFetcherChunkSize + kMockHttpFetcherChunkSize / 2);
   memset(&data[0], 0, data.size());
 
   ScopedTempFile temp_file;
   {
     DirectFileWriter writer;
 
     // takes ownership of passed in HttpFetcher
     ObjectFeederAction<InstallPlan> feeder_action;
     InstallPlan install_plan(true, "", 0, "", temp_file.GetPath(), "");
     feeder_action.set_obj(install_plan);
     DownloadAction download_action(new MockHttpFetcher(&data[0], data.size()));
     download_action.SetTestFileWriter(&writer);
+    DownloadActionDelegateMock download_delegate;
+    if (use_download_delegate) {
+      InSequence s;
+      download_action.set_delegate(&download_delegate);
+      EXPECT_CALL(download_delegate, SetDownloadStatus(true)).Times(1);
+      EXPECT_CALL(download_delegate, SetDownloadStatus(false)).Times(1);
+    }
     TerminateEarlyTestProcessorDelegate delegate;
     delegate.loop_ = loop;
     ActionProcessor processor;
     processor.set_delegate(&delegate);
     processor.EnqueueAction(&feeder_action);
     processor.EnqueueAction(&download_action);
     BondActions(&feeder_action, &download_action);
 
     g_timeout_add(0, &TerminateEarlyTestStarter, &processor);
     g_main_loop_run(loop);
     g_main_loop_unref(loop);
   }
 
   // 1 or 0 chunks should have come through
   const off_t resulting_file_size(utils::FileSize(temp_file.GetPath()));
   EXPECT_GE(resulting_file_size, 0);
   if (resulting_file_size != 0)
     EXPECT_EQ(kMockHttpFetcherChunkSize, resulting_file_size);
 }
 
+}  // namespace {}
+
+TEST(DownloadActionTest, TerminateEarlyTest) {
+  TestTerminateEarly(true);
+}
+
+TEST(DownloadActionTest, TerminateEarlyNoDownloadDelegateTest) {
+  TestTerminateEarly(false);
+}
+
 class DownloadActionTestAction;
 
 template<>
 class ActionTraits<DownloadActionTestAction> {
  public:
   typedef InstallPlan OutputObjectType;
   typedef InstallPlan InputObjectType;
 };
 
 // This is a simple Action class for testing.
@@ skipping 91 matching lines @@
   ActionProcessor processor;
   processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&download_action);
   processor.StartProcessing();
   ASSERT_FALSE(processor.IsRunning());
 
   g_main_loop_unref(loop);
 }
 
 }  // namespace chromeos_update_engine