Turn OmahaRequestPrepAction into OmahaRequestDeviceParams.

omaha_request_action_unittest.cc

-// Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
+// Copyright (c) 2010 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 "base/string_util.h"
 #include "gtest/gtest.h"
 #include "update_engine/action_pipe.h"
 #include "update_engine/mock_http_fetcher.h"
 #include "update_engine/omaha_hash_calculator.h"
 #include "update_engine/omaha_request_action.h"
+#include "update_engine/omaha_request_params.h"
 #include "update_engine/test_utils.h"
 
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 class OmahaRequestActionTest : public ::testing::Test { };
 
 namespace {
@@ skipping 96 matching lines @@
 // out_post_data may be null; if non-null, the post-data received by the
 // mock HttpFetcher is returned.
 bool TestUpdateCheck(const OmahaRequestParams& params,
                      const string& http_response,
                      bool expected_success,
                      OmahaResponse* 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());
-  ObjectFeederAction<OmahaRequestParams> feeder_action;
-  OmahaRequestAction action(NULL, fetcher);  // takes ownership of fetcher
+  OmahaRequestAction action(params, NULL, fetcher);
   OmahaRequestActionTestProcessorDelegate 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.omaha_response_;
   if (out_post_data)
     *out_post_data = fetcher->post_data();
   return collector_action.has_input_object_;
 }
 
 // Tests Event requests -- they should always succeed. |out_post_data|
 // may be null; if non-null, the post-data received by the mock
 // HttpFetcher is returned.
 void TestEvent(const OmahaRequestParams& params,
                OmahaEvent* event,
                const string& http_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());
-  ObjectFeederAction<OmahaRequestParams> feeder_action;
-  OmahaRequestAction action(event, fetcher);  // takes ownership of fetcher
+  OmahaRequestAction action(params, event, fetcher);
   OmahaRequestActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
-  feeder_action.set_obj(params);
   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);
   if (out_post_data)
     *out_post_data = fetcher->post_data();
 }
 
 TEST(OmahaRequestActionTest, NoUpdateTest) {
   OmahaRequestParams params("",  // machine_id
                             "",  // user_id
@@ skipping 61 matching lines @@
                             "",  // os_board
                             OmahaRequestParams::kAppId,
                             "0.1.0.0",
                             "en-US",
                             "unittest",
                             "");  // url
   const string http_response(GetNoUpdateResponse(OmahaRequestParams::kAppId));
 
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
-  ObjectFeederAction<OmahaRequestParams> feeder_action;
-  feeder_action.set_obj(params);
-  OmahaRequestAction action(NULL,
+  OmahaRequestAction action(params, NULL,
                             new MockHttpFetcher(http_response.data(),
                                                 http_response.size()));
   OmahaRequestActionTestProcessorDelegate 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(OmahaRequestActionTest, InvalidXmlTest) {
   OmahaRequestParams params("machine_id",
                             "user_id",
@@ skipping 159 matching lines @@
                             "",  // os_sp
                             "",  // os_board
                             OmahaRequestParams::kAppId,
                             "0.1.0.0",
                             "en-US",
                             "unittest",
                             "http://url");
   string http_response("doesn't matter");
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
-  ObjectFeederAction<OmahaRequestParams> feeder_action;
-  feeder_action.set_obj(params);
-  OmahaRequestAction action(NULL,
+  OmahaRequestAction action(params, NULL,
                             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(OmahaRequestActionTest, XmlEncodeTest) {
   EXPECT_EQ("ab", XmlEncode("ab"));
   EXPECT_EQ("a&lt;b", XmlEncode("a<b"));
   EXPECT_EQ("foo-&#x3A9;", XmlEncode("foo-\xce\xa9"));
@@ skipping 147 matching lines @@
       "errorcode=\"%d\"></o:event>\n",
       OmahaEvent::kTypeDownloadComplete,
       OmahaEvent::kResultError,
       5);
   EXPECT_NE(post_str.find(expected_event), string::npos);
   EXPECT_EQ(post_str.find("o:updatecheck"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, IsEventTest) {
   string http_response("doesn't matter");
+  OmahaRequestParams params("machine_id",
+                            "user_id",
+                            OmahaRequestParams::kOsPlatform,
+                            OmahaRequestParams::kOsVersion,
+                            "service_pack",
+                            "x86-generic",
+                            OmahaRequestParams::kAppId,
+                            "0.1.0.0",
+                            "en-US",
+                            "unittest_track",
+                            "http://url");
 
   OmahaRequestAction update_check_action(
+      params,
       NULL,
       new MockHttpFetcher(http_response.data(),
                           http_response.size()));
   EXPECT_FALSE(update_check_action.IsEvent());
 
   OmahaRequestAction event_action(
+      params,
       new OmahaEvent(OmahaEvent::kTypeInstallComplete,
                      OmahaEvent::kResultError,
                      0),
       new MockHttpFetcher(http_response.data(),
                           http_response.size()));
   EXPECT_TRUE(event_action.IsEvent());
 }
 
 }  // namespace chromeos_update_engine