payload_state_unittest.cc - platform/system/update_engine - Gitiles

 // Copyright (c) 2012 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 <glib.h>

 #include "base/stringprintf.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"

 #include "update_engine/omaha_request_action.h"
 #include "update_engine/payload_state.h"
 #include "update_engine/prefs_mock.h"
 #include "update_engine/test_utils.h"
 #include "update_engine/utils.h"

 using base::Time;
 using base::TimeDelta;
 using std::string;
 using testing::_;
 using testing::NiceMock;
 using testing::Return;
 using testing::SetArgumentPointee;

 namespace chromeos_update_engine {

 static void SetupPayloadStateWith2Urls(string hash,
                                        PayloadState* payload_state,
                                        OmahaResponse* response) {
   response->payload_urls.clear();
   response->payload_urls.push_back("http://test");
   response->payload_urls.push_back("https://test");
   response->size = 523456789;
   response->hash = hash;
   response->metadata_size = 558123;
   response->metadata_signature = "metasign";
   response->max_failure_count_per_url = 3;
   payload_state->SetResponse(*response);
   string stored_response_sign = payload_state->GetResponseSignature();
   string expected_response_sign = StringPrintf(
       "NumURLs = 2\n"
       "Url0 = http://test\n"
       "Url1 = https://test\n"
       "Payload Size = 523456789\n"
       "Payload Sha256 Hash = %s\n"
       "Metadata Size = 558123\n"
       "Metadata Signature = metasign\n"
       "Is Delta Payload = %d\n"
       "Max Failure Count Per Url = %d\n"
       "Disable Payload Backoff = %d\n",
       hash.c_str(),
       response->is_delta_payload,
       response->max_failure_count_per_url,
       response->disable_payload_backoff);
   EXPECT_EQ(expected_response_sign, stored_response_sign);
 }

 class PayloadStateTest : public ::testing::Test { };

 TEST(PayloadStateTest, DidYouAddANewActionExitCode) {
   if (kActionCodeUmaReportedMax != 41) {
     LOG(ERROR) << "The following failure is intentional. If you added a new "
                << "ActionExitCode enum value, make sure to add it to the "
                << "PayloadState::UpdateFailed method and then update this test "
                << "to the new value of kActionCodeUmaReportedMax, which is "
                << kActionCodeUmaReportedMax;
     EXPECT_FALSE("Please see the log line above");
   }
 }

 TEST(PayloadStateTest, SetResponseWorksWithEmptyResponse) {
   OmahaResponse response;
   NiceMock<PrefsMock> prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0));
   EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, 0));
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0));
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0));
   PayloadState payload_state;
   EXPECT_TRUE(payload_state.Initialize(&prefs));
   payload_state.SetResponse(response);
   string stored_response_sign = payload_state.GetResponseSignature();
   string expected_response_sign = "NumURLs = 0\n"
                                   "Payload Size = 0\n"
                                   "Payload Sha256 Hash = \n"
                                   "Metadata Size = 0\n"
                                   "Metadata Signature = \n"
                                   "Is Delta Payload = 0\n"
                                   "Max Failure Count Per Url = 0\n"
                                   "Disable Payload Backoff = 0\n";
   EXPECT_EQ(expected_response_sign, stored_response_sign);
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
 }

 TEST(PayloadStateTest, SetResponseWorksWithSingleUrl) {
   OmahaResponse response;
   response.payload_urls.push_back("http://single.url.test");
   response.size = 123456789;
   response.hash = "hash";
   response.metadata_size = 58123;
   response.metadata_signature = "msign";
   NiceMock<PrefsMock> prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0));
   EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, 0));
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0));
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0));
   PayloadState payload_state;
   EXPECT_TRUE(payload_state.Initialize(&prefs));
   payload_state.SetResponse(response);
   string stored_response_sign = payload_state.GetResponseSignature();
   string expected_response_sign = "NumURLs = 1\n"
                                   "Url0 = http://single.url.test\n"
                                   "Payload Size = 123456789\n"
                                   "Payload Sha256 Hash = hash\n"
                                   "Metadata Size = 58123\n"
                                   "Metadata Signature = msign\n"
                                   "Is Delta Payload = 0\n"
                                   "Max Failure Count Per Url = 0\n"
                                   "Disable Payload Backoff = 0\n";
   EXPECT_EQ(expected_response_sign, stored_response_sign);
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
 }

 TEST(PayloadStateTest, SetResponseWorksWithMultipleUrls) {
   OmahaResponse response;
   response.payload_urls.push_back("http://multiple.url.test");
   response.payload_urls.push_back("https://multiple.url.test");
   response.size = 523456789;
   response.hash = "rhash";
   response.metadata_size = 558123;
   response.metadata_signature = "metasign";
   NiceMock<PrefsMock> prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0));
   EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, 0));
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0));
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0));
   PayloadState payload_state;
   EXPECT_TRUE(payload_state.Initialize(&prefs));
   payload_state.SetResponse(response);
   string stored_response_sign = payload_state.GetResponseSignature();
   string expected_response_sign = "NumURLs = 2\n"
                                   "Url0 = http://multiple.url.test\n"
                                   "Url1 = https://multiple.url.test\n"
                                   "Payload Size = 523456789\n"
                                   "Payload Sha256 Hash = rhash\n"
                                   "Metadata Size = 558123\n"
                                   "Metadata Signature = metasign\n"
                                   "Is Delta Payload = 0\n"
                                   "Max Failure Count Per Url = 0\n"
                                   "Disable Payload Backoff = 0\n";
   EXPECT_EQ(expected_response_sign, stored_response_sign);
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
 }

 TEST(PayloadStateTest, CanAdvanceUrlIndexCorrectly) {
   OmahaResponse response;
   NiceMock<PrefsMock> prefs;
   PayloadState payload_state;

   // Payload attempt should start with 0 and then advance to 1.
   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)).Times(1);
   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)).Times(1);
   EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(2);

   // Url index should go from 0 to 1 twice.
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(2);
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 1)).Times(2);

   // Failure count should be called each times url index is set, so that's
   // 4 times for this test.
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)).Times(4);

   EXPECT_TRUE(payload_state.Initialize(&prefs));

   // This does a SetResponse which causes all the states to be set to 0 for
   // the first time.
   SetupPayloadStateWith2Urls("Hash1235", &payload_state, &response);
   EXPECT_EQ(0, payload_state.GetUrlIndex());

   // Verify that on the first error, the URL index advances to 1.
   ActionExitCode error = kActionCodeDownloadMetadataSignatureMismatch;
   payload_state.UpdateFailed(error);
   EXPECT_EQ(1, payload_state.GetUrlIndex());

   // Verify that on the next error, the URL index wraps around to 0.
   payload_state.UpdateFailed(error);
   EXPECT_EQ(0, payload_state.GetUrlIndex());

   // Verify that on the next error, it again advances to 1.
   payload_state.UpdateFailed(error);
   EXPECT_EQ(1, payload_state.GetUrlIndex());
 }

 TEST(PayloadStateTest, NewResponseResetsPayloadState) {
   OmahaResponse response;
   NiceMock<PrefsMock> prefs;
   PayloadState payload_state;

   EXPECT_TRUE(payload_state.Initialize(&prefs));

   // Set the first response.
   SetupPayloadStateWith2Urls("Hash5823", &payload_state, &response);

   // Advance the URL index to 1 by faking an error.
   ActionExitCode error = kActionCodeDownloadMetadataSignatureMismatch;
   payload_state.UpdateFailed(error);
   EXPECT_EQ(1, payload_state.GetUrlIndex());

   // Now, slightly change the response and set it again.
   SetupPayloadStateWith2Urls("Hash8225", &payload_state, &response);

   // Make sure the url index was reset to 0 because of the new response.
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
 }

 TEST(PayloadStateTest, AllCountersGetUpdatedProperlyOnErrorCodesAndEvents) {
   OmahaResponse response;
   PayloadState payload_state;
   NiceMock<PrefsMock> prefs;

   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)).Times(2);
   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)).Times(1);
   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 2)).Times(1);

   EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(4);

   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(4);
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 1)).Times(2);

   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)).Times(7);
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 1)).Times(2);
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 2)).Times(1);

   EXPECT_TRUE(payload_state.Initialize(&prefs));

   SetupPayloadStateWith2Urls("Hash5873", &payload_state, &response);

   // This should advance the URL index.
   payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
   EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(1, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());

   // This should advance the failure count only.
   payload_state.UpdateFailed(kActionCodeDownloadTransferError);
   EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(1, payload_state.GetUrlIndex());
   EXPECT_EQ(1, payload_state.GetUrlFailureCount());

   // This should advance the failure count only.
   payload_state.UpdateFailed(kActionCodeDownloadTransferError);
   EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(1, payload_state.GetUrlIndex());
   EXPECT_EQ(2, payload_state.GetUrlFailureCount());

   // This should advance the URL index as we've reached the
   // max failure count and reset the failure count for the new URL index.
   // This should also wrap around the URL index and thus cause the payload
   // attempt number to be incremented.
   payload_state.UpdateFailed(kActionCodeDownloadTransferError);
   EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
   EXPECT_TRUE(payload_state.ShouldBackoffDownload());

   // This should advance the URL index.
   payload_state.UpdateFailed(kActionCodePayloadHashMismatchError);
   EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(1, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
   EXPECT_TRUE(payload_state.ShouldBackoffDownload());

   // This should advance the URL index and payload attempt number due to
   // wrap-around of URL index.
   payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMissingError);
   EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
   EXPECT_TRUE(payload_state.ShouldBackoffDownload());

   // This HTTP error code should only increase the failure count.
   payload_state.UpdateFailed(static_cast<ActionExitCode>(
       kActionCodeOmahaRequestHTTPResponseBase + 404));
   EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(1, payload_state.GetUrlFailureCount());
   EXPECT_TRUE(payload_state.ShouldBackoffDownload());

   // And that failure count should be reset when we download some bytes
   // afterwards.
   payload_state.DownloadProgress(100);
   EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
   EXPECT_TRUE(payload_state.ShouldBackoffDownload());

   // Now, slightly change the response and set it again.
   SetupPayloadStateWith2Urls("Hash8532", &payload_state, &response);

   // Make sure the url index was reset to 0 because of the new response.
   EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
   EXPECT_FALSE(payload_state.ShouldBackoffDownload());
 }

 TEST(PayloadStateTest, PayloadAttemptNumberIncreasesOnSuccessfulDownload) {
   OmahaResponse response;
   PayloadState payload_state;
   NiceMock<PrefsMock> prefs;

   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)).Times(1);
   EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)).Times(1);

   EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(2);

   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(1);
   EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)).Times(1);

   EXPECT_TRUE(payload_state.Initialize(&prefs));

   SetupPayloadStateWith2Urls("Hash8593", &payload_state, &response);

   // This should just advance the payload attempt number;
   EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
   payload_state.DownloadComplete();
   EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
 }

 TEST(PayloadStateTest, SetResponseResetsInvalidUrlIndex) {
   OmahaResponse response;
   PayloadState payload_state;
   NiceMock<PrefsMock> prefs;

   EXPECT_TRUE(payload_state.Initialize(&prefs));
   SetupPayloadStateWith2Urls("Hash4427", &payload_state, &response);

   // Generate enough events to advance URL index, failure count and
   // payload attempt number all to 1.
   payload_state.DownloadComplete();
   payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
   payload_state.UpdateFailed(kActionCodeDownloadTransferError);
   EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(1, payload_state.GetUrlIndex());
   EXPECT_EQ(1, payload_state.GetUrlFailureCount());

   // Now, simulate a corrupted url index on persisted store which gets
   // loaded when update_engine restarts. Using a different prefs object
   // so as to not bother accounting for the uninteresting calls above.
   NiceMock<PrefsMock> prefs2;
   EXPECT_CALL(prefs2, Exists(_)).WillRepeatedly(Return(true));
   EXPECT_CALL(prefs2, GetInt64(kPrefsPayloadAttemptNumber, _));
   EXPECT_CALL(prefs2, GetInt64(kPrefsBackoffExpiryTime, _));
   EXPECT_CALL(prefs2, GetInt64(kPrefsCurrentUrlIndex, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(2), Return(true)));
   EXPECT_CALL(prefs2, GetInt64(kPrefsCurrentUrlFailureCount, _));

   // Note: This will be a different payload object, but the response should
   // have the same hash as before so as to not trivially reset because the
   // response was different. We want to specifically test that even if the
   // response is same, we should reset the state if we find it corrupted.
   EXPECT_TRUE(payload_state.Initialize(&prefs2));
   SetupPayloadStateWith2Urls("Hash4427", &payload_state, &response);

   // Make sure all counters get reset to 0 because of the corrupted URL index
   // we supplied above.
   EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetUrlFailureCount());
 }

 TEST(PayloadStateTest, NoBackoffForDeltaPayloads) {
   OmahaResponse response;
   response.is_delta_payload = true;
   PayloadState payload_state;
   NiceMock<PrefsMock> prefs;

   EXPECT_TRUE(payload_state.Initialize(&prefs));
   SetupPayloadStateWith2Urls("Hash6437", &payload_state, &response);

   // Simulate a successful download and see that we're ready to download
   // again without any backoff as this is a delta payload.
   payload_state.DownloadComplete();
   EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
   EXPECT_FALSE(payload_state.ShouldBackoffDownload());

   // Simulate two failures (enough to cause payload backoff) and check
   // again that we're ready to re-download without any backoff as this is
   // a delta payload.
   payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
   payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
   EXPECT_EQ(0, payload_state.GetUrlIndex());
   EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
   EXPECT_FALSE(payload_state.ShouldBackoffDownload());
 }

 static void CheckPayloadBackoffState(PayloadState* payload_state,
                                      int expected_attempt_number,
                                      TimeDelta expected_days) {
   payload_state->DownloadComplete();
   EXPECT_EQ(expected_attempt_number, payload_state->GetPayloadAttemptNumber());
   EXPECT_TRUE(payload_state->ShouldBackoffDownload());
   Time backoff_expiry_time = payload_state->GetBackoffExpiryTime();
   // Add 1 hour extra to the 6 hour fuzz check to tolerate edge cases.
   TimeDelta max_fuzz_delta = TimeDelta::FromHours(7);
   Time expected_min_time = Time::Now() + expected_days - max_fuzz_delta;
   Time expected_max_time = Time::Now() + expected_days + max_fuzz_delta;
   EXPECT_LT(expected_min_time.ToInternalValue(),
             backoff_expiry_time.ToInternalValue());
   EXPECT_GT(expected_max_time.ToInternalValue(),
             backoff_expiry_time.ToInternalValue());
 }

 TEST(PayloadStateTest, BackoffPeriodsAreInCorrectRange) {
   OmahaResponse response;
   response.is_delta_payload = false;
   PayloadState payload_state;
   NiceMock<PrefsMock> prefs;

   EXPECT_TRUE(payload_state.Initialize(&prefs));
   SetupPayloadStateWith2Urls("Hash8939", &payload_state, &response);

   CheckPayloadBackoffState(&payload_state, 1,  TimeDelta::FromDays(1));
   CheckPayloadBackoffState(&payload_state, 2,  TimeDelta::FromDays(2));
   CheckPayloadBackoffState(&payload_state, 3,  TimeDelta::FromDays(4));
   CheckPayloadBackoffState(&payload_state, 4,  TimeDelta::FromDays(8));
   CheckPayloadBackoffState(&payload_state, 5,  TimeDelta::FromDays(16));
   CheckPayloadBackoffState(&payload_state, 6,  TimeDelta::FromDays(16));
   CheckPayloadBackoffState(&payload_state, 7,  TimeDelta::FromDays(16));
   CheckPayloadBackoffState(&payload_state, 8,  TimeDelta::FromDays(16));
   CheckPayloadBackoffState(&payload_state, 9,  TimeDelta::FromDays(16));
   CheckPayloadBackoffState(&payload_state, 10,  TimeDelta::FromDays(16));
 }

 TEST(PayloadStateTest, BackoffLogicCanBeDisabled) {
   OmahaResponse response;
   response.disable_payload_backoff = true;
   PayloadState payload_state;
   NiceMock<PrefsMock> prefs;

   EXPECT_TRUE(payload_state.Initialize(&prefs));
   SetupPayloadStateWith2Urls("Hash8939", &payload_state, &response);

   // Simulate a successful download and see that we are ready to download
   // again without any backoff.
   payload_state.DownloadComplete();
   EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
   EXPECT_FALSE(payload_state.ShouldBackoffDownload());

   // Test again, this time by simulating two errors that would cause
   // the payload attempt number to increment due to wrap around. And
   // check that we are still ready to re-download without any backoff.
   payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
   payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
   EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
   EXPECT_FALSE(payload_state.ShouldBackoffDownload());
 }

 }
	// Copyright (c) 2012 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 <glib.h>

	#include "base/stringprintf.h"
	#include "gmock/gmock.h"
	#include "gtest/gtest.h"

	#include "update_engine/omaha_request_action.h"
	#include "update_engine/payload_state.h"
	#include "update_engine/prefs_mock.h"
	#include "update_engine/test_utils.h"
	#include "update_engine/utils.h"

	using base::Time;
	using base::TimeDelta;
	using std::string;
	using testing::_;
	using testing::NiceMock;
	using testing::Return;
	using testing::SetArgumentPointee;

	namespace chromeos_update_engine {

	static void SetupPayloadStateWith2Urls(string hash,
	PayloadState* payload_state,
	OmahaResponse* response) {
	response->payload_urls.clear();
	response->payload_urls.push_back("http://test");
	response->payload_urls.push_back("https://test");
	response->size = 523456789;
	response->hash = hash;
	response->metadata_size = 558123;
	response->metadata_signature = "metasign";
	response->max_failure_count_per_url = 3;
	payload_state->SetResponse(*response);
	string stored_response_sign = payload_state->GetResponseSignature();
	string expected_response_sign = StringPrintf(
	"NumURLs = 2\n"
	"Url0 = http://test\n"
	"Url1 = https://test\n"
	"Payload Size = 523456789\n"
	"Payload Sha256 Hash = %s\n"
	"Metadata Size = 558123\n"
	"Metadata Signature = metasign\n"
	"Is Delta Payload = %d\n"
	"Max Failure Count Per Url = %d\n"
	"Disable Payload Backoff = %d\n",
	hash.c_str(),
	response->is_delta_payload,
	response->max_failure_count_per_url,
	response->disable_payload_backoff);
	EXPECT_EQ(expected_response_sign, stored_response_sign);
	}

	class PayloadStateTest : public ::testing::Test { };

	TEST(PayloadStateTest, DidYouAddANewActionExitCode) {
	if (kActionCodeUmaReportedMax != 41) {
	LOG(ERROR) << "The following failure is intentional. If you added a new "
	<< "ActionExitCode enum value, make sure to add it to the "
	<< "PayloadState::UpdateFailed method and then update this test "
	<< "to the new value of kActionCodeUmaReportedMax, which is "
	<< kActionCodeUmaReportedMax;
	EXPECT_FALSE("Please see the log line above");
	}
	}

	TEST(PayloadStateTest, SetResponseWorksWithEmptyResponse) {
	OmahaResponse response;
	NiceMock<PrefsMock> prefs;
	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0));
	EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, 0));
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0));
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0));
	PayloadState payload_state;
	EXPECT_TRUE(payload_state.Initialize(&prefs));
	payload_state.SetResponse(response);
	string stored_response_sign = payload_state.GetResponseSignature();
	string expected_response_sign = "NumURLs = 0\n"
	"Payload Size = 0\n"
	"Payload Sha256 Hash = \n"
	"Metadata Size = 0\n"
	"Metadata Signature = \n"
	"Is Delta Payload = 0\n"
	"Max Failure Count Per Url = 0\n"
	"Disable Payload Backoff = 0\n";
	EXPECT_EQ(expected_response_sign, stored_response_sign);
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	}

	TEST(PayloadStateTest, SetResponseWorksWithSingleUrl) {
	OmahaResponse response;
	response.payload_urls.push_back("http://single.url.test");
	response.size = 123456789;
	response.hash = "hash";
	response.metadata_size = 58123;
	response.metadata_signature = "msign";
	NiceMock<PrefsMock> prefs;
	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0));
	EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, 0));
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0));
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0));
	PayloadState payload_state;
	EXPECT_TRUE(payload_state.Initialize(&prefs));
	payload_state.SetResponse(response);
	string stored_response_sign = payload_state.GetResponseSignature();
	string expected_response_sign = "NumURLs = 1\n"
	"Url0 = http://single.url.test\n"
	"Payload Size = 123456789\n"
	"Payload Sha256 Hash = hash\n"
	"Metadata Size = 58123\n"
	"Metadata Signature = msign\n"
	"Is Delta Payload = 0\n"
	"Max Failure Count Per Url = 0\n"
	"Disable Payload Backoff = 0\n";
	EXPECT_EQ(expected_response_sign, stored_response_sign);
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	}

	TEST(PayloadStateTest, SetResponseWorksWithMultipleUrls) {
	OmahaResponse response;
	response.payload_urls.push_back("http://multiple.url.test");
	response.payload_urls.push_back("https://multiple.url.test");
	response.size = 523456789;
	response.hash = "rhash";
	response.metadata_size = 558123;
	response.metadata_signature = "metasign";
	NiceMock<PrefsMock> prefs;
	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0));
	EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, 0));
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0));
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0));
	PayloadState payload_state;
	EXPECT_TRUE(payload_state.Initialize(&prefs));
	payload_state.SetResponse(response);
	string stored_response_sign = payload_state.GetResponseSignature();
	string expected_response_sign = "NumURLs = 2\n"
	"Url0 = http://multiple.url.test\n"
	"Url1 = https://multiple.url.test\n"
	"Payload Size = 523456789\n"
	"Payload Sha256 Hash = rhash\n"
	"Metadata Size = 558123\n"
	"Metadata Signature = metasign\n"
	"Is Delta Payload = 0\n"
	"Max Failure Count Per Url = 0\n"
	"Disable Payload Backoff = 0\n";
	EXPECT_EQ(expected_response_sign, stored_response_sign);
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	}

	TEST(PayloadStateTest, CanAdvanceUrlIndexCorrectly) {
	OmahaResponse response;
	NiceMock<PrefsMock> prefs;
	PayloadState payload_state;

	// Payload attempt should start with 0 and then advance to 1.
	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)).Times(1);
	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)).Times(1);
	EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(2);

	// Url index should go from 0 to 1 twice.
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(2);
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 1)).Times(2);

	// Failure count should be called each times url index is set, so that's
	// 4 times for this test.
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)).Times(4);

	EXPECT_TRUE(payload_state.Initialize(&prefs));

	// This does a SetResponse which causes all the states to be set to 0 for
	// the first time.
	SetupPayloadStateWith2Urls("Hash1235", &payload_state, &response);
	EXPECT_EQ(0, payload_state.GetUrlIndex());

	// Verify that on the first error, the URL index advances to 1.
	ActionExitCode error = kActionCodeDownloadMetadataSignatureMismatch;
	payload_state.UpdateFailed(error);
	EXPECT_EQ(1, payload_state.GetUrlIndex());

	// Verify that on the next error, the URL index wraps around to 0.
	payload_state.UpdateFailed(error);
	EXPECT_EQ(0, payload_state.GetUrlIndex());

	// Verify that on the next error, it again advances to 1.
	payload_state.UpdateFailed(error);
	EXPECT_EQ(1, payload_state.GetUrlIndex());
	}

	TEST(PayloadStateTest, NewResponseResetsPayloadState) {
	OmahaResponse response;
	NiceMock<PrefsMock> prefs;
	PayloadState payload_state;

	EXPECT_TRUE(payload_state.Initialize(&prefs));

	// Set the first response.
	SetupPayloadStateWith2Urls("Hash5823", &payload_state, &response);

	// Advance the URL index to 1 by faking an error.
	ActionExitCode error = kActionCodeDownloadMetadataSignatureMismatch;
	payload_state.UpdateFailed(error);
	EXPECT_EQ(1, payload_state.GetUrlIndex());

	// Now, slightly change the response and set it again.
	SetupPayloadStateWith2Urls("Hash8225", &payload_state, &response);

	// Make sure the url index was reset to 0 because of the new response.
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	}

	TEST(PayloadStateTest, AllCountersGetUpdatedProperlyOnErrorCodesAndEvents) {
	OmahaResponse response;
	PayloadState payload_state;
	NiceMock<PrefsMock> prefs;

	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)).Times(2);
	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)).Times(1);
	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 2)).Times(1);

	EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(4);

	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(4);
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 1)).Times(2);

	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)).Times(7);
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 1)).Times(2);
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 2)).Times(1);

	EXPECT_TRUE(payload_state.Initialize(&prefs));

	SetupPayloadStateWith2Urls("Hash5873", &payload_state, &response);

	// This should advance the URL index.
	payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
	EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(1, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());

	// This should advance the failure count only.
	payload_state.UpdateFailed(kActionCodeDownloadTransferError);
	EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(1, payload_state.GetUrlIndex());
	EXPECT_EQ(1, payload_state.GetUrlFailureCount());

	// This should advance the failure count only.
	payload_state.UpdateFailed(kActionCodeDownloadTransferError);
	EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(1, payload_state.GetUrlIndex());
	EXPECT_EQ(2, payload_state.GetUrlFailureCount());

	// This should advance the URL index as we've reached the
	// max failure count and reset the failure count for the new URL index.
	// This should also wrap around the URL index and thus cause the payload
	// attempt number to be incremented.
	payload_state.UpdateFailed(kActionCodeDownloadTransferError);
	EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	EXPECT_TRUE(payload_state.ShouldBackoffDownload());

	// This should advance the URL index.
	payload_state.UpdateFailed(kActionCodePayloadHashMismatchError);
	EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(1, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	EXPECT_TRUE(payload_state.ShouldBackoffDownload());

	// This should advance the URL index and payload attempt number due to
	// wrap-around of URL index.
	payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMissingError);
	EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	EXPECT_TRUE(payload_state.ShouldBackoffDownload());

	// This HTTP error code should only increase the failure count.
	payload_state.UpdateFailed(static_cast<ActionExitCode>(
	kActionCodeOmahaRequestHTTPResponseBase + 404));
	EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(1, payload_state.GetUrlFailureCount());
	EXPECT_TRUE(payload_state.ShouldBackoffDownload());

	// And that failure count should be reset when we download some bytes
	// afterwards.
	payload_state.DownloadProgress(100);
	EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	EXPECT_TRUE(payload_state.ShouldBackoffDownload());

	// Now, slightly change the response and set it again.
	SetupPayloadStateWith2Urls("Hash8532", &payload_state, &response);

	// Make sure the url index was reset to 0 because of the new response.
	EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	EXPECT_FALSE(payload_state.ShouldBackoffDownload());
	}

	TEST(PayloadStateTest, PayloadAttemptNumberIncreasesOnSuccessfulDownload) {
	OmahaResponse response;
	PayloadState payload_state;
	NiceMock<PrefsMock> prefs;

	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)).Times(1);
	EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)).Times(1);

	EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(2);

	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(1);
	EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)).Times(1);

	EXPECT_TRUE(payload_state.Initialize(&prefs));

	SetupPayloadStateWith2Urls("Hash8593", &payload_state, &response);

	// This should just advance the payload attempt number;
	EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
	payload_state.DownloadComplete();
	EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	}

	TEST(PayloadStateTest, SetResponseResetsInvalidUrlIndex) {
	OmahaResponse response;
	PayloadState payload_state;
	NiceMock<PrefsMock> prefs;

	EXPECT_TRUE(payload_state.Initialize(&prefs));
	SetupPayloadStateWith2Urls("Hash4427", &payload_state, &response);

	// Generate enough events to advance URL index, failure count and
	// payload attempt number all to 1.
	payload_state.DownloadComplete();
	payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
	payload_state.UpdateFailed(kActionCodeDownloadTransferError);
	EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(1, payload_state.GetUrlIndex());
	EXPECT_EQ(1, payload_state.GetUrlFailureCount());

	// Now, simulate a corrupted url index on persisted store which gets
	// loaded when update_engine restarts. Using a different prefs object
	// so as to not bother accounting for the uninteresting calls above.
	NiceMock<PrefsMock> prefs2;
	EXPECT_CALL(prefs2, Exists(_)).WillRepeatedly(Return(true));
	EXPECT_CALL(prefs2, GetInt64(kPrefsPayloadAttemptNumber, _));
	EXPECT_CALL(prefs2, GetInt64(kPrefsBackoffExpiryTime, _));
	EXPECT_CALL(prefs2, GetInt64(kPrefsCurrentUrlIndex, _))
	.WillOnce(DoAll(SetArgumentPointee<1>(2), Return(true)));
	EXPECT_CALL(prefs2, GetInt64(kPrefsCurrentUrlFailureCount, _));

	// Note: This will be a different payload object, but the response should
	// have the same hash as before so as to not trivially reset because the
	// response was different. We want to specifically test that even if the
	// response is same, we should reset the state if we find it corrupted.
	EXPECT_TRUE(payload_state.Initialize(&prefs2));
	SetupPayloadStateWith2Urls("Hash4427", &payload_state, &response);

	// Make sure all counters get reset to 0 because of the corrupted URL index
	// we supplied above.
	EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetUrlFailureCount());
	}

	TEST(PayloadStateTest, NoBackoffForDeltaPayloads) {
	OmahaResponse response;
	response.is_delta_payload = true;
	PayloadState payload_state;
	NiceMock<PrefsMock> prefs;

	EXPECT_TRUE(payload_state.Initialize(&prefs));
	SetupPayloadStateWith2Urls("Hash6437", &payload_state, &response);

	// Simulate a successful download and see that we're ready to download
	// again without any backoff as this is a delta payload.
	payload_state.DownloadComplete();
	EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
	EXPECT_FALSE(payload_state.ShouldBackoffDownload());

	// Simulate two failures (enough to cause payload backoff) and check
	// again that we're ready to re-download without any backoff as this is
	// a delta payload.
	payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
	payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
	EXPECT_EQ(0, payload_state.GetUrlIndex());
	EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber());
	EXPECT_FALSE(payload_state.ShouldBackoffDownload());
	}

	static void CheckPayloadBackoffState(PayloadState* payload_state,
	int expected_attempt_number,
	TimeDelta expected_days) {
	payload_state->DownloadComplete();
	EXPECT_EQ(expected_attempt_number, payload_state->GetPayloadAttemptNumber());
	EXPECT_TRUE(payload_state->ShouldBackoffDownload());
	Time backoff_expiry_time = payload_state->GetBackoffExpiryTime();
	// Add 1 hour extra to the 6 hour fuzz check to tolerate edge cases.
	TimeDelta max_fuzz_delta = TimeDelta::FromHours(7);
	Time expected_min_time = Time::Now() + expected_days - max_fuzz_delta;
	Time expected_max_time = Time::Now() + expected_days + max_fuzz_delta;
	EXPECT_LT(expected_min_time.ToInternalValue(),
	backoff_expiry_time.ToInternalValue());
	EXPECT_GT(expected_max_time.ToInternalValue(),
	backoff_expiry_time.ToInternalValue());
	}

	TEST(PayloadStateTest, BackoffPeriodsAreInCorrectRange) {
	OmahaResponse response;
	response.is_delta_payload = false;
	PayloadState payload_state;
	NiceMock<PrefsMock> prefs;

	EXPECT_TRUE(payload_state.Initialize(&prefs));
	SetupPayloadStateWith2Urls("Hash8939", &payload_state, &response);

	CheckPayloadBackoffState(&payload_state, 1, TimeDelta::FromDays(1));
	CheckPayloadBackoffState(&payload_state, 2, TimeDelta::FromDays(2));
	CheckPayloadBackoffState(&payload_state, 3, TimeDelta::FromDays(4));
	CheckPayloadBackoffState(&payload_state, 4, TimeDelta::FromDays(8));
	CheckPayloadBackoffState(&payload_state, 5, TimeDelta::FromDays(16));
	CheckPayloadBackoffState(&payload_state, 6, TimeDelta::FromDays(16));
	CheckPayloadBackoffState(&payload_state, 7, TimeDelta::FromDays(16));
	CheckPayloadBackoffState(&payload_state, 8, TimeDelta::FromDays(16));
	CheckPayloadBackoffState(&payload_state, 9, TimeDelta::FromDays(16));
	CheckPayloadBackoffState(&payload_state, 10, TimeDelta::FromDays(16));
	}

	TEST(PayloadStateTest, BackoffLogicCanBeDisabled) {
	OmahaResponse response;
	response.disable_payload_backoff = true;
	PayloadState payload_state;
	NiceMock<PrefsMock> prefs;

	EXPECT_TRUE(payload_state.Initialize(&prefs));
	SetupPayloadStateWith2Urls("Hash8939", &payload_state, &response);

	// Simulate a successful download and see that we are ready to download
	// again without any backoff.
	payload_state.DownloadComplete();
	EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber());
	EXPECT_FALSE(payload_state.ShouldBackoffDownload());

	// Test again, this time by simulating two errors that would cause
	// the payload attempt number to increment due to wrap around. And
	// check that we are still ready to re-download without any backoff.
	payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
	payload_state.UpdateFailed(kActionCodeDownloadMetadataSignatureMismatch);
	EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber());
	EXPECT_FALSE(payload_state.ShouldBackoffDownload());
	}

	}