diff options
Diffstat (limited to 'cros/payload_state_unittest.cc')
| -rw-r--r-- | cros/payload_state_unittest.cc | 1758 |
1 files changed, 1758 insertions, 0 deletions
diff --git a/cros/payload_state_unittest.cc b/cros/payload_state_unittest.cc new file mode 100644 index 00000000..5478fcae --- /dev/null +++ b/cros/payload_state_unittest.cc @@ -0,0 +1,1758 @@ +// +// Copyright (C) 2012 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#include "update_engine/cros/payload_state.h" + +#include <base/files/file_path.h> +#include <base/files/file_util.h> +#include <base/strings/stringprintf.h> +#include <gmock/gmock.h> +#include <gtest/gtest.h> + +#include "update_engine/common/constants.h" +#include "update_engine/common/excluder_interface.h" +#include "update_engine/common/fake_hardware.h" +#include "update_engine/common/metrics_reporter_interface.h" +#include "update_engine/common/mock_excluder.h" +#include "update_engine/common/mock_prefs.h" +#include "update_engine/common/prefs.h" +#include "update_engine/common/test_utils.h" +#include "update_engine/common/utils.h" +#include "update_engine/cros/fake_system_state.h" +#include "update_engine/cros/omaha_request_action.h" + +using base::Time; +using base::TimeDelta; +using std::string; +using testing::_; +using testing::AnyNumber; +using testing::AtLeast; +using testing::Mock; +using testing::NiceMock; +using testing::Return; +using testing::SetArgPointee; +using testing::StrictMock; + +namespace chromeos_update_engine { + +const char* kCurrentBytesDownloadedFromHttps = + "current-bytes-downloaded-from-HttpsServer"; +const char* kTotalBytesDownloadedFromHttps = + "total-bytes-downloaded-from-HttpsServer"; +const char* kCurrentBytesDownloadedFromHttp = + "current-bytes-downloaded-from-HttpServer"; +const char* kTotalBytesDownloadedFromHttp = + "total-bytes-downloaded-from-HttpServer"; +const char* kCurrentBytesDownloadedFromHttpPeer = + "current-bytes-downloaded-from-HttpPeer"; +const char* kTotalBytesDownloadedFromHttpPeer = + "total-bytes-downloaded-from-HttpPeer"; + +static void SetupPayloadStateWith2Urls(string hash, + bool http_enabled, + bool is_delta_payload, + PayloadState* payload_state, + OmahaResponse* response) { + response->packages.clear(); + response->packages.push_back({.payload_urls = {"http://test", "https://test"}, + .size = 523456789, + .metadata_size = 558123, + .metadata_signature = "metasign", + .hash = hash, + .is_delta = is_delta_payload}); + response->max_failure_count_per_url = 3; + payload_state->SetResponse(*response); + string stored_response_sign = payload_state->GetResponseSignature(); + + string expected_url_https_only = + " NumURLs = 1\n" + " Candidate Url0 = https://test\n"; + + string expected_urls_both = + " NumURLs = 2\n" + " Candidate Url0 = http://test\n" + " Candidate Url1 = https://test\n"; + + string expected_response_sign = base::StringPrintf( + "Payload 0:\n" + " Size = 523456789\n" + " Sha256 Hash = %s\n" + " Metadata Size = 558123\n" + " Metadata Signature = metasign\n" + " Is Delta = %d\n" + "%s" + "Max Failure Count Per Url = %d\n" + "Disable Payload Backoff = %d\n", + hash.c_str(), + response->packages[0].is_delta, + (http_enabled ? expected_urls_both : expected_url_https_only).c_str(), + response->max_failure_count_per_url, + response->disable_payload_backoff); + EXPECT_EQ(expected_response_sign, stored_response_sign); +} + +class PayloadStateTest : public ::testing::Test { + public: + void SetUp() { FakeSystemState::CreateInstance(); } + + // TODO(b/171829801): Replace all the |MockPrefs| in this file with + // |FakePrefs| so we don't have to catch every single unimportant mock call. +}; + +TEST_F(PayloadStateTest, SetResponseWorksWithEmptyResponse) { + OmahaResponse response; + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateTimestampStart, _)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateDurationUptime, _)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttps, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttpPeer, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)).Times(AtLeast(1)); + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + payload_state.SetResponse(response); + string stored_response_sign = payload_state.GetResponseSignature(); + string expected_response_sign = + "Max Failure Count Per Url = 0\n" + "Disable Payload Backoff = 0\n"; + EXPECT_EQ(expected_response_sign, stored_response_sign); + EXPECT_EQ("", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(0U, payload_state.GetUrlSwitchCount()); + EXPECT_EQ(1, payload_state.GetNumResponsesSeen()); +} + +TEST_F(PayloadStateTest, SetResponseWorksWithSingleUrl) { + OmahaResponse response; + response.packages.push_back({.payload_urls = {"https://single.url.test"}, + .size = 123456789, + .metadata_size = 58123, + .metadata_signature = "msign", + .hash = "hash"}); + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateTimestampStart, _)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateDurationUptime, _)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttps, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttpPeer, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)).Times(AtLeast(1)); + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + payload_state.SetResponse(response); + string stored_response_sign = payload_state.GetResponseSignature(); + string expected_response_sign = + "Payload 0:\n" + " Size = 123456789\n" + " Sha256 Hash = hash\n" + " Metadata Size = 58123\n" + " Metadata Signature = msign\n" + " Is Delta = 0\n" + " NumURLs = 1\n" + " Candidate Url0 = https://single.url.test\n" + "Max Failure Count Per Url = 0\n" + "Disable Payload Backoff = 0\n"; + EXPECT_EQ(expected_response_sign, stored_response_sign); + EXPECT_EQ("https://single.url.test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(0U, payload_state.GetUrlSwitchCount()); + EXPECT_EQ(1, payload_state.GetNumResponsesSeen()); +} + +TEST_F(PayloadStateTest, SetResponseWorksWithMultipleUrls) { + OmahaResponse response; + response.packages.push_back({.payload_urls = {"http://multiple.url.test", + "https://multiple.url.test"}, + .size = 523456789, + .metadata_size = 558123, + .metadata_signature = "metasign", + .hash = "rhash"}); + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttps, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttpPeer, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)).Times(AtLeast(1)); + + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + payload_state.SetResponse(response); + string stored_response_sign = payload_state.GetResponseSignature(); + string expected_response_sign = + "Payload 0:\n" + " Size = 523456789\n" + " Sha256 Hash = rhash\n" + " Metadata Size = 558123\n" + " Metadata Signature = metasign\n" + " Is Delta = 0\n" + " NumURLs = 2\n" + " Candidate Url0 = http://multiple.url.test\n" + " Candidate Url1 = https://multiple.url.test\n" + "Max Failure Count Per Url = 0\n" + "Disable Payload Backoff = 0\n"; + EXPECT_EQ(expected_response_sign, stored_response_sign); + EXPECT_EQ("http://multiple.url.test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(0U, payload_state.GetUrlSwitchCount()); + EXPECT_EQ(1, payload_state.GetNumResponsesSeen()); +} + +TEST_F(PayloadStateTest, CanAdvanceUrlIndexCorrectly) { + OmahaResponse response; + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + PayloadState payload_state; + + EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); + // Payload attempt should start with 0 and then advance to 1. + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 1)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(AtLeast(2)); + + // Reboots will be set + EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, _)).Times(AtLeast(1)); + + // Url index should go from 0 to 1 twice. + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 1)).Times(AtLeast(1)); + + // 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(AtLeast(4)); + + EXPECT_TRUE(payload_state.Initialize()); + + // This does a SetResponse which causes all the states to be set to 0 for + // the first time. + SetupPayloadStateWith2Urls( + "Hash1235", true, false, &payload_state, &response); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + + // Verify that on the first error, the URL index advances to 1. + ErrorCode error = ErrorCode::kDownloadMetadataSignatureMismatch; + payload_state.UpdateFailed(error); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + + // Verify that on the next error, the URL index wraps around to 0. + payload_state.UpdateFailed(error); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + + // Verify that on the next error, it again advances to 1. + payload_state.UpdateFailed(error); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + + // Verify that we switched URLs three times + EXPECT_EQ(3U, payload_state.GetUrlSwitchCount()); +} + +TEST_F(PayloadStateTest, NewResponseResetsPayloadState) { + OmahaResponse response; + PayloadState payload_state; + + EXPECT_TRUE(payload_state.Initialize()); + + // Set the first response. + SetupPayloadStateWith2Urls( + "Hash5823", true, false, &payload_state, &response); + EXPECT_EQ(1, payload_state.GetNumResponsesSeen()); + + // Advance the URL index to 1 by faking an error. + ErrorCode error = ErrorCode::kDownloadMetadataSignatureMismatch; + payload_state.UpdateFailed(error); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(1U, payload_state.GetUrlSwitchCount()); + + // Now, slightly change the response and set it again. + SetupPayloadStateWith2Urls( + "Hash8225", true, false, &payload_state, &response); + EXPECT_EQ(2, payload_state.GetNumResponsesSeen()); + + // Fake an error again. + payload_state.UpdateFailed(error); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(1U, payload_state.GetUrlSwitchCount()); + + // Return a third different response. + SetupPayloadStateWith2Urls( + "Hash9999", true, false, &payload_state, &response); + EXPECT_EQ(3, payload_state.GetNumResponsesSeen()); + + // Make sure the url index was reset to 0 because of the new response. + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(0U, payload_state.GetUrlSwitchCount()); + EXPECT_EQ(0U, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ(0U, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ( + 0U, payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); + EXPECT_EQ(0U, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); +} + +TEST_F(PayloadStateTest, AllCountersGetUpdatedProperlyOnErrorCodesAndEvents) { + OmahaResponse response; + PayloadState payload_state; + int progress_bytes = 100; + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + + EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) + .Times(AtLeast(2)); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 2)) + .Times(AtLeast(1)); + + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) + .Times(AtLeast(2)); + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 1)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 2)) + .Times(AtLeast(1)); + + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(AtLeast(4)); + + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(4)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 1)).Times(AtLeast(2)); + + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) + .Times(AtLeast(7)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 1)) + .Times(AtLeast(2)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 2)) + .Times(AtLeast(1)); + + EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateTimestampStart, _)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsUpdateDurationUptime, _)) + .Times(AtLeast(1)); + + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttps, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttpPeer, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kCurrentBytesDownloadedFromHttp, progress_bytes)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kTotalBytesDownloadedFromHttp, progress_bytes)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 0)).Times(AtLeast(1)); + + EXPECT_TRUE(payload_state.Initialize()); + + SetupPayloadStateWith2Urls( + "Hash5873", true, false, &payload_state, &response); + EXPECT_EQ(1, payload_state.GetNumResponsesSeen()); + + // This should advance the URL index. + payload_state.UpdateFailed(ErrorCode::kDownloadMetadataSignatureMismatch); + EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(1U, payload_state.GetUrlSwitchCount()); + + // This should advance the failure count only. + payload_state.UpdateFailed(ErrorCode::kDownloadTransferError); + EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(1U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(1U, payload_state.GetUrlSwitchCount()); + + // This should advance the failure count only. + payload_state.UpdateFailed(ErrorCode::kDownloadTransferError); + EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(2U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(1U, payload_state.GetUrlSwitchCount()); + + // 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(ErrorCode::kDownloadTransferError); + EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(2U, payload_state.GetUrlSwitchCount()); + EXPECT_TRUE(payload_state.ShouldBackoffDownload()); + + // This should advance the URL index. + payload_state.UpdateFailed(ErrorCode::kPayloadHashMismatchError); + EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(3U, payload_state.GetUrlSwitchCount()); + 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(ErrorCode::kDownloadMetadataSignatureMissingError); + EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(2, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(4U, payload_state.GetUrlSwitchCount()); + EXPECT_TRUE(payload_state.ShouldBackoffDownload()); + + // This HTTP error code should only increase the failure count. + payload_state.UpdateFailed(static_cast<ErrorCode>( + static_cast<int>(ErrorCode::kOmahaRequestHTTPResponseBase) + 404)); + EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(2, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(1U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(4U, payload_state.GetUrlSwitchCount()); + EXPECT_TRUE(payload_state.ShouldBackoffDownload()); + + // And that failure count should be reset when we download some bytes + // afterwards. + payload_state.DownloadProgress(progress_bytes); + EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(2, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(4U, payload_state.GetUrlSwitchCount()); + EXPECT_TRUE(payload_state.ShouldBackoffDownload()); + + // Now, slightly change the response and set it again. + SetupPayloadStateWith2Urls( + "Hash8532", true, false, &payload_state, &response); + EXPECT_EQ(2, payload_state.GetNumResponsesSeen()); + + // 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.GetFullPayloadAttemptNumber()); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(0U, payload_state.GetUrlSwitchCount()); + EXPECT_FALSE(payload_state.ShouldBackoffDownload()); +} + +TEST_F(PayloadStateTest, + PayloadAttemptNumberIncreasesOnSuccessfulFullDownload) { + OmahaResponse response; + PayloadState payload_state; + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + + EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)) + .Times(AtLeast(1)); + + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 1)) + .Times(AtLeast(1)); + + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(AtLeast(2)); + + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) + .Times(AtLeast(1)); + + EXPECT_TRUE(payload_state.Initialize()); + + SetupPayloadStateWith2Urls( + "Hash8593", true, false, &payload_state, &response); + + // This should just advance the payload attempt number; + EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber()); + payload_state.DownloadComplete(); + EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(0U, payload_state.GetUrlSwitchCount()); +} + +TEST_F(PayloadStateTest, + PayloadAttemptNumberIncreasesOnSuccessfulDeltaDownload) { + OmahaResponse response; + PayloadState payload_state; + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + + EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AnyNumber()); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)) + .Times(AtLeast(1)); + + // kPrefsFullPayloadAttemptNumber is not incremented for delta payloads. + EXPECT_CALL(*prefs, SetInt64(kPrefsFullPayloadAttemptNumber, 0)) + .Times(AtLeast(1)); + + EXPECT_CALL(*prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(1); + + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)) + .Times(AtLeast(1)); + + EXPECT_TRUE(payload_state.Initialize()); + + SetupPayloadStateWith2Urls("Hash8593", true, true, &payload_state, &response); + + // This should just advance the payload attempt number; + EXPECT_EQ(0, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber()); + payload_state.DownloadComplete(); + EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(0U, payload_state.GetUrlSwitchCount()); +} + +TEST_F(PayloadStateTest, SetResponseResetsInvalidUrlIndex) { + OmahaResponse response; + PayloadState payload_state; + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash4427", true, false, &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(ErrorCode::kDownloadMetadataSignatureMismatch); + payload_state.UpdateFailed(ErrorCode::kDownloadTransferError); + EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(1U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(1U, payload_state.GetUrlSwitchCount()); + + // Now, simulate a corrupted url index on persisted store which gets + // loaded when update_engine restarts. + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + EXPECT_CALL(*prefs, Exists(_)).WillRepeatedly(Return(true)); + EXPECT_CALL(*prefs, GetInt64(_, _)).Times(AtLeast(1)); + EXPECT_CALL(*prefs, GetInt64(kPrefsPayloadAttemptNumber, _)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, GetInt64(kPrefsFullPayloadAttemptNumber, _)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, GetInt64(kPrefsCurrentUrlIndex, _)) + .WillRepeatedly(DoAll(SetArgPointee<1>(2), Return(true))); + EXPECT_CALL(*prefs, GetInt64(kPrefsCurrentUrlFailureCount, _)) + .Times(AtLeast(1)); + EXPECT_CALL(*prefs, GetInt64(kPrefsUrlSwitchCount, _)).Times(AtLeast(1)); + + // 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()); + SetupPayloadStateWith2Urls( + "Hash4427", true, false, &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.GetFullPayloadAttemptNumber()); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + EXPECT_EQ(0U, payload_state.GetUrlSwitchCount()); +} + +TEST_F(PayloadStateTest, NoBackoffInteractiveChecks) { + OmahaResponse response; + PayloadState payload_state; + OmahaRequestParams params; + params.Init("", "", {.interactive = true}); + FakeSystemState::Get()->set_request_params(¶ms); + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash6437", true, false, &payload_state, &response); + + // Simulate two failures (enough to cause payload backoff) and check + // again that we're ready to re-download without any backoff as this is + // an interactive check. + payload_state.UpdateFailed(ErrorCode::kDownloadMetadataSignatureMismatch); + payload_state.UpdateFailed(ErrorCode::kDownloadMetadataSignatureMismatch); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_FALSE(payload_state.ShouldBackoffDownload()); +} + +TEST_F(PayloadStateTest, NoBackoffForP2PUpdates) { + OmahaResponse response; + PayloadState payload_state; + OmahaRequestParams params; + params.Init("", "", {}); + FakeSystemState::Get()->set_request_params(¶ms); + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash6437", true, false, &payload_state, &response); + + // Simulate two failures (enough to cause payload backoff) and check + // again that we're ready to re-download without any backoff as this is + // an interactive check. + payload_state.UpdateFailed(ErrorCode::kDownloadMetadataSignatureMismatch); + payload_state.UpdateFailed(ErrorCode::kDownloadMetadataSignatureMismatch); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(1, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(1, payload_state.GetFullPayloadAttemptNumber()); + // Set p2p url. + payload_state.SetUsingP2PForDownloading(true); + payload_state.SetP2PUrl("http://mypeer:52909/path/to/file"); + // Should not backoff for p2p updates. + EXPECT_FALSE(payload_state.ShouldBackoffDownload()); + + payload_state.SetP2PUrl(""); + // No actual p2p update if no url is provided. + EXPECT_TRUE(payload_state.ShouldBackoffDownload()); +} + +TEST_F(PayloadStateTest, NoBackoffForDeltaPayloads) { + OmahaResponse response; + PayloadState payload_state; + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls("Hash6437", true, true, &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(1, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber()); + 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(ErrorCode::kDownloadMetadataSignatureMismatch); + payload_state.UpdateFailed(ErrorCode::kDownloadMetadataSignatureMismatch); + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(0, payload_state.GetFullPayloadAttemptNumber()); + 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->GetFullPayloadAttemptNumber()); + 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_F(PayloadStateTest, BackoffPeriodsAreInCorrectRange) { + OmahaResponse response; + PayloadState payload_state; + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash8939", true, false, &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_F(PayloadStateTest, BackoffLogicCanBeDisabled) { + OmahaResponse response; + response.disable_payload_backoff = true; + PayloadState payload_state; + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash8939", true, false, &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_EQ(1, payload_state.GetFullPayloadAttemptNumber()); + 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(ErrorCode::kDownloadMetadataSignatureMismatch); + payload_state.UpdateFailed(ErrorCode::kDownloadMetadataSignatureMismatch); + EXPECT_EQ(2, payload_state.GetPayloadAttemptNumber()); + EXPECT_EQ(2, payload_state.GetFullPayloadAttemptNumber()); + EXPECT_FALSE(payload_state.ShouldBackoffDownload()); +} + +TEST_F(PayloadStateTest, BytesDownloadedMetricsGetAddedToCorrectSources) { + OmahaResponse response; + response.disable_payload_backoff = true; + PayloadState payload_state; + uint64_t https_total = 0; + uint64_t http_total = 0; + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash3286", true, false, &payload_state, &response); + EXPECT_EQ(1, payload_state.GetNumResponsesSeen()); + + // Simulate a previous attempt with in order to set an initial non-zero value + // for the total bytes downloaded for HTTP. + uint64_t prev_chunk = 323456789; + http_total += prev_chunk; + payload_state.DownloadProgress(prev_chunk); + + // Ensure that the initial values for HTTP reflect this attempt. + EXPECT_EQ(prev_chunk, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ(http_total, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); + + // Change the response hash so as to simulate a new response which will + // reset the current bytes downloaded, but not the total bytes downloaded. + SetupPayloadStateWith2Urls( + "Hash9904", true, false, &payload_state, &response); + EXPECT_EQ(2, payload_state.GetNumResponsesSeen()); + + // First, simulate successful download of a few bytes over HTTP. + uint64_t first_chunk = 5000000; + http_total += first_chunk; + payload_state.DownloadProgress(first_chunk); + // Test that first all progress is made on HTTP and none on HTTPS. + EXPECT_EQ(first_chunk, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ(http_total, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ( + 0U, payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); + EXPECT_EQ(https_total, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); + + // Simulate an error that'll cause the url index to point to https. + ErrorCode error = ErrorCode::kDownloadMetadataSignatureMismatch; + payload_state.UpdateFailed(error); + + // Test that no new progress is made on HTTP and new progress is on HTTPS. + uint64_t second_chunk = 23456789; + https_total += second_chunk; + payload_state.DownloadProgress(second_chunk); + EXPECT_EQ(first_chunk, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ(http_total, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ( + second_chunk, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); + EXPECT_EQ(https_total, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); + + // Simulate error to go back to http. + payload_state.UpdateFailed(error); + uint64_t third_chunk = 32345678; + uint64_t http_chunk = first_chunk + third_chunk; + http_total += third_chunk; + payload_state.DownloadProgress(third_chunk); + + // Test that third chunk is again back on HTTP. HTTPS remains on second chunk. + EXPECT_EQ(http_chunk, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ(http_total, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ( + second_chunk, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); + EXPECT_EQ(https_total, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); + + // Simulate error (will cause URL switch), set p2p is to be used and + // then do 42MB worth of progress + payload_state.UpdateFailed(error); + payload_state.SetUsingP2PForDownloading(true); + uint64_t p2p_total = 42 * 1000 * 1000; + payload_state.DownloadProgress(p2p_total); + + EXPECT_EQ(p2p_total, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpPeer)); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportSuccessfulUpdateMetrics( + 1, _, kPayloadTypeFull, _, _, 314, _, _, _, 3)); + + payload_state.UpdateSucceeded(); + + // Make sure the metrics are reset after a successful update. + EXPECT_EQ(0U, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ(0U, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ( + 0U, payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); + EXPECT_EQ(0U, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); + EXPECT_EQ(0, payload_state.GetNumResponsesSeen()); +} + +TEST_F(PayloadStateTest, DownloadSourcesUsedIsCorrect) { + OmahaResponse response; + PayloadState payload_state; + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash3286", true, false, &payload_state, &response); + + // Simulate progress in order to mark HTTP as one of the sources used. + uint64_t num_bytes = 42 * 1000 * 1000; + payload_state.DownloadProgress(num_bytes); + + // Check that this was done via HTTP. + EXPECT_EQ(num_bytes, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ(num_bytes, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); + + // Check that only HTTP is reported as a download source. + int64_t total_bytes[kNumDownloadSources] = {}; + total_bytes[kDownloadSourceHttpServer] = num_bytes; + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportSuccessfulUpdateMetrics( + _, + _, + _, + _, + test_utils::DownloadSourceMatcher(total_bytes), + _, + _, + _, + _, + _)) + .Times(1); + + payload_state.UpdateSucceeded(); +} + +TEST_F(PayloadStateTest, RestartingUpdateResetsMetrics) { + OmahaResponse response; + PayloadState payload_state; + + EXPECT_TRUE(payload_state.Initialize()); + + // Set the first response. + SetupPayloadStateWith2Urls( + "Hash5823", true, false, &payload_state, &response); + + uint64_t num_bytes = 10000; + payload_state.DownloadProgress(num_bytes); + EXPECT_EQ(num_bytes, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ(num_bytes, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ( + 0U, payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpsServer)); + EXPECT_EQ(0U, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpsServer)); + + payload_state.UpdateRestarted(); + // Make sure the current bytes downloaded is reset, but not the total bytes. + EXPECT_EQ(0U, + payload_state.GetCurrentBytesDownloaded(kDownloadSourceHttpServer)); + EXPECT_EQ(num_bytes, + payload_state.GetTotalBytesDownloaded(kDownloadSourceHttpServer)); +} + +TEST_F(PayloadStateTest, NumRebootsIncrementsCorrectly) { + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + EXPECT_CALL(*prefs, SetInt64(_, _)).Times(AtLeast(0)); + EXPECT_CALL(*prefs, SetInt64(kPrefsNumReboots, 1)).Times(AtLeast(1)); + + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + + payload_state.UpdateRestarted(); + EXPECT_EQ(0U, payload_state.GetNumReboots()); + + FakeSystemState::Get()->set_system_rebooted(true); + payload_state.UpdateResumed(); + // Num reboots should be incremented because system rebooted detected. + EXPECT_EQ(1U, payload_state.GetNumReboots()); + + FakeSystemState::Get()->set_system_rebooted(false); + payload_state.UpdateResumed(); + // Num reboots should now be 1 as reboot was not detected. + EXPECT_EQ(1U, payload_state.GetNumReboots()); + + // Restart the update again to verify we set the num of reboots back to 0. + payload_state.UpdateRestarted(); + EXPECT_EQ(0U, payload_state.GetNumReboots()); +} + +TEST_F(PayloadStateTest, RollbackHappened) { + FakeSystemState::Get()->set_powerwash_safe_prefs(nullptr); + auto* mock_powerwash_safe_prefs = + FakeSystemState::Get()->mock_powerwash_safe_prefs(); + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + + // Verify pre-conditions are good. + EXPECT_FALSE(payload_state.GetRollbackHappened()); + + // Set to true. + EXPECT_CALL(*mock_powerwash_safe_prefs, + SetBoolean(kPrefsRollbackHappened, true)); + payload_state.SetRollbackHappened(true); + EXPECT_TRUE(payload_state.GetRollbackHappened()); + + // Set to false. + EXPECT_CALL(*mock_powerwash_safe_prefs, Delete(kPrefsRollbackHappened)); + payload_state.SetRollbackHappened(false); + EXPECT_FALSE(payload_state.GetRollbackHappened()); + + // Let's verify we can reload it correctly. + EXPECT_CALL(*mock_powerwash_safe_prefs, GetBoolean(kPrefsRollbackHappened, _)) + .WillOnce(DoAll(SetArgPointee<1>(true), Return(true))); + EXPECT_CALL(*mock_powerwash_safe_prefs, + SetBoolean(kPrefsRollbackHappened, true)); + payload_state.LoadRollbackHappened(); + EXPECT_TRUE(payload_state.GetRollbackHappened()); +} + +TEST_F(PayloadStateTest, RollbackVersion) { + FakeSystemState::Get()->set_powerwash_safe_prefs(nullptr); + auto* mock_powerwash_safe_prefs = + FakeSystemState::Get()->mock_powerwash_safe_prefs(); + + // Mock out the os version and make sure it's excluded correctly. + string rollback_version = "2345.0.0"; + OmahaRequestParams params; + params.Init(rollback_version, "", {}); + FakeSystemState::Get()->set_request_params(¶ms); + + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + + // Verify pre-conditions are good. + EXPECT_TRUE(payload_state.GetRollbackVersion().empty()); + + EXPECT_CALL(*mock_powerwash_safe_prefs, + SetString(kPrefsRollbackVersion, rollback_version)); + payload_state.Rollback(); + + EXPECT_EQ(rollback_version, payload_state.GetRollbackVersion()); + + // Change it up a little and verify we load it correctly. + rollback_version = "2345.0.1"; + // Let's verify we can reload it correctly. + EXPECT_CALL(*mock_powerwash_safe_prefs, GetString(kPrefsRollbackVersion, _)) + .WillOnce(DoAll(SetArgPointee<1>(rollback_version), Return(true))); + EXPECT_CALL(*mock_powerwash_safe_prefs, + SetString(kPrefsRollbackVersion, rollback_version)); + payload_state.LoadRollbackVersion(); + EXPECT_EQ(rollback_version, payload_state.GetRollbackVersion()); + + // Check that we report only UpdateEngine.Rollback.* metrics in + // UpdateSucceeded(). + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportRollbackMetrics(metrics::RollbackResult::kSuccess)) + .Times(1); + + payload_state.UpdateSucceeded(); +} + +TEST_F(PayloadStateTest, DurationsAreCorrect) { + OmahaResponse response; + response.packages.resize(1); + + // Set the clock to a well-known time - 1 second on the wall-clock + // and 2 seconds on the monotonic clock + auto* fake_clock = FakeSystemState::Get()->fake_clock(); + fake_clock->SetWallclockTime(Time::FromInternalValue(1000000)); + fake_clock->SetMonotonicTime(Time::FromInternalValue(2000000)); + + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + + // Check that durations are correct for a successful update where + // time has advanced 7 seconds on the wall clock and 4 seconds on + // the monotonic clock. + SetupPayloadStateWith2Urls( + "Hash8593", true, false, &payload_state, &response); + fake_clock->SetWallclockTime(Time::FromInternalValue(8000000)); + fake_clock->SetMonotonicTime(Time::FromInternalValue(6000000)); + payload_state.UpdateSucceeded(); + EXPECT_EQ(payload_state.GetUpdateDuration().InMicroseconds(), 7000000); + EXPECT_EQ(payload_state.GetUpdateDurationUptime().InMicroseconds(), 4000000); + + // Check that durations are reset when a new response comes in. + SetupPayloadStateWith2Urls( + "Hash8594", true, false, &payload_state, &response); + EXPECT_EQ(payload_state.GetUpdateDuration().InMicroseconds(), 0); + EXPECT_EQ(payload_state.GetUpdateDurationUptime().InMicroseconds(), 0); + + // Advance time a bit (10 secs), simulate download progress and + // check that durations are updated. + fake_clock->SetWallclockTime(Time::FromInternalValue(18000000)); + fake_clock->SetMonotonicTime(Time::FromInternalValue(16000000)); + payload_state.DownloadProgress(10); + EXPECT_EQ(payload_state.GetUpdateDuration().InMicroseconds(), 10000000); + EXPECT_EQ(payload_state.GetUpdateDurationUptime().InMicroseconds(), 10000000); + + // Now simulate a reboot by resetting monotonic time (to 5000) and + // creating a new PayloadState object and check that we load the + // durations correctly (e.g. they are the same as before). + fake_clock->SetMonotonicTime(Time::FromInternalValue(5000)); + PayloadState payload_state2; + EXPECT_TRUE(payload_state2.Initialize()); + payload_state2.SetResponse(response); + EXPECT_EQ(payload_state2.GetUpdateDuration().InMicroseconds(), 10000000); + EXPECT_EQ(payload_state2.GetUpdateDurationUptime().InMicroseconds(), + 10000000); + + // Advance wall-clock by 7 seconds and monotonic clock by 6 seconds + // and check that the durations are increased accordingly. + fake_clock->SetWallclockTime(Time::FromInternalValue(25000000)); + fake_clock->SetMonotonicTime(Time::FromInternalValue(6005000)); + payload_state2.UpdateSucceeded(); + EXPECT_EQ(payload_state2.GetUpdateDuration().InMicroseconds(), 17000000); + EXPECT_EQ(payload_state2.GetUpdateDurationUptime().InMicroseconds(), + 16000000); +} + +TEST_F(PayloadStateTest, RebootAfterSuccessfulUpdateTest) { + OmahaResponse response; + + // Set the clock to a well-known time (t = 30 seconds). + auto* fake_clock = FakeSystemState::Get()->fake_clock(); + fake_clock->SetMonotonicTime( + Time::FromInternalValue(30 * Time::kMicrosecondsPerSecond)); + + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + + // Make the update succeed. + SetupPayloadStateWith2Urls( + "Hash8593", true, false, &payload_state, &response); + payload_state.UpdateSucceeded(); + + auto* fake_prefs = FakeSystemState::Get()->fake_prefs(); + // Check that the marker was written. + EXPECT_TRUE(fake_prefs->Exists(kPrefsSystemUpdatedMarker)); + + // Now simulate a reboot and set the wallclock time to a later point + // (t = 500 seconds). We do this by using a new PayloadState object + // and checking that it emits the right UMA metric with the right + // value. + fake_clock->SetMonotonicTime( + Time::FromInternalValue(500 * Time::kMicrosecondsPerSecond)); + PayloadState payload_state2; + EXPECT_TRUE(payload_state2.Initialize()); + + // Expect 500 - 30 seconds = 470 seconds ~= 7 min 50 sec + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportTimeToReboot(7)); + FakeSystemState::Get()->set_system_rebooted(true); + + payload_state2.UpdateEngineStarted(); + + // Check that the marker was nuked. + EXPECT_FALSE(fake_prefs->Exists(kPrefsSystemUpdatedMarker)); +} + +TEST_F(PayloadStateTest, RestartAfterCrash) { + PayloadState payload_state; + testing::StrictMock<MockMetricsReporter> mock_metrics_reporter; + FakeSystemState::Get()->set_metrics_reporter(&mock_metrics_reporter); + FakeSystemState::Get()->set_prefs(nullptr); + auto* prefs = FakeSystemState::Get()->mock_prefs(); + + EXPECT_TRUE(payload_state.Initialize()); + + // Only the |kPrefsAttemptInProgress| state variable should be read. + EXPECT_CALL(*prefs, Exists(_)).Times(0); + EXPECT_CALL(*prefs, SetString(_, _)).Times(0); + EXPECT_CALL(*prefs, SetInt64(_, _)).Times(0); + EXPECT_CALL(*prefs, SetBoolean(_, _)).Times(0); + EXPECT_CALL(*prefs, GetString(_, _)).Times(0); + EXPECT_CALL(*prefs, GetInt64(_, _)).Times(0); + EXPECT_CALL(*prefs, GetBoolean(_, _)).Times(0); + EXPECT_CALL(*prefs, GetBoolean(kPrefsAttemptInProgress, _)); + + // Simulate an update_engine restart without a reboot. + FakeSystemState::Get()->set_system_rebooted(false); + + payload_state.UpdateEngineStarted(); +} + +TEST_F(PayloadStateTest, AbnormalTerminationAttemptMetricsNoReporting) { + PayloadState payload_state; + + // If there's no marker at startup, ensure we don't report a metric. + EXPECT_TRUE(payload_state.Initialize()); + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportAbnormallyTerminatedUpdateAttemptMetrics()) + .Times(0); + payload_state.UpdateEngineStarted(); +} + +TEST_F(PayloadStateTest, AbnormalTerminationAttemptMetricsReported) { + // If we have a marker at startup, ensure it's reported and the + // marker is then cleared. + auto* fake_prefs = FakeSystemState::Get()->fake_prefs(); + fake_prefs->SetBoolean(kPrefsAttemptInProgress, true); + + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportAbnormallyTerminatedUpdateAttemptMetrics()) + .Times(1); + payload_state.UpdateEngineStarted(); + + EXPECT_FALSE(fake_prefs->Exists(kPrefsAttemptInProgress)); +} + +TEST_F(PayloadStateTest, AbnormalTerminationAttemptMetricsClearedOnSucceess) { + // Make sure the marker is written and cleared during an attempt and + // also that we DO NOT emit the metric (since the attempt didn't end + // abnormally). + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + OmahaResponse response; + response.packages.resize(1); + payload_state.SetResponse(response); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportAbnormallyTerminatedUpdateAttemptMetrics()) + .Times(0); + + auto* fake_prefs = FakeSystemState::Get()->fake_prefs(); + // Attempt not in progress, should be clear. + EXPECT_FALSE(fake_prefs->Exists(kPrefsAttemptInProgress)); + + payload_state.UpdateRestarted(); + + // Attempt not in progress, should be set. + EXPECT_TRUE(fake_prefs->Exists(kPrefsAttemptInProgress)); + + payload_state.UpdateSucceeded(); + + // Attempt not in progress, should be clear. + EXPECT_FALSE(fake_prefs->Exists(kPrefsAttemptInProgress)); +} + +TEST_F(PayloadStateTest, CandidateUrlsComputedCorrectly) { + OmahaResponse response; + PayloadState payload_state; + + policy::MockDevicePolicy disable_http_policy; + FakeSystemState::Get()->set_device_policy(&disable_http_policy); + EXPECT_TRUE(payload_state.Initialize()); + + // Test with no device policy. Should default to allowing http. + EXPECT_CALL(disable_http_policy, GetHttpDownloadsEnabled(_)) + .WillRepeatedly(Return(false)); + + // Set the first response. + SetupPayloadStateWith2Urls( + "Hash8433", true, false, &payload_state, &response); + + // Check that we use the HTTP URL since there is no value set for allowing + // http. + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + + // Test with device policy not allowing http updates. + EXPECT_CALL(disable_http_policy, GetHttpDownloadsEnabled(_)) + .WillRepeatedly(DoAll(SetArgPointee<0>(false), Return(true))); + + // Reset state and set again. + SetupPayloadStateWith2Urls( + "Hash8433", false, false, &payload_state, &response); + + // Check that we skip the HTTP URL and use only the HTTPS url. + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + + // Advance the URL index to 1 by faking an error. + ErrorCode error = ErrorCode::kDownloadMetadataSignatureMismatch; + payload_state.UpdateFailed(error); + + // Check that we still skip the HTTP URL and use only the HTTPS url. + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlSwitchCount()); + + // Now, slightly change the response and set it again. + SetupPayloadStateWith2Urls( + "Hash2399", false, false, &payload_state, &response); + + // Check that we still skip the HTTP URL and use only the HTTPS url. + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + + // Now, pretend that the HTTP policy is turned on. We want to make sure + // the new policy is honored. + policy::MockDevicePolicy enable_http_policy; + FakeSystemState::Get()->set_device_policy(&enable_http_policy); + EXPECT_CALL(enable_http_policy, GetHttpDownloadsEnabled(_)) + .WillRepeatedly(DoAll(SetArgPointee<0>(true), Return(true))); + + // Now, set the same response using the same hash + // so that we can test that the state is reset not because of the + // hash but because of the policy change which results in candidate url + // list change. + SetupPayloadStateWith2Urls( + "Hash2399", true, false, &payload_state, &response); + + // Check that we use the HTTP URL now and the failure count is reset. + EXPECT_EQ("http://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); + + // Fake a failure and see if we're moving over to the HTTPS url and update + // the URL switch count properly. + payload_state.UpdateFailed(error); + EXPECT_EQ("https://test", payload_state.GetCurrentUrl()); + EXPECT_EQ(1U, payload_state.GetUrlSwitchCount()); + EXPECT_EQ(0U, payload_state.GetUrlFailureCount()); +} + +TEST_F(PayloadStateTest, PayloadTypeMetricWhenTypeIsDelta) { + OmahaResponse response; + PayloadState payload_state; + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls("Hash6437", true, true, &payload_state, &response); + + // Simulate a successful download and update. + payload_state.DownloadComplete(); + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportSuccessfulUpdateMetrics( + _, _, kPayloadTypeDelta, _, _, _, _, _, _, _)); + payload_state.UpdateSucceeded(); + + // Mock the request to a request where the delta was disabled but Omaha sends + // a delta anyway and test again. + OmahaRequestParams params; + params.set_delta_okay(false); + FakeSystemState::Get()->set_request_params(¶ms); + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls("Hash6437", true, true, &payload_state, &response); + + payload_state.DownloadComplete(); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportSuccessfulUpdateMetrics( + _, _, kPayloadTypeDelta, _, _, _, _, _, _, _)); + payload_state.UpdateSucceeded(); +} + +TEST_F(PayloadStateTest, PayloadTypeMetricWhenTypeIsForcedFull) { + OmahaResponse response; + PayloadState payload_state; + + // Mock the request to a request where the delta was disabled. + OmahaRequestParams params; + params.set_delta_okay(false); + FakeSystemState::Get()->set_request_params(¶ms); + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash6437", true, false, &payload_state, &response); + + // Simulate a successful download and update. + payload_state.DownloadComplete(); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportSuccessfulUpdateMetrics( + _, _, kPayloadTypeForcedFull, _, _, _, _, _, _, _)); + payload_state.UpdateSucceeded(); +} + +TEST_F(PayloadStateTest, PayloadTypeMetricWhenTypeIsFull) { + OmahaResponse response; + PayloadState payload_state; + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash6437", true, false, &payload_state, &response); + + // Mock the request to a request where the delta is enabled, although the + // result is full. + OmahaRequestParams params; + params.set_delta_okay(true); + FakeSystemState::Get()->set_request_params(¶ms); + + // Simulate a successful download and update. + payload_state.DownloadComplete(); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportSuccessfulUpdateMetrics( + _, _, kPayloadTypeFull, _, _, _, _, _, _, _)); + payload_state.UpdateSucceeded(); +} + +TEST_F(PayloadStateTest, RebootAfterUpdateFailedMetric) { + OmahaResponse response; + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash3141", true, false, &payload_state, &response); + + // Simulate a successful download and update. + payload_state.DownloadComplete(); + payload_state.UpdateSucceeded(); + payload_state.ExpectRebootInNewVersion("Version:12345678"); + + // Reboot into the same environment to get an UMA metric with a value of 1. + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportFailedUpdateCount(1)); + payload_state.ReportFailedBootIfNeeded(); + Mock::VerifyAndClearExpectations( + FakeSystemState::Get()->mock_metrics_reporter()); + + // Simulate a second update and reboot into the same environment, this should + // send a value of 2. + payload_state.ExpectRebootInNewVersion("Version:12345678"); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportFailedUpdateCount(2)); + payload_state.ReportFailedBootIfNeeded(); + Mock::VerifyAndClearExpectations( + FakeSystemState::Get()->mock_metrics_reporter()); + + // Simulate a third failed reboot to new version, but this time for a + // different payload. This should send a value of 1 this time. + payload_state.ExpectRebootInNewVersion("Version:3141592"); + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportFailedUpdateCount(1)); + payload_state.ReportFailedBootIfNeeded(); + Mock::VerifyAndClearExpectations( + FakeSystemState::Get()->mock_metrics_reporter()); +} + +TEST_F(PayloadStateTest, RebootAfterUpdateSucceed) { + OmahaResponse response; + PayloadState payload_state; + FakeBootControl* fake_boot_control = + FakeSystemState::Get()->fake_boot_control(); + fake_boot_control->SetCurrentSlot(0); + + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash3141", true, false, &payload_state, &response); + + // Simulate a successful download and update. + payload_state.DownloadComplete(); + payload_state.UpdateSucceeded(); + payload_state.ExpectRebootInNewVersion("Version:12345678"); + + // Change the BootDevice to a different one, no metric should be sent. + fake_boot_control->SetCurrentSlot(1); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportFailedUpdateCount(_)) + .Times(0); + payload_state.ReportFailedBootIfNeeded(); + + // A second reboot in either partition should not send a metric. + payload_state.ReportFailedBootIfNeeded(); + fake_boot_control->SetCurrentSlot(0); + payload_state.ReportFailedBootIfNeeded(); +} + +TEST_F(PayloadStateTest, RebootAfterCanceledUpdate) { + OmahaResponse response; + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash3141", true, false, &payload_state, &response); + + // Simulate a successful download and update. + payload_state.DownloadComplete(); + payload_state.UpdateSucceeded(); + payload_state.ExpectRebootInNewVersion("Version:12345678"); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportFailedUpdateCount(_)) + .Times(0); + + // Cancel the applied update. + payload_state.ResetUpdateStatus(); + + // Simulate a reboot. + payload_state.ReportFailedBootIfNeeded(); +} + +TEST_F(PayloadStateTest, UpdateSuccessWithWipedPrefs) { + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + + EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(), + ReportFailedUpdateCount(_)) + .Times(0); + + // Simulate a reboot in this environment. + payload_state.ReportFailedBootIfNeeded(); +} + +TEST_F(PayloadStateTest, DisallowP2PAfterTooManyAttempts) { + OmahaResponse response; + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash8593", true, false, &payload_state, &response); + + // Should allow exactly kMaxP2PAttempts... + for (int n = 0; n < kMaxP2PAttempts; n++) { + payload_state.P2PNewAttempt(); + EXPECT_TRUE(payload_state.P2PAttemptAllowed()); + } + // ... but not more than that. + payload_state.P2PNewAttempt(); + EXPECT_FALSE(payload_state.P2PAttemptAllowed()); +} + +TEST_F(PayloadStateTest, DisallowP2PAfterDeadline) { + OmahaResponse response; + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash8593", true, false, &payload_state, &response); + + // Set the clock to 1 second. + Time epoch = Time::FromInternalValue(1000000); + auto* fake_clock = FakeSystemState::Get()->fake_clock(); + fake_clock->SetWallclockTime(epoch); + + // Do an attempt - this will set the timestamp. + payload_state.P2PNewAttempt(); + + // Check that the timestamp equals what we just set. + EXPECT_EQ(epoch, payload_state.GetP2PFirstAttemptTimestamp()); + + // Time hasn't advanced - this should work. + EXPECT_TRUE(payload_state.P2PAttemptAllowed()); + + // Set clock to half the deadline - this should work. + fake_clock->SetWallclockTime( + epoch + TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds) / 2); + EXPECT_TRUE(payload_state.P2PAttemptAllowed()); + + // Check that the first attempt timestamp hasn't changed just + // because the wall-clock time changed. + EXPECT_EQ(epoch, payload_state.GetP2PFirstAttemptTimestamp()); + + // Set clock to _just_ before the deadline - this should work. + fake_clock->SetWallclockTime( + epoch + TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds - 1)); + EXPECT_TRUE(payload_state.P2PAttemptAllowed()); + + // Set clock to _just_ after the deadline - this should not work. + fake_clock->SetWallclockTime( + epoch + TimeDelta::FromSeconds(kMaxP2PAttemptTimeSeconds + 1)); + EXPECT_FALSE(payload_state.P2PAttemptAllowed()); +} + +TEST_F(PayloadStateTest, P2PStateVarsInitialValue) { + OmahaResponse response; + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash8593", true, false, &payload_state, &response); + + Time null_time = Time(); + EXPECT_EQ(null_time, payload_state.GetP2PFirstAttemptTimestamp()); + EXPECT_EQ(0, payload_state.GetP2PNumAttempts()); +} + +TEST_F(PayloadStateTest, P2PStateVarsArePersisted) { + OmahaResponse response; + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash8593", true, false, &payload_state, &response); + + // Set the clock to something known. + Time time = Time::FromInternalValue(12345); + FakeSystemState::Get()->fake_clock()->SetWallclockTime(time); + + // New p2p attempt - as a side-effect this will update the p2p state vars. + payload_state.P2PNewAttempt(); + EXPECT_EQ(1, payload_state.GetP2PNumAttempts()); + EXPECT_EQ(time, payload_state.GetP2PFirstAttemptTimestamp()); + + // Now create a new PayloadState and check that it loads the state + // vars correctly. + PayloadState payload_state2; + EXPECT_TRUE(payload_state2.Initialize()); + EXPECT_EQ(1, payload_state2.GetP2PNumAttempts()); + EXPECT_EQ(time, payload_state2.GetP2PFirstAttemptTimestamp()); +} + +TEST_F(PayloadStateTest, P2PStateVarsAreClearedOnNewResponse) { + OmahaResponse response; + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + SetupPayloadStateWith2Urls( + "Hash8593", true, false, &payload_state, &response); + + // Set the clock to something known. + Time time = Time::FromInternalValue(12345); + FakeSystemState::Get()->fake_clock()->SetWallclockTime(time); + + // New p2p attempt - as a side-effect this will update the p2p state vars. + payload_state.P2PNewAttempt(); + EXPECT_EQ(1, payload_state.GetP2PNumAttempts()); + EXPECT_EQ(time, payload_state.GetP2PFirstAttemptTimestamp()); + + // Set a new response... + SetupPayloadStateWith2Urls( + "Hash9904", true, false, &payload_state, &response); + + // ... and check that it clears the P2P state vars. + Time null_time = Time(); + EXPECT_EQ(0, payload_state.GetP2PNumAttempts()); + EXPECT_EQ(null_time, payload_state.GetP2PFirstAttemptTimestamp()); +} + +TEST_F(PayloadStateTest, NextPayloadResetsUrlIndex) { + PayloadState payload_state; + StrictMock<MockExcluder> mock_excluder; + EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetExcluder()) + .WillOnce(Return(&mock_excluder)); + EXPECT_TRUE(payload_state.Initialize()); + + OmahaResponse response; + response.packages.push_back( + {.payload_urls = {"http://test1a", "http://test2a"}, + .size = 123456789, + .metadata_size = 58123, + .metadata_signature = "msign", + .hash = "hash"}); + response.packages.push_back({.payload_urls = {"http://test1b"}, + .size = 123456789, + .metadata_size = 58123, + .metadata_signature = "msign", + .hash = "hash"}); + payload_state.SetResponse(response); + + EXPECT_EQ(payload_state.GetCurrentUrl(), "http://test1a"); + payload_state.IncrementUrlIndex(); + EXPECT_EQ(payload_state.GetCurrentUrl(), "http://test2a"); + + EXPECT_TRUE(payload_state.NextPayload()); + EXPECT_EQ(payload_state.GetCurrentUrl(), "http://test1b"); +} + +TEST_F(PayloadStateTest, ExcludeNoopForNonExcludables) { + PayloadState payload_state; + StrictMock<MockExcluder> mock_excluder; + EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetExcluder()) + .WillOnce(Return(&mock_excluder)); + EXPECT_TRUE(payload_state.Initialize()); + + OmahaResponse response; + response.packages.push_back( + {.payload_urls = {"http://test1a", "http://test2a"}, + .size = 123456789, + .metadata_size = 58123, + .metadata_signature = "msign", + .hash = "hash", + .can_exclude = false}); + payload_state.SetResponse(response); + + EXPECT_CALL(mock_excluder, Exclude(_)).Times(0); + payload_state.ExcludeCurrentPayload(); +} + +TEST_F(PayloadStateTest, ExcludeOnlyCanExcludables) { + PayloadState payload_state; + StrictMock<MockExcluder> mock_excluder; + EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetExcluder()) + .WillOnce(Return(&mock_excluder)); + EXPECT_TRUE(payload_state.Initialize()); + + OmahaResponse response; + response.packages.push_back( + {.payload_urls = {"http://test1a", "http://test2a"}, + .size = 123456789, + .metadata_size = 58123, + .metadata_signature = "msign", + .hash = "hash", + .can_exclude = true}); + payload_state.SetResponse(response); + + EXPECT_CALL(mock_excluder, Exclude(utils::GetExclusionName("http://test1a"))) + .WillOnce(Return(true)); + payload_state.ExcludeCurrentPayload(); +} + +TEST_F(PayloadStateTest, IncrementFailureExclusionTest) { + PayloadState payload_state; + StrictMock<MockExcluder> mock_excluder; + EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetExcluder()) + .WillOnce(Return(&mock_excluder)); + EXPECT_TRUE(payload_state.Initialize()); + + OmahaResponse response; + // Critical package. + response.packages.push_back( + {.payload_urls = {"http://crit-test1a", "http://crit-test2a"}, + .size = 123456789, + .metadata_size = 58123, + .metadata_signature = "msign", + .hash = "hash", + .can_exclude = false}); + // Non-critical package. + response.packages.push_back( + {.payload_urls = {"http://test1a", "http://test2a"}, + .size = 123456789, + .metadata_size = 58123, + .metadata_signature = "msign", + .hash = "hash", + .can_exclude = true}); + response.max_failure_count_per_url = 2; + payload_state.SetResponse(response); + + // Critical package won't be excluded. + // Increment twice as failure count allowed per URL is set to 2. + payload_state.IncrementFailureCount(); + payload_state.IncrementFailureCount(); + + EXPECT_TRUE(payload_state.NextPayload()); + + // First increment failure should not exclude. + payload_state.IncrementFailureCount(); + + // Second increment failure should exclude. + EXPECT_CALL(mock_excluder, Exclude(utils::GetExclusionName("http://test1a"))) + .WillOnce(Return(true)); + payload_state.IncrementFailureCount(); +} + +TEST_F(PayloadStateTest, HaltExclusionPostPayloadExhaustion) { + PayloadState payload_state; + StrictMock<MockExcluder> mock_excluder; + EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetExcluder()) + .WillOnce(Return(&mock_excluder)); + EXPECT_TRUE(payload_state.Initialize()); + + OmahaResponse response; + // Non-critical package. + response.packages.push_back( + {.payload_urls = {"http://test1a", "http://test2a"}, + .size = 123456789, + .metadata_size = 58123, + .metadata_signature = "msign", + .hash = "hash", + .can_exclude = true}); + payload_state.SetResponse(response); + + // Exclusion should be called when excluded. + EXPECT_CALL(mock_excluder, Exclude(utils::GetExclusionName("http://test1a"))) + .WillOnce(Return(true)); + payload_state.ExcludeCurrentPayload(); + + // No more paylods to go through. + EXPECT_FALSE(payload_state.NextPayload()); + + // Exclusion should not be called as all |Payload|s are exhausted. + payload_state.ExcludeCurrentPayload(); +} + +TEST_F(PayloadStateTest, NonInfinitePayloadIndexIncrement) { + PayloadState payload_state; + EXPECT_TRUE(payload_state.Initialize()); + + payload_state.SetResponse({}); + + EXPECT_FALSE(payload_state.NextPayload()); + int payload_index = payload_state.payload_index_; + + EXPECT_FALSE(payload_state.NextPayload()); + EXPECT_EQ(payload_index, payload_state.payload_index_); +} + +} // namespace chromeos_update_engine |