Start action processing asynchronously in UpdateAttempter.

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 21 matching lines @@
 // methods within the class. There're explicit unit tests for the mocked out
 // methods.
 class UpdateAttempterUnderTest : public UpdateAttempter {
  public:
   explicit UpdateAttempterUnderTest(MockDbusGlib* dbus)
       : UpdateAttempter(NULL, NULL, dbus) {}
 };
 
 class UpdateAttempterTest : public ::testing::Test {
  protected:
-  UpdateAttempterTest() : attempter_(&dbus_) {}
+  UpdateAttempterTest() : attempter_(&dbus_), loop_(NULL) {}
   virtual void SetUp() {
     EXPECT_EQ(NULL, attempter_.dbus_service_);
     EXPECT_EQ(NULL, attempter_.prefs_);
     EXPECT_EQ(NULL, attempter_.metrics_lib_);
     EXPECT_EQ(NULL, attempter_.update_check_scheduler_);
     EXPECT_EQ(0, attempter_.http_response_code_);
     EXPECT_EQ(utils::kProcessPriorityNormal, attempter_.priority_);
     EXPECT_EQ(NULL, attempter_.manage_priority_source_);
     EXPECT_FALSE(attempter_.download_active_);
     EXPECT_EQ(UPDATE_STATUS_IDLE, attempter_.status_);
     EXPECT_EQ(0.0, attempter_.download_progress_);
     EXPECT_EQ(0, attempter_.last_checked_time_);
     EXPECT_EQ("0.0.0.0", attempter_.new_version_);
     EXPECT_EQ(0, attempter_.new_size_);
     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);
+
   MockDbusGlib dbus_;
   UpdateAttempterUnderTest attempter_;
   ActionProcessorMock* processor_;
   NiceMock<PrefsMock> prefs_;
+  GMainLoop* loop_;
 };
 
 TEST_F(UpdateAttempterTest, ActionCompletedDownloadTest) {
   scoped_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, NULL));
   fetcher->FailTransfer(503);  // Sets the HTTP response code.
   DownloadAction action(&prefs_, fetcher.release());
   EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)).Times(0);
   attempter_.ActionCompleted(NULL, &action, kActionCodeSuccess);
   EXPECT_EQ(503, attempter_.http_response_code());
   EXPECT_EQ(UPDATE_STATUS_FINALIZING, attempter_.status());
@@ skipping 143 matching lines @@
   EXPECT_STREQ("UPDATE_STATUS_FINALIZING",
                UpdateStatusToString(UPDATE_STATUS_FINALIZING));
   EXPECT_STREQ("UPDATE_STATUS_UPDATED_NEED_REBOOT",
                UpdateStatusToString(UPDATE_STATUS_UPDATED_NEED_REBOOT));
   EXPECT_STREQ("UPDATE_STATUS_REPORTING_ERROR_EVENT",
                UpdateStatusToString(UPDATE_STATUS_REPORTING_ERROR_EVENT));
   EXPECT_STREQ("unknown status",
                UpdateStatusToString(static_cast<UpdateStatus>(-1)));
 }
 
-TEST_F(UpdateAttempterTest, UpdateTest) {
+gboolean UpdateAttempterTest::StaticUpdateTestStart(gpointer data) {
+  reinterpret_cast<UpdateAttempterTest*>(data)->UpdateTestStart();
+  return FALSE;
+}
+
+gboolean UpdateAttempterTest::StaticUpdateTestVerify(gpointer data) {
+  reinterpret_cast<UpdateAttempterTest*>(data)->UpdateTestVerify();
+  return FALSE;
+}
+
+namespace {
+const string kActionTypes[] = {
+  OmahaRequestAction::StaticType(),
+  OmahaResponseHandlerAction::StaticType(),
+  FilesystemCopierAction::StaticType(),
+  FilesystemCopierAction::StaticType(),
+  OmahaRequestAction::StaticType(),
+  DownloadAction::StaticType(),
+  OmahaRequestAction::StaticType(),
+  FilesystemCopierAction::StaticType(),
+  FilesystemCopierAction::StaticType(),
+  PostinstallRunnerAction::StaticType(),
+  OmahaRequestAction::StaticType()
+};
+}  // namespace {}
+
+void UpdateAttempterTest::UpdateTestStart() {
   attempter_.set_http_response_code(200);
   InSequence s;
-  const string kActionTypes[] = {
-    OmahaRequestAction::StaticType(),
-    OmahaResponseHandlerAction::StaticType(),
-    FilesystemCopierAction::StaticType(),
-    FilesystemCopierAction::StaticType(),
-    OmahaRequestAction::StaticType(),
-    DownloadAction::StaticType(),
-    OmahaRequestAction::StaticType(),
-    FilesystemCopierAction::StaticType(),
-    FilesystemCopierAction::StaticType(),
-    PostinstallRunnerAction::StaticType(),
-    OmahaRequestAction::StaticType()
-  };
   for (size_t i = 0; i < arraysize(kActionTypes); ++i) {
     EXPECT_CALL(*processor_,
                 EnqueueAction(Property(&AbstractAction::Type,
                                        kActionTypes[i]))).Times(1);
   }
   EXPECT_CALL(*processor_, StartProcessing()).Times(1);
 
   attempter_.Update("", "", false);
+  g_idle_add(&StaticUpdateTestVerify, this);
+}
 
+void UpdateAttempterTest::UpdateTestVerify() {
   EXPECT_EQ(0, attempter_.http_response_code());
   EXPECT_EQ(&attempter_, processor_->delegate());
   EXPECT_EQ(arraysize(kActionTypes), attempter_.actions_.size());
   for (size_t i = 0; i < arraysize(kActionTypes); ++i) {
     EXPECT_EQ(kActionTypes[i], attempter_.actions_[i]->Type());
   }
   EXPECT_EQ(attempter_.response_handler_action_.get(),
             attempter_.actions_[1].get());
   DownloadAction* download_action =
       dynamic_cast<DownloadAction*>(attempter_.actions_[5].get());
   ASSERT_TRUE(download_action != NULL);
   EXPECT_EQ(&attempter_, download_action->delegate());
   EXPECT_EQ(UPDATE_STATUS_CHECKING_FOR_UPDATE, attempter_.status());
+  g_main_loop_quit(loop_);
+}
+
+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;
 }
 
 }  // namespace chromeos_update_engine