You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3190 lines
131 KiB
3190 lines
131 KiB
//
|
|
// 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/omaha_request_action.h"
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <limits>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <base/bind.h>
|
|
#include <base/files/file_util.h>
|
|
#include <base/files/scoped_temp_dir.h>
|
|
#include <base/memory/ptr_util.h>
|
|
#include <base/strings/string_number_conversions.h>
|
|
#include <base/strings/string_util.h>
|
|
#include <base/strings/stringprintf.h>
|
|
#include <base/time/time.h>
|
|
#include <brillo/message_loops/fake_message_loop.h>
|
|
#include <brillo/message_loops/message_loop.h>
|
|
#include <brillo/message_loops/message_loop_utils.h>
|
|
#include <expat.h>
|
|
#include <gtest/gtest.h>
|
|
#include <policy/libpolicy.h>
|
|
#include <policy/mock_libpolicy.h>
|
|
|
|
#include "update_engine/common/action_pipe.h"
|
|
#include "update_engine/common/constants.h"
|
|
#include "update_engine/common/fake_prefs.h"
|
|
#include "update_engine/common/hash_calculator.h"
|
|
#include "update_engine/common/metrics_reporter_interface.h"
|
|
#include "update_engine/common/mock_excluder.h"
|
|
#include "update_engine/common/mock_http_fetcher.h"
|
|
#include "update_engine/common/platform_constants.h"
|
|
#include "update_engine/common/prefs.h"
|
|
#include "update_engine/common/test_utils.h"
|
|
#include "update_engine/cros/fake_system_state.h"
|
|
#include "update_engine/cros/mock_connection_manager.h"
|
|
#include "update_engine/cros/mock_payload_state.h"
|
|
#include "update_engine/cros/omaha_request_builder_xml.h"
|
|
#include "update_engine/cros/omaha_request_params.h"
|
|
#include "update_engine/cros/omaha_utils.h"
|
|
#include "update_engine/update_manager/rollback_prefs.h"
|
|
|
|
using base::Time;
|
|
using base::TimeDelta;
|
|
using chromeos_update_manager::kRollforwardInfinity;
|
|
using std::pair;
|
|
using std::string;
|
|
using std::vector;
|
|
using testing::_;
|
|
using testing::AllOf;
|
|
using testing::AnyNumber;
|
|
using testing::DoAll;
|
|
using testing::Ge;
|
|
using testing::Le;
|
|
using testing::NiceMock;
|
|
using testing::Return;
|
|
using testing::ReturnPointee;
|
|
using testing::ReturnRef;
|
|
using testing::SaveArg;
|
|
using testing::SetArgPointee;
|
|
using testing::StrictMock;
|
|
|
|
namespace {
|
|
|
|
static_assert(kRollforwardInfinity == 0xfffffffe,
|
|
"Don't change the value of kRollforward infinity unless its "
|
|
"size has been changed in firmware.");
|
|
|
|
const char kCurrentVersion[] = "0.1.0.0";
|
|
const char kTestAppId[] = "test-app-id";
|
|
const char kTestAppId2[] = "test-app2-id";
|
|
const char kTestAppIdSkipUpdatecheck[] = "test-app-id-skip-updatecheck";
|
|
const char kDlcId1[] = "dlc-id-1";
|
|
const char kDlcId2[] = "dlc-id-2";
|
|
|
|
// This is a helper struct to allow unit tests build an update response with the
|
|
// values they care about.
|
|
struct FakeUpdateResponse {
|
|
string GetRollbackVersionAttributes() const {
|
|
string num_milestones;
|
|
num_milestones = base::NumberToString(rollback_allowed_milestones);
|
|
const string rollback_version =
|
|
" _firmware_version_" + num_milestones + "=\"" +
|
|
past_rollback_key_version.first + "\"" + " _kernel_version_" +
|
|
num_milestones + "=\"" + past_rollback_key_version.second + "\"";
|
|
|
|
return (rollback ? " _rollback=\"true\"" : "") + rollback_version +
|
|
(!rollback_firmware_version.empty()
|
|
? " _firmware_version=\"" + rollback_firmware_version + "\""
|
|
: "") +
|
|
(!rollback_kernel_version.empty()
|
|
? " _kernel_version=\"" + rollback_kernel_version + "\""
|
|
: "");
|
|
}
|
|
|
|
string GetNoUpdateResponse() const {
|
|
string entity_str;
|
|
if (include_entity)
|
|
entity_str = "<!DOCTYPE response [<!ENTITY CrOS \"ChromeOS\">]>";
|
|
return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + entity_str +
|
|
"<response protocol=\"3.0\">"
|
|
"<daystart elapsed_seconds=\"100\"/>"
|
|
"<app appid=\"" +
|
|
app_id + "\" " +
|
|
(include_cohorts
|
|
? "cohort=\"" + cohort + "\" cohorthint=\"" + cohorthint +
|
|
"\" cohortname=\"" + cohortname + "\" "
|
|
: "") +
|
|
" status=\"ok\">"
|
|
"<ping status=\"ok\"/>"
|
|
"<updatecheck status=\"noupdate\"/></app>" +
|
|
(multi_app_no_update
|
|
? "<app appid=\"" + app_id2 +
|
|
"\"><updatecheck status=\"noupdate\"/></app>"
|
|
: "") +
|
|
"</response>";
|
|
}
|
|
|
|
string GetUpdateResponse() const {
|
|
chromeos_update_engine::OmahaRequestParams request_params;
|
|
request_params.set_app_id(app_id);
|
|
return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
|
|
"protocol=\"3.0\">"
|
|
"<daystart elapsed_seconds=\"100\"" +
|
|
(elapsed_days.empty() ? ""
|
|
: (" elapsed_days=\"" + elapsed_days + "\"")) +
|
|
"/>"
|
|
"<app appid=\"" +
|
|
app_id + "\" " +
|
|
(include_cohorts
|
|
? "cohort=\"" + cohort + "\" cohorthint=\"" + cohorthint +
|
|
"\" cohortname=\"" + cohortname + "\" "
|
|
: "") +
|
|
" status=\"ok\">"
|
|
"<ping status=\"ok\"/><updatecheck status=\"ok\"" +
|
|
GetRollbackVersionAttributes() + ">" + "<urls><url codebase=\"" +
|
|
codebase +
|
|
"\"/></urls>"
|
|
"<manifest version=\"" +
|
|
version +
|
|
"\">"
|
|
"<packages><package hash=\"not-used\" name=\"" +
|
|
filename + "\" size=\"" + base::NumberToString(size) + "\" fp=\"" +
|
|
fp + "\" hash_sha256=\"" + hash + "\"/>" +
|
|
(multi_package ? "<package name=\"package2\" size=\"222\" fp=\"" +
|
|
fp2 + "\" hash_sha256=\"hash2\"/>"
|
|
: "") +
|
|
"</packages>"
|
|
"<actions><action event=\"postinstall\" MetadataSize=\"11" +
|
|
(multi_package ? ":22" : "") + "\" MoreInfo=\"" + more_info_url +
|
|
"\" Prompt=\"" + prompt +
|
|
"\" "
|
|
"IsDeltaPayload=\"true" +
|
|
(multi_package ? ":false" : "") +
|
|
"\" "
|
|
"MaxDaysToScatter=\"" +
|
|
max_days_to_scatter +
|
|
"\" "
|
|
"sha256=\"not-used\" " +
|
|
(deadline.empty() ? "" : ("deadline=\"" + deadline + "\" ")) +
|
|
(disable_p2p_for_downloading ? "DisableP2PForDownloading=\"true\" "
|
|
: "") +
|
|
(disable_p2p_for_sharing ? "DisableP2PForSharing=\"true\" " : "") +
|
|
(powerwash ? "Powerwash=\"true\" " : "") +
|
|
"/></actions></manifest></updatecheck></app>" +
|
|
(multi_app
|
|
? "<app appid=\"" + app_id2 + "\"" +
|
|
(include_cohorts ? " cohort=\"cohort2\"" : "") +
|
|
"><updatecheck status=\"ok\"><urls><url codebase=\"" +
|
|
codebase2 + "\"/></urls><manifest version=\"" + version2 +
|
|
"\"><packages>"
|
|
"<package name=\"package3\" size=\"333\" fp=\"" +
|
|
fp2 +
|
|
"\" hash_sha256=\"hash3\"/></packages>"
|
|
"<actions><action event=\"postinstall\" " +
|
|
(multi_app_self_update
|
|
? "noupdate=\"true\" IsDeltaPayload=\"true\" "
|
|
: "IsDeltaPayload=\"false\" ") +
|
|
"MetadataSize=\"33\"/></actions>"
|
|
"</manifest></updatecheck></app>"
|
|
: "") +
|
|
(multi_app_no_update
|
|
? "<app><updatecheck status=\"noupdate\"/></app>"
|
|
: "") +
|
|
(multi_app_skip_updatecheck
|
|
? "<app appid=\"" + app_id_skip_updatecheck + "\"></app>"
|
|
: "") +
|
|
(dlc_app_update
|
|
? "<app appid=\"" + request_params.GetDlcAppId(kDlcId1) +
|
|
"\" " +
|
|
(include_dlc_cohorts
|
|
? "cohort=\"" + dlc_cohort + "\" cohorthint=\"" +
|
|
dlc_cohorthint + "\" cohortname=\"" +
|
|
dlc_cohortname + "\" "
|
|
: "") +
|
|
"status=\"ok\">"
|
|
"<updatecheck status=\"ok\"><urls><url codebase=\"" +
|
|
codebase + "\"/><url codebase=\"" + codebase2 +
|
|
"\"/></urls><manifest version=\"" + version +
|
|
"\"><packages><package name=\"package3\" size=\"333\" "
|
|
"fp=\"" +
|
|
fp2 +
|
|
"\" hash_sha256=\"hash3\"/></packages>"
|
|
"<actions><action event=\"install\" run=\".signed\"/>"
|
|
"<action event=\"postinstall\" MetadataSize=\"33\"/>"
|
|
"</actions></manifest></updatecheck></app>"
|
|
: "") +
|
|
(dlc_app_no_update
|
|
? "<app appid=\"" + request_params.GetDlcAppId(kDlcId2) +
|
|
+"\" " +
|
|
(include_dlc_cohorts
|
|
? "cohort=\"" + dlc_cohort + "\" cohorthint=\"" +
|
|
dlc_cohorthint + "\" cohortname=\"" +
|
|
dlc_cohortname + "\" "
|
|
: "") +
|
|
"><updatecheck status=\"noupdate\"/></app>"
|
|
: "") +
|
|
"</response>";
|
|
}
|
|
|
|
// Return the payload URL, which is split in two fields in the XML response.
|
|
string GetPayloadUrl() { return codebase + filename; }
|
|
|
|
string app_id = kTestAppId;
|
|
string app_id2 = kTestAppId2;
|
|
string app_id_skip_updatecheck = kTestAppIdSkipUpdatecheck;
|
|
string version = "1.2.3.4";
|
|
string version2 = "2.3.4.5";
|
|
string more_info_url = "http://more/info";
|
|
string prompt = "true";
|
|
string codebase = "http://code/base/";
|
|
string codebase2 = "http://code/base/2/";
|
|
string filename = "file.signed";
|
|
string hash = "4841534831323334";
|
|
string fp = "3.98ba213e";
|
|
string fp2 = "3.755aff78e";
|
|
uint64_t size = 123;
|
|
string deadline = "";
|
|
string max_days_to_scatter = "7";
|
|
string elapsed_days = "42";
|
|
|
|
// P2P setting defaults to allowed.
|
|
bool disable_p2p_for_downloading = false;
|
|
bool disable_p2p_for_sharing = false;
|
|
|
|
bool powerwash = false;
|
|
|
|
// Omaha cohorts settings.
|
|
bool include_cohorts = false;
|
|
string cohort = "";
|
|
string cohorthint = "";
|
|
string cohortname = "";
|
|
// Whether to include Omaha cohorts for DLC apps.
|
|
bool include_dlc_cohorts = false;
|
|
string dlc_cohort = "";
|
|
string dlc_cohorthint = "";
|
|
string dlc_cohortname = "";
|
|
|
|
// Whether to include the CrOS <!ENTITY> in the XML response.
|
|
bool include_entity = false;
|
|
|
|
// Whether to include more than one app.
|
|
bool multi_app = false;
|
|
// Whether to include an app with noupdate="true".
|
|
bool multi_app_self_update = false;
|
|
// Whether to include an additional app with status="noupdate".
|
|
bool multi_app_no_update = false;
|
|
// Whether to include an additional app with no updatecheck tag.
|
|
bool multi_app_skip_updatecheck = false;
|
|
// Whether to include more than one package in an app.
|
|
bool multi_package = false;
|
|
// Whether to include a DLC app with updatecheck tag.
|
|
bool dlc_app_update = false;
|
|
// Whether to include a DLC app with no updatecheck tag.
|
|
bool dlc_app_no_update = false;
|
|
|
|
// Whether the payload is a rollback.
|
|
bool rollback = false;
|
|
// The verified boot firmware key version for the rollback image.
|
|
string rollback_firmware_version = "";
|
|
// The verified boot kernel key version for the rollback image.
|
|
string rollback_kernel_version = "";
|
|
// The number of milestones back that the verified boot key version has been
|
|
// supplied.
|
|
uint32_t rollback_allowed_milestones = 0;
|
|
// The verified boot key version for the
|
|
// |current - rollback_allowed_milestones| most recent release.
|
|
// The pair contains <firmware_key_version, kernel_key_version> each
|
|
// of which is in the form "key_version.version".
|
|
pair<string, string> past_rollback_key_version;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
namespace chromeos_update_engine {
|
|
|
|
class OmahaRequestActionTestProcessorDelegate : public ActionProcessorDelegate {
|
|
public:
|
|
OmahaRequestActionTestProcessorDelegate()
|
|
: expected_code_(ErrorCode::kSuccess),
|
|
interactive_(false),
|
|
test_http_fetcher_headers_(false) {}
|
|
~OmahaRequestActionTestProcessorDelegate() override = default;
|
|
|
|
void ProcessingDone(const ActionProcessor* processor,
|
|
ErrorCode code) override {
|
|
brillo::MessageLoop::current()->BreakLoop();
|
|
}
|
|
|
|
void ActionCompleted(ActionProcessor* processor,
|
|
AbstractAction* action,
|
|
ErrorCode code) override {
|
|
// Make sure actions always succeed.
|
|
if (action->Type() == OmahaRequestAction::StaticType()) {
|
|
EXPECT_EQ(expected_code_, code);
|
|
// Check that the headers were set in the fetcher during the action. Note
|
|
// that we set this request as "interactive".
|
|
auto fetcher = static_cast<const MockHttpFetcher*>(
|
|
static_cast<OmahaRequestAction*>(action)->http_fetcher_.get());
|
|
|
|
if (test_http_fetcher_headers_) {
|
|
EXPECT_EQ(interactive_ ? "fg" : "bg",
|
|
fetcher->GetHeader("X-Goog-Update-Interactivity"));
|
|
EXPECT_EQ(kTestAppId, fetcher->GetHeader("X-Goog-Update-AppId"));
|
|
EXPECT_NE("", fetcher->GetHeader("X-Goog-Update-Updater"));
|
|
}
|
|
post_data_ = fetcher->post_data();
|
|
} else if (action->Type() ==
|
|
ObjectCollectorAction<OmahaResponse>::StaticType()) {
|
|
EXPECT_EQ(ErrorCode::kSuccess, code);
|
|
auto collector_action =
|
|
static_cast<ObjectCollectorAction<OmahaResponse>*>(action);
|
|
omaha_response_.reset(new OmahaResponse(collector_action->object()));
|
|
EXPECT_TRUE(omaha_response_);
|
|
} else {
|
|
EXPECT_EQ(ErrorCode::kSuccess, code);
|
|
}
|
|
}
|
|
ErrorCode expected_code_;
|
|
brillo::Blob post_data_;
|
|
bool interactive_;
|
|
bool test_http_fetcher_headers_;
|
|
std::unique_ptr<OmahaResponse> omaha_response_;
|
|
};
|
|
|
|
struct TestUpdateCheckParams {
|
|
string http_response;
|
|
int fail_http_response_code;
|
|
bool ping_only;
|
|
bool is_consumer_device;
|
|
int rollback_allowed_milestones;
|
|
bool is_policy_loaded;
|
|
ErrorCode expected_code;
|
|
metrics::CheckResult expected_check_result;
|
|
metrics::CheckReaction expected_check_reaction;
|
|
metrics::DownloadErrorCode expected_download_error_code;
|
|
string session_id;
|
|
};
|
|
|
|
class OmahaRequestActionTest : public ::testing::Test {
|
|
protected:
|
|
void SetUp() override {
|
|
FakeSystemState::CreateInstance();
|
|
|
|
request_params_.set_os_sp("service_pack");
|
|
request_params_.set_os_board("x86-generic");
|
|
request_params_.set_app_id(kTestAppId);
|
|
request_params_.set_app_version(kCurrentVersion);
|
|
request_params_.set_app_lang("en-US");
|
|
request_params_.set_current_channel("unittest");
|
|
request_params_.set_target_channel("unittest");
|
|
request_params_.set_hwid("OEM MODEL 09235 7471");
|
|
request_params_.set_delta_okay(true);
|
|
request_params_.set_interactive(false);
|
|
request_params_.set_update_url("http://url");
|
|
request_params_.set_target_version_prefix("");
|
|
request_params_.set_rollback_allowed(false);
|
|
request_params_.set_is_powerwash_allowed(false);
|
|
request_params_.set_is_install(false);
|
|
request_params_.set_dlc_apps_params({});
|
|
|
|
FakeSystemState::Get()->set_request_params(&request_params_);
|
|
fake_prefs_ = FakeSystemState::Get()->fake_prefs();
|
|
|
|
// Setting the default update check params. Lookup |TestUpdateCheck()|.
|
|
tuc_params_ = {
|
|
.http_response = "",
|
|
.fail_http_response_code = -1,
|
|
.ping_only = false,
|
|
.is_consumer_device = true,
|
|
.rollback_allowed_milestones = 0,
|
|
.is_policy_loaded = false,
|
|
.expected_code = ErrorCode::kSuccess,
|
|
.expected_check_result = metrics::CheckResult::kUpdateAvailable,
|
|
.expected_check_reaction = metrics::CheckReaction::kUpdating,
|
|
.expected_download_error_code = metrics::DownloadErrorCode::kUnset,
|
|
};
|
|
|
|
ON_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetExcluder())
|
|
.WillByDefault(Return(&mock_excluder_));
|
|
}
|
|
|
|
// This function uses the parameters in |tuc_params_| to do an update check.
|
|
// It will fill out |post_str_| with the result data and |response| with
|
|
// |OmahaResponse|. Returns true iff an output response was obtained from the
|
|
// |OmahaRequestAction|. If |fail_http_response_code| is non-negative, the
|
|
// transfer will fail with that code. |ping_only| is passed through to the
|
|
// |OmahaRequestAction| constructor.
|
|
//
|
|
// The |expected_check_result|, |expected_check_reaction| and
|
|
// |expected_error_code| parameters are for checking expectations about
|
|
// reporting UpdateEngine.Check.{Result,Reaction,DownloadError} UMA
|
|
// statistics. Use the appropriate ::kUnset value to specify that the given
|
|
// metric should not be reported.
|
|
bool TestUpdateCheck();
|
|
|
|
// Tests events using |event| and |https_response|. It will fill up
|
|
// |post_str_| with the result data.
|
|
void TestEvent(OmahaEvent* event, const string& http_response);
|
|
|
|
// Runs and checks a ping test. |ping_only| indicates whether it should send
|
|
// only a ping or also an updatecheck.
|
|
void PingTest(bool ping_only);
|
|
|
|
// InstallDate test helper function.
|
|
bool InstallDateParseHelper(const string& elapsed_days,
|
|
OmahaResponse* response);
|
|
|
|
// P2P test helper function.
|
|
void P2PTest(bool initial_allow_p2p_for_downloading,
|
|
bool initial_allow_p2p_for_sharing,
|
|
bool omaha_disable_p2p_for_downloading,
|
|
bool omaha_disable_p2p_for_sharing,
|
|
bool payload_state_allow_p2p_attempt,
|
|
bool expect_p2p_client_lookup,
|
|
const string& p2p_client_result_url,
|
|
bool expected_allow_p2p_for_downloading,
|
|
bool expected_allow_p2p_for_sharing,
|
|
const string& expected_p2p_url);
|
|
|
|
StrictMock<MockExcluder> mock_excluder_;
|
|
FakeUpdateResponse fake_update_response_;
|
|
// Used by all tests.
|
|
OmahaRequestParams request_params_;
|
|
|
|
FakePrefs* fake_prefs_;
|
|
|
|
OmahaRequestActionTestProcessorDelegate delegate_;
|
|
|
|
bool test_http_fetcher_headers_{false};
|
|
|
|
TestUpdateCheckParams tuc_params_;
|
|
|
|
OmahaResponse response_;
|
|
string post_str_;
|
|
};
|
|
|
|
class OmahaRequestActionDlcPingTest : public OmahaRequestActionTest {
|
|
protected:
|
|
void SetUp() override {
|
|
OmahaRequestActionTest::SetUp();
|
|
dlc_id_ = "dlc0";
|
|
active_key_ = PrefsInterface::CreateSubKey(
|
|
{kDlcPrefsSubDir, dlc_id_, kPrefsPingActive});
|
|
last_active_key_ = PrefsInterface::CreateSubKey(
|
|
{kDlcPrefsSubDir, dlc_id_, kPrefsPingLastActive});
|
|
last_rollcall_key_ = PrefsInterface::CreateSubKey(
|
|
{kDlcPrefsSubDir, dlc_id_, kPrefsPingLastRollcall});
|
|
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
|
|
"protocol=\"3.0\"><daystart elapsed_days=\"4763\" "
|
|
"elapsed_seconds=\"36540\"/><app appid=\"test-app-id\" status=\"ok\">\""
|
|
"<updatecheck status=\"noupdate\"/></app><app "
|
|
"appid=\"test-app-id_dlc0\" "
|
|
"status=\"ok\"><ping status=\"ok\"/><updatecheck status=\"noupdate\"/>"
|
|
"</app></response>";
|
|
tuc_params_.expected_check_result =
|
|
metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
}
|
|
|
|
std::string dlc_id_;
|
|
std::string active_key_;
|
|
std::string last_active_key_;
|
|
std::string last_rollcall_key_;
|
|
};
|
|
|
|
bool OmahaRequestActionTest::TestUpdateCheck() {
|
|
brillo::FakeMessageLoop loop(nullptr);
|
|
loop.SetAsCurrent();
|
|
auto fetcher =
|
|
std::make_unique<MockHttpFetcher>(tuc_params_.http_response.data(),
|
|
tuc_params_.http_response.size(),
|
|
nullptr);
|
|
if (tuc_params_.fail_http_response_code >= 0) {
|
|
fetcher->FailTransfer(tuc_params_.fail_http_response_code);
|
|
}
|
|
// This ensures the tests didn't forget to update |FakeSystemState| if they
|
|
// are not using the default |request_params_|.
|
|
EXPECT_EQ(&request_params_, FakeSystemState::Get()->request_params());
|
|
|
|
auto omaha_request_action =
|
|
std::make_unique<OmahaRequestAction>(nullptr,
|
|
std::move(fetcher),
|
|
tuc_params_.ping_only,
|
|
tuc_params_.session_id);
|
|
|
|
auto mock_policy_provider =
|
|
std::make_unique<NiceMock<policy::MockPolicyProvider>>();
|
|
EXPECT_CALL(*mock_policy_provider, IsConsumerDevice())
|
|
.WillRepeatedly(Return(tuc_params_.is_consumer_device));
|
|
|
|
EXPECT_CALL(*mock_policy_provider, device_policy_is_loaded())
|
|
.WillRepeatedly(Return(tuc_params_.is_policy_loaded));
|
|
|
|
const policy::MockDevicePolicy device_policy;
|
|
const bool get_allowed_milestone_succeeds =
|
|
tuc_params_.rollback_allowed_milestones >= 0;
|
|
EXPECT_CALL(device_policy, GetRollbackAllowedMilestones(_))
|
|
.WillRepeatedly(
|
|
DoAll(SetArgPointee<0>(tuc_params_.rollback_allowed_milestones),
|
|
Return(get_allowed_milestone_succeeds)));
|
|
|
|
EXPECT_CALL(*mock_policy_provider, GetDevicePolicy())
|
|
.WillRepeatedly(ReturnRef(device_policy));
|
|
omaha_request_action->policy_provider_ = std::move(mock_policy_provider);
|
|
|
|
delegate_.expected_code_ = tuc_params_.expected_code;
|
|
delegate_.interactive_ = request_params_.interactive();
|
|
delegate_.test_http_fetcher_headers_ = test_http_fetcher_headers_;
|
|
ActionProcessor processor;
|
|
processor.set_delegate(&delegate_);
|
|
|
|
auto collector_action =
|
|
std::make_unique<ObjectCollectorAction<OmahaResponse>>();
|
|
BondActions(omaha_request_action.get(), collector_action.get());
|
|
processor.EnqueueAction(std::move(omaha_request_action));
|
|
processor.EnqueueAction(std::move(collector_action));
|
|
|
|
EXPECT_CALL(*FakeSystemState::Get()->mock_metrics_reporter(),
|
|
ReportUpdateCheckMetrics(_, _, _))
|
|
.Times(AnyNumber());
|
|
|
|
EXPECT_CALL(
|
|
*FakeSystemState::Get()->mock_metrics_reporter(),
|
|
ReportUpdateCheckMetrics(tuc_params_.expected_check_result,
|
|
tuc_params_.expected_check_reaction,
|
|
tuc_params_.expected_download_error_code))
|
|
.Times(tuc_params_.ping_only ? 0 : 1);
|
|
|
|
loop.PostTask(base::Bind(
|
|
[](ActionProcessor* processor) { processor->StartProcessing(); },
|
|
base::Unretained(&processor)));
|
|
loop.Run();
|
|
EXPECT_FALSE(loop.PendingTasks());
|
|
if (delegate_.omaha_response_)
|
|
response_ = *delegate_.omaha_response_;
|
|
post_str_ = string(delegate_.post_data_.begin(), delegate_.post_data_.end());
|
|
return delegate_.omaha_response_ != nullptr;
|
|
}
|
|
|
|
// Tests Event requests -- they should always succeed. |out_post_data| may be
|
|
// null; if non-null, the post-data received by the mock HttpFetcher is
|
|
// returned.
|
|
void OmahaRequestActionTest::TestEvent(OmahaEvent* event,
|
|
const string& http_response) {
|
|
brillo::FakeMessageLoop loop(nullptr);
|
|
loop.SetAsCurrent();
|
|
|
|
auto action = std::make_unique<OmahaRequestAction>(
|
|
event,
|
|
std::make_unique<MockHttpFetcher>(
|
|
http_response.data(), http_response.size(), nullptr),
|
|
false,
|
|
"");
|
|
ActionProcessor processor;
|
|
processor.set_delegate(&delegate_);
|
|
processor.EnqueueAction(std::move(action));
|
|
|
|
loop.PostTask(base::Bind(
|
|
[](ActionProcessor* processor) { processor->StartProcessing(); },
|
|
base::Unretained(&processor)));
|
|
loop.Run();
|
|
EXPECT_FALSE(loop.PendingTasks());
|
|
|
|
post_str_ = string(delegate_.post_data_.begin(), delegate_.post_data_.end());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, RejectEntities) {
|
|
fake_update_response_.include_entity = true;
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLHasEntityDecl;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NoUpdateTest) {
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MultiAppNoUpdateTest) {
|
|
fake_update_response_.multi_app_no_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MultiAppNoPartialUpdateTest) {
|
|
fake_update_response_.multi_app_no_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NoSelfUpdateTest) {
|
|
tuc_params_.http_response =
|
|
"<response><app><updatecheck status=\"ok\"><manifest><actions><action "
|
|
"event=\"postinstall\" noupdate=\"true\"/></actions>"
|
|
"</manifest></updatecheck></app></response>";
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
// Test that all the values in the response are parsed in a normal update
|
|
// response_.
|
|
TEST_F(OmahaRequestActionTest, ValidUpdateTest) {
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(fake_update_response_.version, response_.version);
|
|
EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
|
|
response_.packages[0].payload_urls[0]);
|
|
EXPECT_EQ(fake_update_response_.more_info_url, response_.more_info_url);
|
|
EXPECT_EQ(fake_update_response_.hash, response_.packages[0].hash);
|
|
EXPECT_EQ(fake_update_response_.size, response_.packages[0].size);
|
|
EXPECT_EQ(fake_update_response_.fp, response_.packages[0].fp);
|
|
EXPECT_EQ(true, response_.packages[0].is_delta);
|
|
EXPECT_EQ(fake_update_response_.prompt == "true", response_.prompt);
|
|
EXPECT_EQ(fake_update_response_.deadline, response_.deadline);
|
|
EXPECT_FALSE(response_.powerwash_required);
|
|
// Omaha cohort attributes are not set in the response, so they should not be
|
|
// persisted.
|
|
EXPECT_FALSE(fake_prefs_->Exists(kPrefsOmahaCohort));
|
|
EXPECT_FALSE(fake_prefs_->Exists(kPrefsOmahaCohortHint));
|
|
EXPECT_FALSE(fake_prefs_->Exists(kPrefsOmahaCohortName));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MultiPackageUpdateTest) {
|
|
fake_update_response_.multi_package = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(fake_update_response_.version, response_.version);
|
|
EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
|
|
response_.packages[0].payload_urls[0]);
|
|
EXPECT_EQ(fake_update_response_.codebase + "package2",
|
|
response_.packages[1].payload_urls[0]);
|
|
EXPECT_EQ(fake_update_response_.hash, response_.packages[0].hash);
|
|
EXPECT_EQ(fake_update_response_.size, response_.packages[0].size);
|
|
EXPECT_EQ(fake_update_response_.fp, response_.packages[0].fp);
|
|
EXPECT_EQ(true, response_.packages[0].is_delta);
|
|
EXPECT_EQ(11u, response_.packages[0].metadata_size);
|
|
ASSERT_EQ(2u, response_.packages.size());
|
|
EXPECT_EQ(string("hash2"), response_.packages[1].hash);
|
|
EXPECT_EQ(222u, response_.packages[1].size);
|
|
EXPECT_EQ(fake_update_response_.fp2, response_.packages[1].fp);
|
|
EXPECT_EQ(22u, response_.packages[1].metadata_size);
|
|
EXPECT_EQ(false, response_.packages[1].is_delta);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MultiAppUpdateTest) {
|
|
fake_update_response_.multi_app = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(fake_update_response_.version, response_.version);
|
|
EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
|
|
response_.packages[0].payload_urls[0]);
|
|
EXPECT_EQ(fake_update_response_.codebase2 + "package3",
|
|
response_.packages[1].payload_urls[0]);
|
|
EXPECT_EQ(fake_update_response_.hash, response_.packages[0].hash);
|
|
EXPECT_EQ(fake_update_response_.size, response_.packages[0].size);
|
|
EXPECT_EQ(fake_update_response_.fp, response_.packages[0].fp);
|
|
EXPECT_EQ(11u, response_.packages[0].metadata_size);
|
|
EXPECT_EQ(true, response_.packages[0].is_delta);
|
|
ASSERT_EQ(2u, response_.packages.size());
|
|
EXPECT_EQ(string("hash3"), response_.packages[1].hash);
|
|
EXPECT_EQ(333u, response_.packages[1].size);
|
|
EXPECT_EQ(fake_update_response_.fp2, response_.packages[1].fp);
|
|
EXPECT_EQ(33u, response_.packages[1].metadata_size);
|
|
EXPECT_EQ(false, response_.packages[1].is_delta);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MultiAppPartialUpdateTest) {
|
|
fake_update_response_.multi_app = true;
|
|
fake_update_response_.multi_app_self_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(fake_update_response_.version, response_.version);
|
|
EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
|
|
response_.packages[0].payload_urls[0]);
|
|
EXPECT_EQ(fake_update_response_.hash, response_.packages[0].hash);
|
|
EXPECT_EQ(fake_update_response_.size, response_.packages[0].size);
|
|
EXPECT_EQ(fake_update_response_.fp, response_.packages[0].fp);
|
|
EXPECT_EQ(11u, response_.packages[0].metadata_size);
|
|
ASSERT_EQ(2u, response_.packages.size());
|
|
EXPECT_EQ(string("hash3"), response_.packages[1].hash);
|
|
EXPECT_EQ(333u, response_.packages[1].size);
|
|
EXPECT_EQ(fake_update_response_.fp2, response_.packages[1].fp);
|
|
EXPECT_EQ(33u, response_.packages[1].metadata_size);
|
|
EXPECT_EQ(true, response_.packages[1].is_delta);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MultiAppMultiPackageUpdateTest) {
|
|
fake_update_response_.multi_app = true;
|
|
fake_update_response_.multi_package = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(fake_update_response_.version, response_.version);
|
|
EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
|
|
response_.packages[0].payload_urls[0]);
|
|
EXPECT_EQ(fake_update_response_.codebase + "package2",
|
|
response_.packages[1].payload_urls[0]);
|
|
EXPECT_EQ(fake_update_response_.codebase2 + "package3",
|
|
response_.packages[2].payload_urls[0]);
|
|
EXPECT_EQ(fake_update_response_.hash, response_.packages[0].hash);
|
|
EXPECT_EQ(fake_update_response_.size, response_.packages[0].size);
|
|
EXPECT_EQ(fake_update_response_.fp, response_.packages[0].fp);
|
|
EXPECT_EQ(11u, response_.packages[0].metadata_size);
|
|
EXPECT_EQ(true, response_.packages[0].is_delta);
|
|
ASSERT_EQ(3u, response_.packages.size());
|
|
EXPECT_EQ(string("hash2"), response_.packages[1].hash);
|
|
EXPECT_EQ(222u, response_.packages[1].size);
|
|
EXPECT_EQ(fake_update_response_.fp2, response_.packages[1].fp);
|
|
EXPECT_EQ(22u, response_.packages[1].metadata_size);
|
|
EXPECT_EQ(false, response_.packages[1].is_delta);
|
|
EXPECT_EQ(string("hash3"), response_.packages[2].hash);
|
|
EXPECT_EQ(333u, response_.packages[2].size);
|
|
EXPECT_EQ(fake_update_response_.fp2, response_.packages[2].fp);
|
|
EXPECT_EQ(33u, response_.packages[2].metadata_size);
|
|
EXPECT_EQ(false, response_.packages[2].is_delta);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, PowerwashTest) {
|
|
fake_update_response_.powerwash = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_TRUE(response_.powerwash_required);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ExtraHeadersSentInteractiveTest) {
|
|
request_params_.set_interactive(true);
|
|
test_http_fetcher_headers_ = true;
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ExtraHeadersSentNoInteractiveTest) {
|
|
request_params_.set_interactive(false);
|
|
test_http_fetcher_headers_ = true;
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ValidUpdateBlockedByConnection) {
|
|
// Set up a connection manager that doesn't allow a valid update over
|
|
// the current ethernet connection.
|
|
MockConnectionManager mock_cm;
|
|
FakeSystemState::Get()->set_connection_manager(&mock_cm);
|
|
|
|
EXPECT_CALL(mock_cm, GetConnectionProperties(_, _))
|
|
.WillRepeatedly(DoAll(SetArgPointee<0>(ConnectionType::kEthernet),
|
|
SetArgPointee<1>(ConnectionTethering::kUnknown),
|
|
Return(true)));
|
|
EXPECT_CALL(mock_cm, IsUpdateAllowedOver(ConnectionType::kEthernet, _))
|
|
.WillRepeatedly(Return(false));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaUpdateIgnoredPerPolicy;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kIgnored;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ValidUpdateOverCellularAllowedByDevicePolicy) {
|
|
// This test tests that update over cellular is allowed as device policy
|
|
// says yes.
|
|
MockConnectionManager mock_cm;
|
|
FakeSystemState::Get()->set_connection_manager(&mock_cm);
|
|
|
|
EXPECT_CALL(mock_cm, GetConnectionProperties(_, _))
|
|
.WillRepeatedly(DoAll(SetArgPointee<0>(ConnectionType::kCellular),
|
|
SetArgPointee<1>(ConnectionTethering::kUnknown),
|
|
Return(true)));
|
|
EXPECT_CALL(mock_cm, IsAllowedConnectionTypesForUpdateSet())
|
|
.WillRepeatedly(Return(true));
|
|
EXPECT_CALL(mock_cm, IsUpdateAllowedOver(ConnectionType::kCellular, _))
|
|
.WillRepeatedly(Return(true));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ValidUpdateOverCellularBlockedByDevicePolicy) {
|
|
// This test tests that update over cellular is blocked as device policy
|
|
// says no.
|
|
MockConnectionManager mock_cm;
|
|
FakeSystemState::Get()->set_connection_manager(&mock_cm);
|
|
|
|
EXPECT_CALL(mock_cm, GetConnectionProperties(_, _))
|
|
.WillRepeatedly(DoAll(SetArgPointee<0>(ConnectionType::kCellular),
|
|
SetArgPointee<1>(ConnectionTethering::kUnknown),
|
|
Return(true)));
|
|
EXPECT_CALL(mock_cm, IsAllowedConnectionTypesForUpdateSet())
|
|
.WillRepeatedly(Return(true));
|
|
EXPECT_CALL(mock_cm, IsUpdateAllowedOver(ConnectionType::kCellular, _))
|
|
.WillRepeatedly(Return(false));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaUpdateIgnoredPerPolicy;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kIgnored;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest,
|
|
ValidUpdateOverCellularAllowedByUserPermissionTrue) {
|
|
// This test tests that, when device policy is not set, update over cellular
|
|
// is allowed as permission for update over cellular is set to true.
|
|
MockConnectionManager mock_cm;
|
|
fake_prefs_->SetBoolean(kPrefsUpdateOverCellularPermission, true);
|
|
FakeSystemState::Get()->set_connection_manager(&mock_cm);
|
|
|
|
EXPECT_CALL(mock_cm, GetConnectionProperties(_, _))
|
|
.WillRepeatedly(DoAll(SetArgPointee<0>(ConnectionType::kCellular),
|
|
SetArgPointee<1>(ConnectionTethering::kUnknown),
|
|
Return(true)));
|
|
EXPECT_CALL(mock_cm, IsAllowedConnectionTypesForUpdateSet())
|
|
.WillRepeatedly(Return(false));
|
|
EXPECT_CALL(mock_cm, IsUpdateAllowedOver(ConnectionType::kCellular, _))
|
|
.WillRepeatedly(Return(true));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest,
|
|
ValidUpdateOverCellularBlockedByUpdateTargetNotMatch) {
|
|
// This test tests that, when device policy is not set and permission for
|
|
// update over cellular is set to false or does not exist, update over
|
|
// cellular is blocked as update target does not match the omaha response.
|
|
MockConnectionManager mock_cm;
|
|
// A version different from the version in omaha response.
|
|
string diff_version = "99.99.99";
|
|
// A size different from the size in omaha response.
|
|
int64_t diff_size = 999;
|
|
|
|
fake_prefs_->SetString(kPrefsUpdateOverCellularTargetVersion, diff_version);
|
|
fake_prefs_->SetInt64(kPrefsUpdateOverCellularTargetSize, diff_size);
|
|
// This test tests cellular (3G) being the only connection type being allowed.
|
|
FakeSystemState::Get()->set_connection_manager(&mock_cm);
|
|
|
|
EXPECT_CALL(mock_cm, GetConnectionProperties(_, _))
|
|
.WillRepeatedly(DoAll(SetArgPointee<0>(ConnectionType::kCellular),
|
|
SetArgPointee<1>(ConnectionTethering::kUnknown),
|
|
Return(true)));
|
|
EXPECT_CALL(mock_cm, IsAllowedConnectionTypesForUpdateSet())
|
|
.WillRepeatedly(Return(false));
|
|
EXPECT_CALL(mock_cm, IsUpdateAllowedOver(ConnectionType::kCellular, _))
|
|
.WillRepeatedly(Return(true));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaUpdateIgnoredOverCellular;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kIgnored;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest,
|
|
ValidUpdateOverCellularAllowedByUpdateTargetMatch) {
|
|
// This test tests that, when device policy is not set and permission for
|
|
// update over cellular is set to false or does not exist, update over
|
|
// cellular is allowed as update target matches the omaha response.
|
|
MockConnectionManager mock_cm;
|
|
// A version same as the version in omaha response.
|
|
string new_version = fake_update_response_.version;
|
|
// A size same as the size in omaha response.
|
|
int64_t new_size = fake_update_response_.size;
|
|
|
|
fake_prefs_->SetString(kPrefsUpdateOverCellularTargetVersion, new_version);
|
|
fake_prefs_->SetInt64(kPrefsUpdateOverCellularTargetSize, new_size);
|
|
FakeSystemState::Get()->set_connection_manager(&mock_cm);
|
|
|
|
EXPECT_CALL(mock_cm, GetConnectionProperties(_, _))
|
|
.WillRepeatedly(DoAll(SetArgPointee<0>(ConnectionType::kCellular),
|
|
SetArgPointee<1>(ConnectionTethering::kUnknown),
|
|
Return(true)));
|
|
EXPECT_CALL(mock_cm, IsAllowedConnectionTypesForUpdateSet())
|
|
.WillRepeatedly(Return(false));
|
|
EXPECT_CALL(mock_cm, IsUpdateAllowedOver(ConnectionType::kCellular, _))
|
|
.WillRepeatedly(Return(true));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ValidUpdateBlockedByRollback) {
|
|
string rollback_version = "1234.0.0";
|
|
MockPayloadState mock_payload_state;
|
|
FakeSystemState::Get()->set_payload_state(&mock_payload_state);
|
|
fake_update_response_.version = rollback_version;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaUpdateIgnoredPerPolicy;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kIgnored;
|
|
|
|
EXPECT_CALL(mock_payload_state, GetRollbackVersion())
|
|
.WillRepeatedly(Return(rollback_version));
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
// Verify that update checks called during OOBE will not try to download an
|
|
// update if the response doesn't include the deadline field.
|
|
TEST_F(OmahaRequestActionTest, SkipNonCriticalUpdatesBeforeOOBE) {
|
|
FakeSystemState::Get()->fake_hardware()->UnsetIsOOBEComplete();
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kNonCriticalUpdateInOOBE;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
// TODO(senj): set better default value for metrics::checkresult in
|
|
// OmahaRequestAction::ActionCompleted.
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
// Verify that the IsOOBEComplete() value is ignored when the OOBE flow is not
|
|
// enabled.
|
|
TEST_F(OmahaRequestActionTest, SkipNonCriticalUpdatesBeforeOOBEDisabled) {
|
|
FakeSystemState::Get()->fake_hardware()->UnsetIsOOBEComplete();
|
|
FakeSystemState::Get()->fake_hardware()->SetIsOOBEEnabled(false);
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
// Verify that update checks called during OOBE will still try to download an
|
|
// update if the response includes the deadline field.
|
|
TEST_F(OmahaRequestActionTest, SkipNonCriticalUpdatesBeforeOOBEDeadlineSet) {
|
|
FakeSystemState::Get()->fake_hardware()->UnsetIsOOBEComplete();
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
// Verify that update checks called during OOBE will not try to download an
|
|
// update if a rollback happened, even when the response includes the deadline
|
|
// field.
|
|
TEST_F(OmahaRequestActionTest, SkipNonCriticalUpdatesBeforeOOBERollback) {
|
|
FakeSystemState::Get()->fake_hardware()->UnsetIsOOBEComplete();
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kNonCriticalUpdateInOOBE;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
EXPECT_CALL(*(FakeSystemState::Get()->mock_payload_state()),
|
|
GetRollbackHappened())
|
|
.WillOnce(Return(true));
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
// Verify that non-critical updates are skipped by reporting the
|
|
// kNonCriticalUpdateInOOBE error code when attempted over cellular network -
|
|
// i.e. when the update would need user permission. Note that reporting
|
|
// kOmahaUpdateIgnoredOverCellular error in this case might cause undesired UX
|
|
// in OOBE (warning the user about an update that will be skipped).
|
|
TEST_F(OmahaRequestActionTest, SkipNonCriticalUpdatesInOOBEOverCellular) {
|
|
FakeSystemState::Get()->fake_hardware()->UnsetIsOOBEComplete();
|
|
|
|
MockConnectionManager mock_cm;
|
|
FakeSystemState::Get()->set_connection_manager(&mock_cm);
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kNonCriticalUpdateInOOBE;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
EXPECT_CALL(mock_cm, GetConnectionProperties(_, _))
|
|
.WillRepeatedly(DoAll(SetArgPointee<0>(ConnectionType::kCellular),
|
|
SetArgPointee<1>(ConnectionTethering::kUnknown),
|
|
Return(true)));
|
|
EXPECT_CALL(mock_cm, IsAllowedConnectionTypesForUpdateSet())
|
|
.WillRepeatedly(Return(false));
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, WallClockBasedWaitAloneCausesScattering) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_update_check_count_wait_enabled(false);
|
|
request_params_.set_waiting_period(TimeDelta::FromDays(2));
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(Time::Now());
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaUpdateDeferredPerPolicy;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kDeferring;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest,
|
|
WallClockBasedWaitAloneCausesScatteringInteractive) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_update_check_count_wait_enabled(false);
|
|
request_params_.set_waiting_period(TimeDelta::FromDays(2));
|
|
request_params_.set_interactive(true);
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(Time::Now());
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
// Verify if we are interactive check we don't defer.
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NoWallClockBasedWaitCausesNoScattering) {
|
|
request_params_.set_wall_clock_based_wait_enabled(false);
|
|
request_params_.set_waiting_period(TimeDelta::FromDays(2));
|
|
request_params_.set_update_check_count_wait_enabled(true);
|
|
request_params_.set_min_update_checks_needed(1);
|
|
request_params_.set_max_update_checks_allowed(8);
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ZeroMaxDaysToScatterCausesNoScattering) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_waiting_period(TimeDelta::FromDays(2));
|
|
request_params_.set_update_check_count_wait_enabled(true);
|
|
request_params_.set_min_update_checks_needed(1);
|
|
request_params_.set_max_update_checks_allowed(8);
|
|
fake_update_response_.max_days_to_scatter = "0";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ZeroUpdateCheckCountCausesNoScattering) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_waiting_period(TimeDelta());
|
|
request_params_.set_update_check_count_wait_enabled(true);
|
|
request_params_.set_min_update_checks_needed(0);
|
|
request_params_.set_max_update_checks_allowed(0);
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(Time::Now());
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
int64_t count;
|
|
ASSERT_TRUE(fake_prefs_->GetInt64(kPrefsUpdateCheckCount, &count));
|
|
ASSERT_EQ(count, 0);
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NonZeroUpdateCheckCountCausesScattering) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_waiting_period(TimeDelta());
|
|
request_params_.set_update_check_count_wait_enabled(true);
|
|
request_params_.set_min_update_checks_needed(1);
|
|
request_params_.set_max_update_checks_allowed(8);
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(Time::Now());
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaUpdateDeferredPerPolicy;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kDeferring;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
int64_t count;
|
|
ASSERT_TRUE(fake_prefs_->GetInt64(kPrefsUpdateCheckCount, &count));
|
|
ASSERT_GT(count, 0);
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest,
|
|
NonZeroUpdateCheckCountCausesScatteringInteractive) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_waiting_period(TimeDelta());
|
|
request_params_.set_update_check_count_wait_enabled(true);
|
|
request_params_.set_min_update_checks_needed(1);
|
|
request_params_.set_max_update_checks_allowed(8);
|
|
request_params_.set_interactive(true);
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(Time::Now());
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
// Verify if we are interactive check we don't defer.
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ExistingUpdateCheckCountCausesScattering) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_waiting_period(TimeDelta());
|
|
request_params_.set_update_check_count_wait_enabled(true);
|
|
request_params_.set_min_update_checks_needed(1);
|
|
request_params_.set_max_update_checks_allowed(8);
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(Time::Now());
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaUpdateDeferredPerPolicy;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kDeferring;
|
|
|
|
ASSERT_TRUE(fake_prefs_->SetInt64(kPrefsUpdateCheckCount, 5));
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
int64_t count;
|
|
ASSERT_TRUE(fake_prefs_->GetInt64(kPrefsUpdateCheckCount, &count));
|
|
// |count| remains the same, as the decrementing happens in update_attempter
|
|
// which this test doesn't exercise.
|
|
ASSERT_EQ(count, 5);
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest,
|
|
ExistingUpdateCheckCountCausesScatteringInteractive) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_waiting_period(TimeDelta());
|
|
request_params_.set_update_check_count_wait_enabled(true);
|
|
request_params_.set_min_update_checks_needed(1);
|
|
request_params_.set_max_update_checks_allowed(8);
|
|
request_params_.set_interactive(true);
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(Time::Now());
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(fake_prefs_->SetInt64(kPrefsUpdateCheckCount, 5));
|
|
|
|
// Verify if we are interactive check we don't defer.
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, StagingTurnedOnCausesScattering) {
|
|
// If staging is on, the value for max days to scatter should be ignored, and
|
|
// staging's scatter value should be used.
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_waiting_period(TimeDelta::FromDays(6));
|
|
request_params_.set_update_check_count_wait_enabled(false);
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(Time::Now());
|
|
|
|
ASSERT_TRUE(fake_prefs_->SetInt64(kPrefsWallClockStagingWaitPeriod, 6));
|
|
// This should not prevent scattering due to staging.
|
|
fake_update_response_.max_days_to_scatter = "0";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaUpdateDeferredPerPolicy;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kDeferring;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
|
|
// Interactive updates should not be affected.
|
|
request_params_.set_interactive(true);
|
|
tuc_params_.expected_code = ErrorCode::kSuccess;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUpdating;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, CohortsArePersisted) {
|
|
fake_update_response_.include_cohorts = true;
|
|
fake_update_response_.cohort = "s/154454/8479665";
|
|
fake_update_response_.cohorthint = "please-put-me-on-beta";
|
|
fake_update_response_.cohortname = "stable";
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(kDlcId1), {.name = kDlcId1}}});
|
|
fake_update_response_.dlc_app_update = true;
|
|
fake_update_response_.include_dlc_cohorts = true;
|
|
fake_update_response_.dlc_cohort = "s/154454/8479665/dlc";
|
|
fake_update_response_.dlc_cohorthint = "please-put-me-on-beta-dlc";
|
|
fake_update_response_.dlc_cohortname = "stable-dlc";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_)).WillRepeatedly(Return(false));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
string value;
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohort, &value));
|
|
EXPECT_EQ(fake_update_response_.cohort, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohortHint, &value));
|
|
EXPECT_EQ(fake_update_response_.cohorthint, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohortName, &value));
|
|
EXPECT_EQ(fake_update_response_.cohortname, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey({kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohort}),
|
|
&value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohort, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohortHint}),
|
|
&value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohorthint, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohortName}),
|
|
&value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohortname, value);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, CohortsAreUpdated) {
|
|
EXPECT_TRUE(fake_prefs_->SetString(kPrefsOmahaCohort, "old_value"));
|
|
EXPECT_TRUE(fake_prefs_->SetString(kPrefsOmahaCohortHint, "old_hint"));
|
|
EXPECT_TRUE(fake_prefs_->SetString(kPrefsOmahaCohortName, "old_name"));
|
|
const string dlc_cohort_key =
|
|
fake_prefs_->CreateSubKey({kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohort});
|
|
const string dlc_cohort_hint_key = fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohortHint});
|
|
const string dlc_cohort_name_key = fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohortName});
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(kDlcId1), {.name = kDlcId1}}});
|
|
EXPECT_TRUE(fake_prefs_->SetString(dlc_cohort_key, "old_value_dlc"));
|
|
EXPECT_TRUE(fake_prefs_->SetString(dlc_cohort_hint_key, "old_hint_dlc"));
|
|
EXPECT_TRUE(fake_prefs_->SetString(dlc_cohort_name_key, "old_name_dlc"));
|
|
fake_update_response_.include_cohorts = true;
|
|
fake_update_response_.cohort = "s/154454/8479665";
|
|
fake_update_response_.cohorthint = "please-put-me-on-beta";
|
|
fake_update_response_.cohortname = "";
|
|
fake_update_response_.dlc_app_update = true;
|
|
fake_update_response_.include_dlc_cohorts = true;
|
|
fake_update_response_.dlc_cohort = "s/154454/8479665/dlc";
|
|
fake_update_response_.dlc_cohorthint = "please-put-me-on-beta-dlc";
|
|
fake_update_response_.dlc_cohortname = "";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_)).WillRepeatedly(Return(false));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
string value;
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohort, &value));
|
|
EXPECT_EQ(fake_update_response_.cohort, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohortHint, &value));
|
|
EXPECT_EQ(fake_update_response_.cohorthint, value);
|
|
|
|
EXPECT_FALSE(fake_prefs_->GetString(kPrefsOmahaCohortName, &value));
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(dlc_cohort_key, &value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohort, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(dlc_cohort_hint_key, &value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohorthint, value);
|
|
|
|
EXPECT_FALSE(fake_prefs_->GetString(dlc_cohort_name_key, &value));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, CohortsAreNotModifiedWhenMissing) {
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
EXPECT_TRUE(fake_prefs_->SetString(kPrefsOmahaCohort, "old_value"));
|
|
const string dlc_cohort_key =
|
|
fake_prefs_->CreateSubKey({kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohort});
|
|
EXPECT_TRUE(fake_prefs_->SetString(dlc_cohort_key, "old_value_dlc"));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
string value;
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohort, &value));
|
|
EXPECT_EQ("old_value", value);
|
|
|
|
EXPECT_FALSE(fake_prefs_->GetString(kPrefsOmahaCohortHint, &value));
|
|
EXPECT_FALSE(fake_prefs_->GetString(kPrefsOmahaCohortName, &value));
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(dlc_cohort_key, &value));
|
|
EXPECT_EQ("old_value_dlc", value);
|
|
|
|
EXPECT_FALSE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohortHint}),
|
|
&value));
|
|
EXPECT_FALSE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohortName}),
|
|
&value));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, CohortsArePersistedWhenNoUpdate) {
|
|
fake_update_response_.include_cohorts = true;
|
|
fake_update_response_.cohort = "s/154454/8479665";
|
|
fake_update_response_.cohorthint = "please-put-me-on-beta";
|
|
fake_update_response_.cohortname = "stable";
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
string value;
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohort, &value));
|
|
EXPECT_EQ(fake_update_response_.cohort, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohortHint, &value));
|
|
EXPECT_EQ(fake_update_response_.cohorthint, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohortName, &value));
|
|
EXPECT_EQ(fake_update_response_.cohortname, value);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MultiAppCohortTest) {
|
|
fake_update_response_.multi_app = true;
|
|
fake_update_response_.include_cohorts = true;
|
|
fake_update_response_.cohort = "s/154454/8479665";
|
|
fake_update_response_.cohorthint = "please-put-me-on-beta";
|
|
fake_update_response_.cohortname = "stable";
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(kDlcId1), {.name = kDlcId1}},
|
|
{request_params_.GetDlcAppId(kDlcId2), {.name = kDlcId2}}});
|
|
fake_update_response_.dlc_app_update = true;
|
|
fake_update_response_.dlc_app_no_update = true;
|
|
fake_update_response_.include_dlc_cohorts = true;
|
|
fake_update_response_.dlc_cohort = "s/154454/8479665/dlc";
|
|
fake_update_response_.dlc_cohorthint = "please-put-me-on-beta-dlc";
|
|
fake_update_response_.dlc_cohortname = "stable-dlc";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_)).WillRepeatedly(Return(false));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
string value;
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohort, &value));
|
|
EXPECT_EQ(fake_update_response_.cohort, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohortHint, &value));
|
|
EXPECT_EQ(fake_update_response_.cohorthint, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsOmahaCohortName, &value));
|
|
EXPECT_EQ(fake_update_response_.cohortname, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey({kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohort}),
|
|
&value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohort, value);
|
|
EXPECT_TRUE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey({kDlcPrefsSubDir, kDlcId2, kPrefsOmahaCohort}),
|
|
&value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohort, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohortHint}),
|
|
&value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohorthint, value);
|
|
EXPECT_TRUE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId2, kPrefsOmahaCohortHint}),
|
|
&value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohorthint, value);
|
|
|
|
EXPECT_TRUE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId1, kPrefsOmahaCohortName}),
|
|
&value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohortname, value);
|
|
EXPECT_TRUE(fake_prefs_->GetString(
|
|
fake_prefs_->CreateSubKey(
|
|
{kDlcPrefsSubDir, kDlcId2, kPrefsOmahaCohortName}),
|
|
&value));
|
|
EXPECT_EQ(fake_update_response_.dlc_cohortname, value);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NoOutputPipeTest) {
|
|
const string http_response(fake_update_response_.GetNoUpdateResponse());
|
|
brillo::FakeMessageLoop loop(nullptr);
|
|
loop.SetAsCurrent();
|
|
|
|
auto action = std::make_unique<OmahaRequestAction>(
|
|
nullptr,
|
|
std::make_unique<MockHttpFetcher>(
|
|
http_response.data(), http_response.size(), nullptr),
|
|
false,
|
|
"");
|
|
ActionProcessor processor;
|
|
processor.set_delegate(&delegate_);
|
|
processor.EnqueueAction(std::move(action));
|
|
|
|
loop.PostTask(base::Bind(
|
|
[](ActionProcessor* processor) { processor->StartProcessing(); },
|
|
base::Unretained(&processor)));
|
|
loop.Run();
|
|
EXPECT_FALSE(loop.PendingTasks());
|
|
EXPECT_FALSE(processor.IsRunning());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, InvalidXmlTest) {
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, EmptyResponseTest) {
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestEmptyResponseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MissingStatusTest) {
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response protocol=\"3.0\">"
|
|
"<daystart elapsed_seconds=\"100\"/>"
|
|
"<app appid=\"foo\" status=\"ok\">"
|
|
"<ping status=\"ok\"/>"
|
|
"<updatecheck/></app></response>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaResponseInvalid;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, InvalidStatusTest) {
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response protocol=\"3.0\">"
|
|
"<daystart elapsed_seconds=\"100\"/>"
|
|
"<app appid=\"foo\" status=\"ok\">"
|
|
"<ping status=\"ok\"/>"
|
|
"<updatecheck status=\"InvalidStatusTest\"/></app></response>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaResponseInvalid;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MissingNodesetTest) {
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response protocol=\"3.0\">"
|
|
"<daystart elapsed_seconds=\"100\"/>"
|
|
"<app appid=\"foo\" status=\"ok\">"
|
|
"<ping status=\"ok\"/>"
|
|
"</app></response>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaResponseInvalid;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MissingFieldTest) {
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response protocol=\"3.0\">"
|
|
"<daystart elapsed_seconds=\"100\"/>"
|
|
// the appid needs to match that in the request params
|
|
"<app appid=\"" +
|
|
fake_update_response_.app_id +
|
|
"\" status=\"ok\">"
|
|
"<updatecheck status=\"ok\">"
|
|
"<urls><url codebase=\"http://missing/field/test/\"/></urls>"
|
|
"<manifest version=\"10.2.3.4\">"
|
|
"<packages><package hash=\"not-used\" name=\"f\" "
|
|
"size=\"587\" fp=\"3.789\" hash_sha256=\"lkq34j5345\"/></packages>"
|
|
"<actions><action event=\"postinstall\" "
|
|
"Prompt=\"false\" "
|
|
"IsDeltaPayload=\"false\" "
|
|
"sha256=\"not-used\" "
|
|
"/></actions></manifest></updatecheck></app></response>";
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ("10.2.3.4", response_.version);
|
|
EXPECT_EQ("http://missing/field/test/f",
|
|
response_.packages[0].payload_urls[0]);
|
|
EXPECT_EQ("", response_.more_info_url);
|
|
EXPECT_EQ("lkq34j5345", response_.packages[0].hash);
|
|
EXPECT_EQ(string("3.789"), response_.packages[0].fp);
|
|
EXPECT_EQ(587u, response_.packages[0].size);
|
|
EXPECT_FALSE(response_.prompt);
|
|
EXPECT_TRUE(response_.deadline.empty());
|
|
}
|
|
|
|
namespace {
|
|
class TerminateEarlyTestProcessorDelegate : public ActionProcessorDelegate {
|
|
public:
|
|
void ProcessingStopped(const ActionProcessor* processor) {
|
|
brillo::MessageLoop::current()->BreakLoop();
|
|
}
|
|
};
|
|
|
|
void TerminateTransferTestStarter(ActionProcessor* processor) {
|
|
processor->StartProcessing();
|
|
CHECK(processor->IsRunning());
|
|
processor->StopProcessing();
|
|
}
|
|
} // namespace
|
|
|
|
TEST_F(OmahaRequestActionTest, TerminateTransferTest) {
|
|
brillo::FakeMessageLoop loop(nullptr);
|
|
loop.SetAsCurrent();
|
|
|
|
string http_response("doesn't matter");
|
|
auto action = std::make_unique<OmahaRequestAction>(
|
|
nullptr,
|
|
std::make_unique<MockHttpFetcher>(
|
|
http_response.data(), http_response.size(), nullptr),
|
|
false,
|
|
"");
|
|
TerminateEarlyTestProcessorDelegate delegate;
|
|
ActionProcessor processor;
|
|
processor.set_delegate(&delegate);
|
|
processor.EnqueueAction(std::move(action));
|
|
|
|
loop.PostTask(base::Bind(&TerminateTransferTestStarter, &processor));
|
|
loop.Run();
|
|
EXPECT_FALSE(loop.PendingTasks());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, XmlEncodeIsUsedForParams) {
|
|
// Make sure XML Encode is being called on the params.
|
|
request_params_.set_os_sp("testtheservice_pack>");
|
|
request_params_.set_os_board("x86 generic<id");
|
|
request_params_.set_current_channel("unittest_track<");
|
|
request_params_.set_target_channel("unittest_track<");
|
|
request_params_.set_lts_tag("unittest_hint<");
|
|
request_params_.set_hwid("<OEM MODEL>");
|
|
fake_prefs_->SetString(kPrefsOmahaCohort, "evil\nstring");
|
|
fake_prefs_->SetString(kPrefsOmahaCohortHint, "evil&string\\");
|
|
fake_prefs_->SetString(
|
|
kPrefsOmahaCohortName,
|
|
base::JoinString(vector<string>(100, "My spoon is too big."), " "));
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(string::npos, post_str_.find("testtheservice_pack>"));
|
|
EXPECT_EQ(string::npos, post_str_.find("testtheservice_pack>"));
|
|
EXPECT_NE(string::npos, post_str_.find("x86 generic<id"));
|
|
EXPECT_EQ(string::npos, post_str_.find("x86 generic<id"));
|
|
EXPECT_NE(string::npos, post_str_.find("unittest_track&lt;"));
|
|
EXPECT_EQ(string::npos, post_str_.find("unittest_track<"));
|
|
EXPECT_NE(string::npos, post_str_.find("unittest_hint&lt;"));
|
|
EXPECT_EQ(string::npos, post_str_.find("unittest_hint<"));
|
|
EXPECT_NE(string::npos, post_str_.find("<OEM MODEL>"));
|
|
EXPECT_EQ(string::npos, post_str_.find("<OEM MODEL>"));
|
|
EXPECT_NE(string::npos, post_str_.find("cohort=\"evil\nstring\""));
|
|
EXPECT_EQ(string::npos, post_str_.find("cohorthint=\"evil&string\\\""));
|
|
EXPECT_NE(string::npos, post_str_.find("cohorthint=\"evil&string\\\""));
|
|
// Values from Prefs that are too big are removed from the XML instead of
|
|
// encoded.
|
|
EXPECT_EQ(string::npos, post_str_.find("cohortname="));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, XmlDecodeTest) {
|
|
fake_update_response_.deadline = "<20110101";
|
|
fake_update_response_.more_info_url = "testthe<url";
|
|
fake_update_response_.codebase = "testthe&codebase/";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_EQ("testthe<url", response_.more_info_url);
|
|
EXPECT_EQ("testthe&codebase/file.signed",
|
|
response_.packages[0].payload_urls[0]);
|
|
EXPECT_EQ("<20110101", response_.deadline);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ParseIntTest) {
|
|
// overflows int32_t:
|
|
fake_update_response_.size = 123123123123123ull;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_EQ(fake_update_response_.size, response_.packages[0].size);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, FormatUpdateCheckOutputTest) {
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
EXPECT_CALL(prefs, GetString(kPrefsPreviousVersion, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(string("")), Return(true)));
|
|
// An existing but empty previous version means that we didn't reboot to a new
|
|
// update, therefore, no need to update the previous version.
|
|
EXPECT_CALL(prefs, SetString(kPrefsPreviousVersion, _)).Times(0);
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(
|
|
post_str_.find(" <ping active=\"1\" a=\"-1\" r=\"-1\"></ping>\n"
|
|
" <updatecheck></updatecheck>\n"),
|
|
string::npos);
|
|
EXPECT_NE(post_str_.find("hardware_class=\"OEM MODEL 09235 7471\""),
|
|
string::npos);
|
|
// No <event> tag should be sent if we didn't reboot to an update.
|
|
EXPECT_EQ(post_str_.find("<event"), string::npos);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, FormatSuccessEventOutputTest) {
|
|
TestEvent(new OmahaEvent(OmahaEvent::kTypeUpdateDownloadStarted),
|
|
"invalid xml>");
|
|
|
|
string expected_event = base::StringPrintf(
|
|
" <event eventtype=\"%d\" eventresult=\"%d\"></event>\n",
|
|
OmahaEvent::kTypeUpdateDownloadStarted,
|
|
OmahaEvent::kResultSuccess);
|
|
EXPECT_NE(post_str_.find(expected_event), string::npos);
|
|
EXPECT_EQ(post_str_.find("ping"), string::npos);
|
|
EXPECT_EQ(post_str_.find("updatecheck"), string::npos);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, FormatErrorEventOutputTest) {
|
|
TestEvent(new OmahaEvent(OmahaEvent::kTypeDownloadComplete,
|
|
OmahaEvent::kResultError,
|
|
ErrorCode::kError),
|
|
"invalid xml>");
|
|
|
|
string expected_event = base::StringPrintf(
|
|
" <event eventtype=\"%d\" eventresult=\"%d\" "
|
|
"errorcode=\"%d\"></event>\n",
|
|
OmahaEvent::kTypeDownloadComplete,
|
|
OmahaEvent::kResultError,
|
|
static_cast<int>(ErrorCode::kError));
|
|
EXPECT_NE(post_str_.find(expected_event), string::npos);
|
|
EXPECT_EQ(post_str_.find("updatecheck"), string::npos);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, IsEventTest) {
|
|
string http_response("doesn't matter");
|
|
OmahaRequestAction update_check_action(
|
|
nullptr,
|
|
std::make_unique<MockHttpFetcher>(
|
|
http_response.data(), http_response.size(), nullptr),
|
|
false,
|
|
"");
|
|
EXPECT_FALSE(update_check_action.IsEvent());
|
|
|
|
OmahaRequestAction event_action(
|
|
new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
|
|
std::make_unique<MockHttpFetcher>(
|
|
http_response.data(), http_response.size(), nullptr),
|
|
false,
|
|
"");
|
|
EXPECT_TRUE(event_action.IsEvent());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, FormatDeltaOkayOutputTest) {
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
bool delta_okay = i == 1;
|
|
const char* delta_okay_str = delta_okay ? "true" : "false";
|
|
request_params_.set_delta_okay(delta_okay);
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
EXPECT_NE(post_str_.find(
|
|
base::StringPrintf(" delta_okay=\"%s\"", delta_okay_str)),
|
|
string::npos)
|
|
<< "i = " << i;
|
|
}
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, FormatInteractiveOutputTest) {
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
bool interactive = i == 1;
|
|
const char* interactive_str = interactive ? "ondemandupdate" : "scheduler";
|
|
request_params_.set_interactive(interactive);
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
EXPECT_NE(post_str_.find(
|
|
base::StringPrintf("installsource=\"%s\"", interactive_str)),
|
|
string::npos)
|
|
<< "i = " << i;
|
|
}
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, FormatTargetVersionPrefixOutputTest) {
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
bool target_version_set = i == 1;
|
|
const char* target_version_prefix = target_version_set ? "10032." : "";
|
|
request_params_.set_target_version_prefix(target_version_prefix);
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
if (target_version_set) {
|
|
EXPECT_NE(post_str_.find("<updatecheck targetversionprefix=\"10032.\">"),
|
|
string::npos)
|
|
<< "i = " << i;
|
|
} else {
|
|
EXPECT_EQ(post_str_.find("targetversionprefix"), string::npos)
|
|
<< "i = " << i;
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, FormatRollbackAllowedOutputTest) {
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
bool rollback_allowed = i / 2 == 0;
|
|
bool target_version_set = i % 2 == 0;
|
|
request_params_.set_target_version_prefix(target_version_set ? "10032."
|
|
: "");
|
|
request_params_.set_rollback_allowed(rollback_allowed);
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
if (rollback_allowed && target_version_set) {
|
|
EXPECT_NE(post_str_.find("rollback_allowed=\"true\""), string::npos)
|
|
<< "i = " << i;
|
|
} else {
|
|
EXPECT_EQ(post_str_.find("rollback_allowed"), string::npos)
|
|
<< "i = " << i;
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, OmahaEventTest) {
|
|
OmahaEvent default_event;
|
|
EXPECT_EQ(OmahaEvent::kTypeUnknown, default_event.type);
|
|
EXPECT_EQ(OmahaEvent::kResultError, default_event.result);
|
|
EXPECT_EQ(ErrorCode::kError, default_event.error_code);
|
|
|
|
OmahaEvent success_event(OmahaEvent::kTypeUpdateDownloadStarted);
|
|
EXPECT_EQ(OmahaEvent::kTypeUpdateDownloadStarted, success_event.type);
|
|
EXPECT_EQ(OmahaEvent::kResultSuccess, success_event.result);
|
|
EXPECT_EQ(ErrorCode::kSuccess, success_event.error_code);
|
|
|
|
OmahaEvent error_event(OmahaEvent::kTypeUpdateDownloadFinished,
|
|
OmahaEvent::kResultError,
|
|
ErrorCode::kError);
|
|
EXPECT_EQ(OmahaEvent::kTypeUpdateDownloadFinished, error_event.type);
|
|
EXPECT_EQ(OmahaEvent::kResultError, error_event.result);
|
|
EXPECT_EQ(ErrorCode::kError, error_event.error_code);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, DeviceQuickFixBuildTokenIsSetTest) {
|
|
// If DeviceQuickFixBuildToken value is set it takes precedence over pref
|
|
// value.
|
|
constexpr char autoupdate_token[] = "autoupdate_token>";
|
|
constexpr char xml_encoded_autoupdate_token[] = "autoupdate_token>";
|
|
constexpr char omaha_cohort_hint[] = "cohort_hint";
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
request_params_.set_autoupdate_token(autoupdate_token);
|
|
fake_prefs_->SetString(kPrefsOmahaCohortHint, omaha_cohort_hint);
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(string::npos,
|
|
post_str_.find("cohorthint=\"" +
|
|
string(xml_encoded_autoupdate_token) + "\""));
|
|
EXPECT_EQ(string::npos, post_str_.find(autoupdate_token));
|
|
EXPECT_EQ(string::npos, post_str_.find(omaha_cohort_hint));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, DeviceQuickFixBuildTokenIsNotSetTest) {
|
|
// If DeviceQuickFixBuildToken is not set, pref value will be provided in
|
|
// cohorthint attribute.
|
|
constexpr char omaha_cohort_hint[] = "evil_string>";
|
|
constexpr char xml_encoded_cohort_hint[] = "evil_string>";
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
fake_prefs_->SetString(kPrefsOmahaCohortHint, omaha_cohort_hint);
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(
|
|
string::npos,
|
|
post_str_.find("cohorthint=\"" + string(xml_encoded_cohort_hint) + "\""));
|
|
EXPECT_EQ(string::npos, post_str_.find(omaha_cohort_hint));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, TargetChannelHintTest) {
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
request_params_.set_lts_tag("hint>");
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(string::npos, post_str_.find("ltstag=\"hint>\""));
|
|
}
|
|
|
|
void OmahaRequestActionTest::PingTest(bool ping_only) {
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
|
|
.Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
|
|
// Add a few hours to the day difference to test no rounding, etc.
|
|
int64_t five_days_ago =
|
|
(Time::Now() - TimeDelta::FromHours(5 * 24 + 13)).ToInternalValue();
|
|
int64_t six_days_ago =
|
|
(Time::Now() - TimeDelta::FromHours(6 * 24 + 11)).ToInternalValue();
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(0), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(six_days_ago), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(five_days_ago), Return(true)));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.ping_only = ping_only;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(post_str_.find("<ping active=\"1\" a=\"6\" r=\"5\"></ping>"),
|
|
string::npos);
|
|
if (ping_only) {
|
|
EXPECT_EQ(post_str_.find("updatecheck"), string::npos);
|
|
EXPECT_EQ(post_str_.find("previousversion"), string::npos);
|
|
} else {
|
|
EXPECT_NE(post_str_.find("updatecheck"), string::npos);
|
|
EXPECT_NE(post_str_.find("previousversion"), string::npos);
|
|
}
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, PingTestSendOnlyAPing) {
|
|
PingTest(true /* ping_only */);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, PingTestSendAlsoAnUpdateCheck) {
|
|
PingTest(false /* ping_only */);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ActivePingTest) {
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
|
|
.Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
|
|
int64_t three_days_ago =
|
|
(Time::Now() - TimeDelta::FromHours(3 * 24 + 12)).ToInternalValue();
|
|
int64_t now = Time::Now().ToInternalValue();
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(0), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(three_days_ago), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(now), Return(true)));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(post_str_.find("<ping active=\"1\" a=\"3\"></ping>"), string::npos);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, RollCallPingTest) {
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
|
|
.Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
|
|
int64_t four_days_ago =
|
|
(Time::Now() - TimeDelta::FromHours(4 * 24)).ToInternalValue();
|
|
int64_t now = Time::Now().ToInternalValue();
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(0), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(now), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(four_days_ago), Return(true)));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(post_str_.find("<ping active=\"1\" r=\"4\"></ping>\n"),
|
|
string::npos);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NoPingTest) {
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
|
|
.Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
|
|
int64_t one_hour_ago =
|
|
(Time::Now() - TimeDelta::FromHours(1)).ToInternalValue();
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(0), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(one_hour_ago), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(one_hour_ago), Return(true)));
|
|
// LastActivePingDay and PrefsLastRollCallPingDay are set even if we didn't
|
|
// send a ping.
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _))
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _))
|
|
.WillOnce(Return(true));
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_EQ(post_str_.find("ping"), string::npos);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, IgnoreEmptyPingTest) {
|
|
// This test ensures that we ignore empty ping only requests.
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
int64_t now = Time::Now().ToInternalValue();
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(now), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(now), Return(true)));
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.ping_only = true;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kUnset;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(post_str_.empty());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, BackInTimePingTest) {
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
|
|
.Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
|
|
int64_t future =
|
|
(Time::Now() + TimeDelta::FromHours(3 * 24 + 4)).ToInternalValue();
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(0), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(future), Return(true)));
|
|
EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(future), Return(true)));
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _))
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _))
|
|
.WillOnce(Return(true));
|
|
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
|
|
"protocol=\"3.0\"><daystart elapsed_seconds=\"100\"/>"
|
|
"<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
|
|
"<updatecheck status=\"noupdate\"/></app></response>";
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_EQ(post_str_.find("ping"), string::npos);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, LastPingDayUpdateTest) {
|
|
// This test checks that the action updates the last ping day to now
|
|
// minus 200 seconds with a slack of 5 seconds. Therefore, the test
|
|
// may fail if it runs for longer than 5 seconds. It shouldn't run
|
|
// that long though.
|
|
int64_t midnight =
|
|
(Time::Now() - TimeDelta::FromSeconds(200)).ToInternalValue();
|
|
int64_t midnight_slack =
|
|
(Time::Now() - TimeDelta::FromSeconds(195)).ToInternalValue();
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
EXPECT_CALL(prefs, GetInt64(_, _)).Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
|
|
EXPECT_CALL(prefs,
|
|
SetInt64(kPrefsLastActivePingDay,
|
|
AllOf(Ge(midnight), Le(midnight_slack))))
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(prefs,
|
|
SetInt64(kPrefsLastRollCallPingDay,
|
|
AllOf(Ge(midnight), Le(midnight_slack))))
|
|
.WillOnce(Return(true));
|
|
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
|
|
"protocol=\"3.0\"><daystart elapsed_seconds=\"200\"/>"
|
|
"<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
|
|
"<updatecheck status=\"noupdate\"/></app></response>";
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NoElapsedSecondsTest) {
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
EXPECT_CALL(prefs, GetInt64(_, _)).Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
|
|
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
|
|
"protocol=\"3.0\"><daystart blah=\"200\"/>"
|
|
"<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
|
|
"<updatecheck status=\"noupdate\"/></app></response>";
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, BadElapsedSecondsTest) {
|
|
NiceMock<MockPrefs> prefs;
|
|
FakeSystemState::Get()->set_prefs(&prefs);
|
|
EXPECT_CALL(prefs, GetInt64(_, _)).Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
|
|
EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
|
|
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
|
|
"protocol=\"3.0\"><daystart elapsed_seconds=\"x\"/>"
|
|
"<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
|
|
"<updatecheck status=\"noupdate\"/></app></response>";
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NoUniqueIDTest) {
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_EQ(post_str_.find("machineid="), string::npos);
|
|
EXPECT_EQ(post_str_.find("userid="), string::npos);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NetworkFailureTest) {
|
|
const int http_error_code =
|
|
static_cast<int>(ErrorCode::kOmahaRequestHTTPResponseBase) + 501;
|
|
tuc_params_.fail_http_response_code = 501;
|
|
tuc_params_.expected_code = static_cast<ErrorCode>(http_error_code);
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kDownloadError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
tuc_params_.expected_download_error_code =
|
|
static_cast<metrics::DownloadErrorCode>(501);
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NetworkFailureBadHTTPCodeTest) {
|
|
const int http_error_code =
|
|
static_cast<int>(ErrorCode::kOmahaRequestHTTPResponseBase) + 999;
|
|
|
|
tuc_params_.fail_http_response_code = 1500;
|
|
tuc_params_.expected_code = static_cast<ErrorCode>(http_error_code);
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kDownloadError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
tuc_params_.expected_download_error_code =
|
|
metrics::DownloadErrorCode::kHttpStatusOther;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
EXPECT_FALSE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, TestUpdateFirstSeenAtGetsPersistedFirstTime) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_waiting_period(TimeDelta().FromDays(1));
|
|
request_params_.set_update_check_count_wait_enabled(false);
|
|
|
|
Time arbitrary_date;
|
|
ASSERT_TRUE(Time::FromString("6/4/1989", &arbitrary_date));
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(arbitrary_date);
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_code = ErrorCode::kOmahaUpdateDeferredPerPolicy;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kDeferring;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
int64_t timestamp = 0;
|
|
ASSERT_TRUE(fake_prefs_->GetInt64(kPrefsUpdateFirstSeenAt, ×tamp));
|
|
EXPECT_EQ(arbitrary_date.ToInternalValue(), timestamp);
|
|
EXPECT_FALSE(response_.update_exists);
|
|
|
|
// Verify if we are interactive check we don't defer.
|
|
request_params_.set_interactive(true);
|
|
tuc_params_.expected_code = ErrorCode::kSuccess;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUpdating;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, TestUpdateFirstSeenAtGetsUsedIfAlreadyPresent) {
|
|
request_params_.set_wall_clock_based_wait_enabled(true);
|
|
request_params_.set_waiting_period(TimeDelta().FromDays(1));
|
|
request_params_.set_update_check_count_wait_enabled(false);
|
|
|
|
Time t1, t2;
|
|
ASSERT_TRUE(Time::FromString("1/1/2012", &t1));
|
|
ASSERT_TRUE(Time::FromString("1/3/2012", &t2));
|
|
ASSERT_TRUE(
|
|
fake_prefs_->SetInt64(kPrefsUpdateFirstSeenAt, t1.ToInternalValue()));
|
|
FakeSystemState::Get()->fake_clock()->SetWallclockTime(t2);
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
|
|
// Make sure the timestamp t1 is unchanged showing that it was reused.
|
|
int64_t timestamp = 0;
|
|
ASSERT_TRUE(fake_prefs_->GetInt64(kPrefsUpdateFirstSeenAt, ×tamp));
|
|
ASSERT_TRUE(timestamp == t1.ToInternalValue());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, TestChangingToMoreStableChannel) {
|
|
// Create a uniquely named test directory.
|
|
base::ScopedTempDir tempdir;
|
|
ASSERT_TRUE(tempdir.CreateUniqueTempDir());
|
|
|
|
request_params_.set_root(tempdir.GetPath().value());
|
|
request_params_.set_app_id("{22222222-2222-2222-2222-222222222222}");
|
|
request_params_.set_app_version("1.2.3.4");
|
|
request_params_.set_product_components("o.bundle=1");
|
|
request_params_.set_current_channel("canary-channel");
|
|
EXPECT_TRUE(
|
|
request_params_.SetTargetChannel("stable-channel", true, nullptr));
|
|
request_params_.UpdateDownloadChannel();
|
|
EXPECT_TRUE(request_params_.ShouldPowerwash());
|
|
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(string::npos,
|
|
post_str_.find(
|
|
"appid=\"{22222222-2222-2222-2222-222222222222}\" "
|
|
"version=\"0.0.0.0\" from_version=\"1.2.3.4\" "
|
|
"track=\"stable-channel\" from_track=\"canary-channel\" "));
|
|
EXPECT_EQ(string::npos, post_str_.find("o.bundle"));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, TestChangingToLessStableChannel) {
|
|
// Create a uniquely named test directory.
|
|
base::ScopedTempDir tempdir;
|
|
ASSERT_TRUE(tempdir.CreateUniqueTempDir());
|
|
|
|
request_params_.set_root(tempdir.GetPath().value());
|
|
request_params_.set_app_id("{11111111-1111-1111-1111-111111111111}");
|
|
request_params_.set_app_version("5.6.7.8");
|
|
request_params_.set_product_components("o.bundle=1");
|
|
request_params_.set_current_channel("stable-channel");
|
|
EXPECT_TRUE(
|
|
request_params_.SetTargetChannel("canary-channel", false, nullptr));
|
|
request_params_.UpdateDownloadChannel();
|
|
EXPECT_FALSE(request_params_.ShouldPowerwash());
|
|
|
|
tuc_params_.http_response = "invalid xml>";
|
|
tuc_params_.expected_code = ErrorCode::kOmahaRequestXMLParseError;
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kParsingError;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_FALSE(TestUpdateCheck());
|
|
|
|
EXPECT_NE(
|
|
string::npos,
|
|
post_str_.find("appid=\"{11111111-1111-1111-1111-111111111111}\" "
|
|
"version=\"5.6.7.8\" "
|
|
"track=\"canary-channel\" from_track=\"stable-channel\""));
|
|
EXPECT_EQ(string::npos, post_str_.find("from_version"));
|
|
EXPECT_NE(string::npos, post_str_.find("o.bundle.version=\"1\""));
|
|
}
|
|
|
|
// Checks that the initial ping with a=-1 r=-1 is not send when the device
|
|
// was powerwashed.
|
|
TEST_F(OmahaRequestActionTest, PingWhenPowerwashed) {
|
|
fake_prefs_->SetString(kPrefsPreviousVersion, "");
|
|
|
|
// Flag that the device was powerwashed in the past.
|
|
FakeSystemState::Get()->fake_hardware()->SetPowerwashCount(1);
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
// We shouldn't send a ping in this case since powerwash > 0.
|
|
EXPECT_EQ(string::npos, post_str_.find("<ping"));
|
|
}
|
|
|
|
// Checks that the initial ping with a=-1 r=-1 is not send when the device
|
|
// first_active_omaha_ping_sent is set.
|
|
TEST_F(OmahaRequestActionTest, PingWhenFirstActiveOmahaPingIsSent) {
|
|
fake_prefs_->SetString(kPrefsPreviousVersion, "");
|
|
|
|
// Flag that the device was not powerwashed in the past.
|
|
FakeSystemState::Get()->fake_hardware()->SetPowerwashCount(0);
|
|
|
|
// Flag that the device has sent first active ping in the past.
|
|
FakeSystemState::Get()->fake_hardware()->SetFirstActiveOmahaPingSent();
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
// We shouldn't send a ping in this case since
|
|
// first_active_omaha_ping_sent=true
|
|
EXPECT_EQ(string::npos, post_str_.find("<ping"));
|
|
}
|
|
|
|
// Checks that the event 54 is sent on a reboot to a new update.
|
|
TEST_F(OmahaRequestActionTest, RebootAfterUpdateEvent) {
|
|
// Flag that the device was updated in a previous boot.
|
|
fake_prefs_->SetString(kPrefsPreviousVersion, "1.2.3.4");
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
// An event 54 is included and has the right version.
|
|
EXPECT_NE(
|
|
string::npos,
|
|
post_str_.find(base::StringPrintf("<event eventtype=\"%d\"",
|
|
OmahaEvent::kTypeRebootedAfterUpdate)));
|
|
EXPECT_NE(string::npos,
|
|
post_str_.find("previousversion=\"1.2.3.4\"></event>"));
|
|
|
|
// The previous version flag should have been removed.
|
|
EXPECT_TRUE(fake_prefs_->Exists(kPrefsPreviousVersion));
|
|
string prev_version;
|
|
EXPECT_TRUE(fake_prefs_->GetString(kPrefsPreviousVersion, &prev_version));
|
|
EXPECT_TRUE(prev_version.empty());
|
|
}
|
|
|
|
void OmahaRequestActionTest::P2PTest(bool initial_allow_p2p_for_downloading,
|
|
bool initial_allow_p2p_for_sharing,
|
|
bool omaha_disable_p2p_for_downloading,
|
|
bool omaha_disable_p2p_for_sharing,
|
|
bool payload_state_allow_p2p_attempt,
|
|
bool expect_p2p_client_lookup,
|
|
const string& p2p_client_result_url,
|
|
bool expected_allow_p2p_for_downloading,
|
|
bool expected_allow_p2p_for_sharing,
|
|
const string& expected_p2p_url) {
|
|
bool actual_allow_p2p_for_downloading = initial_allow_p2p_for_downloading;
|
|
bool actual_allow_p2p_for_sharing = initial_allow_p2p_for_sharing;
|
|
string actual_p2p_url;
|
|
|
|
MockPayloadState mock_payload_state;
|
|
FakeSystemState::Get()->set_payload_state(&mock_payload_state);
|
|
EXPECT_CALL(mock_payload_state, P2PAttemptAllowed())
|
|
.WillRepeatedly(Return(payload_state_allow_p2p_attempt));
|
|
EXPECT_CALL(mock_payload_state, GetUsingP2PForDownloading())
|
|
.WillRepeatedly(ReturnPointee(&actual_allow_p2p_for_downloading));
|
|
EXPECT_CALL(mock_payload_state, GetUsingP2PForSharing())
|
|
.WillRepeatedly(ReturnPointee(&actual_allow_p2p_for_sharing));
|
|
EXPECT_CALL(mock_payload_state, SetUsingP2PForDownloading(_))
|
|
.WillRepeatedly(SaveArg<0>(&actual_allow_p2p_for_downloading));
|
|
EXPECT_CALL(mock_payload_state, SetUsingP2PForSharing(_))
|
|
.WillRepeatedly(SaveArg<0>(&actual_allow_p2p_for_sharing));
|
|
EXPECT_CALL(mock_payload_state, SetP2PUrl(_))
|
|
.WillRepeatedly(SaveArg<0>(&actual_p2p_url));
|
|
|
|
MockP2PManager mock_p2p_manager;
|
|
FakeSystemState::Get()->set_p2p_manager(&mock_p2p_manager);
|
|
mock_p2p_manager.fake().SetLookupUrlForFileResult(p2p_client_result_url);
|
|
|
|
TimeDelta timeout = TimeDelta::FromSeconds(kMaxP2PNetworkWaitTimeSeconds);
|
|
EXPECT_CALL(mock_p2p_manager, LookupUrlForFile(_, _, timeout, _))
|
|
.Times(expect_p2p_client_lookup ? 1 : 0);
|
|
|
|
fake_update_response_.disable_p2p_for_downloading =
|
|
omaha_disable_p2p_for_downloading;
|
|
fake_update_response_.disable_p2p_for_sharing = omaha_disable_p2p_for_sharing;
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kUpdateAvailable;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
|
|
EXPECT_EQ(omaha_disable_p2p_for_downloading,
|
|
response_.disable_p2p_for_downloading);
|
|
EXPECT_EQ(omaha_disable_p2p_for_sharing, response_.disable_p2p_for_sharing);
|
|
|
|
EXPECT_EQ(expected_allow_p2p_for_downloading,
|
|
actual_allow_p2p_for_downloading);
|
|
EXPECT_EQ(expected_allow_p2p_for_sharing, actual_allow_p2p_for_sharing);
|
|
EXPECT_EQ(expected_p2p_url, actual_p2p_url);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, P2PWithPeer) {
|
|
P2PTest(true, // initial_allow_p2p_for_downloading
|
|
true, // initial_allow_p2p_for_sharing
|
|
false, // omaha_disable_p2p_for_downloading
|
|
false, // omaha_disable_p2p_for_sharing
|
|
true, // payload_state_allow_p2p_attempt
|
|
true, // expect_p2p_client_lookup
|
|
"http://1.3.5.7/p2p", // p2p_client_result_url
|
|
true, // expected_allow_p2p_for_downloading
|
|
true, // expected_allow_p2p_for_sharing
|
|
"http://1.3.5.7/p2p"); // expected_p2p_url
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, P2PWithoutPeer) {
|
|
P2PTest(true, // initial_allow_p2p_for_downloading
|
|
true, // initial_allow_p2p_for_sharing
|
|
false, // omaha_disable_p2p_for_downloading
|
|
false, // omaha_disable_p2p_for_sharing
|
|
true, // payload_state_allow_p2p_attempt
|
|
true, // expect_p2p_client_lookup
|
|
"", // p2p_client_result_url
|
|
false, // expected_allow_p2p_for_downloading
|
|
true, // expected_allow_p2p_for_sharing
|
|
""); // expected_p2p_url
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, P2PDownloadNotAllowed) {
|
|
P2PTest(false, // initial_allow_p2p_for_downloading
|
|
true, // initial_allow_p2p_for_sharing
|
|
false, // omaha_disable_p2p_for_downloading
|
|
false, // omaha_disable_p2p_for_sharing
|
|
true, // payload_state_allow_p2p_attempt
|
|
false, // expect_p2p_client_lookup
|
|
"unset", // p2p_client_result_url
|
|
false, // expected_allow_p2p_for_downloading
|
|
true, // expected_allow_p2p_for_sharing
|
|
""); // expected_p2p_url
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, P2PWithPeerDownloadDisabledByOmaha) {
|
|
P2PTest(true, // initial_allow_p2p_for_downloading
|
|
true, // initial_allow_p2p_for_sharing
|
|
true, // omaha_disable_p2p_for_downloading
|
|
false, // omaha_disable_p2p_for_sharing
|
|
true, // payload_state_allow_p2p_attempt
|
|
false, // expect_p2p_client_lookup
|
|
"unset", // p2p_client_result_url
|
|
false, // expected_allow_p2p_for_downloading
|
|
true, // expected_allow_p2p_for_sharing
|
|
""); // expected_p2p_url
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, P2PWithPeerSharingDisabledByOmaha) {
|
|
P2PTest(true, // initial_allow_p2p_for_downloading
|
|
true, // initial_allow_p2p_for_sharing
|
|
false, // omaha_disable_p2p_for_downloading
|
|
true, // omaha_disable_p2p_for_sharing
|
|
true, // payload_state_allow_p2p_attempt
|
|
true, // expect_p2p_client_lookup
|
|
"http://1.3.5.7/p2p", // p2p_client_result_url
|
|
true, // expected_allow_p2p_for_downloading
|
|
false, // expected_allow_p2p_for_sharing
|
|
"http://1.3.5.7/p2p"); // expected_p2p_url
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, P2PWithPeerBothDisabledByOmaha) {
|
|
P2PTest(true, // initial_allow_p2p_for_downloading
|
|
true, // initial_allow_p2p_for_sharing
|
|
true, // omaha_disable_p2p_for_downloading
|
|
true, // omaha_disable_p2p_for_sharing
|
|
true, // payload_state_allow_p2p_attempt
|
|
false, // expect_p2p_client_lookup
|
|
"unset", // p2p_client_result_url
|
|
false, // expected_allow_p2p_for_downloading
|
|
false, // expected_allow_p2p_for_sharing
|
|
""); // expected_p2p_url
|
|
}
|
|
|
|
bool OmahaRequestActionTest::InstallDateParseHelper(const string& elapsed_days,
|
|
OmahaResponse* response) {
|
|
fake_update_response_.elapsed_days = elapsed_days;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
return TestUpdateCheck();
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, ParseInstallDateFromResponse) {
|
|
// Simulate a successful update check that happens during OOBE. The
|
|
// deadline in the response is needed to force the update attempt to
|
|
// occur; responses without a deadline seen during OOBE will normally
|
|
// return ErrorCode::kNonCriticalUpdateInOOBE.
|
|
FakeSystemState::Get()->fake_hardware()->UnsetIsOOBEComplete();
|
|
fake_update_response_.deadline = "20101020";
|
|
|
|
// Check that we parse elapsed_days in the Omaha Response correctly.
|
|
// and that the kPrefsInstallDateDays value is written to.
|
|
EXPECT_FALSE(fake_prefs_->Exists(kPrefsInstallDateDays));
|
|
EXPECT_TRUE(InstallDateParseHelper("42", &response_));
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(42, response_.install_date_days);
|
|
EXPECT_TRUE(fake_prefs_->Exists(kPrefsInstallDateDays));
|
|
int64_t prefs_days;
|
|
EXPECT_TRUE(fake_prefs_->GetInt64(kPrefsInstallDateDays, &prefs_days));
|
|
EXPECT_EQ(prefs_days, 42);
|
|
|
|
// If there already is a value set, we shouldn't do anything.
|
|
EXPECT_TRUE(InstallDateParseHelper("7", &response_));
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(7, response_.install_date_days);
|
|
EXPECT_TRUE(fake_prefs_->GetInt64(kPrefsInstallDateDays, &prefs_days));
|
|
EXPECT_EQ(prefs_days, 42);
|
|
|
|
// Note that elapsed_days is not necessarily divisible by 7 so check
|
|
// that we round down correctly when populating kPrefsInstallDateDays.
|
|
EXPECT_TRUE(fake_prefs_->Delete(kPrefsInstallDateDays));
|
|
EXPECT_TRUE(InstallDateParseHelper("23", &response_));
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(23, response_.install_date_days);
|
|
EXPECT_TRUE(fake_prefs_->GetInt64(kPrefsInstallDateDays, &prefs_days));
|
|
EXPECT_EQ(prefs_days, 21);
|
|
|
|
// Check that we correctly handle elapsed_days not being included in
|
|
// the Omaha Response_.
|
|
EXPECT_TRUE(InstallDateParseHelper("", &response_));
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(-1, response_.install_date_days);
|
|
}
|
|
|
|
// If there is no prefs and OOBE is not complete, we should not
|
|
// report anything to Omaha.
|
|
TEST_F(OmahaRequestActionTest, GetInstallDateWhenNoPrefsNorOOBE) {
|
|
FakeSystemState::Get()->fake_hardware()->UnsetIsOOBEComplete();
|
|
EXPECT_EQ(OmahaRequestAction::GetInstallDate(), -1);
|
|
EXPECT_FALSE(fake_prefs_->Exists(kPrefsInstallDateDays));
|
|
}
|
|
|
|
// If OOBE is complete and happened on a valid date (e.g. after Jan
|
|
// 1 2007 0:00 PST), that date should be used and written to
|
|
// prefs. However, first try with an invalid date and check we do
|
|
// nothing.
|
|
TEST_F(OmahaRequestActionTest, GetInstallDateWhenOOBECompletedWithInvalidDate) {
|
|
Time oobe_date = Time::FromTimeT(42); // Dec 31, 1969 16:00:42 PST.
|
|
FakeSystemState::Get()->fake_hardware()->SetIsOOBEComplete(oobe_date);
|
|
EXPECT_EQ(OmahaRequestAction::GetInstallDate(), -1);
|
|
EXPECT_FALSE(fake_prefs_->Exists(kPrefsInstallDateDays));
|
|
}
|
|
|
|
// Then check with a valid date. The date Jan 20, 2007 0:00 PST
|
|
// should yield an InstallDate of 14.
|
|
TEST_F(OmahaRequestActionTest, GetInstallDateWhenOOBECompletedWithValidDate) {
|
|
Time oobe_date = Time::FromTimeT(1169280000); // Jan 20, 2007 0:00 PST.
|
|
FakeSystemState::Get()->fake_hardware()->SetIsOOBEComplete(oobe_date);
|
|
EXPECT_EQ(OmahaRequestAction::GetInstallDate(), 14);
|
|
EXPECT_TRUE(fake_prefs_->Exists(kPrefsInstallDateDays));
|
|
|
|
int64_t prefs_days;
|
|
EXPECT_TRUE(fake_prefs_->GetInt64(kPrefsInstallDateDays, &prefs_days));
|
|
EXPECT_EQ(prefs_days, 14);
|
|
}
|
|
|
|
// Now that we have a valid date in prefs, check that we keep using
|
|
// that even if OOBE date reports something else. The date Jan 30,
|
|
// 2007 0:00 PST should yield an InstallDate of 28... but since
|
|
// there's a prefs file, we should still get 14.
|
|
TEST_F(OmahaRequestActionTest, GetInstallDateWhenOOBECompletedDateChanges) {
|
|
// Set a valid date in the prefs first.
|
|
EXPECT_TRUE(fake_prefs_->SetInt64(kPrefsInstallDateDays, 14));
|
|
|
|
Time oobe_date = Time::FromTimeT(1170144000); // Jan 30, 2007 0:00 PST.
|
|
FakeSystemState::Get()->fake_hardware()->SetIsOOBEComplete(oobe_date);
|
|
EXPECT_EQ(OmahaRequestAction::GetInstallDate(), 14);
|
|
|
|
int64_t prefs_days;
|
|
EXPECT_TRUE(fake_prefs_->GetInt64(kPrefsInstallDateDays, &prefs_days));
|
|
EXPECT_EQ(prefs_days, 14);
|
|
|
|
// If we delete the prefs file, we should get 28 days.
|
|
EXPECT_TRUE(fake_prefs_->Delete(kPrefsInstallDateDays));
|
|
EXPECT_EQ(OmahaRequestAction::GetInstallDate(), 28);
|
|
EXPECT_TRUE(fake_prefs_->GetInt64(kPrefsInstallDateDays, &prefs_days));
|
|
EXPECT_EQ(prefs_days, 28);
|
|
}
|
|
|
|
// Verifies that a device with no device policy, and is not a consumer
|
|
// device sets the max kernel key version to the current version.
|
|
// ie. the same behavior as if rollback is enabled.
|
|
TEST_F(OmahaRequestActionTest, NoPolicyEnterpriseDevicesSetMaxRollback) {
|
|
FakeHardware* fake_hw = FakeSystemState::Get()->fake_hardware();
|
|
|
|
// Setup and verify some initial default values for the kernel TPM
|
|
// values that control verified boot and rollback.
|
|
const int min_kernel_version = 4;
|
|
fake_hw->SetMinKernelKeyVersion(min_kernel_version);
|
|
fake_hw->SetMaxKernelKeyRollforward(kRollforwardInfinity);
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMinKernelKeyVersion());
|
|
EXPECT_EQ(kRollforwardInfinity, fake_hw->GetMaxKernelKeyRollforward());
|
|
|
|
EXPECT_CALL(
|
|
*FakeSystemState::Get()->mock_metrics_reporter(),
|
|
ReportKeyVersionMetrics(min_kernel_version, min_kernel_version, true))
|
|
.Times(1);
|
|
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.is_consumer_device = false;
|
|
tuc_params_.rollback_allowed_milestones = 3;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
|
|
// Verify kernel_max_rollforward was set to the current minimum
|
|
// kernel key version. This has the effect of freezing roll
|
|
// forwards indefinitely. This will hold the rollback window
|
|
// open until a future change will be able to move this forward
|
|
// relative the configured window.
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMinKernelKeyVersion());
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMaxKernelKeyRollforward());
|
|
}
|
|
|
|
// Verifies that a conmsumer device with no device policy sets the
|
|
// max kernel key version to the current version. ie. the same
|
|
// behavior as if rollback is enabled.
|
|
TEST_F(OmahaRequestActionTest, NoPolicyConsumerDevicesSetMaxRollback) {
|
|
FakeHardware* fake_hw = FakeSystemState::Get()->fake_hardware();
|
|
|
|
// Setup and verify some initial default values for the kernel TPM
|
|
// values that control verified boot and rollback.
|
|
const int min_kernel_version = 3;
|
|
fake_hw->SetMinKernelKeyVersion(min_kernel_version);
|
|
fake_hw->SetMaxKernelKeyRollforward(kRollforwardInfinity);
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMinKernelKeyVersion());
|
|
EXPECT_EQ(kRollforwardInfinity, fake_hw->GetMaxKernelKeyRollforward());
|
|
|
|
EXPECT_CALL(
|
|
*FakeSystemState::Get()->mock_metrics_reporter(),
|
|
ReportKeyVersionMetrics(min_kernel_version, kRollforwardInfinity, true))
|
|
.Times(1);
|
|
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.is_consumer_device = true;
|
|
tuc_params_.rollback_allowed_milestones = 3;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
|
|
// Verify that with rollback disabled that kernel_max_rollforward
|
|
// was set to logical infinity. This is the expected behavior for
|
|
// consumer devices and matches the existing behavior prior to the
|
|
// rollback features.
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMinKernelKeyVersion());
|
|
EXPECT_EQ(kRollforwardInfinity, fake_hw->GetMaxKernelKeyRollforward());
|
|
}
|
|
|
|
// Verifies that a device with rollback enabled sets kernel_max_rollforward
|
|
// in the TPM to prevent roll forward.
|
|
TEST_F(OmahaRequestActionTest, RollbackEnabledDevicesSetMaxRollback) {
|
|
FakeHardware* fake_hw = FakeSystemState::Get()->fake_hardware();
|
|
|
|
// Setup and verify some initial default values for the kernel TPM
|
|
// values that control verified boot and rollback.
|
|
const int allowed_milestones = 4;
|
|
const int min_kernel_version = 3;
|
|
fake_hw->SetMinKernelKeyVersion(min_kernel_version);
|
|
fake_hw->SetMaxKernelKeyRollforward(kRollforwardInfinity);
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMinKernelKeyVersion());
|
|
EXPECT_EQ(kRollforwardInfinity, fake_hw->GetMaxKernelKeyRollforward());
|
|
|
|
EXPECT_CALL(
|
|
*FakeSystemState::Get()->mock_metrics_reporter(),
|
|
ReportKeyVersionMetrics(min_kernel_version, min_kernel_version, true))
|
|
.Times(1);
|
|
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.is_consumer_device = false;
|
|
tuc_params_.rollback_allowed_milestones = allowed_milestones;
|
|
tuc_params_.is_policy_loaded = true;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
|
|
// Verify that with rollback enabled that kernel_max_rollforward
|
|
// was set to the current minimum kernel key version. This has
|
|
// the effect of freezing roll forwards indefinitely. This will
|
|
// hold the rollback window open until a future change will
|
|
// be able to move this forward relative the configured window.
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMinKernelKeyVersion());
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMaxKernelKeyRollforward());
|
|
}
|
|
|
|
// Verifies that a device with rollback disabled sets kernel_max_rollforward
|
|
// in the TPM to logical infinity, to allow roll forward.
|
|
TEST_F(OmahaRequestActionTest, RollbackDisabledDevicesSetMaxRollback) {
|
|
FakeHardware* fake_hw = FakeSystemState::Get()->fake_hardware();
|
|
|
|
// Setup and verify some initial default values for the kernel TPM
|
|
// values that control verified boot and rollback.
|
|
const int allowed_milestones = 0;
|
|
const int min_kernel_version = 3;
|
|
fake_hw->SetMinKernelKeyVersion(min_kernel_version);
|
|
fake_hw->SetMaxKernelKeyRollforward(kRollforwardInfinity);
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMinKernelKeyVersion());
|
|
EXPECT_EQ(kRollforwardInfinity, fake_hw->GetMaxKernelKeyRollforward());
|
|
|
|
EXPECT_CALL(
|
|
*FakeSystemState::Get()->mock_metrics_reporter(),
|
|
ReportKeyVersionMetrics(min_kernel_version, kRollforwardInfinity, true))
|
|
.Times(1);
|
|
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.is_consumer_device = false;
|
|
tuc_params_.rollback_allowed_milestones = allowed_milestones;
|
|
tuc_params_.is_policy_loaded = true;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
|
|
// Verify that with rollback disabled that kernel_max_rollforward
|
|
// was set to logical infinity.
|
|
EXPECT_EQ(min_kernel_version, fake_hw->GetMinKernelKeyVersion());
|
|
EXPECT_EQ(kRollforwardInfinity, fake_hw->GetMaxKernelKeyRollforward());
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, RollbackResponseParsedNoEntries) {
|
|
fake_update_response_.rollback = true;
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.is_consumer_device = false;
|
|
tuc_params_.rollback_allowed_milestones = 4;
|
|
tuc_params_.is_policy_loaded = true;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_TRUE(response_.is_rollback);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, RollbackResponseValidVersionsParsed) {
|
|
fake_update_response_.rollback_firmware_version = "1.2";
|
|
fake_update_response_.rollback_kernel_version = "3.4";
|
|
fake_update_response_.rollback = true;
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.is_consumer_device = false;
|
|
tuc_params_.rollback_allowed_milestones = 4;
|
|
tuc_params_.is_policy_loaded = true;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_TRUE(response_.is_rollback);
|
|
EXPECT_EQ(1, response_.rollback_key_version.firmware_key);
|
|
EXPECT_EQ(2, response_.rollback_key_version.firmware);
|
|
EXPECT_EQ(3, response_.rollback_key_version.kernel_key);
|
|
EXPECT_EQ(4, response_.rollback_key_version.kernel);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest,
|
|
TestUpdateFirstSeenAtPrefPersistedIfUpdateExists) {
|
|
FakeClock fake_clock;
|
|
Time now = Time::Now();
|
|
fake_clock.SetWallclockTime(now);
|
|
FakeSystemState::Get()->set_clock(&fake_clock);
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_TRUE(fake_prefs_->Exists(kPrefsUpdateFirstSeenAt));
|
|
|
|
int64_t stored_first_seen_at_time;
|
|
EXPECT_TRUE(fake_prefs_->GetInt64(kPrefsUpdateFirstSeenAt,
|
|
&stored_first_seen_at_time));
|
|
EXPECT_EQ(now.ToInternalValue(), stored_first_seen_at_time);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest,
|
|
TestUpdateFirstSeenAtPrefNotPersistedIfUpdateFails) {
|
|
FakeClock fake_clock;
|
|
Time now = Time::Now();
|
|
fake_clock.SetWallclockTime(now);
|
|
FakeSystemState::Get()->set_clock(&fake_clock);
|
|
|
|
tuc_params_.http_response = fake_update_response_.GetNoUpdateResponse();
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_FALSE(response_.update_exists);
|
|
EXPECT_FALSE(fake_prefs_->Exists(kPrefsUpdateFirstSeenAt));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, InstallTest) {
|
|
request_params_.set_is_install(true);
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId("dlc_no_0"), {.name = "dlc_no_0"}},
|
|
{request_params_.GetDlcAppId("dlc_no_1"), {.name = "dlc_no_1"}}});
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
for (const auto& it : request_params_.dlc_apps_params()) {
|
|
EXPECT_NE(string::npos, post_str_.find("appid=\"" + it.first + "\""));
|
|
}
|
|
EXPECT_NE(string::npos,
|
|
post_str_.find("appid=\"" + fake_update_response_.app_id + "\""));
|
|
|
|
// Count number of updatecheck tag in response_.
|
|
int updatecheck_count = 0;
|
|
size_t pos = 0;
|
|
while ((pos = post_str_.find("<updatecheck", pos)) != string::npos) {
|
|
updatecheck_count++;
|
|
pos++;
|
|
}
|
|
EXPECT_EQ(request_params_.dlc_apps_params().size(), updatecheck_count);
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, InstallMissingPlatformVersionTest) {
|
|
fake_update_response_.multi_app_skip_updatecheck = true;
|
|
fake_update_response_.multi_app_no_update = false;
|
|
request_params_.set_is_install(true);
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId("dlc_no_0"), {.name = "dlc_no_0"}},
|
|
{request_params_.GetDlcAppId("dlc_no_1"), {.name = "dlc_no_1"}}});
|
|
request_params_.set_app_id(fake_update_response_.app_id_skip_updatecheck);
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_EQ(fake_update_response_.version, response_.version);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, UpdateWithDlcTest) {
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(kDlcId1), {.name = kDlcId1}}});
|
|
fake_update_response_.dlc_app_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_)).WillRepeatedly(Return(false));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_EQ(response_.packages.size(), 2u);
|
|
// Two candidate URLs.
|
|
EXPECT_EQ(response_.packages[1].payload_urls.size(), 2u);
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, UpdateWithPartiallyExcludedDlcTest) {
|
|
const string kDlcAppId = request_params_.GetDlcAppId(kDlcId1);
|
|
request_params_.set_dlc_apps_params({{kDlcAppId, {.name = kDlcId1}}});
|
|
fake_update_response_.dlc_app_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
// The first DLC candidate URL is excluded.
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_))
|
|
.WillOnce(Return(true))
|
|
.WillOnce(Return(false));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_EQ(response_.packages.size(), 2u);
|
|
// One candidate URL.
|
|
EXPECT_EQ(response_.packages[1].payload_urls.size(), 1u);
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_TRUE(request_params_.dlc_apps_params().at(kDlcAppId).updated);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, UpdateWithExcludedDlcTest) {
|
|
const string kDlcAppId = request_params_.GetDlcAppId(kDlcId1);
|
|
request_params_.set_dlc_apps_params({{kDlcAppId, {.name = kDlcId1}}});
|
|
fake_update_response_.dlc_app_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
// Both DLC candidate URLs are excluded.
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_))
|
|
.WillOnce(Return(true))
|
|
.WillOnce(Return(true));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_EQ(response_.packages.size(), 1u);
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_FALSE(request_params_.dlc_apps_params().at(kDlcAppId).updated);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, UpdateWithDeprecatedDlcTest) {
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(kDlcId2), {.name = kDlcId2}}});
|
|
fake_update_response_.dlc_app_no_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_)).WillRepeatedly(Return(false));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, UpdateWithDlcAndDeprecatedDlcTest) {
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(kDlcId1), {.name = kDlcId1}},
|
|
{request_params_.GetDlcAppId(kDlcId2), {.name = kDlcId2}}});
|
|
fake_update_response_.dlc_app_update = true;
|
|
fake_update_response_.dlc_app_no_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_)).WillRepeatedly(Return(false));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
EXPECT_TRUE(response_.update_exists);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, PastRollbackVersionsNoEntries) {
|
|
fake_update_response_.rollback = true;
|
|
fake_update_response_.rollback_allowed_milestones = 4;
|
|
request_params_.set_rollback_allowed_milestones(4);
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.is_consumer_device = false;
|
|
tuc_params_.rollback_allowed_milestones = 4;
|
|
tuc_params_.is_policy_loaded = true;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_TRUE(response_.is_rollback);
|
|
EXPECT_EQ(std::numeric_limits<uint16_t>::max(),
|
|
response_.past_rollback_key_version.firmware_key);
|
|
EXPECT_EQ(std::numeric_limits<uint16_t>::max(),
|
|
response_.past_rollback_key_version.firmware);
|
|
EXPECT_EQ(std::numeric_limits<uint16_t>::max(),
|
|
response_.past_rollback_key_version.kernel_key);
|
|
EXPECT_EQ(std::numeric_limits<uint16_t>::max(),
|
|
response_.past_rollback_key_version.kernel);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, PastRollbackVersionsValidEntries) {
|
|
request_params_.set_rollback_allowed_milestones(4);
|
|
fake_update_response_.rollback = true;
|
|
fake_update_response_.rollback_allowed_milestones = 4;
|
|
fake_update_response_.rollback_firmware_version = "4.3";
|
|
fake_update_response_.rollback_kernel_version = "2.1";
|
|
fake_update_response_.past_rollback_key_version =
|
|
std::make_pair("16.15", "14.13");
|
|
fake_update_response_.deadline = "20101020";
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.is_consumer_device = false;
|
|
tuc_params_.rollback_allowed_milestones = 4;
|
|
tuc_params_.is_policy_loaded = true;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_TRUE(response_.is_rollback);
|
|
EXPECT_EQ(16, response_.past_rollback_key_version.firmware_key);
|
|
EXPECT_EQ(15, response_.past_rollback_key_version.firmware);
|
|
EXPECT_EQ(14, response_.past_rollback_key_version.kernel_key);
|
|
EXPECT_EQ(13, response_.past_rollback_key_version.kernel);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, MismatchNumberOfVersions) {
|
|
fake_update_response_.rollback = true;
|
|
fake_update_response_.rollback_allowed_milestones = 2;
|
|
fake_update_response_.deadline = "20101020";
|
|
request_params_.set_rollback_allowed_milestones(4);
|
|
|
|
// Since |request_params_.rollback_allowed_milestones| is 4 but the response
|
|
// is constructed with |fake_update_response_.rollback_allowed_milestones| set
|
|
// to 2, OmahaRequestAction will look for the key values of N-4 version but
|
|
// only the N-2 version will exist.
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
tuc_params_.is_consumer_device = false;
|
|
tuc_params_.rollback_allowed_milestones = 2;
|
|
tuc_params_.is_policy_loaded = true;
|
|
|
|
EXPECT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(response_.update_exists);
|
|
EXPECT_TRUE(response_.is_rollback);
|
|
EXPECT_EQ(std::numeric_limits<uint16_t>::max(),
|
|
response_.past_rollback_key_version.firmware_key);
|
|
EXPECT_EQ(std::numeric_limits<uint16_t>::max(),
|
|
response_.past_rollback_key_version.firmware);
|
|
EXPECT_EQ(std::numeric_limits<uint16_t>::max(),
|
|
response_.past_rollback_key_version.kernel_key);
|
|
EXPECT_EQ(std::numeric_limits<uint16_t>::max(),
|
|
response_.past_rollback_key_version.kernel);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, IncludeRequisitionTest) {
|
|
request_params_.set_device_requisition("remora");
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_NE(string::npos, post_str_.find("requisition=\"remora\""));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, NoIncludeRequisitionTest) {
|
|
request_params_.set_device_requisition("");
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_EQ(string::npos, post_str_.find("requisition"));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, PersistEolDateTest) {
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
|
|
"protocol=\"3.0\"><app appid=\"test-app-id\" status=\"ok\">"
|
|
"<ping status=\"ok\"/><updatecheck status=\"noupdate\" "
|
|
"_eol_date=\"200\" _foo=\"bar\"/></app></response>";
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
string eol_date;
|
|
EXPECT_TRUE(FakeSystemState::Get()->prefs()->GetString(kPrefsOmahaEolDate,
|
|
&eol_date));
|
|
EXPECT_EQ("200", eol_date);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, PersistEolMissingDateTest) {
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
|
|
"protocol=\"3.0\"><app appid=\"test-app-id\" status=\"ok\">"
|
|
"<ping status=\"ok\"/><updatecheck status=\"noupdate\" "
|
|
"_foo=\"bar\"/></app></response>";
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
const string kDate = "123";
|
|
FakeSystemState::Get()->prefs()->SetString(kPrefsOmahaEolDate, kDate);
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
string eol_date;
|
|
EXPECT_TRUE(FakeSystemState::Get()->prefs()->GetString(kPrefsOmahaEolDate,
|
|
&eol_date));
|
|
EXPECT_EQ(kDate, eol_date);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, PersistEolBadDateTest) {
|
|
tuc_params_.http_response =
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
|
|
"protocol=\"3.0\"><app appid=\"test-app-id\" status=\"ok\">"
|
|
"<ping status=\"ok\"/><updatecheck status=\"noupdate\" "
|
|
"_eol_date=\"bad\" foo=\"bar\"/></app></response>";
|
|
tuc_params_.expected_check_result = metrics::CheckResult::kNoUpdateAvailable;
|
|
tuc_params_.expected_check_reaction = metrics::CheckReaction::kUnset;
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
string eol_date;
|
|
EXPECT_TRUE(FakeSystemState::Get()->prefs()->GetString(kPrefsOmahaEolDate,
|
|
&eol_date));
|
|
EXPECT_EQ(kEolDateInvalid, StringToEolDate(eol_date));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionDlcPingTest, StorePingReplyNoPing) {
|
|
OmahaRequestParams::AppParams app_param = {.name = dlc_id_};
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(dlc_id_), app_param}});
|
|
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
|
|
int64_t temp_int;
|
|
// If there was no ping, the metadata files shouldn't exist yet.
|
|
EXPECT_FALSE(fake_prefs_->GetInt64(active_key_, &temp_int));
|
|
EXPECT_FALSE(fake_prefs_->GetInt64(last_active_key_, &temp_int));
|
|
EXPECT_FALSE(fake_prefs_->GetInt64(last_rollcall_key_, &temp_int));
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionDlcPingTest, StorePingReplyActiveTest) {
|
|
// Create Active value
|
|
fake_prefs_->SetInt64(active_key_, 0);
|
|
|
|
OmahaRequestParams::AppParams app_param = {
|
|
.active_counting_type = OmahaRequestParams::kDateBased,
|
|
.name = dlc_id_,
|
|
.ping_active = 1,
|
|
.send_ping = true};
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(dlc_id_), app_param}});
|
|
|
|
int64_t temp_int;
|
|
string temp_str;
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(fake_prefs_->GetInt64(active_key_, &temp_int));
|
|
EXPECT_EQ(temp_int, kPingInactiveValue);
|
|
EXPECT_TRUE(fake_prefs_->GetString(last_active_key_, &temp_str));
|
|
EXPECT_EQ(temp_str, "4763");
|
|
EXPECT_TRUE(fake_prefs_->GetString(last_rollcall_key_, &temp_str));
|
|
EXPECT_EQ(temp_str, "4763");
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionDlcPingTest, StorePingReplyInactiveTest) {
|
|
// Create Active value
|
|
fake_prefs_->SetInt64(active_key_, 0);
|
|
|
|
OmahaRequestParams::AppParams app_param = {
|
|
.active_counting_type = OmahaRequestParams::kDateBased,
|
|
.name = dlc_id_,
|
|
.ping_active = 0,
|
|
.send_ping = true};
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(dlc_id_), app_param}});
|
|
|
|
// Set the previous active value to an older value than 4763.
|
|
fake_prefs_->SetString(last_active_key_, "555");
|
|
|
|
int64_t temp_int;
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
EXPECT_TRUE(fake_prefs_->GetInt64(active_key_, &temp_int));
|
|
EXPECT_EQ(temp_int, kPingInactiveValue);
|
|
string temp_str;
|
|
EXPECT_TRUE(fake_prefs_->GetString(last_active_key_, &temp_str));
|
|
EXPECT_EQ(temp_str, "555");
|
|
EXPECT_TRUE(fake_prefs_->GetString(last_rollcall_key_, &temp_str));
|
|
EXPECT_EQ(temp_str, "4763");
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, OmahaResponseUpdateCanExcludeCheck) {
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(kDlcId1), {.name = kDlcId1}}});
|
|
fake_update_response_.dlc_app_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_)).WillRepeatedly(Return(false));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
ASSERT_TRUE(delegate_.omaha_response_);
|
|
const auto& packages = delegate_.omaha_response_->packages;
|
|
ASSERT_EQ(packages.size(), 2);
|
|
|
|
EXPECT_FALSE(packages[0].can_exclude);
|
|
EXPECT_TRUE(packages[1].can_exclude);
|
|
}
|
|
|
|
TEST_F(OmahaRequestActionTest, OmahaResponseInstallCannotExcludeCheck) {
|
|
request_params_.set_is_install(true);
|
|
request_params_.set_dlc_apps_params(
|
|
{{request_params_.GetDlcAppId(kDlcId1), {.name = kDlcId1}}});
|
|
fake_update_response_.dlc_app_update = true;
|
|
tuc_params_.http_response = fake_update_response_.GetUpdateResponse();
|
|
|
|
EXPECT_CALL(mock_excluder_, IsExcluded(_)).WillRepeatedly(Return(false));
|
|
ASSERT_TRUE(TestUpdateCheck());
|
|
ASSERT_TRUE(delegate_.omaha_response_);
|
|
const auto& packages = delegate_.omaha_response_->packages;
|
|
ASSERT_EQ(packages.size(), 2);
|
|
|
|
EXPECT_FALSE(packages[0].can_exclude);
|
|
EXPECT_FALSE(packages[1].can_exclude);
|
|
}
|
|
|
|
} // namespace chromeos_update_engine
|