AU: Implement server-dictated poll interval.

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;
@@ skipping 30 matching lines @@
   UpdateCheckSchedulerTest() : scheduler_(&attempter_) {}
 
  protected:
   virtual void SetUp() {
     test_ = this;
     loop_ = NULL;
     EXPECT_EQ(&attempter_, scheduler_.update_attempter_);
     EXPECT_FALSE(scheduler_.enabled_);
     EXPECT_FALSE(scheduler_.scheduled_);
     EXPECT_EQ(0, scheduler_.last_interval_);
+    EXPECT_EQ(0, scheduler_.poll_interval_);
   }
 
   virtual void TearDown() {
     test_ = NULL;
     loop_ = NULL;
   }
 
   static gboolean SourceCallback(gpointer data) {
     g_main_loop_quit(test_->loop_);
     // Forwards the call to the function mock so that expectations can be set.
@@ skipping 22 matching lines @@
 TEST_F(UpdateCheckSchedulerTest, ComputeNextIntervalAndFuzzBackoffTest) {
   int interval, fuzz;
   attempter_.set_http_response_code(500);
   int last_interval = UpdateCheckScheduler::kTimeoutPeriodic + 50;
   scheduler_.last_interval_ = last_interval;
   scheduler_.ComputeNextIntervalAndFuzz(&interval, &fuzz);
   EXPECT_EQ(2 * last_interval, interval);
   EXPECT_EQ(2 * last_interval, fuzz);
 
   attempter_.set_http_response_code(503);
-  last_interval = UpdateCheckScheduler::kTimeoutMaxBackoff / 2 + 1;
-  scheduler_.last_interval_ = last_interval;
+  scheduler_.last_interval_ = UpdateCheckScheduler::kTimeoutMaxBackoff / 2 + 1;
   scheduler_.ComputeNextIntervalAndFuzz(&interval, &fuzz);
   EXPECT_EQ(UpdateCheckScheduler::kTimeoutMaxBackoff, interval);
   EXPECT_EQ(UpdateCheckScheduler::kTimeoutMaxBackoff, fuzz);
 }
 
+TEST_F(UpdateCheckSchedulerTest, ComputeNextIntervalAndFuzzPollTest) {
+  int interval, fuzz;
+  int poll_interval = UpdateCheckScheduler::kTimeoutPeriodic + 50;
+  scheduler_.set_poll_interval(poll_interval);
+  scheduler_.ComputeNextIntervalAndFuzz(&interval, &fuzz);
+  EXPECT_EQ(poll_interval, interval);
+  EXPECT_EQ(poll_interval, fuzz);
+
+  scheduler_.set_poll_interval(UpdateCheckScheduler::kTimeoutMaxBackoff + 1);
+  scheduler_.ComputeNextIntervalAndFuzz(&interval, &fuzz);
+  EXPECT_EQ(UpdateCheckScheduler::kTimeoutMaxBackoff, interval);
+  EXPECT_EQ(UpdateCheckScheduler::kTimeoutMaxBackoff, fuzz);
+
+  scheduler_.set_poll_interval(UpdateCheckScheduler::kTimeoutPeriodic - 1);
+  scheduler_.ComputeNextIntervalAndFuzz(&interval, &fuzz);
+  EXPECT_EQ(UpdateCheckScheduler::kTimeoutPeriodic, interval);
+  EXPECT_EQ(UpdateCheckScheduler::kTimeoutRegularFuzz, fuzz);
+}
+
+TEST_F(UpdateCheckSchedulerTest, ComputeNextIntervalAndFuzzPriorityTest) {
+  int interval, fuzz;
+  attempter_.set_http_response_code(500);
+  scheduler_.last_interval_ = UpdateCheckScheduler::kTimeoutPeriodic + 50;
+  int poll_interval = UpdateCheckScheduler::kTimeoutPeriodic + 100;
+  scheduler_.set_poll_interval(poll_interval);
+  scheduler_.ComputeNextIntervalAndFuzz(&interval, &fuzz);
+  EXPECT_EQ(poll_interval, interval);
+  EXPECT_EQ(poll_interval, fuzz);
+}
+
 TEST_F(UpdateCheckSchedulerTest, ComputeNextIntervalAndFuzzTest) {
   int interval, fuzz;
   scheduler_.ComputeNextIntervalAndFuzz(&interval, &fuzz);
   EXPECT_EQ(UpdateCheckScheduler::kTimeoutPeriodic, interval);
   EXPECT_EQ(UpdateCheckScheduler::kTimeoutRegularFuzz, fuzz);
 }
 
 TEST_F(UpdateCheckSchedulerTest, GTimeoutAddSecondsTest) {
   loop_ = g_main_loop_new(g_main_context_default(), FALSE);
   // Invokes the actual GLib wrapper method rather than the subclass mock.
@@ skipping 120 matching lines @@
   scheduler_.SetUpdateStatus(UPDATE_STATUS_DOWNLOADING);
 }
 
 TEST_F(UpdateCheckSchedulerTest, StaticCheckTest) {
   scheduler_.scheduled_ = true;
   EXPECT_CALL(attempter_, Update("", "")).Times(1);
   UpdateCheckSchedulerUnderTest::StaticCheck(&scheduler_);
 }
 
 }  // namespace chromeos_update_engine