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

update_attempter_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 <base/file_util.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/action_mock.h"
 #include "update_engine/action_processor_mock.h"
 #include "update_engine/filesystem_copier_action.h"
@@ skipping 46 matching lines @@
     EXPECT_FALSE(attempter_.is_full_update_);
     processor_ = new ActionProcessorMock();
     attempter_.processor_.reset(processor_);  // Transfers ownership.
     attempter_.prefs_ = &prefs_;
   }
 
   void UpdateTestStart();
   void UpdateTestVerify();
   static gboolean StaticUpdateTestStart(gpointer data);
   static gboolean StaticUpdateTestVerify(gpointer data);
+  void PingOmahaTestStart();
+  void PingOmahaTestDone();
+  static gboolean StaticPingOmahaTestStart(gpointer data);
+  static gboolean StaticPingOmahaTestDone(gpointer data);
 
   MockDbusGlib dbus_;
   UpdateAttempterUnderTest attempter_;
   ActionProcessorMock* processor_;
   NiceMock<PrefsMock> prefs_;
   GMainLoop* loop_;
 };
 
 TEST_F(UpdateAttempterTest, ActionCompletedDownloadTest) {
   scoped_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, NULL));
@@ skipping 13 matching lines @@
   EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
       .WillOnce(Return(false));
   attempter_.ActionCompleted(NULL, &action, kActionCodeError);
   ASSERT_TRUE(attempter_.error_event_.get() != NULL);
 }
 
 TEST_F(UpdateAttempterTest, ActionCompletedOmahaRequestTest) {
   scoped_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, NULL));
   fetcher->FailTransfer(500);  // Sets the HTTP response code.
   OmahaRequestParams params;
-  OmahaRequestAction action(&prefs_, params, NULL, fetcher.release());
+  OmahaRequestAction action(&prefs_, params, NULL, fetcher.release(), false);
   ObjectCollectorAction<OmahaResponse> collector_action;
   BondActions(&action, &collector_action);
   OmahaResponse response;
   response.poll_interval = 234;
   action.SetOutputObject(response);
   UpdateCheckScheduler scheduler(&attempter_);
   attempter_.set_update_check_scheduler(&scheduler);
   EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)).Times(0);
   attempter_.ActionCompleted(NULL, &action, kActionCodeSuccess);
   EXPECT_EQ(500, attempter_.http_response_code());
@@ skipping 12 matching lines @@
   EXPECT_TRUE(file_util::Delete(kMarker, false));
 }
 
 TEST_F(UpdateAttempterTest, GetErrorCodeForActionTest) {
   extern ActionExitCode GetErrorCodeForAction(AbstractAction* action,
                                               ActionExitCode code);
   EXPECT_EQ(kActionCodeSuccess,
             GetErrorCodeForAction(NULL, kActionCodeSuccess));
 
   OmahaRequestParams params;
-  OmahaRequestAction omaha_request_action(NULL, params, NULL, NULL);
+  OmahaRequestAction omaha_request_action(NULL, params, NULL, NULL, false);
   EXPECT_EQ(kActionCodeOmahaRequestError,
             GetErrorCodeForAction(&omaha_request_action, kActionCodeError));
   OmahaResponseHandlerAction omaha_response_handler_action(&prefs_);
   EXPECT_EQ(kActionCodeOmahaResponseHandlerError,
             GetErrorCodeForAction(&omaha_response_handler_action,
                                   kActionCodeError));
   FilesystemCopierAction filesystem_copier_action(false, false);
   EXPECT_EQ(kActionCodeFilesystemCopierError,
             GetErrorCodeForAction(&filesystem_copier_action, kActionCodeError));
   PostinstallRunnerAction postinstall_runner_action;
@@ skipping 92 matching lines @@
 gboolean UpdateAttempterTest::StaticUpdateTestStart(gpointer data) {
   reinterpret_cast<UpdateAttempterTest*>(data)->UpdateTestStart();
   return FALSE;
 }
 
 gboolean UpdateAttempterTest::StaticUpdateTestVerify(gpointer data) {
   reinterpret_cast<UpdateAttempterTest*>(data)->UpdateTestVerify();
   return FALSE;
 }
 
+gboolean UpdateAttempterTest::StaticPingOmahaTestStart(gpointer data) {
+  reinterpret_cast<UpdateAttempterTest*>(data)->PingOmahaTestStart();
+  return FALSE;
+}
+
+gboolean UpdateAttempterTest::StaticPingOmahaTestDone(gpointer data) {
+  reinterpret_cast<UpdateAttempterTest*>(data)->PingOmahaTestDone();
+  return FALSE;
+}
+
 namespace {
 const string kActionTypes[] = {
   OmahaRequestAction::StaticType(),
   OmahaResponseHandlerAction::StaticType(),
   FilesystemCopierAction::StaticType(),
   FilesystemCopierAction::StaticType(),
   OmahaRequestAction::StaticType(),
   DownloadAction::StaticType(),
   OmahaRequestAction::StaticType(),
   OmahaRequestAction::StaticType(),
@@ skipping 36 matching lines @@
 }
 
 TEST_F(UpdateAttempterTest, UpdateTest) {
   loop_ = g_main_loop_new(g_main_context_default(), FALSE);
   g_idle_add(&StaticUpdateTestStart, this);
   g_main_loop_run(loop_);
   g_main_loop_unref(loop_);
   loop_ = NULL;
 }
 
+void UpdateAttempterTest::PingOmahaTestStart() {
+  EXPECT_CALL(*processor_,
+              EnqueueAction(Property(&AbstractAction::Type,
+                                     OmahaRequestAction::StaticType())))
+      .Times(1);
+  EXPECT_CALL(*processor_, StartProcessing()).Times(1);
+  attempter_.PingOmaha();
+  g_idle_add(&StaticPingOmahaTestDone, this);
+}
+
+void UpdateAttempterTest::PingOmahaTestDone() {
+  g_main_loop_quit(loop_);

[adlr, 2011/04/18 18:05:28]

this still may run before the action completes. Can you get notified by the
action processor that processing has completed to exit the main loop?

[thieule, 2011/04/18 21:40:15]

It looks like the processor is a mock so it doesn't really run the action.

+}
+
+TEST_F(UpdateAttempterTest, PingOmahaTest) {
+  UpdateCheckScheduler scheduler(&attempter_);
+  scheduler.enabled_ = true;
+  EXPECT_EQ(false, scheduler.scheduled_);
+  attempter_.set_update_check_scheduler(&scheduler);
+  loop_ = g_main_loop_new(g_main_context_default(), FALSE);
+  g_idle_add(&StaticPingOmahaTestStart, this);
+  g_main_loop_run(loop_);
+  g_main_loop_unref(loop_);
+  loop_ = NULL;
+  EXPECT_EQ(UPDATE_STATUS_UPDATED_NEED_REBOOT, attempter_.status());
+  EXPECT_EQ(true, scheduler.scheduled_);
+}
+
 }  // namespace chromeos_update_engine