AU: Beginnings of delta support

src/platform/update_engine/update_check_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 <gtest/gtest.h>
 #include "update_engine/action_pipe.h"
 #include "update_engine/update_check_action.h"
 #include "update_engine/mock_http_fetcher.h"
 #include "update_engine/omaha_hash_calculator.h"
 #include "update_engine/test_utils.h"
 
+using std::string;
+using std::vector;
+
 namespace chromeos_update_engine {
 
-using std::string;
-
 class UpdateCheckActionTest : public ::testing::Test { };
 
 namespace {
 string GetNoUpdateResponse(const string& app_id) {
   return string(
       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
       "xmlns=\"http://www.google.com/update2/response\" protocol=\"2.0\"><app "
       "appid=\"") + app_id + "\" status=\"ok\"><ping "
       "status=\"ok\"/><updatecheck status=\"noupdate\"/></app></gupdate>";
 }
 
 string GetUpdateResponse(const string& app_id,
                          const string& display_version,
                          const string& more_info_url,
                          const string& prompt,
                          const string& codebase,
                          const string& hash,
                          const string& needsadmin,
                          const string& size) {
   return string("<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
-      "xmlns=\"http://www.google.com/update2/response\" protocol=\"2.0\"><app "
-      "appid=\"") + app_id + "\" status=\"ok\"><ping "
+                "xmlns=\"http://www.google.com/update2/response\" "
+                "protocol=\"2.0\"><app "
+                "appid=\"") + app_id + "\" status=\"ok\"><ping "
       "status=\"ok\"/><updatecheck DisplayVersion=\"" + display_version + "\" "
       "MoreInfo=\"" + more_info_url + "\" Prompt=\"" + prompt + "\" "
       "codebase=\"" + codebase + "\" "
       "hash=\"" + hash + "\" needsadmin=\"" + needsadmin + "\" "
       "size=\"" + size + "\" status=\"ok\"/></app></gupdate>";
 }
 
 class UpdateCheckActionTestProcessorDelegate : public ActionProcessorDelegate {
  public:
   UpdateCheckActionTestProcessorDelegate()
       : loop_(NULL),
         expected_success_(true) {}
   virtual ~UpdateCheckActionTestProcessorDelegate() {
   }
   virtual void ProcessingDone(const ActionProcessor* processor) {
     ASSERT_TRUE(loop_);
     g_main_loop_quit(loop_);
   }
 
-  virtual void ActionCompleted(const ActionProcessor* processor,
-                               const AbstractAction* action,
+  virtual void ActionCompleted(ActionProcessor* processor,
+                               AbstractAction* action,
                                bool success) {
     // make sure actions always succeed
-    if (action->Type() == "UpdateCheckAction")
+    if (action->Type() == UpdateCheckAction::StaticType())
       EXPECT_EQ(expected_success_, success);
     else
       EXPECT_TRUE(success);
   }
   GMainLoop *loop_;
   bool expected_success_;
 };
 
 gboolean StartProcessorInRunLoop(gpointer data) {
   ActionProcessor *processor = reinterpret_cast<ActionProcessor*>(data);
@@ skipping 21 matching lines @@
     has_input_object_ = HasInputObject();
     if (has_input_object_)
       update_check_response_ = GetInputObject();
     processor_->ActionComplete(this, true);
   }
   // Should never be called
   void TerminateProcessing() {
     CHECK(false);
   }
   // Debugging/logging
-  std::string Type() const { return "OutputObjectCollectorAction"; }
+  static std::string StaticType() {
+    return "OutputObjectCollectorAction";
+  }
+  std::string Type() const { return StaticType(); }
   bool has_input_object_;
   UpdateCheckResponse update_check_response_;
 };
 
 // returns true iff an output response was obtained from the
 // UpdateCheckAction. out_response may be NULL.
 // out_post_data may be null; if non-null, the post-data received by the
 // mock HttpFetcher is returned.
 bool TestUpdateCheckAction(const UpdateCheckParams& params,
                            const string& http_response,
                            bool expected_success,
                            UpdateCheckResponse* out_response,
                            vector<char> *out_post_data) {
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
   MockHttpFetcher *fetcher = new MockHttpFetcher(http_response.data(),
                                                  http_response.size());
-
-  UpdateCheckAction action(params, fetcher);  // takes ownership of fetcher
+  ObjectFeederAction<UpdateCheckParams> feeder_action;
+  UpdateCheckAction action(fetcher);  // takes ownership of fetcher
   UpdateCheckActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   delegate.expected_success_ = expected_success;
   ActionProcessor processor;
+  feeder_action.set_obj(params);
   processor.set_delegate(&delegate);
+  processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&action);
 
   OutputObjectCollectorAction collector_action;
 
+  BondActions(&feeder_action, &action);
   BondActions(&action, &collector_action);
   processor.EnqueueAction(&collector_action);
 
   g_timeout_add(0, &StartProcessorInRunLoop, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
   if (collector_action.has_input_object_ && out_response)
     *out_response = collector_action.update_check_response_;
   if (out_post_data)
     *out_post_data = fetcher->post_data();
@@ skipping 61 matching lines @@
                            UpdateCheckParams::kOsVersion,
                            "",  // os_sp
                            UpdateCheckParams::kAppId,
                            "0.1.0.0",
                            "en-US",
                            "unittest");
   const string http_response(GetNoUpdateResponse(UpdateCheckParams::kAppId));
 
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
-  UpdateCheckAction action(params,
-                           new MockHttpFetcher(http_response.data(),
+  ObjectFeederAction<UpdateCheckParams> feeder_action;
+  feeder_action.set_obj(params);
+  UpdateCheckAction action(new MockHttpFetcher(http_response.data(),
                                                http_response.size()));
   UpdateCheckActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
   processor.set_delegate(&delegate);
+  processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&action);
+  BondActions(&feeder_action, &action);
 
   g_timeout_add(0, &StartProcessorInRunLoop, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
   EXPECT_FALSE(processor.IsRunning());
 }
 
 TEST(UpdateCheckActionTest, InvalidXmlTest) {
   UpdateCheckParams params("machine_id",
                            "user_id",
@@ skipping 88 matching lines @@
                            "user_id",
                            UpdateCheckParams::kOsPlatform,
                            UpdateCheckParams::kOsVersion,
                            "service_pack",
                            UpdateCheckParams::kAppId,
                            "0.1.0.0",
                            "en-US",
                            "unittest_track");
   UpdateCheckResponse response;
   ASSERT_TRUE(TestUpdateCheckAction(params,
-      string("<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
-          "xmlns=\"http://www.google.com/update2/response\" "
-          "protocol=\"2.0\"><app  appid=\"") +
-          UpdateCheckParams::kAppId + "\" status=\"ok\"><ping "
-          "status=\"ok\"/><updatecheck DisplayVersion=\"1.2.3.4\" "
-          "Prompt=\"false\" "
-          "codebase=\"http://code/base\" "
-          "hash=\"HASH1234=\" needsadmin=\"true\" "
-          "size=\"123\" status=\"ok\"/></app></gupdate>",
-      true,
-      &response,
-      NULL));
+                                    string("<?xml version=\"1.0\" "
+                                           "encoding=\"UTF-8\"?><gupdate "
+                                           "xmlns=\"http://www.google.com/"
+                                           "update2/response\" "
+                                           "protocol=\"2.0\"><app  appid=\"") +
+                                    UpdateCheckParams::kAppId
+                                    + "\" status=\"ok\"><ping "
+                                    "status=\"ok\"/><updatecheck "
+                                    "DisplayVersion=\"1.2.3.4\" "
+                                    "Prompt=\"false\" "
+                                    "codebase=\"http://code/base\" "
+                                    "hash=\"HASH1234=\" needsadmin=\"true\" "
+                                    "size=\"123\" "
+                                    "status=\"ok\"/></app></gupdate>",
+                                    true,
+                                    &response,
+                                    NULL));
   EXPECT_TRUE(response.update_exists);
   EXPECT_EQ("1.2.3.4", response.display_version);
   EXPECT_EQ("http://code/base", response.codebase);
   EXPECT_EQ("", response.more_info_url);
   EXPECT_EQ("HASH1234=", response.hash);
   EXPECT_EQ(123, response.size);
   EXPECT_TRUE(response.needs_admin);
   EXPECT_FALSE(response.prompt);
 }
 
@@ skipping 22 matching lines @@
                            UpdateCheckParams::kOsPlatform,
                            UpdateCheckParams::kOsVersion,
                            "",  // os_sp
                            UpdateCheckParams::kAppId,
                            "0.1.0.0",
                            "en-US",
                            "unittest");
   string http_response("doesn't matter");
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
-  UpdateCheckAction action(params,
-                           new MockHttpFetcher(http_response.data(),
+  ObjectFeederAction<UpdateCheckParams> feeder_action;
+  feeder_action.set_obj(params);
+  UpdateCheckAction action(new MockHttpFetcher(http_response.data(),
                                                http_response.size()));
   TerminateEarlyTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
   processor.set_delegate(&delegate);
+  processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&action);
+  BondActions(&feeder_action, &action);
 
   g_timeout_add(0, &TerminateTransferTestStarter, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
 }
 
 TEST(UpdateCheckActionTest, XmlEncodeTest) {
   EXPECT_EQ("ab", XmlEncode("ab"));
   EXPECT_EQ("a&lt;b", XmlEncode("a<b"));
   EXPECT_EQ("foo-&#x3A9;", XmlEncode("foo-\xce\xa9"));
@@ skipping 81 matching lines @@
                                               // overflows int32:
                                               "123123123123123"),  // size
                             true,
                             &response,
                             NULL));
 
   EXPECT_EQ(response.size, 123123123123123ll);
 }
 
 }  // namespace chromeos_update_engine