AU: Verify that the actual download size matches the size reported by Omaha.

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"
@@ skipping 67 matching lines @@
 };
 
 gboolean StartProcessorInRunLoop(gpointer data) {
   ActionProcessor *processor = reinterpret_cast<ActionProcessor*>(data);
   processor->StartProcessing();
   return FALSE;
 }
 
 void TestWithData(const vector<char>& data,
                   bool hash_test,
+                  bool size_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);
+  uint64_t size = data.size() + (size_test ? 1 : 0);
   InstallPlan install_plan(true,
                            "",
-                           0,
+                           size,
                            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);
+  ActionExitCode expected_code = kActionCodeSuccess;
+  if (hash_test)
+    expected_code = kActionCodeDownloadHashMismatchError;
+  else if (size_test)
+    expected_code = kActionCodeDownloadSizeMismatchError;
+  DownloadActionTestProcessorDelegate delegate(expected_code);
   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, true);
+  TestWithData(small,
+               false,  // hash_test
+               false,  // size_test
+               true);  // use_download_delegate
 }
 
 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, true);
+  TestWithData(big,
+               false,  // hash_test
+               false,  // size_test
+               true);  // use_download_delegate
 }
 
 TEST(DownloadActionTest, BadHashTest) {
   vector<char> small;
   const char* foo = "foo";
   small.insert(small.end(), foo, foo + strlen(foo));
-  TestWithData(small, true, true);
+  TestWithData(small,
+               true,  // hash_test
+               false,  // size_test
+               true);  // use_download_delegate
+}
+
+TEST(DownloadActionTest, BadSizeTest) {
+  const char* something = "something";
+  vector<char> small(something, something + strlen(something));
+  TestWithData(small,
+               false,  // hash_test
+               true,  // size_test
+               true);  // use_download_delegate
 }
 
 TEST(DownloadActionTest, NoDownloadDelegateTest) {
   vector<char> small;
   const char* foo = "foofoo";
   small.insert(small.end(), foo, foo + strlen(foo));
-  TestWithData(small, false, false);
+  TestWithData(small,
+               false,  // hash_test
+               false,  // size_test
+               false);  // use_download_delegate
 }
 
 namespace {
 class TerminateEarlyTestProcessorDelegate : public ActionProcessorDelegate {
  public:
   void ProcessingStopped(const ActionProcessor* processor) {
     ASSERT_TRUE(loop_);
     g_main_loop_quit(loop_);
   }
   GMainLoop *loop_;
@@ skipping 110 matching lines @@
 }
 
 TEST(DownloadActionTest, PassObjectOutTest) {
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   DirectFileWriter writer;
 
   // takes ownership of passed in HttpFetcher
   InstallPlan install_plan(true,
                            "",
-                           0,
+                           1,
                            OmahaHashCalculator::OmahaHashOfString("x"),
                            "/dev/null",
                            "/dev/null");
   ObjectFeederAction<InstallPlan> feeder_action;
   feeder_action.set_obj(install_plan);
   DownloadAction download_action(new MockHttpFetcher("x", 1));
   download_action.SetTestFileWriter(&writer);
 
   DownloadActionTestAction test_action;
   test_action.expected_input_object_ = install_plan;
@@ skipping 33 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