AU: Skip all automatic update checks if OOBE is not complete.

update_check_scheduler_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 <gtest/gtest.h>
 
 #include "update_engine/update_attempter_mock.h"
 #include "update_engine/update_check_scheduler.h"
 
 using std::string;
 using testing::_;
 using testing::AllOf;
+using testing::Assign;
 using testing::Ge;
 using testing::Le;
 using testing::MockFunction;
 using testing::Return;
 
 namespace chromeos_update_engine {
 
 namespace {
 void FuzzRange(int interval, int fuzz, int* interval_min, int* interval_max) {
   *interval_min = interval - fuzz / 2;
   *interval_max = interval + fuzz - fuzz / 2;
 }
 }  // namespace {}
 
 // Test a subclass rather than the main class directly so that we can mock out
 // GLib and utils in tests. There're explicit unit test for the wrapper methods.
 class UpdateCheckSchedulerUnderTest : public UpdateCheckScheduler {
  public:
   UpdateCheckSchedulerUnderTest(UpdateAttempter* update_attempter)
       : UpdateCheckScheduler(update_attempter) {}
 
   MOCK_METHOD2(GTimeoutAddSeconds, guint(guint seconds, GSourceFunc function));
   MOCK_METHOD0(IsBootDeviceRemovable, bool());
   MOCK_METHOD0(IsOfficialBuild, bool());
+  MOCK_METHOD0(IsOOBEComplete, bool());
 };
 
 class UpdateCheckSchedulerTest : public ::testing::Test {
  public:
   UpdateCheckSchedulerTest() : scheduler_(&attempter_) {}
 
  protected:
   virtual void SetUp() {
     test_ = this;
     loop_ = NULL;
@@ skipping 94 matching lines @@
   EXPECT_CALL(source_callback_, Call(&scheduler_)).Times(1);
   g_main_loop_run(loop_);
   g_main_loop_unref(loop_);
 }
 
 TEST_F(UpdateCheckSchedulerTest, IsBootDeviceRemovableTest) {
   // Invokes the actual utils wrapper method rather than the subclass mock.
   EXPECT_FALSE(scheduler_.UpdateCheckScheduler::IsBootDeviceRemovable());
 }
 
+TEST_F(UpdateCheckSchedulerTest, IsOOBECompleteTest) {
+  // Invokes the actual utils wrapper method rather than the subclass mock.
+  EXPECT_FALSE(scheduler_.UpdateCheckScheduler::IsOOBEComplete());
+}
+
 TEST_F(UpdateCheckSchedulerTest, IsOfficialBuildTest) {
   // Invokes the actual utils wrapper method rather than the subclass mock.
   EXPECT_TRUE(scheduler_.UpdateCheckScheduler::IsOfficialBuild());
 }
 
 TEST_F(UpdateCheckSchedulerTest, RunBootDeviceRemovableTest) {
   scheduler_.enabled_ = true;
   EXPECT_CALL(scheduler_, IsOfficialBuild()).Times(1).WillOnce(Return(true));
   EXPECT_CALL(scheduler_, IsBootDeviceRemovable())
       .Times(1)
@@ skipping 92 matching lines @@
   scheduler_.SetUpdateStatus(UPDATE_STATUS_IDLE);
 }
 
 TEST_F(UpdateCheckSchedulerTest, SetUpdateStatusNonIdleTest) {
   EXPECT_CALL(scheduler_, GTimeoutAddSeconds(_, _)).Times(0);
   scheduler_.SetUpdateStatus(UPDATE_STATUS_DOWNLOADING);
   scheduler_.enabled_ = true;
   scheduler_.SetUpdateStatus(UPDATE_STATUS_DOWNLOADING);
 }
 
-TEST_F(UpdateCheckSchedulerTest, StaticCheckTest) {
+TEST_F(UpdateCheckSchedulerTest, StaticCheckOOBECompleteTest) {
   scheduler_.scheduled_ = true;
-  EXPECT_CALL(attempter_, Update("", "")).Times(1);
+  EXPECT_CALL(scheduler_, IsOOBEComplete()).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(attempter_, Update("", ""))
+      .Times(1)
+      .WillOnce(Assign(&scheduler_.scheduled_, true));
+  scheduler_.enabled_ = true;
+  EXPECT_CALL(scheduler_, GTimeoutAddSeconds(_, _)).Times(0);
   UpdateCheckSchedulerUnderTest::StaticCheck(&scheduler_);
 }
 
+TEST_F(UpdateCheckSchedulerTest, StaticCheckOOBENotCompleteTest) {
+  scheduler_.scheduled_ = true;
+  EXPECT_CALL(scheduler_, IsOOBEComplete()).Times(1).WillOnce(Return(false));
+  EXPECT_CALL(attempter_, Update("", "")).Times(0);
+  int interval_min, interval_max;
+  FuzzRange(UpdateCheckScheduler::kTimeoutOnce,
+            UpdateCheckScheduler::kTimeoutRegularFuzz,
+            &interval_min,
+            &interval_max);
+  scheduler_.enabled_ = true;
+  EXPECT_CALL(scheduler_,
+              GTimeoutAddSeconds(AllOf(Ge(interval_min), Le(interval_max)),
+                                 scheduler_.StaticCheck)).Times(1);
+  UpdateCheckSchedulerUnderTest::StaticCheck(&scheduler_);
+}
+
 }  // namespace chromeos_update_engine