Add support to update_engine to poke Omaha after an update has been applied

omaha_request_action_unittest.cc

 // 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"
@@ skipping 151 matching lines @@
   MockHttpFetcher* fetcher = new MockHttpFetcher(http_response.data(),
                                                  http_response.size(),
                                                  NULL);
   if (fail_http_response_code >= 0) {
     fetcher->FailTransfer(fail_http_response_code);
   }
   NiceMock<PrefsMock> local_prefs;
   OmahaRequestAction action(prefs ? prefs : &local_prefs,
                             params,
                             NULL,
-                            fetcher);
+                            fetcher,
+                            false);
   OmahaRequestActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   delegate.expected_code_ = expected_code;
 
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&action);
 
   OutputObjectCollectorAction collector_action;
   BondActions(&action, &collector_action);
@@ skipping 14 matching lines @@
 // 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(),
                                                  NULL);
   NiceMock<PrefsMock> prefs;
-  OmahaRequestAction action(&prefs, params, event, fetcher);
+  OmahaRequestAction action(&prefs, params, event, fetcher, false);
   OmahaRequestActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&action);
 
   g_timeout_add(0, &StartProcessorInRunLoop, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
   if (out_post_data)
@@ skipping 45 matching lines @@
 
 TEST(OmahaRequestActionTest, NoOutputPipeTest) {
   const string http_response(GetNoUpdateResponse(OmahaRequestParams::kAppId));
 
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   NiceMock<PrefsMock> prefs;
   OmahaRequestAction action(&prefs, kDefaultTestParams, NULL,
                             new MockHttpFetcher(http_response.data(),
                                                 http_response.size(),
-                                                NULL));
+                                                NULL),
+                            false);
   OmahaRequestActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&action);
 
   g_timeout_add(0, &StartProcessorInRunLoop, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
   EXPECT_FALSE(processor.IsRunning());
 }
 
 TEST(OmahaRequestActionTest, SkipTest) {
   const string http_response("invalid xml>");
 
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   NiceMock<PrefsMock> prefs;
   MockHttpFetcher* fetcher = new MockHttpFetcher(http_response.data(),
                                                  http_response.size(),
                                                  NULL);
   fetcher->set_never_use(true);
   OmahaRequestAction action(&prefs, kDefaultTestParams,
                             new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
-                            fetcher);  // Passes fetcher ownership
+                            fetcher,   // Passes fetcher ownership
+                            false);
   action.set_should_skip(true);
   OmahaRequestActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&action);
 
   g_timeout_add(0, &StartProcessorInRunLoop, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
@@ skipping 128 matching lines @@
 }  // namespace {}
 
 TEST(OmahaRequestActionTest, TerminateTransferTest) {
   string http_response("doesn't matter");
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   NiceMock<PrefsMock> prefs;
   OmahaRequestAction action(&prefs, kDefaultTestParams, NULL,
                             new MockHttpFetcher(http_response.data(),
                                                 http_response.size(),
-                                                NULL));
+                                                NULL),
+                            false);
   TerminateEarlyTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&action);
 
   g_timeout_add(0, &TerminateTransferTestStarter, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
 }
@@ skipping 95 matching lines @@
   EXPECT_CALL(prefs, SetString(kPrefsPreviousVersion, _)).Times(0);
   ASSERT_FALSE(TestUpdateCheck(&prefs,
                                kDefaultTestParams,
                                "invalid xml>",
                                -1,
                                kActionCodeOmahaRequestXMLParseError,
                                NULL,  // response
                                &post_data));
   // convert post_data to string
   string post_str(&post_data[0], post_data.size());
-  EXPECT_NE(post_str.find("        <o:ping a=\"-1\" r=\"-1\"></o:ping>\n"
-                          "        <o:updatecheck></o:updatecheck>\n"),
+  EXPECT_NE(post_str.find(
+                "        <o:ping active=\"1\" a=\"-1\" r=\"-1\"></o:ping>\n"
+                "        <o:updatecheck></o:updatecheck>\n"),
             string::npos);
   EXPECT_NE(post_str.find("hardware_class=\"OEM MODEL 09235 7471\""),
             string::npos);
   EXPECT_EQ(post_str.find("o:event"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, FormatUpdateCheckPrevVersionOutputTest) {
   vector<char> post_data;
   NiceMock<PrefsMock> prefs;
   EXPECT_CALL(prefs, GetString(kPrefsPreviousVersion, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(string("1.2>3.4")), Return(true)));
   EXPECT_CALL(prefs, SetString(kPrefsPreviousVersion, ""))
       .WillOnce(Return(true));
   ASSERT_FALSE(TestUpdateCheck(&prefs,
                                kDefaultTestParams,
                                "invalid xml>",
                                -1,
                                kActionCodeOmahaRequestXMLParseError,
                                NULL,  // response
                                &post_data));
   // convert post_data to string
   string post_str(&post_data[0], post_data.size());
-  EXPECT_NE(post_str.find("        <o:ping a=\"-1\" r=\"-1\"></o:ping>\n"
-                          "        <o:updatecheck></o:updatecheck>\n"),
+  EXPECT_NE(post_str.find(
+                "        <o:ping active=\"1\" a=\"-1\" r=\"-1\"></o:ping>\n"
+                "        <o:updatecheck></o:updatecheck>\n"),
             string::npos);
   EXPECT_NE(post_str.find("hardware_class=\"OEM MODEL 09235 7471\""),
             string::npos);
   string prev_version_event = StringPrintf(
       "        <o:event eventtype=\"%d\" eventresult=\"%d\" "
       "previousversion=\"1.2&gt;3.4\"></o:event>\n",
       OmahaEvent::kTypeUpdateComplete,
       OmahaEvent::kResultSuccessReboot);
   EXPECT_NE(post_str.find(prev_version_event), string::npos);
 }
@@ skipping 37 matching lines @@
 
 TEST(OmahaRequestActionTest, IsEventTest) {
   string http_response("doesn't matter");
   NiceMock<PrefsMock> prefs;
   OmahaRequestAction update_check_action(
       &prefs,
       kDefaultTestParams,
       NULL,
       new MockHttpFetcher(http_response.data(),
                           http_response.size(),
-                          NULL));
+                          NULL),
+      false);
   EXPECT_FALSE(update_check_action.IsEvent());
 
   OmahaRequestAction event_action(
       &prefs,
       kDefaultTestParams,
       new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
       new MockHttpFetcher(http_response.data(),
                           http_response.size(),
-                          NULL));
+                          NULL),
+      false);
   EXPECT_TRUE(event_action.IsEvent());
 }
 
 TEST(OmahaRequestActionTest, FormatDeltaOkayOutputTest) {
   for (int i = 0; i < 2; i++) {
     bool delta_okay = i == 1;
     const char* delta_okay_str = delta_okay ? "true" : "false";
     vector<char> post_data;
     OmahaRequestParams params(OmahaRequestParams::kOsPlatform,
                               OmahaRequestParams::kOsVersion,
@@ skipping 54 matching lines @@
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
                       -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
-  EXPECT_NE(post_str.find("<o:ping a=\"6\" r=\"5\"></o:ping>"), string::npos);
+  EXPECT_NE(post_str.find("<o:ping active=\"1\" a=\"6\" r=\"5\"></o:ping>"),
+            string::npos);
 }
 
 TEST(OmahaRequestActionTest, ActivePingTest) {
   NiceMock<PrefsMock> prefs;
   int64_t three_days_ago =
       (Time::Now() - TimeDelta::FromHours(3 * 24 + 12)).ToInternalValue();
   int64_t now = Time::Now().ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(three_days_ago), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
                       -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
-  EXPECT_NE(post_str.find("<o:ping a=\"3\"></o:ping>"), string::npos);
+  EXPECT_NE(post_str.find("<o:ping active=\"1\" a=\"3\"></o:ping>"),
+            string::npos);
 }
 
 TEST(OmahaRequestActionTest, RollCallPingTest) {
   NiceMock<PrefsMock> prefs;
   int64_t four_days_ago =
       (Time::Now() - TimeDelta::FromHours(4 * 24)).ToInternalValue();
   int64_t now = Time::Now().ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(four_days_ago), Return(true)));
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
                       -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
-  EXPECT_NE(post_str.find("<o:ping r=\"4\"></o:ping>\n"), string::npos);
+  EXPECT_NE(post_str.find("<o:ping active=\"1\" r=\"4\"></o:ping>\n"),
+            string::npos);
 }
 
 TEST(OmahaRequestActionTest, NoPingTest) {
   NiceMock<PrefsMock> prefs;
   int64_t one_hour_ago =
       (Time::Now() - TimeDelta::FromHours(1)).ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(one_hour_ago), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(one_hour_ago), Return(true)));
@@ skipping 144 matching lines @@
                       "",
                       1500,
                       static_cast<ActionExitCode>(
                           kActionCodeOmahaRequestHTTPResponseBase + 999),
                       &response,
                       NULL));
   EXPECT_FALSE(response.update_exists);
 }
 
 }  // namespace chromeos_update_engine