blob: bf2f1a054f21555910552bd28244c4c9ea43d0ae [file] [log] [blame]
Alex Deymoaea4c1c2015-08-19 20:24:43 -07001//
2// Copyright (C) 2012 The Android Open Source Project
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
Darin Petkov6a5b3222010-07-13 14:55:28 -070016
Alex Deymo8427b4a2014-11-05 14:00:32 -080017#include "update_engine/omaha_request_action.h"
18
Ben Chan9abb7632014-08-07 00:10:53 -070019#include <stdint.h>
20
Darin Petkov6a5b3222010-07-13 14:55:28 -070021#include <string>
22#include <vector>
Darin Petkov0dc8e9a2010-07-14 14:51:57 -070023
Alex Deymo60ca1a72015-06-18 18:19:15 -070024#include <base/bind.h>
Alex Deymo110e0302015-10-19 20:35:21 -070025#include <base/files/file_util.h>
Sen Jiang297e5832016-03-17 14:45:51 -070026#include <base/files/scoped_temp_dir.h>
Alex Deymo8e18f932015-03-27 16:16:59 -070027#include <base/strings/string_number_conversions.h>
Alex Vakulenko75039d72014-03-25 12:36:28 -070028#include <base/strings/string_util.h>
29#include <base/strings/stringprintf.h>
30#include <base/time/time.h>
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070031#include <brillo/bind_lambda.h>
Alex Deymoc1c17b42015-11-23 03:53:15 -030032#include <brillo/make_unique_ptr.h>
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070033#include <brillo/message_loops/fake_message_loop.h>
34#include <brillo/message_loops/message_loop.h>
35#include <brillo/message_loops/message_loop_utils.h>
Alex Deymoe1e3afe2014-10-30 13:02:49 -070036#include <gtest/gtest.h>
Jay Srinivasand29695d2013-04-08 15:08:05 -070037
Alex Deymo39910dc2015-11-09 17:04:30 -080038#include "update_engine/common/action_pipe.h"
39#include "update_engine/common/constants.h"
40#include "update_engine/common/fake_prefs.h"
41#include "update_engine/common/hash_calculator.h"
42#include "update_engine/common/mock_http_fetcher.h"
43#include "update_engine/common/platform_constants.h"
44#include "update_engine/common/prefs.h"
45#include "update_engine/common/test_utils.h"
Alex Deymoc1c17b42015-11-23 03:53:15 -030046#include "update_engine/fake_system_state.h"
Alex Deymo38429cf2015-11-11 18:27:22 -080047#include "update_engine/metrics.h"
Chris Sosa77f79e82014-06-02 18:16:24 -070048#include "update_engine/mock_connection_manager.h"
Gilad Arnold74b5f552014-10-07 08:17:16 -070049#include "update_engine/mock_payload_state.h"
Darin Petkova4a8a8c2010-07-15 22:21:12 -070050#include "update_engine/omaha_request_params.h"
Darin Petkov6a5b3222010-07-13 14:55:28 -070051
Darin Petkov1cbd78f2010-07-29 12:38:34 -070052using base::Time;
53using base::TimeDelta;
Darin Petkov6a5b3222010-07-13 14:55:28 -070054using std::string;
55using std::vector;
Darin Petkov1cbd78f2010-07-29 12:38:34 -070056using testing::AllOf;
Alex Deymof329b932014-10-30 01:37:48 -070057using testing::AnyNumber;
Jay Srinivasan34b5d862012-07-23 11:43:22 -070058using testing::DoAll;
Darin Petkov1cbd78f2010-07-29 12:38:34 -070059using testing::Ge;
60using testing::Le;
Darin Petkov9c096d62010-11-17 14:49:04 -080061using testing::NiceMock;
Darin Petkov1cbd78f2010-07-29 12:38:34 -070062using testing::Return;
Gilad Arnold74b5f552014-10-07 08:17:16 -070063using testing::ReturnPointee;
64using testing::SaveArg;
Darin Petkov1cbd78f2010-07-29 12:38:34 -070065using testing::SetArgumentPointee;
Alex Deymof329b932014-10-30 01:37:48 -070066using testing::_;
Darin Petkov6a5b3222010-07-13 14:55:28 -070067
Alex Deymo8e18f932015-03-27 16:16:59 -070068namespace {
69
Alex Deymo85616652015-10-15 18:48:31 -070070const char kTestAppId[] = "test-app-id";
71
Alex Deymo8e18f932015-03-27 16:16:59 -070072// This is a helper struct to allow unit tests build an update response with the
73// values they care about.
74struct FakeUpdateResponse {
75 string GetNoUpdateResponse() const {
76 string entity_str;
77 if (include_entity)
78 entity_str = "<!DOCTYPE response [<!ENTITY CrOS \"ChromeOS\">]>";
Sen Jiang81259682017-03-30 15:11:30 -070079 return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + entity_str +
80 "<response protocol=\"3.0\">"
81 "<daystart elapsed_seconds=\"100\"/>"
82 "<app appid=\"" +
83 app_id + "\" " +
84 (include_cohorts
85 ? "cohort=\"" + cohort + "\" cohorthint=\"" + cohorthint +
86 "\" cohortname=\"" + cohortname + "\" "
87 : "") +
88 " status=\"ok\">"
89 "<ping status=\"ok\"/>"
90 "<updatecheck status=\"noupdate\"/></app>" +
91 (multi_app_no_update
92 ? "<app><updatecheck status=\"noupdate\"/></app>"
93 : "") +
94 "</response>";
Alex Deymo8e18f932015-03-27 16:16:59 -070095 }
96
97 string GetUpdateResponse() const {
Sen Jiang2703ef42017-03-16 13:36:21 -070098 return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
99 "protocol=\"3.0\">"
100 "<daystart elapsed_seconds=\"100\"" +
101 (elapsed_days.empty() ? ""
102 : (" elapsed_days=\"" + elapsed_days + "\"")) +
103 "/>"
104 "<app appid=\"" +
105 app_id + "\" " +
106 (include_cohorts
107 ? "cohort=\"" + cohort + "\" cohorthint=\"" + cohorthint +
108 "\" cohortname=\"" + cohortname + "\" "
109 : "") +
110 " status=\"ok\">"
111 "<ping status=\"ok\"/><updatecheck status=\"ok\">"
112 "<urls><url codebase=\"" +
113 codebase +
114 "\"/></urls>"
115 "<manifest version=\"" +
116 version +
117 "\">"
118 "<packages><package hash=\"not-used\" name=\"" +
119 filename + "\" size=\"" + base::Int64ToString(size) +
Sen Jiang0affc2c2017-02-10 15:55:05 -0800120 "\" hash_sha256=\"" + hash + "\"/>" +
121 (multi_package ? "<package name=\"package2\" size=\"222\" "
122 "hash_sha256=\"hash2\"/>"
123 : "") +
124 "</packages>"
Sen Jiang81259682017-03-30 15:11:30 -0700125 "<actions><action event=\"postinstall\" MetadataSize=\"11" +
126 (multi_package ? ":22" : "") + "\" ChromeOSVersion=\"" + version +
127 "\" MoreInfo=\"" + more_info_url + "\" Prompt=\"" + prompt +
Sen Jiang2703ef42017-03-16 13:36:21 -0700128 "\" "
129 "IsDelta=\"true\" "
Sen Jiangcdd52062017-05-18 15:33:10 -0700130 "IsDeltaPayload=\"true" +
131 (multi_package ? ":false" : "") +
132 "\" "
Sen Jiang2703ef42017-03-16 13:36:21 -0700133 "MaxDaysToScatter=\"" +
134 max_days_to_scatter +
135 "\" "
136 "sha256=\"not-used\" "
137 "needsadmin=\"" +
138 needsadmin + "\" " +
139 (deadline.empty() ? "" : ("deadline=\"" + deadline + "\" ")) +
140 (disable_p2p_for_downloading ? "DisableP2PForDownloading=\"true\" "
141 : "") +
142 (disable_p2p_for_sharing ? "DisableP2PForSharing=\"true\" " : "") +
Sen Jiang81259682017-03-30 15:11:30 -0700143 "/></actions></manifest></updatecheck></app>" +
144 (multi_app
145 ? "<app><updatecheck status=\"ok\"><urls><url codebase=\"" +
146 codebase2 +
147 "\"/></urls><manifest><packages>"
148 "<package name=\"package3\" size=\"333\" "
149 "hash_sha256=\"hash3\"/></packages>"
150 "<actions><action event=\"postinstall\" "
Sen Jiangcdd52062017-05-18 15:33:10 -0700151 "MetadataSize=\"33\" IsDeltaPayload=\"false\"/></actions>"
Sen Jiang81259682017-03-30 15:11:30 -0700152 "</manifest></updatecheck></app>"
153 : "") +
154 (multi_app_no_update
155 ? "<app><updatecheck status=\"noupdate\"/></app>"
156 : "") +
157 "</response>";
Alex Deymo8e18f932015-03-27 16:16:59 -0700158 }
159
160 // Return the payload URL, which is split in two fields in the XML response.
161 string GetPayloadUrl() {
162 return codebase + filename;
163 }
164
Alex Deymo85616652015-10-15 18:48:31 -0700165 string app_id = kTestAppId;
Alex Deymo8e18f932015-03-27 16:16:59 -0700166 string version = "1.2.3.4";
167 string more_info_url = "http://more/info";
168 string prompt = "true";
169 string codebase = "http://code/base/";
Sen Jiang81259682017-03-30 15:11:30 -0700170 string codebase2 = "http://code/base/2/";
Alex Deymo8e18f932015-03-27 16:16:59 -0700171 string filename = "file.signed";
Sen Jiang2703ef42017-03-16 13:36:21 -0700172 string hash = "4841534831323334";
Alex Deymo8e18f932015-03-27 16:16:59 -0700173 string needsadmin = "false";
Sen Jiang0affc2c2017-02-10 15:55:05 -0800174 uint64_t size = 123;
Alex Deymo8e18f932015-03-27 16:16:59 -0700175 string deadline = "";
176 string max_days_to_scatter = "7";
177 string elapsed_days = "42";
178
179 // P2P setting defaults to allowed.
180 bool disable_p2p_for_downloading = false;
181 bool disable_p2p_for_sharing = false;
182
183 // Omaha cohorts settings.
184 bool include_cohorts = false;
185 string cohort = "";
186 string cohorthint = "";
187 string cohortname = "";
188
189 // Whether to include the CrOS <!ENTITY> in the XML response.
190 bool include_entity = false;
Sen Jiang0affc2c2017-02-10 15:55:05 -0800191
Sen Jiang81259682017-03-30 15:11:30 -0700192 // Whether to include more than one app.
193 bool multi_app = false;
194 // Whether to include an additional app with no update.
195 bool multi_app_no_update = false;
196 // Whether to include more than one package in an app.
Sen Jiang0affc2c2017-02-10 15:55:05 -0800197 bool multi_package = false;
Alex Deymo8e18f932015-03-27 16:16:59 -0700198};
199
200} // namespace
201
Darin Petkov6a5b3222010-07-13 14:55:28 -0700202namespace chromeos_update_engine {
203
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700204class OmahaRequestActionTest : public ::testing::Test {
205 protected:
Alex Deymo610277e2014-11-11 21:18:11 -0800206 void SetUp() override {
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700207 fake_system_state_.set_request_params(&request_params_);
208 fake_system_state_.set_prefs(&fake_prefs_);
209 }
210
211 // Returns true iff an output response was obtained from the
Alex Deymo8427b4a2014-11-05 14:00:32 -0800212 // OmahaRequestAction. |prefs| may be null, in which case a local MockPrefs
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700213 // is used. |payload_state| may be null, in which case a local mock is used.
214 // |p2p_manager| may be null, in which case a local mock is used.
215 // |connection_manager| may be null, in which case a local mock is used.
216 // out_response may be null. If |fail_http_response_code| is non-negative,
217 // the transfer will fail with that code. |ping_only| is passed through to the
218 // OmahaRequestAction constructor. out_post_data may be null; if non-null, the
219 // post-data received by the mock HttpFetcher is returned.
220 //
221 // The |expected_check_result|, |expected_check_reaction| and
222 // |expected_error_code| parameters are for checking expectations
223 // about reporting UpdateEngine.Check.{Result,Reaction,DownloadError}
224 // UMA statistics. Use the appropriate ::kUnset value to specify that
225 // the given metric should not be reported.
226 bool TestUpdateCheck(OmahaRequestParams* request_params,
227 const string& http_response,
228 int fail_http_response_code,
229 bool ping_only,
230 ErrorCode expected_code,
231 metrics::CheckResult expected_check_result,
232 metrics::CheckReaction expected_check_reaction,
233 metrics::DownloadErrorCode expected_download_error_code,
234 OmahaResponse* out_response,
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700235 brillo::Blob* out_post_data);
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700236
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800237 // Runs and checks a ping test. |ping_only| indicates whether it should send
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700238 // only a ping or also an updatecheck.
239 void PingTest(bool ping_only);
240
241 // InstallDate test helper function.
Alex Deymof329b932014-10-30 01:37:48 -0700242 bool InstallDateParseHelper(const string &elapsed_days,
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700243 OmahaResponse *response);
244
245 // P2P test helper function.
246 void P2PTest(
247 bool initial_allow_p2p_for_downloading,
248 bool initial_allow_p2p_for_sharing,
249 bool omaha_disable_p2p_for_downloading,
250 bool omaha_disable_p2p_for_sharing,
251 bool payload_state_allow_p2p_attempt,
252 bool expect_p2p_client_lookup,
253 const string& p2p_client_result_url,
254 bool expected_allow_p2p_for_downloading,
255 bool expected_allow_p2p_for_sharing,
256 const string& expected_p2p_url);
257
258 FakeSystemState fake_system_state_;
Alex Deymo8e18f932015-03-27 16:16:59 -0700259 FakeUpdateResponse fake_update_response_;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700260
261 // By default, all tests use these objects unless they replace them in the
262 // fake_system_state_.
263 OmahaRequestParams request_params_ = OmahaRequestParams{
264 &fake_system_state_,
Alex Deymoac41a822015-09-15 20:52:53 -0700265 constants::kOmahaPlatformName,
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700266 OmahaRequestParams::kOsVersion,
267 "service_pack",
268 "x86-generic",
Alex Deymo85616652015-10-15 18:48:31 -0700269 kTestAppId,
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700270 "0.1.0.0",
271 "en-US",
272 "unittest",
273 "OEM MODEL 09235 7471",
274 "ChromeOSFirmware.1.0",
275 "0X0A1",
276 false, // delta okay
277 false, // interactive
278 "http://url",
Gilad Arnold74b5f552014-10-07 08:17:16 -0700279 ""}; // target_version_prefix
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700280
281 FakePrefs fake_prefs_;
282};
Darin Petkov6a5b3222010-07-13 14:55:28 -0700283
284namespace {
Darin Petkov6a5b3222010-07-13 14:55:28 -0700285class OmahaRequestActionTestProcessorDelegate : public ActionProcessorDelegate {
286 public:
287 OmahaRequestActionTestProcessorDelegate()
Alex Deymo60ca1a72015-06-18 18:19:15 -0700288 : expected_code_(ErrorCode::kSuccess) {}
Alex Deymo610277e2014-11-11 21:18:11 -0800289 ~OmahaRequestActionTestProcessorDelegate() override {
Darin Petkov6a5b3222010-07-13 14:55:28 -0700290 }
Yunlian Jiang35866ed2015-01-29 13:09:20 -0800291 void ProcessingDone(const ActionProcessor* processor,
292 ErrorCode code) override {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700293 brillo::MessageLoop::current()->BreakLoop();
Darin Petkov6a5b3222010-07-13 14:55:28 -0700294 }
295
Yunlian Jiang35866ed2015-01-29 13:09:20 -0800296 void ActionCompleted(ActionProcessor* processor,
297 AbstractAction* action,
298 ErrorCode code) override {
Darin Petkov6a5b3222010-07-13 14:55:28 -0700299 // make sure actions always succeed
300 if (action->Type() == OmahaRequestAction::StaticType())
Darin Petkovc1a8b422010-07-19 11:34:49 -0700301 EXPECT_EQ(expected_code_, code);
Darin Petkov6a5b3222010-07-13 14:55:28 -0700302 else
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700303 EXPECT_EQ(ErrorCode::kSuccess, code);
Darin Petkov6a5b3222010-07-13 14:55:28 -0700304 }
David Zeuthena99981f2013-04-29 13:42:47 -0700305 ErrorCode expected_code_;
Darin Petkov6a5b3222010-07-13 14:55:28 -0700306};
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700307} // namespace
Darin Petkov6a5b3222010-07-13 14:55:28 -0700308
309class OutputObjectCollectorAction;
310
311template<>
312class ActionTraits<OutputObjectCollectorAction> {
313 public:
314 // Does not take an object for input
315 typedef OmahaResponse InputObjectType;
316 // On success, puts the output path on output
317 typedef NoneType OutputObjectType;
318};
319
320class OutputObjectCollectorAction : public Action<OutputObjectCollectorAction> {
321 public:
322 OutputObjectCollectorAction() : has_input_object_(false) {}
323 void PerformAction() {
324 // copy input object
325 has_input_object_ = HasInputObject();
326 if (has_input_object_)
327 omaha_response_ = GetInputObject();
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700328 processor_->ActionComplete(this, ErrorCode::kSuccess);
Darin Petkov6a5b3222010-07-13 14:55:28 -0700329 }
330 // Should never be called
331 void TerminateProcessing() {
332 CHECK(false);
333 }
334 // Debugging/logging
Alex Deymof329b932014-10-30 01:37:48 -0700335 static string StaticType() {
Darin Petkov6a5b3222010-07-13 14:55:28 -0700336 return "OutputObjectCollectorAction";
337 }
Alex Deymof329b932014-10-30 01:37:48 -0700338 string Type() const { return StaticType(); }
Alex Vakulenko0057daa2016-01-23 16:22:50 -0800339 using InputObjectType =
340 ActionTraits<OutputObjectCollectorAction>::InputObjectType;
341 using OutputObjectType =
342 ActionTraits<OutputObjectCollectorAction>::OutputObjectType;
Darin Petkov6a5b3222010-07-13 14:55:28 -0700343 bool has_input_object_;
344 OmahaResponse omaha_response_;
345};
346
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700347bool OmahaRequestActionTest::TestUpdateCheck(
348 OmahaRequestParams* request_params,
349 const string& http_response,
350 int fail_http_response_code,
351 bool ping_only,
352 ErrorCode expected_code,
353 metrics::CheckResult expected_check_result,
354 metrics::CheckReaction expected_check_reaction,
355 metrics::DownloadErrorCode expected_download_error_code,
356 OmahaResponse* out_response,
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700357 brillo::Blob* out_post_data) {
358 brillo::FakeMessageLoop loop(nullptr);
Alex Deymo60ca1a72015-06-18 18:19:15 -0700359 loop.SetAsCurrent();
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700360 MockHttpFetcher* fetcher = new MockHttpFetcher(http_response.data(),
Andrew de los Reyes45168102010-11-22 11:13:50 -0800361 http_response.size(),
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700362 nullptr);
Darin Petkovedc522e2010-11-05 09:35:17 -0700363 if (fail_http_response_code >= 0) {
364 fetcher->FailTransfer(fail_http_response_code);
365 }
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700366 if (request_params)
367 fake_system_state_.set_request_params(request_params);
368 OmahaRequestAction action(&fake_system_state_,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700369 nullptr,
Alex Deymoc1c17b42015-11-23 03:53:15 -0300370 brillo::make_unique_ptr(fetcher),
Darin Petkov265f2902011-05-09 15:17:40 -0700371 ping_only);
Darin Petkov6a5b3222010-07-13 14:55:28 -0700372 OmahaRequestActionTestProcessorDelegate delegate;
Darin Petkovc1a8b422010-07-19 11:34:49 -0700373 delegate.expected_code_ = expected_code;
Darin Petkova4a8a8c2010-07-15 22:21:12 -0700374
Darin Petkov6a5b3222010-07-13 14:55:28 -0700375 ActionProcessor processor;
Darin Petkov6a5b3222010-07-13 14:55:28 -0700376 processor.set_delegate(&delegate);
Darin Petkov6a5b3222010-07-13 14:55:28 -0700377 processor.EnqueueAction(&action);
378
379 OutputObjectCollectorAction collector_action;
Darin Petkov6a5b3222010-07-13 14:55:28 -0700380 BondActions(&action, &collector_action);
381 processor.EnqueueAction(&collector_action);
382
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700383 EXPECT_CALL(*fake_system_state_.mock_metrics_lib(), SendEnumToUMA(_, _, _))
David Zeuthen33bae492014-02-25 16:16:18 -0800384 .Times(AnyNumber());
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700385 EXPECT_CALL(*fake_system_state_.mock_metrics_lib(),
David Zeuthen33bae492014-02-25 16:16:18 -0800386 SendEnumToUMA(metrics::kMetricCheckResult,
387 static_cast<int>(expected_check_result),
388 static_cast<int>(metrics::CheckResult::kNumConstants) - 1))
389 .Times(expected_check_result == metrics::CheckResult::kUnset ? 0 : 1);
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700390 EXPECT_CALL(*fake_system_state_.mock_metrics_lib(),
David Zeuthen33bae492014-02-25 16:16:18 -0800391 SendEnumToUMA(metrics::kMetricCheckReaction,
392 static_cast<int>(expected_check_reaction),
393 static_cast<int>(metrics::CheckReaction::kNumConstants) - 1))
394 .Times(expected_check_reaction == metrics::CheckReaction::kUnset ? 0 : 1);
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700395 EXPECT_CALL(*fake_system_state_.mock_metrics_lib(),
David Zeuthenc0dd0212014-04-04 14:49:49 -0700396 SendSparseToUMA(metrics::kMetricCheckDownloadErrorCode,
397 static_cast<int>(expected_download_error_code)))
David Zeuthen33bae492014-02-25 16:16:18 -0800398 .Times(expected_download_error_code == metrics::DownloadErrorCode::kUnset
399 ? 0 : 1);
400
Luis Hector Chavezf1cf3482016-07-19 14:29:19 -0700401 loop.PostTask(base::Bind(
402 [](ActionProcessor* processor) { processor->StartProcessing(); },
403 base::Unretained(&processor)));
Alex Deymo60ca1a72015-06-18 18:19:15 -0700404 loop.Run();
Alex Deymo60ca1a72015-06-18 18:19:15 -0700405 EXPECT_FALSE(loop.PendingTasks());
Darin Petkov6a5b3222010-07-13 14:55:28 -0700406 if (collector_action.has_input_object_ && out_response)
407 *out_response = collector_action.omaha_response_;
408 if (out_post_data)
409 *out_post_data = fetcher->post_data();
410 return collector_action.has_input_object_;
411}
412
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700413// Tests Event requests -- they should always succeed. |out_post_data|
414// may be null; if non-null, the post-data received by the mock
415// HttpFetcher is returned.
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700416void TestEvent(OmahaRequestParams params,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700417 OmahaEvent* event,
418 const string& http_response,
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700419 brillo::Blob* out_post_data) {
420 brillo::FakeMessageLoop loop(nullptr);
Alex Deymo60ca1a72015-06-18 18:19:15 -0700421 loop.SetAsCurrent();
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700422 MockHttpFetcher* fetcher = new MockHttpFetcher(http_response.data(),
Andrew de los Reyes45168102010-11-22 11:13:50 -0800423 http_response.size(),
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700424 nullptr);
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700425 FakeSystemState fake_system_state;
426 fake_system_state.set_request_params(&params);
Alex Deymoc1c17b42015-11-23 03:53:15 -0300427 OmahaRequestAction action(&fake_system_state,
428 event,
429 brillo::make_unique_ptr(fetcher),
430 false);
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700431 OmahaRequestActionTestProcessorDelegate delegate;
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700432 ActionProcessor processor;
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700433 processor.set_delegate(&delegate);
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700434 processor.EnqueueAction(&action);
435
Luis Hector Chavezf1cf3482016-07-19 14:29:19 -0700436 loop.PostTask(base::Bind(
437 [](ActionProcessor* processor) { processor->StartProcessing(); },
438 base::Unretained(&processor)));
Alex Deymo60ca1a72015-06-18 18:19:15 -0700439 loop.Run();
Alex Deymo72a25672016-03-23 15:44:39 -0700440 EXPECT_FALSE(loop.PendingTasks());
Alex Deymo60ca1a72015-06-18 18:19:15 -0700441
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700442 if (out_post_data)
443 *out_post_data = fetcher->post_data();
444}
445
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700446TEST_F(OmahaRequestActionTest, RejectEntities) {
David Zeuthenf3e28012014-08-26 18:23:52 -0400447 OmahaResponse response;
Alex Deymo8e18f932015-03-27 16:16:59 -0700448 fake_update_response_.include_entity = true;
David Zeuthenf3e28012014-08-26 18:23:52 -0400449 ASSERT_FALSE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700450 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -0700451 fake_update_response_.GetNoUpdateResponse(),
David Zeuthenf3e28012014-08-26 18:23:52 -0400452 -1,
453 false, // ping_only
454 ErrorCode::kOmahaRequestXMLHasEntityDecl,
455 metrics::CheckResult::kParsingError,
456 metrics::CheckReaction::kUnset,
457 metrics::DownloadErrorCode::kUnset,
458 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700459 nullptr));
David Zeuthenf3e28012014-08-26 18:23:52 -0400460 EXPECT_FALSE(response.update_exists);
461}
462
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700463TEST_F(OmahaRequestActionTest, NoUpdateTest) {
Darin Petkov6a5b3222010-07-13 14:55:28 -0700464 OmahaResponse response;
465 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700466 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -0700467 fake_update_response_.GetNoUpdateResponse(),
Darin Petkovedc522e2010-11-05 09:35:17 -0700468 -1,
Darin Petkov265f2902011-05-09 15:17:40 -0700469 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700470 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -0800471 metrics::CheckResult::kNoUpdateAvailable,
472 metrics::CheckReaction::kUnset,
473 metrics::DownloadErrorCode::kUnset,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700474 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700475 nullptr));
Darin Petkov6a5b3222010-07-13 14:55:28 -0700476 EXPECT_FALSE(response.update_exists);
477}
478
Sen Jiang81259682017-03-30 15:11:30 -0700479TEST_F(OmahaRequestActionTest, MultiAppNoUpdateTest) {
480 OmahaResponse response;
481 fake_update_response_.multi_app_no_update = true;
482 ASSERT_TRUE(TestUpdateCheck(nullptr, // request_params
483 fake_update_response_.GetNoUpdateResponse(),
484 -1,
485 false, // ping_only
486 ErrorCode::kSuccess,
487 metrics::CheckResult::kNoUpdateAvailable,
488 metrics::CheckReaction::kUnset,
489 metrics::DownloadErrorCode::kUnset,
490 &response,
491 nullptr));
492 EXPECT_FALSE(response.update_exists);
493}
494
Alex Deymo8e18f932015-03-27 16:16:59 -0700495// Test that all the values in the response are parsed in a normal update
496// response.
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700497TEST_F(OmahaRequestActionTest, ValidUpdateTest) {
Darin Petkov6a5b3222010-07-13 14:55:28 -0700498 OmahaResponse response;
Alex Deymo8e18f932015-03-27 16:16:59 -0700499 fake_update_response_.deadline = "20101020";
Darin Petkov6a5b3222010-07-13 14:55:28 -0700500 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700501 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -0700502 fake_update_response_.GetUpdateResponse(),
Darin Petkovedc522e2010-11-05 09:35:17 -0700503 -1,
Darin Petkov265f2902011-05-09 15:17:40 -0700504 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700505 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -0800506 metrics::CheckResult::kUpdateAvailable,
507 metrics::CheckReaction::kUpdating,
508 metrics::DownloadErrorCode::kUnset,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700509 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700510 nullptr));
Darin Petkov6a5b3222010-07-13 14:55:28 -0700511 EXPECT_TRUE(response.update_exists);
Alex Deymo8e18f932015-03-27 16:16:59 -0700512 EXPECT_EQ(fake_update_response_.version, response.version);
Sen Jiang0affc2c2017-02-10 15:55:05 -0800513 EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
514 response.packages[0].payload_urls[0]);
Alex Deymo8e18f932015-03-27 16:16:59 -0700515 EXPECT_EQ(fake_update_response_.more_info_url, response.more_info_url);
Sen Jiang0affc2c2017-02-10 15:55:05 -0800516 EXPECT_EQ(fake_update_response_.hash, response.packages[0].hash);
517 EXPECT_EQ(fake_update_response_.size, response.packages[0].size);
Sen Jiangcdd52062017-05-18 15:33:10 -0700518 EXPECT_EQ(true, response.packages[0].is_delta);
Alex Deymo8e18f932015-03-27 16:16:59 -0700519 EXPECT_EQ(fake_update_response_.prompt == "true", response.prompt);
520 EXPECT_EQ(fake_update_response_.deadline, response.deadline);
521 // Omaha cohort attribets are not set in the response, so they should not be
522 // persisted.
523 EXPECT_FALSE(fake_prefs_.Exists(kPrefsOmahaCohort));
524 EXPECT_FALSE(fake_prefs_.Exists(kPrefsOmahaCohortHint));
525 EXPECT_FALSE(fake_prefs_.Exists(kPrefsOmahaCohortName));
Darin Petkov6a5b3222010-07-13 14:55:28 -0700526}
527
Sen Jiang0affc2c2017-02-10 15:55:05 -0800528TEST_F(OmahaRequestActionTest, MultiPackageUpdateTest) {
529 OmahaResponse response;
530 fake_update_response_.multi_package = true;
531 ASSERT_TRUE(TestUpdateCheck(nullptr, // request_params
532 fake_update_response_.GetUpdateResponse(),
533 -1,
534 false, // ping_only
535 ErrorCode::kSuccess,
536 metrics::CheckResult::kUpdateAvailable,
537 metrics::CheckReaction::kUpdating,
538 metrics::DownloadErrorCode::kUnset,
539 &response,
540 nullptr));
541 EXPECT_TRUE(response.update_exists);
542 EXPECT_EQ(fake_update_response_.version, response.version);
543 EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
544 response.packages[0].payload_urls[0]);
545 EXPECT_EQ(fake_update_response_.codebase + "package2",
546 response.packages[1].payload_urls[0]);
547 EXPECT_EQ(fake_update_response_.hash, response.packages[0].hash);
548 EXPECT_EQ(fake_update_response_.size, response.packages[0].size);
Sen Jiangcdd52062017-05-18 15:33:10 -0700549 EXPECT_EQ(true, response.packages[0].is_delta);
Sen Jiang81259682017-03-30 15:11:30 -0700550 EXPECT_EQ(11u, response.packages[0].metadata_size);
Sen Jiang0affc2c2017-02-10 15:55:05 -0800551 ASSERT_EQ(2u, response.packages.size());
Sen Jiang81259682017-03-30 15:11:30 -0700552 EXPECT_EQ(string("hash2"), response.packages[1].hash);
Sen Jiang0affc2c2017-02-10 15:55:05 -0800553 EXPECT_EQ(222u, response.packages[1].size);
Sen Jiang81259682017-03-30 15:11:30 -0700554 EXPECT_EQ(22u, response.packages[1].metadata_size);
Sen Jiangcdd52062017-05-18 15:33:10 -0700555 EXPECT_EQ(false, response.packages[1].is_delta);
Sen Jiang81259682017-03-30 15:11:30 -0700556}
557
558TEST_F(OmahaRequestActionTest, MultiAppUpdateTest) {
559 OmahaResponse response;
560 fake_update_response_.multi_app = true;
561 ASSERT_TRUE(TestUpdateCheck(nullptr, // request_params
562 fake_update_response_.GetUpdateResponse(),
563 -1,
564 false, // ping_only
565 ErrorCode::kSuccess,
566 metrics::CheckResult::kUpdateAvailable,
567 metrics::CheckReaction::kUpdating,
568 metrics::DownloadErrorCode::kUnset,
569 &response,
570 nullptr));
571 EXPECT_TRUE(response.update_exists);
572 EXPECT_EQ(fake_update_response_.version, response.version);
573 EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
574 response.packages[0].payload_urls[0]);
575 EXPECT_EQ(fake_update_response_.codebase2 + "package3",
576 response.packages[1].payload_urls[0]);
577 EXPECT_EQ(fake_update_response_.hash, response.packages[0].hash);
578 EXPECT_EQ(fake_update_response_.size, response.packages[0].size);
579 EXPECT_EQ(11u, response.packages[0].metadata_size);
Sen Jiangcdd52062017-05-18 15:33:10 -0700580 EXPECT_EQ(true, response.packages[0].is_delta);
Sen Jiang81259682017-03-30 15:11:30 -0700581 ASSERT_EQ(2u, response.packages.size());
582 EXPECT_EQ(string("hash3"), response.packages[1].hash);
583 EXPECT_EQ(333u, response.packages[1].size);
584 EXPECT_EQ(33u, response.packages[1].metadata_size);
Sen Jiangcdd52062017-05-18 15:33:10 -0700585 EXPECT_EQ(false, response.packages[1].is_delta);
Sen Jiang81259682017-03-30 15:11:30 -0700586}
587
588TEST_F(OmahaRequestActionTest, MultiAppPartialUpdateTest) {
589 OmahaResponse response;
590 fake_update_response_.multi_app_no_update = true;
591 ASSERT_TRUE(TestUpdateCheck(nullptr, // request_params
592 fake_update_response_.GetUpdateResponse(),
593 -1,
594 false, // ping_only
595 ErrorCode::kSuccess,
596 metrics::CheckResult::kUpdateAvailable,
597 metrics::CheckReaction::kUpdating,
598 metrics::DownloadErrorCode::kUnset,
599 &response,
600 nullptr));
601 EXPECT_TRUE(response.update_exists);
602 EXPECT_EQ(fake_update_response_.version, response.version);
603 EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
604 response.packages[0].payload_urls[0]);
605 EXPECT_EQ(fake_update_response_.hash, response.packages[0].hash);
606 EXPECT_EQ(fake_update_response_.size, response.packages[0].size);
607 EXPECT_EQ(11u, response.packages[0].metadata_size);
608 ASSERT_EQ(1u, response.packages.size());
609}
610
611TEST_F(OmahaRequestActionTest, MultiAppMultiPackageUpdateTest) {
612 OmahaResponse response;
613 fake_update_response_.multi_app = true;
614 fake_update_response_.multi_package = true;
615 ASSERT_TRUE(TestUpdateCheck(nullptr, // request_params
616 fake_update_response_.GetUpdateResponse(),
617 -1,
618 false, // ping_only
619 ErrorCode::kSuccess,
620 metrics::CheckResult::kUpdateAvailable,
621 metrics::CheckReaction::kUpdating,
622 metrics::DownloadErrorCode::kUnset,
623 &response,
624 nullptr));
625 EXPECT_TRUE(response.update_exists);
626 EXPECT_EQ(fake_update_response_.version, response.version);
627 EXPECT_EQ(fake_update_response_.GetPayloadUrl(),
628 response.packages[0].payload_urls[0]);
629 EXPECT_EQ(fake_update_response_.codebase + "package2",
630 response.packages[1].payload_urls[0]);
631 EXPECT_EQ(fake_update_response_.codebase2 + "package3",
632 response.packages[2].payload_urls[0]);
633 EXPECT_EQ(fake_update_response_.hash, response.packages[0].hash);
634 EXPECT_EQ(fake_update_response_.size, response.packages[0].size);
635 EXPECT_EQ(11u, response.packages[0].metadata_size);
Sen Jiangcdd52062017-05-18 15:33:10 -0700636 EXPECT_EQ(true, response.packages[0].is_delta);
Sen Jiang81259682017-03-30 15:11:30 -0700637 ASSERT_EQ(3u, response.packages.size());
638 EXPECT_EQ(string("hash2"), response.packages[1].hash);
639 EXPECT_EQ(222u, response.packages[1].size);
640 EXPECT_EQ(22u, response.packages[1].metadata_size);
Sen Jiangcdd52062017-05-18 15:33:10 -0700641 EXPECT_EQ(false, response.packages[1].is_delta);
Sen Jiang81259682017-03-30 15:11:30 -0700642 EXPECT_EQ(string("hash3"), response.packages[2].hash);
643 EXPECT_EQ(333u, response.packages[2].size);
644 EXPECT_EQ(33u, response.packages[2].metadata_size);
Sen Jiangcdd52062017-05-18 15:33:10 -0700645 EXPECT_EQ(false, response.packages[2].is_delta);
Sen Jiang0affc2c2017-02-10 15:55:05 -0800646}
647
Alex Deymo14ad88e2016-06-29 12:30:14 -0700648TEST_F(OmahaRequestActionTest, ExtraHeadersSentTest) {
649 const string http_response = "<?xml invalid response";
650 request_params_.set_interactive(true);
651
652 brillo::FakeMessageLoop loop(nullptr);
653 loop.SetAsCurrent();
654
655 MockHttpFetcher* fetcher =
656 new MockHttpFetcher(http_response.data(), http_response.size(), nullptr);
657 OmahaRequestAction action(
658 &fake_system_state_, nullptr, brillo::make_unique_ptr(fetcher), false);
659 ActionProcessor processor;
660 processor.EnqueueAction(&action);
661
Luis Hector Chavezf1cf3482016-07-19 14:29:19 -0700662 loop.PostTask(base::Bind(
663 [](ActionProcessor* processor) { processor->StartProcessing(); },
664 base::Unretained(&processor)));
Alex Deymo14ad88e2016-06-29 12:30:14 -0700665 loop.Run();
666 EXPECT_FALSE(loop.PendingTasks());
667
668 // Check that the headers were set in the fetcher during the action. Note that
669 // we set this request as "interactive".
670 EXPECT_EQ("fg", fetcher->GetHeader("X-GoogleUpdate-Interactivity"));
671 EXPECT_EQ(kTestAppId, fetcher->GetHeader("X-GoogleUpdate-AppId"));
672 EXPECT_NE("", fetcher->GetHeader("X-GoogleUpdate-Updater"));
673}
674
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700675TEST_F(OmahaRequestActionTest, ValidUpdateBlockedByConnection) {
Chris Sosa77f79e82014-06-02 18:16:24 -0700676 OmahaResponse response;
677 // Set up a connection manager that doesn't allow a valid update over
678 // the current ethernet connection.
Alex Deymof6ee0162015-07-31 12:35:22 -0700679 MockConnectionManager mock_cm;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700680 fake_system_state_.set_connection_manager(&mock_cm);
681
Alex Deymo30534502015-07-20 15:06:33 -0700682 EXPECT_CALL(mock_cm, GetConnectionProperties(_, _))
683 .WillRepeatedly(
Sen Jiang255e22b2016-05-20 16:15:29 -0700684 DoAll(SetArgumentPointee<0>(ConnectionType::kEthernet),
685 SetArgumentPointee<1>(ConnectionTethering::kUnknown),
Alex Deymo30534502015-07-20 15:06:33 -0700686 Return(true)));
Sen Jiang255e22b2016-05-20 16:15:29 -0700687 EXPECT_CALL(mock_cm, IsUpdateAllowedOver(ConnectionType::kEthernet, _))
688 .WillRepeatedly(Return(false));
Chris Sosa77f79e82014-06-02 18:16:24 -0700689
690 ASSERT_FALSE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700691 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -0700692 fake_update_response_.GetUpdateResponse(),
Chris Sosa77f79e82014-06-02 18:16:24 -0700693 -1,
694 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700695 ErrorCode::kOmahaUpdateIgnoredPerPolicy,
Chris Sosa77f79e82014-06-02 18:16:24 -0700696 metrics::CheckResult::kUpdateAvailable,
697 metrics::CheckReaction::kIgnored,
698 metrics::DownloadErrorCode::kUnset,
699 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700700 nullptr));
Chris Sosa77f79e82014-06-02 18:16:24 -0700701 EXPECT_FALSE(response.update_exists);
702}
703
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700704TEST_F(OmahaRequestActionTest, ValidUpdateBlockedByRollback) {
Chris Sosa77f79e82014-06-02 18:16:24 -0700705 string rollback_version = "1234.0.0";
706 OmahaResponse response;
707
708 MockPayloadState mock_payload_state;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700709 fake_system_state_.set_payload_state(&mock_payload_state);
710
Chris Sosa77f79e82014-06-02 18:16:24 -0700711 EXPECT_CALL(mock_payload_state, GetRollbackVersion())
712 .WillRepeatedly(Return(rollback_version));
713
Alex Deymo8e18f932015-03-27 16:16:59 -0700714 fake_update_response_.version = rollback_version;
Chris Sosa77f79e82014-06-02 18:16:24 -0700715 ASSERT_FALSE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700716 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -0700717 fake_update_response_.GetUpdateResponse(),
Chris Sosa77f79e82014-06-02 18:16:24 -0700718 -1,
719 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700720 ErrorCode::kOmahaUpdateIgnoredPerPolicy,
Chris Sosa77f79e82014-06-02 18:16:24 -0700721 metrics::CheckResult::kUpdateAvailable,
722 metrics::CheckReaction::kIgnored,
723 metrics::DownloadErrorCode::kUnset,
724 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700725 nullptr));
Chris Sosa77f79e82014-06-02 18:16:24 -0700726 EXPECT_FALSE(response.update_exists);
727}
728
Kevin Cernekee2494e282016-03-29 18:03:53 -0700729// Verify that update checks called during OOBE will only try to download
730// an update if the response includes a non-empty deadline field.
731TEST_F(OmahaRequestActionTest, SkipNonCriticalUpdatesBeforeOOBE) {
732 OmahaResponse response;
733
734 fake_system_state_.fake_hardware()->UnsetIsOOBEComplete();
735 ASSERT_FALSE(
736 TestUpdateCheck(nullptr, // request_params
737 fake_update_response_.GetUpdateResponse(),
738 -1,
739 false, // ping_only
740 ErrorCode::kNonCriticalUpdateInOOBE,
741 metrics::CheckResult::kUnset,
742 metrics::CheckReaction::kUnset,
743 metrics::DownloadErrorCode::kUnset,
744 &response,
745 nullptr));
746 EXPECT_FALSE(response.update_exists);
747
Alex Deymo46a9aae2016-05-04 20:20:11 -0700748 // The IsOOBEComplete() value is ignored when the OOBE flow is not enabled.
749 fake_system_state_.fake_hardware()->SetIsOOBEEnabled(false);
750 ASSERT_TRUE(TestUpdateCheck(nullptr, // request_params
751 fake_update_response_.GetUpdateResponse(),
752 -1,
753 false, // ping_only
754 ErrorCode::kSuccess,
755 metrics::CheckResult::kUpdateAvailable,
756 metrics::CheckReaction::kUpdating,
757 metrics::DownloadErrorCode::kUnset,
758 &response,
759 nullptr));
760 EXPECT_TRUE(response.update_exists);
761 fake_system_state_.fake_hardware()->SetIsOOBEEnabled(true);
762
763 // The payload is applied when a deadline was set in the response.
Kevin Cernekee2494e282016-03-29 18:03:53 -0700764 fake_update_response_.deadline = "20101020";
765 ASSERT_TRUE(
766 TestUpdateCheck(nullptr, // request_params
767 fake_update_response_.GetUpdateResponse(),
768 -1,
769 false, // ping_only
770 ErrorCode::kSuccess,
771 metrics::CheckResult::kUpdateAvailable,
772 metrics::CheckReaction::kUpdating,
773 metrics::DownloadErrorCode::kUnset,
774 &response,
775 nullptr));
776 EXPECT_TRUE(response.update_exists);
777}
778
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700779TEST_F(OmahaRequestActionTest, WallClockBasedWaitAloneCausesScattering) {
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700780 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700781 OmahaRequestParams params = request_params_;
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700782 params.set_wall_clock_based_wait_enabled(true);
783 params.set_update_check_count_wait_enabled(false);
784 params.set_waiting_period(TimeDelta::FromDays(2));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700785
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700786 ASSERT_FALSE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700787 TestUpdateCheck(&params,
Alex Deymo8e18f932015-03-27 16:16:59 -0700788 fake_update_response_.GetUpdateResponse(),
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700789 -1,
790 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700791 ErrorCode::kOmahaUpdateDeferredPerPolicy,
David Zeuthen33bae492014-02-25 16:16:18 -0800792 metrics::CheckResult::kUpdateAvailable,
793 metrics::CheckReaction::kDeferring,
794 metrics::DownloadErrorCode::kUnset,
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700795 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700796 nullptr));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700797 EXPECT_FALSE(response.update_exists);
Chris Sosa968d0572013-08-23 14:46:02 -0700798
799 // Verify if we are interactive check we don't defer.
800 params.set_interactive(true);
801 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700802 TestUpdateCheck(&params,
Alex Deymo8e18f932015-03-27 16:16:59 -0700803 fake_update_response_.GetUpdateResponse(),
Chris Sosa968d0572013-08-23 14:46:02 -0700804 -1,
805 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700806 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -0800807 metrics::CheckResult::kUpdateAvailable,
808 metrics::CheckReaction::kUpdating,
809 metrics::DownloadErrorCode::kUnset,
Chris Sosa968d0572013-08-23 14:46:02 -0700810 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700811 nullptr));
Chris Sosa968d0572013-08-23 14:46:02 -0700812 EXPECT_TRUE(response.update_exists);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700813}
814
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700815TEST_F(OmahaRequestActionTest, NoWallClockBasedWaitCausesNoScattering) {
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700816 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700817 OmahaRequestParams params = request_params_;
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700818 params.set_wall_clock_based_wait_enabled(false);
819 params.set_waiting_period(TimeDelta::FromDays(2));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700820
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700821 params.set_update_check_count_wait_enabled(true);
822 params.set_min_update_checks_needed(1);
823 params.set_max_update_checks_allowed(8);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700824
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700825 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700826 TestUpdateCheck(&params,
Alex Deymo8e18f932015-03-27 16:16:59 -0700827 fake_update_response_.GetUpdateResponse(),
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700828 -1,
829 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700830 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -0800831 metrics::CheckResult::kUpdateAvailable,
832 metrics::CheckReaction::kUpdating,
833 metrics::DownloadErrorCode::kUnset,
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700834 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700835 nullptr));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700836 EXPECT_TRUE(response.update_exists);
837}
838
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700839TEST_F(OmahaRequestActionTest, ZeroMaxDaysToScatterCausesNoScattering) {
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700840 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700841 OmahaRequestParams params = request_params_;
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700842 params.set_wall_clock_based_wait_enabled(true);
843 params.set_waiting_period(TimeDelta::FromDays(2));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700844
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700845 params.set_update_check_count_wait_enabled(true);
846 params.set_min_update_checks_needed(1);
847 params.set_max_update_checks_allowed(8);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700848
Alex Deymo8e18f932015-03-27 16:16:59 -0700849 fake_update_response_.max_days_to_scatter = "0";
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700850 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700851 TestUpdateCheck(&params,
Alex Deymo8e18f932015-03-27 16:16:59 -0700852 fake_update_response_.GetUpdateResponse(),
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700853 -1,
854 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700855 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -0800856 metrics::CheckResult::kUpdateAvailable,
857 metrics::CheckReaction::kUpdating,
858 metrics::DownloadErrorCode::kUnset,
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700859 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700860 nullptr));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700861 EXPECT_TRUE(response.update_exists);
862}
863
864
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700865TEST_F(OmahaRequestActionTest, ZeroUpdateCheckCountCausesNoScattering) {
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700866 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700867 OmahaRequestParams params = request_params_;
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700868 params.set_wall_clock_based_wait_enabled(true);
869 params.set_waiting_period(TimeDelta());
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700870
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700871 params.set_update_check_count_wait_enabled(true);
872 params.set_min_update_checks_needed(0);
873 params.set_max_update_checks_allowed(0);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700874
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700875 ASSERT_TRUE(TestUpdateCheck(
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700876 &params,
Alex Deymo8e18f932015-03-27 16:16:59 -0700877 fake_update_response_.GetUpdateResponse(),
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700878 -1,
879 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700880 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -0800881 metrics::CheckResult::kUpdateAvailable,
882 metrics::CheckReaction::kUpdating,
883 metrics::DownloadErrorCode::kUnset,
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700884 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700885 nullptr));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700886
Ben Chan9abb7632014-08-07 00:10:53 -0700887 int64_t count;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700888 ASSERT_TRUE(fake_prefs_.GetInt64(kPrefsUpdateCheckCount, &count));
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700889 ASSERT_EQ(count, 0);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700890 EXPECT_TRUE(response.update_exists);
891}
892
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700893TEST_F(OmahaRequestActionTest, NonZeroUpdateCheckCountCausesScattering) {
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700894 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700895 OmahaRequestParams params = request_params_;
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700896 params.set_wall_clock_based_wait_enabled(true);
897 params.set_waiting_period(TimeDelta());
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700898
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700899 params.set_update_check_count_wait_enabled(true);
900 params.set_min_update_checks_needed(1);
901 params.set_max_update_checks_allowed(8);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700902
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700903 ASSERT_FALSE(TestUpdateCheck(
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700904 &params,
Alex Deymo8e18f932015-03-27 16:16:59 -0700905 fake_update_response_.GetUpdateResponse(),
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700906 -1,
907 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700908 ErrorCode::kOmahaUpdateDeferredPerPolicy,
David Zeuthen33bae492014-02-25 16:16:18 -0800909 metrics::CheckResult::kUpdateAvailable,
910 metrics::CheckReaction::kDeferring,
911 metrics::DownloadErrorCode::kUnset,
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700912 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700913 nullptr));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700914
Ben Chan9abb7632014-08-07 00:10:53 -0700915 int64_t count;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700916 ASSERT_TRUE(fake_prefs_.GetInt64(kPrefsUpdateCheckCount, &count));
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700917 ASSERT_GT(count, 0);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700918 EXPECT_FALSE(response.update_exists);
Chris Sosa968d0572013-08-23 14:46:02 -0700919
920 // Verify if we are interactive check we don't defer.
921 params.set_interactive(true);
922 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700923 TestUpdateCheck(&params,
Alex Deymo8e18f932015-03-27 16:16:59 -0700924 fake_update_response_.GetUpdateResponse(),
Chris Sosa968d0572013-08-23 14:46:02 -0700925 -1,
926 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700927 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -0800928 metrics::CheckResult::kUpdateAvailable,
929 metrics::CheckReaction::kUpdating,
930 metrics::DownloadErrorCode::kUnset,
Chris Sosa968d0572013-08-23 14:46:02 -0700931 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700932 nullptr));
Chris Sosa968d0572013-08-23 14:46:02 -0700933 EXPECT_TRUE(response.update_exists);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700934}
935
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700936TEST_F(OmahaRequestActionTest, ExistingUpdateCheckCountCausesScattering) {
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700937 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700938 OmahaRequestParams params = request_params_;
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700939 params.set_wall_clock_based_wait_enabled(true);
940 params.set_waiting_period(TimeDelta());
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700941
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700942 params.set_update_check_count_wait_enabled(true);
943 params.set_min_update_checks_needed(1);
944 params.set_max_update_checks_allowed(8);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700945
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700946 ASSERT_TRUE(fake_prefs_.SetInt64(kPrefsUpdateCheckCount, 5));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700947
948 ASSERT_FALSE(TestUpdateCheck(
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700949 &params,
Alex Deymo8e18f932015-03-27 16:16:59 -0700950 fake_update_response_.GetUpdateResponse(),
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700951 -1,
952 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700953 ErrorCode::kOmahaUpdateDeferredPerPolicy,
David Zeuthen33bae492014-02-25 16:16:18 -0800954 metrics::CheckResult::kUpdateAvailable,
955 metrics::CheckReaction::kDeferring,
956 metrics::DownloadErrorCode::kUnset,
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700957 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700958 nullptr));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700959
Ben Chan9abb7632014-08-07 00:10:53 -0700960 int64_t count;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700961 ASSERT_TRUE(fake_prefs_.GetInt64(kPrefsUpdateCheckCount, &count));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700962 // count remains the same, as the decrementing happens in update_attempter
963 // which this test doesn't exercise.
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700964 ASSERT_EQ(count, 5);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700965 EXPECT_FALSE(response.update_exists);
Chris Sosa968d0572013-08-23 14:46:02 -0700966
967 // Verify if we are interactive check we don't defer.
968 params.set_interactive(true);
969 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700970 TestUpdateCheck(&params,
Alex Deymo8e18f932015-03-27 16:16:59 -0700971 fake_update_response_.GetUpdateResponse(),
Chris Sosa968d0572013-08-23 14:46:02 -0700972 -1,
973 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700974 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -0800975 metrics::CheckResult::kUpdateAvailable,
976 metrics::CheckReaction::kUpdating,
977 metrics::DownloadErrorCode::kUnset,
Chris Sosa968d0572013-08-23 14:46:02 -0700978 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700979 nullptr));
Chris Sosa968d0572013-08-23 14:46:02 -0700980 EXPECT_TRUE(response.update_exists);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700981}
Jay Srinivasan0a708742012-03-20 11:26:12 -0700982
Alex Deymo8e18f932015-03-27 16:16:59 -0700983TEST_F(OmahaRequestActionTest, CohortsArePersisted) {
984 OmahaResponse response;
985 OmahaRequestParams params = request_params_;
986 fake_update_response_.include_cohorts = true;
987 fake_update_response_.cohort = "s/154454/8479665";
988 fake_update_response_.cohorthint = "please-put-me-on-beta";
989 fake_update_response_.cohortname = "stable";
990
991 ASSERT_TRUE(TestUpdateCheck(&params,
992 fake_update_response_.GetUpdateResponse(),
993 -1,
994 false, // ping_only
995 ErrorCode::kSuccess,
996 metrics::CheckResult::kUpdateAvailable,
997 metrics::CheckReaction::kUpdating,
998 metrics::DownloadErrorCode::kUnset,
999 &response,
1000 nullptr));
1001
1002 string value;
1003 EXPECT_TRUE(fake_prefs_.GetString(kPrefsOmahaCohort, &value));
1004 EXPECT_EQ(fake_update_response_.cohort, value);
1005
1006 EXPECT_TRUE(fake_prefs_.GetString(kPrefsOmahaCohortHint, &value));
1007 EXPECT_EQ(fake_update_response_.cohorthint, value);
1008
1009 EXPECT_TRUE(fake_prefs_.GetString(kPrefsOmahaCohortName, &value));
1010 EXPECT_EQ(fake_update_response_.cohortname, value);
1011}
1012
1013TEST_F(OmahaRequestActionTest, CohortsAreUpdated) {
1014 OmahaResponse response;
1015 OmahaRequestParams params = request_params_;
1016 EXPECT_TRUE(fake_prefs_.SetString(kPrefsOmahaCohort, "old_value"));
1017 EXPECT_TRUE(fake_prefs_.SetString(kPrefsOmahaCohortHint, "old_hint"));
1018 EXPECT_TRUE(fake_prefs_.SetString(kPrefsOmahaCohortName, "old_name"));
1019 fake_update_response_.include_cohorts = true;
1020 fake_update_response_.cohort = "s/154454/8479665";
1021 fake_update_response_.cohorthint = "please-put-me-on-beta";
1022 fake_update_response_.cohortname = "";
1023
1024 ASSERT_TRUE(TestUpdateCheck(&params,
1025 fake_update_response_.GetUpdateResponse(),
1026 -1,
1027 false, // ping_only
1028 ErrorCode::kSuccess,
1029 metrics::CheckResult::kUpdateAvailable,
1030 metrics::CheckReaction::kUpdating,
1031 metrics::DownloadErrorCode::kUnset,
1032 &response,
1033 nullptr));
1034
1035 string value;
1036 EXPECT_TRUE(fake_prefs_.GetString(kPrefsOmahaCohort, &value));
1037 EXPECT_EQ(fake_update_response_.cohort, value);
1038
1039 EXPECT_TRUE(fake_prefs_.GetString(kPrefsOmahaCohortHint, &value));
1040 EXPECT_EQ(fake_update_response_.cohorthint, value);
1041
1042 EXPECT_FALSE(fake_prefs_.GetString(kPrefsOmahaCohortName, &value));
1043}
1044
1045TEST_F(OmahaRequestActionTest, CohortsAreNotModifiedWhenMissing) {
1046 OmahaResponse response;
1047 OmahaRequestParams params = request_params_;
1048 EXPECT_TRUE(fake_prefs_.SetString(kPrefsOmahaCohort, "old_value"));
1049
1050 ASSERT_TRUE(TestUpdateCheck(&params,
1051 fake_update_response_.GetUpdateResponse(),
1052 -1,
1053 false, // ping_only
1054 ErrorCode::kSuccess,
1055 metrics::CheckResult::kUpdateAvailable,
1056 metrics::CheckReaction::kUpdating,
1057 metrics::DownloadErrorCode::kUnset,
1058 &response,
1059 nullptr));
1060
1061 string value;
1062 EXPECT_TRUE(fake_prefs_.GetString(kPrefsOmahaCohort, &value));
1063 EXPECT_EQ("old_value", value);
1064
1065 EXPECT_FALSE(fake_prefs_.GetString(kPrefsOmahaCohortHint, &value));
1066 EXPECT_FALSE(fake_prefs_.GetString(kPrefsOmahaCohortName, &value));
1067}
1068
Alex Deymo00d79ac2015-06-29 15:41:49 -07001069TEST_F(OmahaRequestActionTest, CohortsArePersistedWhenNoUpdate) {
1070 OmahaResponse response;
1071 OmahaRequestParams params = request_params_;
1072 fake_update_response_.include_cohorts = true;
1073 fake_update_response_.cohort = "s/154454/8479665";
1074 fake_update_response_.cohorthint = "please-put-me-on-beta";
1075 fake_update_response_.cohortname = "stable";
1076
1077 ASSERT_TRUE(TestUpdateCheck(&params,
1078 fake_update_response_.GetNoUpdateResponse(),
1079 -1,
1080 false, // ping_only
1081 ErrorCode::kSuccess,
1082 metrics::CheckResult::kNoUpdateAvailable,
1083 metrics::CheckReaction::kUnset,
1084 metrics::DownloadErrorCode::kUnset,
1085 &response,
1086 nullptr));
1087
1088 string value;
1089 EXPECT_TRUE(fake_prefs_.GetString(kPrefsOmahaCohort, &value));
1090 EXPECT_EQ(fake_update_response_.cohort, value);
1091
1092 EXPECT_TRUE(fake_prefs_.GetString(kPrefsOmahaCohortHint, &value));
1093 EXPECT_EQ(fake_update_response_.cohorthint, value);
1094
1095 EXPECT_TRUE(fake_prefs_.GetString(kPrefsOmahaCohortName, &value));
1096 EXPECT_EQ(fake_update_response_.cohortname, value);
1097}
1098
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001099TEST_F(OmahaRequestActionTest, NoOutputPipeTest) {
Alex Deymo8e18f932015-03-27 16:16:59 -07001100 const string http_response(fake_update_response_.GetNoUpdateResponse());
Darin Petkov6a5b3222010-07-13 14:55:28 -07001101
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001102 brillo::FakeMessageLoop loop(nullptr);
Alex Deymo60ca1a72015-06-18 18:19:15 -07001103 loop.SetAsCurrent();
Darin Petkov6a5b3222010-07-13 14:55:28 -07001104
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001105 OmahaRequestParams params = request_params_;
1106 fake_system_state_.set_request_params(&params);
1107 OmahaRequestAction action(&fake_system_state_, nullptr,
Alex Deymoc1c17b42015-11-23 03:53:15 -03001108 brillo::make_unique_ptr(
1109 new MockHttpFetcher(http_response.data(),
1110 http_response.size(),
1111 nullptr)),
Thieu Le116fda32011-04-19 11:01:54 -07001112 false);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001113 OmahaRequestActionTestProcessorDelegate delegate;
Darin Petkov6a5b3222010-07-13 14:55:28 -07001114 ActionProcessor processor;
1115 processor.set_delegate(&delegate);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001116 processor.EnqueueAction(&action);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001117
Luis Hector Chavezf1cf3482016-07-19 14:29:19 -07001118 loop.PostTask(base::Bind(
1119 [](ActionProcessor* processor) { processor->StartProcessing(); },
1120 base::Unretained(&processor)));
Alex Deymo60ca1a72015-06-18 18:19:15 -07001121 loop.Run();
1122 EXPECT_FALSE(loop.PendingTasks());
Darin Petkov6a5b3222010-07-13 14:55:28 -07001123 EXPECT_FALSE(processor.IsRunning());
1124}
1125
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001126TEST_F(OmahaRequestActionTest, InvalidXmlTest) {
Darin Petkov6a5b3222010-07-13 14:55:28 -07001127 OmahaResponse response;
1128 ASSERT_FALSE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001129 TestUpdateCheck(nullptr, // request_params
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001130 "invalid xml>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001131 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001132 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001133 ErrorCode::kOmahaRequestXMLParseError,
David Zeuthen33bae492014-02-25 16:16:18 -08001134 metrics::CheckResult::kParsingError,
1135 metrics::CheckReaction::kUnset,
1136 metrics::DownloadErrorCode::kUnset,
Darin Petkovedc522e2010-11-05 09:35:17 -07001137 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001138 nullptr));
Darin Petkovedc522e2010-11-05 09:35:17 -07001139 EXPECT_FALSE(response.update_exists);
1140}
1141
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001142TEST_F(OmahaRequestActionTest, EmptyResponseTest) {
Darin Petkovedc522e2010-11-05 09:35:17 -07001143 OmahaResponse response;
1144 ASSERT_FALSE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001145 TestUpdateCheck(nullptr, // request_params
Darin Petkovedc522e2010-11-05 09:35:17 -07001146 "",
1147 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001148 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001149 ErrorCode::kOmahaRequestEmptyResponseError,
David Zeuthen33bae492014-02-25 16:16:18 -08001150 metrics::CheckResult::kParsingError,
1151 metrics::CheckReaction::kUnset,
1152 metrics::DownloadErrorCode::kUnset,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001153 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001154 nullptr));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001155 EXPECT_FALSE(response.update_exists);
1156}
1157
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001158TEST_F(OmahaRequestActionTest, MissingStatusTest) {
Darin Petkov6a5b3222010-07-13 14:55:28 -07001159 OmahaResponse response;
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001160 ASSERT_FALSE(TestUpdateCheck(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001161 nullptr, // request_params
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001162 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response protocol=\"3.0\">"
1163 "<daystart elapsed_seconds=\"100\"/>"
1164 "<app appid=\"foo\" status=\"ok\">"
1165 "<ping status=\"ok\"/>"
1166 "<updatecheck/></app></response>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001167 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001168 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001169 ErrorCode::kOmahaResponseInvalid,
David Zeuthen33bae492014-02-25 16:16:18 -08001170 metrics::CheckResult::kParsingError,
1171 metrics::CheckReaction::kUnset,
1172 metrics::DownloadErrorCode::kUnset,
Darin Petkov6a5b3222010-07-13 14:55:28 -07001173 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001174 nullptr));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001175 EXPECT_FALSE(response.update_exists);
1176}
1177
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001178TEST_F(OmahaRequestActionTest, InvalidStatusTest) {
Darin Petkov6a5b3222010-07-13 14:55:28 -07001179 OmahaResponse response;
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001180 ASSERT_FALSE(TestUpdateCheck(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001181 nullptr, // request_params
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001182 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response protocol=\"3.0\">"
1183 "<daystart elapsed_seconds=\"100\"/>"
1184 "<app appid=\"foo\" status=\"ok\">"
1185 "<ping status=\"ok\"/>"
1186 "<updatecheck status=\"InvalidStatusTest\"/></app></response>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001187 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001188 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001189 ErrorCode::kOmahaResponseInvalid,
David Zeuthen33bae492014-02-25 16:16:18 -08001190 metrics::CheckResult::kParsingError,
1191 metrics::CheckReaction::kUnset,
1192 metrics::DownloadErrorCode::kUnset,
Darin Petkov6a5b3222010-07-13 14:55:28 -07001193 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001194 nullptr));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001195 EXPECT_FALSE(response.update_exists);
1196}
1197
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001198TEST_F(OmahaRequestActionTest, MissingNodesetTest) {
Darin Petkov6a5b3222010-07-13 14:55:28 -07001199 OmahaResponse response;
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001200 ASSERT_FALSE(TestUpdateCheck(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001201 nullptr, // request_params
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001202 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response protocol=\"3.0\">"
1203 "<daystart elapsed_seconds=\"100\"/>"
1204 "<app appid=\"foo\" status=\"ok\">"
1205 "<ping status=\"ok\"/>"
1206 "</app></response>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001207 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001208 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001209 ErrorCode::kOmahaResponseInvalid,
David Zeuthen33bae492014-02-25 16:16:18 -08001210 metrics::CheckResult::kParsingError,
1211 metrics::CheckReaction::kUnset,
1212 metrics::DownloadErrorCode::kUnset,
Darin Petkov6a5b3222010-07-13 14:55:28 -07001213 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001214 nullptr));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001215 EXPECT_FALSE(response.update_exists);
1216}
1217
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001218TEST_F(OmahaRequestActionTest, MissingFieldTest) {
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001219 string input_response =
1220 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response protocol=\"3.0\">"
1221 "<daystart elapsed_seconds=\"100\"/>"
1222 "<app appid=\"xyz\" status=\"ok\">"
1223 "<updatecheck status=\"ok\">"
1224 "<urls><url codebase=\"http://missing/field/test/\"/></urls>"
Chris Sosa3b748432013-06-20 16:42:59 -07001225 "<manifest version=\"10.2.3.4\">"
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001226 "<packages><package hash=\"not-used\" name=\"f\" "
Sen Jiang2703ef42017-03-16 13:36:21 -07001227 "size=\"587\" hash_sha256=\"lkq34j5345\"/></packages>"
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001228 "<actions><action event=\"postinstall\" "
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001229 "ChromeOSVersion=\"10.2.3.4\" "
1230 "Prompt=\"false\" "
1231 "IsDelta=\"true\" "
Jay Srinivasand671e972013-01-11 17:17:19 -08001232 "IsDeltaPayload=\"false\" "
Sen Jiang2703ef42017-03-16 13:36:21 -07001233 "sha256=\"not-used\" "
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001234 "needsadmin=\"true\" "
1235 "/></actions></manifest></updatecheck></app></response>";
1236 LOG(INFO) << "Input Response = " << input_response;
1237
Darin Petkov6a5b3222010-07-13 14:55:28 -07001238 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001239 ASSERT_TRUE(TestUpdateCheck(nullptr, // request_params
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001240 input_response,
Darin Petkovedc522e2010-11-05 09:35:17 -07001241 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001242 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001243 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001244 metrics::CheckResult::kUpdateAvailable,
1245 metrics::CheckReaction::kUpdating,
1246 metrics::DownloadErrorCode::kUnset,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001247 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001248 nullptr));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001249 EXPECT_TRUE(response.update_exists);
Chris Sosa3b748432013-06-20 16:42:59 -07001250 EXPECT_EQ("10.2.3.4", response.version);
Sen Jiang0affc2c2017-02-10 15:55:05 -08001251 EXPECT_EQ("http://missing/field/test/f",
1252 response.packages[0].payload_urls[0]);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001253 EXPECT_EQ("", response.more_info_url);
Sen Jiang0affc2c2017-02-10 15:55:05 -08001254 EXPECT_EQ("lkq34j5345", response.packages[0].hash);
1255 EXPECT_EQ(587u, response.packages[0].size);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001256 EXPECT_FALSE(response.prompt);
Darin Petkov6c118642010-10-21 12:06:30 -07001257 EXPECT_TRUE(response.deadline.empty());
Darin Petkov6a5b3222010-07-13 14:55:28 -07001258}
1259
1260namespace {
1261class TerminateEarlyTestProcessorDelegate : public ActionProcessorDelegate {
1262 public:
1263 void ProcessingStopped(const ActionProcessor* processor) {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001264 brillo::MessageLoop::current()->BreakLoop();
Darin Petkov6a5b3222010-07-13 14:55:28 -07001265 }
Darin Petkov6a5b3222010-07-13 14:55:28 -07001266};
1267
Alex Deymo60ca1a72015-06-18 18:19:15 -07001268void TerminateTransferTestStarter(ActionProcessor* processor) {
Darin Petkov6a5b3222010-07-13 14:55:28 -07001269 processor->StartProcessing();
1270 CHECK(processor->IsRunning());
1271 processor->StopProcessing();
Darin Petkov6a5b3222010-07-13 14:55:28 -07001272}
Alex Vakulenkod2779df2014-06-16 13:19:00 -07001273} // namespace
Darin Petkov6a5b3222010-07-13 14:55:28 -07001274
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001275TEST_F(OmahaRequestActionTest, TerminateTransferTest) {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001276 brillo::FakeMessageLoop loop(nullptr);
Alex Deymo60ca1a72015-06-18 18:19:15 -07001277 loop.SetAsCurrent();
Darin Petkov6a5b3222010-07-13 14:55:28 -07001278
Alex Deymo60ca1a72015-06-18 18:19:15 -07001279 string http_response("doesn't matter");
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001280 OmahaRequestAction action(&fake_system_state_, nullptr,
Alex Deymoc1c17b42015-11-23 03:53:15 -03001281 brillo::make_unique_ptr(
1282 new MockHttpFetcher(http_response.data(),
1283 http_response.size(),
1284 nullptr)),
Thieu Le116fda32011-04-19 11:01:54 -07001285 false);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001286 TerminateEarlyTestProcessorDelegate delegate;
Darin Petkov6a5b3222010-07-13 14:55:28 -07001287 ActionProcessor processor;
1288 processor.set_delegate(&delegate);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001289 processor.EnqueueAction(&action);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001290
Alex Deymo60ca1a72015-06-18 18:19:15 -07001291 loop.PostTask(base::Bind(&TerminateTransferTestStarter, &processor));
1292 loop.Run();
1293 EXPECT_FALSE(loop.PendingTasks());
Darin Petkov6a5b3222010-07-13 14:55:28 -07001294}
1295
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001296TEST_F(OmahaRequestActionTest, XmlEncodeTest) {
Alex Deymob0d74eb2015-03-30 17:59:17 -07001297 string output;
1298 EXPECT_TRUE(XmlEncode("ab", &output));
1299 EXPECT_EQ("ab", output);
1300 EXPECT_TRUE(XmlEncode("a<b", &output));
1301 EXPECT_EQ("a&lt;b", output);
Alex Deymocc457852015-06-18 18:35:50 -07001302 EXPECT_TRUE(XmlEncode("<&>\"\'\\", &output));
1303 EXPECT_EQ("&lt;&amp;&gt;&quot;&apos;\\", output);
Alex Deymob0d74eb2015-03-30 17:59:17 -07001304 EXPECT_TRUE(XmlEncode("&lt;&amp;&gt;", &output));
1305 EXPECT_EQ("&amp;lt;&amp;amp;&amp;gt;", output);
Alex Deymocc457852015-06-18 18:35:50 -07001306 // Check that unterminated UTF-8 strings are handled properly.
Alex Deymob0d74eb2015-03-30 17:59:17 -07001307 EXPECT_FALSE(XmlEncode("\xc2", &output));
1308 // Fail with invalid ASCII-7 chars.
1309 EXPECT_FALSE(XmlEncode("This is an 'n' with a tilde: \xc3\xb1", &output));
1310}
Darin Petkov6a5b3222010-07-13 14:55:28 -07001311
Alex Deymob0d74eb2015-03-30 17:59:17 -07001312TEST_F(OmahaRequestActionTest, XmlEncodeWithDefaultTest) {
1313 EXPECT_EQ("&lt;&amp;&gt;", XmlEncodeWithDefault("<&>", "something else"));
1314 EXPECT_EQ("<not escaped>", XmlEncodeWithDefault("\xc2", "<not escaped>"));
1315}
1316
1317TEST_F(OmahaRequestActionTest, XmlEncodeIsUsedForParams) {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001318 brillo::Blob post_data;
Darin Petkov6a5b3222010-07-13 14:55:28 -07001319
1320 // Make sure XML Encode is being called on the params
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001321 OmahaRequestParams params(&fake_system_state_,
Alex Deymoac41a822015-09-15 20:52:53 -07001322 constants::kOmahaPlatformName,
Darin Petkov6a5b3222010-07-13 14:55:28 -07001323 OmahaRequestParams::kOsVersion,
1324 "testtheservice_pack>",
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001325 "x86 generic<id",
Alex Deymo85616652015-10-15 18:48:31 -07001326 kTestAppId,
Darin Petkov6a5b3222010-07-13 14:55:28 -07001327 "0.1.0.0",
1328 "en-US",
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001329 "unittest_track&lt;",
Darin Petkovfbb40092010-07-29 17:05:50 -07001330 "<OEM MODEL>",
Chris Sosac1972482013-04-30 22:31:10 -07001331 "ChromeOSFirmware.1.0",
1332 "EC100",
Alex Vakulenkod2779df2014-06-16 13:19:00 -07001333 false, // delta okay
1334 false, // interactive
Jay Srinivasan0a708742012-03-20 11:26:12 -07001335 "http://url",
Gilad Arnold74b5f552014-10-07 08:17:16 -07001336 ""); // target_version_prefix
Alex Deymo8e18f932015-03-27 16:16:59 -07001337 fake_prefs_.SetString(kPrefsOmahaCohort, "evil\nstring");
1338 fake_prefs_.SetString(kPrefsOmahaCohortHint, "evil&string\\");
1339 fake_prefs_.SetString(kPrefsOmahaCohortName,
Alex Vakulenko0103c362016-01-20 07:56:15 -08001340 base::JoinString(
1341 vector<string>(100, "My spoon is too big."), " "));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001342 OmahaResponse response;
1343 ASSERT_FALSE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001344 TestUpdateCheck(&params,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001345 "invalid xml>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001346 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001347 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001348 ErrorCode::kOmahaRequestXMLParseError,
David Zeuthen33bae492014-02-25 16:16:18 -08001349 metrics::CheckResult::kParsingError,
1350 metrics::CheckReaction::kUnset,
1351 metrics::DownloadErrorCode::kUnset,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001352 &response,
1353 &post_data));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001354 // convert post_data to string
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001355 string post_str(post_data.begin(), post_data.end());
Alex Deymo8e18f932015-03-27 16:16:59 -07001356 EXPECT_NE(string::npos, post_str.find("testtheservice_pack&gt;"));
1357 EXPECT_EQ(string::npos, post_str.find("testtheservice_pack>"));
1358 EXPECT_NE(string::npos, post_str.find("x86 generic&lt;id"));
1359 EXPECT_EQ(string::npos, post_str.find("x86 generic<id"));
1360 EXPECT_NE(string::npos, post_str.find("unittest_track&amp;lt;"));
1361 EXPECT_EQ(string::npos, post_str.find("unittest_track&lt;"));
1362 EXPECT_NE(string::npos, post_str.find("&lt;OEM MODEL&gt;"));
1363 EXPECT_EQ(string::npos, post_str.find("<OEM MODEL>"));
1364 EXPECT_NE(string::npos, post_str.find("cohort=\"evil\nstring\""));
1365 EXPECT_EQ(string::npos, post_str.find("cohorthint=\"evil&string\\\""));
1366 EXPECT_NE(string::npos, post_str.find("cohorthint=\"evil&amp;string\\\""));
1367 // Values from Prefs that are too big are removed from the XML instead of
1368 // encoded.
1369 EXPECT_EQ(string::npos, post_str.find("cohortname="));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001370}
1371
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001372TEST_F(OmahaRequestActionTest, XmlDecodeTest) {
Darin Petkov6a5b3222010-07-13 14:55:28 -07001373 OmahaResponse response;
Alex Deymo8e18f932015-03-27 16:16:59 -07001374 fake_update_response_.deadline = "&lt;20110101";
1375 fake_update_response_.more_info_url = "testthe&lt;url";
1376 fake_update_response_.codebase = "testthe&amp;codebase/";
Darin Petkov6a5b3222010-07-13 14:55:28 -07001377 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001378 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -07001379 fake_update_response_.GetUpdateResponse(),
Darin Petkovedc522e2010-11-05 09:35:17 -07001380 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001381 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001382 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001383 metrics::CheckResult::kUpdateAvailable,
1384 metrics::CheckReaction::kUpdating,
1385 metrics::DownloadErrorCode::kUnset,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001386 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001387 nullptr));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001388
Sen Jiang0affc2c2017-02-10 15:55:05 -08001389 EXPECT_EQ("testthe<url", response.more_info_url);
1390 EXPECT_EQ("testthe&codebase/file.signed",
1391 response.packages[0].payload_urls[0]);
1392 EXPECT_EQ("<20110101", response.deadline);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001393}
1394
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001395TEST_F(OmahaRequestActionTest, ParseIntTest) {
Darin Petkov6a5b3222010-07-13 14:55:28 -07001396 OmahaResponse response;
Alex Deymo8e18f932015-03-27 16:16:59 -07001397 // overflows int32_t:
Sen Jiang0affc2c2017-02-10 15:55:05 -08001398 fake_update_response_.size = 123123123123123ull;
Darin Petkov6a5b3222010-07-13 14:55:28 -07001399 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001400 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -07001401 fake_update_response_.GetUpdateResponse(),
Darin Petkovedc522e2010-11-05 09:35:17 -07001402 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001403 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001404 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001405 metrics::CheckResult::kUpdateAvailable,
1406 metrics::CheckReaction::kUpdating,
1407 metrics::DownloadErrorCode::kUnset,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001408 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001409 nullptr));
Darin Petkov6a5b3222010-07-13 14:55:28 -07001410
Sen Jiang0affc2c2017-02-10 15:55:05 -08001411 EXPECT_EQ(fake_update_response_.size, response.packages[0].size);
Darin Petkov6a5b3222010-07-13 14:55:28 -07001412}
1413
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001414TEST_F(OmahaRequestActionTest, FormatUpdateCheckOutputTest) {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001415 brillo::Blob post_data;
Alex Deymo8427b4a2014-11-05 14:00:32 -08001416 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001417 fake_system_state_.set_prefs(&prefs);
1418
Darin Petkov95508da2011-01-05 12:42:29 -08001419 EXPECT_CALL(prefs, GetString(kPrefsPreviousVersion, _))
1420 .WillOnce(DoAll(SetArgumentPointee<1>(string("")), Return(true)));
Alex Deymoefb9d832015-11-02 18:39:02 -08001421 // An existing but empty previous version means that we didn't reboot to a new
1422 // update, therefore, no need to update the previous version.
1423 EXPECT_CALL(prefs, SetString(kPrefsPreviousVersion, _)).Times(0);
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001424 ASSERT_FALSE(TestUpdateCheck(nullptr, // request_params
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001425 "invalid xml>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001426 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001427 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001428 ErrorCode::kOmahaRequestXMLParseError,
David Zeuthen33bae492014-02-25 16:16:18 -08001429 metrics::CheckResult::kParsingError,
1430 metrics::CheckReaction::kUnset,
1431 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001432 nullptr, // response
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001433 &post_data));
1434 // convert post_data to string
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001435 string post_str(post_data.begin(), post_data.end());
Thieu Le116fda32011-04-19 11:01:54 -07001436 EXPECT_NE(post_str.find(
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001437 " <ping active=\"1\" a=\"-1\" r=\"-1\"></ping>\n"
Jay Srinivasanae4697c2013-03-18 17:08:08 -07001438 " <updatecheck targetversionprefix=\"\"></updatecheck>\n"),
Jay Srinivasan0a708742012-03-20 11:26:12 -07001439 string::npos);
Darin Petkovfbb40092010-07-29 17:05:50 -07001440 EXPECT_NE(post_str.find("hardware_class=\"OEM MODEL 09235 7471\""),
1441 string::npos);
Chris Sosac1972482013-04-30 22:31:10 -07001442 EXPECT_NE(post_str.find("fw_version=\"ChromeOSFirmware.1.0\""),
1443 string::npos);
1444 EXPECT_NE(post_str.find("ec_version=\"0X0A1\""),
1445 string::npos);
Alex Deymoefb9d832015-11-02 18:39:02 -08001446 // No <event> tag should be sent if we didn't reboot to an update.
1447 EXPECT_EQ(post_str.find("<event"), string::npos);
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001448}
1449
Jay Srinivasan0a708742012-03-20 11:26:12 -07001450
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001451TEST_F(OmahaRequestActionTest, FormatSuccessEventOutputTest) {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001452 brillo::Blob post_data;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001453 TestEvent(request_params_,
Darin Petkove17f86b2010-07-20 09:12:01 -07001454 new OmahaEvent(OmahaEvent::kTypeUpdateDownloadStarted),
1455 "invalid xml>",
1456 &post_data);
1457 // convert post_data to string
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001458 string post_str(post_data.begin(), post_data.end());
Alex Vakulenko75039d72014-03-25 12:36:28 -07001459 string expected_event = base::StringPrintf(
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001460 " <event eventtype=\"%d\" eventresult=\"%d\"></event>\n",
Darin Petkove17f86b2010-07-20 09:12:01 -07001461 OmahaEvent::kTypeUpdateDownloadStarted,
1462 OmahaEvent::kResultSuccess);
1463 EXPECT_NE(post_str.find(expected_event), string::npos);
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001464 EXPECT_EQ(post_str.find("ping"), string::npos);
1465 EXPECT_EQ(post_str.find("updatecheck"), string::npos);
Darin Petkove17f86b2010-07-20 09:12:01 -07001466}
1467
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001468TEST_F(OmahaRequestActionTest, FormatErrorEventOutputTest) {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001469 brillo::Blob post_data;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001470 TestEvent(request_params_,
Darin Petkove17f86b2010-07-20 09:12:01 -07001471 new OmahaEvent(OmahaEvent::kTypeDownloadComplete,
1472 OmahaEvent::kResultError,
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001473 ErrorCode::kError),
Darin Petkove17f86b2010-07-20 09:12:01 -07001474 "invalid xml>",
1475 &post_data);
1476 // convert post_data to string
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001477 string post_str(post_data.begin(), post_data.end());
Alex Vakulenko75039d72014-03-25 12:36:28 -07001478 string expected_event = base::StringPrintf(
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001479 " <event eventtype=\"%d\" eventresult=\"%d\" "
1480 "errorcode=\"%d\"></event>\n",
Darin Petkove17f86b2010-07-20 09:12:01 -07001481 OmahaEvent::kTypeDownloadComplete,
1482 OmahaEvent::kResultError,
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001483 static_cast<int>(ErrorCode::kError));
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001484 EXPECT_NE(post_str.find(expected_event), string::npos);
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001485 EXPECT_EQ(post_str.find("updatecheck"), string::npos);
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001486}
1487
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001488TEST_F(OmahaRequestActionTest, IsEventTest) {
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001489 string http_response("doesn't matter");
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001490 // Create a copy of the OmahaRequestParams to reuse it later.
1491 OmahaRequestParams params = request_params_;
1492 fake_system_state_.set_request_params(&params);
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001493 OmahaRequestAction update_check_action(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001494 &fake_system_state_,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001495 nullptr,
Alex Deymoc1c17b42015-11-23 03:53:15 -03001496 brillo::make_unique_ptr(
1497 new MockHttpFetcher(http_response.data(),
1498 http_response.size(),
1499 nullptr)),
Thieu Le116fda32011-04-19 11:01:54 -07001500 false);
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001501 EXPECT_FALSE(update_check_action.IsEvent());
1502
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001503 params = request_params_;
1504 fake_system_state_.set_request_params(&params);
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001505 OmahaRequestAction event_action(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001506 &fake_system_state_,
Darin Petkove17f86b2010-07-20 09:12:01 -07001507 new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
Alex Deymoc1c17b42015-11-23 03:53:15 -03001508 brillo::make_unique_ptr(
1509 new MockHttpFetcher(http_response.data(),
1510 http_response.size(),
1511 nullptr)),
Thieu Le116fda32011-04-19 11:01:54 -07001512 false);
Darin Petkov0dc8e9a2010-07-14 14:51:57 -07001513 EXPECT_TRUE(event_action.IsEvent());
1514}
1515
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001516TEST_F(OmahaRequestActionTest, FormatDeltaOkayOutputTest) {
Andrew de los Reyes3f0303a2010-07-15 22:35:35 -07001517 for (int i = 0; i < 2; i++) {
1518 bool delta_okay = i == 1;
1519 const char* delta_okay_str = delta_okay ? "true" : "false";
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001520 brillo::Blob post_data;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001521 OmahaRequestParams params(&fake_system_state_,
Alex Deymoac41a822015-09-15 20:52:53 -07001522 constants::kOmahaPlatformName,
Andrew de los Reyes3f0303a2010-07-15 22:35:35 -07001523 OmahaRequestParams::kOsVersion,
1524 "service_pack",
1525 "x86-generic",
Alex Deymo85616652015-10-15 18:48:31 -07001526 kTestAppId,
Andrew de los Reyes3f0303a2010-07-15 22:35:35 -07001527 "0.1.0.0",
1528 "en-US",
1529 "unittest_track",
Darin Petkovfbb40092010-07-29 17:05:50 -07001530 "OEM MODEL REV 1234",
Chris Sosac1972482013-04-30 22:31:10 -07001531 "ChromeOSFirmware.1.0",
1532 "EC100",
Andrew de los Reyes3f0303a2010-07-15 22:35:35 -07001533 delta_okay,
Gilad Arnoldbbdd4902013-01-10 16:06:30 -08001534 false, // interactive
Jay Srinivasan0a708742012-03-20 11:26:12 -07001535 "http://url",
Gilad Arnold74b5f552014-10-07 08:17:16 -07001536 ""); // target_version_prefix
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001537 ASSERT_FALSE(TestUpdateCheck(&params,
Andrew de los Reyes3f0303a2010-07-15 22:35:35 -07001538 "invalid xml>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001539 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001540 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001541 ErrorCode::kOmahaRequestXMLParseError,
David Zeuthen33bae492014-02-25 16:16:18 -08001542 metrics::CheckResult::kParsingError,
1543 metrics::CheckReaction::kUnset,
1544 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001545 nullptr,
Andrew de los Reyes3f0303a2010-07-15 22:35:35 -07001546 &post_data));
1547 // convert post_data to string
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001548 string post_str(post_data.begin(), post_data.end());
Alex Vakulenko75039d72014-03-25 12:36:28 -07001549 EXPECT_NE(post_str.find(base::StringPrintf(" delta_okay=\"%s\"",
1550 delta_okay_str)),
Andrew de los Reyes3f0303a2010-07-15 22:35:35 -07001551 string::npos)
1552 << "i = " << i;
1553 }
1554}
1555
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001556TEST_F(OmahaRequestActionTest, FormatInteractiveOutputTest) {
Gilad Arnoldbbdd4902013-01-10 16:06:30 -08001557 for (int i = 0; i < 2; i++) {
1558 bool interactive = i == 1;
Gilad Arnold8a659d82013-01-24 11:26:00 -08001559 const char* interactive_str = interactive ? "ondemandupdate" : "scheduler";
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001560 brillo::Blob post_data;
Gilad Arnold5bb4c902014-04-10 12:32:13 -07001561 FakeSystemState fake_system_state;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001562 OmahaRequestParams params(&fake_system_state_,
Alex Deymoac41a822015-09-15 20:52:53 -07001563 constants::kOmahaPlatformName,
Gilad Arnoldbbdd4902013-01-10 16:06:30 -08001564 OmahaRequestParams::kOsVersion,
1565 "service_pack",
1566 "x86-generic",
Alex Deymo85616652015-10-15 18:48:31 -07001567 kTestAppId,
Gilad Arnoldbbdd4902013-01-10 16:06:30 -08001568 "0.1.0.0",
1569 "en-US",
1570 "unittest_track",
1571 "OEM MODEL REV 1234",
Chris Sosac1972482013-04-30 22:31:10 -07001572 "ChromeOSFirmware.1.0",
1573 "EC100",
David Zeuthen8f191b22013-08-06 12:27:50 -07001574 true, // delta_okay
Gilad Arnoldbbdd4902013-01-10 16:06:30 -08001575 interactive,
1576 "http://url",
Gilad Arnold74b5f552014-10-07 08:17:16 -07001577 ""); // target_version_prefix
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001578 ASSERT_FALSE(TestUpdateCheck(&params,
Gilad Arnoldbbdd4902013-01-10 16:06:30 -08001579 "invalid xml>",
1580 -1,
1581 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001582 ErrorCode::kOmahaRequestXMLParseError,
David Zeuthen33bae492014-02-25 16:16:18 -08001583 metrics::CheckResult::kParsingError,
1584 metrics::CheckReaction::kUnset,
1585 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001586 nullptr,
Gilad Arnoldbbdd4902013-01-10 16:06:30 -08001587 &post_data));
1588 // convert post_data to string
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001589 string post_str(post_data.begin(), post_data.end());
Alex Vakulenko75039d72014-03-25 12:36:28 -07001590 EXPECT_NE(post_str.find(base::StringPrintf("installsource=\"%s\"",
1591 interactive_str)),
Gilad Arnoldbbdd4902013-01-10 16:06:30 -08001592 string::npos)
1593 << "i = " << i;
1594 }
1595}
1596
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001597TEST_F(OmahaRequestActionTest, OmahaEventTest) {
Darin Petkove17f86b2010-07-20 09:12:01 -07001598 OmahaEvent default_event;
1599 EXPECT_EQ(OmahaEvent::kTypeUnknown, default_event.type);
1600 EXPECT_EQ(OmahaEvent::kResultError, default_event.result);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001601 EXPECT_EQ(ErrorCode::kError, default_event.error_code);
Darin Petkove17f86b2010-07-20 09:12:01 -07001602
1603 OmahaEvent success_event(OmahaEvent::kTypeUpdateDownloadStarted);
1604 EXPECT_EQ(OmahaEvent::kTypeUpdateDownloadStarted, success_event.type);
1605 EXPECT_EQ(OmahaEvent::kResultSuccess, success_event.result);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001606 EXPECT_EQ(ErrorCode::kSuccess, success_event.error_code);
Darin Petkove17f86b2010-07-20 09:12:01 -07001607
1608 OmahaEvent error_event(OmahaEvent::kTypeUpdateDownloadFinished,
1609 OmahaEvent::kResultError,
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001610 ErrorCode::kError);
Darin Petkove17f86b2010-07-20 09:12:01 -07001611 EXPECT_EQ(OmahaEvent::kTypeUpdateDownloadFinished, error_event.type);
1612 EXPECT_EQ(OmahaEvent::kResultError, error_event.result);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001613 EXPECT_EQ(ErrorCode::kError, error_event.error_code);
Darin Petkove17f86b2010-07-20 09:12:01 -07001614}
1615
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001616void OmahaRequestActionTest::PingTest(bool ping_only) {
Alex Deymo8427b4a2014-11-05 14:00:32 -08001617 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001618 fake_system_state_.set_prefs(&prefs);
1619 EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
1620 .Times(AnyNumber());
1621 EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
1622 // Add a few hours to the day difference to test no rounding, etc.
1623 int64_t five_days_ago =
1624 (Time::Now() - TimeDelta::FromHours(5 * 24 + 13)).ToInternalValue();
1625 int64_t six_days_ago =
1626 (Time::Now() - TimeDelta::FromHours(6 * 24 + 11)).ToInternalValue();
1627 EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
1628 .WillOnce(DoAll(SetArgumentPointee<1>(0), Return(true)));
1629 EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
1630 .WillOnce(DoAll(SetArgumentPointee<1>(six_days_ago), Return(true)));
1631 EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
1632 .WillOnce(DoAll(SetArgumentPointee<1>(five_days_ago), Return(true)));
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001633 brillo::Blob post_data;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001634 ASSERT_TRUE(
1635 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -07001636 fake_update_response_.GetNoUpdateResponse(),
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001637 -1,
1638 ping_only,
1639 ErrorCode::kSuccess,
1640 metrics::CheckResult::kUnset,
1641 metrics::CheckReaction::kUnset,
1642 metrics::DownloadErrorCode::kUnset,
1643 nullptr,
1644 &post_data));
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001645 string post_str(post_data.begin(), post_data.end());
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001646 EXPECT_NE(post_str.find("<ping active=\"1\" a=\"6\" r=\"5\"></ping>"),
1647 string::npos);
1648 if (ping_only) {
1649 EXPECT_EQ(post_str.find("updatecheck"), string::npos);
1650 EXPECT_EQ(post_str.find("previousversion"), string::npos);
1651 } else {
1652 EXPECT_NE(post_str.find("updatecheck"), string::npos);
1653 EXPECT_NE(post_str.find("previousversion"), string::npos);
Darin Petkov265f2902011-05-09 15:17:40 -07001654 }
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001655}
1656
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001657TEST_F(OmahaRequestActionTest, PingTestSendOnlyAPing) {
1658 PingTest(true /* ping_only */);
1659}
1660
1661TEST_F(OmahaRequestActionTest, PingTestSendAlsoAnUpdateCheck) {
1662 PingTest(false /* ping_only */);
1663}
1664
1665TEST_F(OmahaRequestActionTest, ActivePingTest) {
Alex Deymo8427b4a2014-11-05 14:00:32 -08001666 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001667 fake_system_state_.set_prefs(&prefs);
David Zeuthen33bae492014-02-25 16:16:18 -08001668 EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
1669 .Times(AnyNumber());
1670 EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001671 int64_t three_days_ago =
1672 (Time::Now() - TimeDelta::FromHours(3 * 24 + 12)).ToInternalValue();
1673 int64_t now = Time::Now().ToInternalValue();
David Zeuthen639aa362014-02-03 16:23:44 -08001674 EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
1675 .WillOnce(DoAll(SetArgumentPointee<1>(0), Return(true)));
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001676 EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
1677 .WillOnce(DoAll(SetArgumentPointee<1>(three_days_ago), Return(true)));
1678 EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
1679 .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001680 brillo::Blob post_data;
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001681 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001682 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -07001683 fake_update_response_.GetNoUpdateResponse(),
Darin Petkovedc522e2010-11-05 09:35:17 -07001684 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001685 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001686 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001687 metrics::CheckResult::kNoUpdateAvailable,
1688 metrics::CheckReaction::kUnset,
1689 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001690 nullptr,
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001691 &post_data));
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001692 string post_str(post_data.begin(), post_data.end());
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001693 EXPECT_NE(post_str.find("<ping active=\"1\" a=\"3\"></ping>"),
Thieu Le116fda32011-04-19 11:01:54 -07001694 string::npos);
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001695}
1696
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001697TEST_F(OmahaRequestActionTest, RollCallPingTest) {
Alex Deymo8427b4a2014-11-05 14:00:32 -08001698 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001699 fake_system_state_.set_prefs(&prefs);
David Zeuthen33bae492014-02-25 16:16:18 -08001700 EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
1701 .Times(AnyNumber());
1702 EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001703 int64_t four_days_ago =
1704 (Time::Now() - TimeDelta::FromHours(4 * 24)).ToInternalValue();
1705 int64_t now = Time::Now().ToInternalValue();
David Zeuthen639aa362014-02-03 16:23:44 -08001706 EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
1707 .WillOnce(DoAll(SetArgumentPointee<1>(0), Return(true)));
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001708 EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
1709 .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
1710 EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
1711 .WillOnce(DoAll(SetArgumentPointee<1>(four_days_ago), Return(true)));
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001712 brillo::Blob post_data;
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001713 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001714 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -07001715 fake_update_response_.GetNoUpdateResponse(),
Darin Petkovedc522e2010-11-05 09:35:17 -07001716 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001717 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001718 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001719 metrics::CheckResult::kNoUpdateAvailable,
1720 metrics::CheckReaction::kUnset,
1721 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001722 nullptr,
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001723 &post_data));
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001724 string post_str(post_data.begin(), post_data.end());
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001725 EXPECT_NE(post_str.find("<ping active=\"1\" r=\"4\"></ping>\n"),
Thieu Le116fda32011-04-19 11:01:54 -07001726 string::npos);
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001727}
1728
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001729TEST_F(OmahaRequestActionTest, NoPingTest) {
Alex Deymo8427b4a2014-11-05 14:00:32 -08001730 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001731 fake_system_state_.set_prefs(&prefs);
David Zeuthen33bae492014-02-25 16:16:18 -08001732 EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
1733 .Times(AnyNumber());
1734 EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001735 int64_t one_hour_ago =
1736 (Time::Now() - TimeDelta::FromHours(1)).ToInternalValue();
David Zeuthen639aa362014-02-03 16:23:44 -08001737 EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
1738 .WillOnce(DoAll(SetArgumentPointee<1>(0), Return(true)));
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001739 EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
1740 .WillOnce(DoAll(SetArgumentPointee<1>(one_hour_ago), Return(true)));
1741 EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
1742 .WillOnce(DoAll(SetArgumentPointee<1>(one_hour_ago), Return(true)));
Alex Deymoebbe7ef2014-10-30 13:02:49 -07001743 // LastActivePingDay and PrefsLastRollCallPingDay are set even if we didn't
1744 // send a ping.
1745 EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _))
1746 .WillOnce(Return(true));
1747 EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _))
1748 .WillOnce(Return(true));
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001749 brillo::Blob post_data;
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001750 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001751 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -07001752 fake_update_response_.GetNoUpdateResponse(),
Darin Petkovedc522e2010-11-05 09:35:17 -07001753 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001754 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001755 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001756 metrics::CheckResult::kNoUpdateAvailable,
1757 metrics::CheckReaction::kUnset,
1758 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001759 nullptr,
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001760 &post_data));
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001761 string post_str(post_data.begin(), post_data.end());
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001762 EXPECT_EQ(post_str.find("ping"), string::npos);
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001763}
1764
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001765TEST_F(OmahaRequestActionTest, IgnoreEmptyPingTest) {
Thieu Leb44e9e82011-06-06 14:34:04 -07001766 // This test ensures that we ignore empty ping only requests.
Alex Deymo8427b4a2014-11-05 14:00:32 -08001767 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001768 fake_system_state_.set_prefs(&prefs);
Thieu Leb44e9e82011-06-06 14:34:04 -07001769 int64_t now = Time::Now().ToInternalValue();
1770 EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
1771 .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
1772 EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
1773 .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
1774 EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
1775 EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001776 brillo::Blob post_data;
Thieu Leb44e9e82011-06-06 14:34:04 -07001777 EXPECT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001778 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -07001779 fake_update_response_.GetNoUpdateResponse(),
Thieu Leb44e9e82011-06-06 14:34:04 -07001780 -1,
1781 true, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001782 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001783 metrics::CheckResult::kUnset,
1784 metrics::CheckReaction::kUnset,
1785 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001786 nullptr,
Thieu Leb44e9e82011-06-06 14:34:04 -07001787 &post_data));
Alex Deymo80f70ff2016-02-10 16:08:11 -08001788 EXPECT_EQ(0U, post_data.size());
Thieu Leb44e9e82011-06-06 14:34:04 -07001789}
1790
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001791TEST_F(OmahaRequestActionTest, BackInTimePingTest) {
Alex Deymo8427b4a2014-11-05 14:00:32 -08001792 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001793 fake_system_state_.set_prefs(&prefs);
David Zeuthen33bae492014-02-25 16:16:18 -08001794 EXPECT_CALL(prefs, GetInt64(kPrefsMetricsCheckLastReportingTime, _))
1795 .Times(AnyNumber());
1796 EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001797 int64_t future =
1798 (Time::Now() + TimeDelta::FromHours(3 * 24 + 4)).ToInternalValue();
David Zeuthen639aa362014-02-03 16:23:44 -08001799 EXPECT_CALL(prefs, GetInt64(kPrefsInstallDateDays, _))
1800 .WillOnce(DoAll(SetArgumentPointee<1>(0), Return(true)));
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001801 EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
1802 .WillOnce(DoAll(SetArgumentPointee<1>(future), Return(true)));
1803 EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
1804 .WillOnce(DoAll(SetArgumentPointee<1>(future), Return(true)));
1805 EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _))
1806 .WillOnce(Return(true));
1807 EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _))
1808 .WillOnce(Return(true));
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001809 brillo::Blob post_data;
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001810 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001811 TestUpdateCheck(nullptr, // request_params
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001812 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
1813 "protocol=\"3.0\"><daystart elapsed_seconds=\"100\"/>"
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001814 "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001815 "<updatecheck status=\"noupdate\"/></app></response>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001816 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001817 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001818 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001819 metrics::CheckResult::kNoUpdateAvailable,
1820 metrics::CheckReaction::kUnset,
1821 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001822 nullptr,
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001823 &post_data));
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001824 string post_str(post_data.begin(), post_data.end());
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001825 EXPECT_EQ(post_str.find("ping"), string::npos);
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001826}
1827
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001828TEST_F(OmahaRequestActionTest, LastPingDayUpdateTest) {
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001829 // This test checks that the action updates the last ping day to now
Darin Petkov84c763c2010-07-29 16:27:58 -07001830 // minus 200 seconds with a slack of 5 seconds. Therefore, the test
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001831 // may fail if it runs for longer than 5 seconds. It shouldn't run
1832 // that long though.
1833 int64_t midnight =
1834 (Time::Now() - TimeDelta::FromSeconds(200)).ToInternalValue();
1835 int64_t midnight_slack =
1836 (Time::Now() - TimeDelta::FromSeconds(195)).ToInternalValue();
Alex Deymo8427b4a2014-11-05 14:00:32 -08001837 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001838 fake_system_state_.set_prefs(&prefs);
David Zeuthen33bae492014-02-25 16:16:18 -08001839 EXPECT_CALL(prefs, GetInt64(_, _)).Times(AnyNumber());
1840 EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001841 EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay,
1842 AllOf(Ge(midnight), Le(midnight_slack))))
1843 .WillOnce(Return(true));
1844 EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay,
1845 AllOf(Ge(midnight), Le(midnight_slack))))
1846 .WillOnce(Return(true));
1847 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001848 TestUpdateCheck(nullptr, // request_params
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001849 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
1850 "protocol=\"3.0\"><daystart elapsed_seconds=\"200\"/>"
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001851 "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001852 "<updatecheck status=\"noupdate\"/></app></response>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001853 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001854 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001855 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001856 metrics::CheckResult::kNoUpdateAvailable,
1857 metrics::CheckReaction::kUnset,
1858 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001859 nullptr,
1860 nullptr));
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001861}
1862
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001863TEST_F(OmahaRequestActionTest, NoElapsedSecondsTest) {
Alex Deymo8427b4a2014-11-05 14:00:32 -08001864 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001865 fake_system_state_.set_prefs(&prefs);
David Zeuthen33bae492014-02-25 16:16:18 -08001866 EXPECT_CALL(prefs, GetInt64(_, _)).Times(AnyNumber());
1867 EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001868 EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
1869 EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
1870 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001871 TestUpdateCheck(nullptr, // request_params
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001872 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
1873 "protocol=\"3.0\"><daystart blah=\"200\"/>"
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001874 "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001875 "<updatecheck status=\"noupdate\"/></app></response>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001876 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001877 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001878 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001879 metrics::CheckResult::kNoUpdateAvailable,
1880 metrics::CheckReaction::kUnset,
1881 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001882 nullptr,
1883 nullptr));
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001884}
1885
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001886TEST_F(OmahaRequestActionTest, BadElapsedSecondsTest) {
Alex Deymo8427b4a2014-11-05 14:00:32 -08001887 NiceMock<MockPrefs> prefs;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001888 fake_system_state_.set_prefs(&prefs);
David Zeuthen33bae492014-02-25 16:16:18 -08001889 EXPECT_CALL(prefs, GetInt64(_, _)).Times(AnyNumber());
1890 EXPECT_CALL(prefs, SetInt64(_, _)).Times(AnyNumber());
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001891 EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
1892 EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
1893 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001894 TestUpdateCheck(nullptr, // request_params
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001895 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
1896 "protocol=\"3.0\"><daystart elapsed_seconds=\"x\"/>"
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001897 "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
Jay Srinivasan23b92a52012-10-27 02:00:21 -07001898 "<updatecheck status=\"noupdate\"/></app></response>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001899 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001900 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001901 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08001902 metrics::CheckResult::kNoUpdateAvailable,
1903 metrics::CheckReaction::kUnset,
1904 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001905 nullptr,
1906 nullptr));
Darin Petkov1cbd78f2010-07-29 12:38:34 -07001907}
1908
Alex Deymob3fa53b2016-04-18 19:57:58 -07001909TEST_F(OmahaRequestActionTest, ParseUpdateCheckAttributesTest) {
1910 // Test that the "eol" flags is only parsed from the "_eol" attribute and not
1911 // the "eol" attribute.
1912 ASSERT_TRUE(
1913 TestUpdateCheck(nullptr, // request_params
1914 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response "
1915 "protocol=\"3.0\"><app appid=\"foo\" status=\"ok\">"
1916 "<ping status=\"ok\"/><updatecheck status=\"noupdate\" "
1917 "_eol=\"security-only\" eol=\"eol\" _foo=\"bar\"/>"
1918 "</app></response>",
1919 -1,
1920 false, // ping_only
1921 ErrorCode::kSuccess,
1922 metrics::CheckResult::kNoUpdateAvailable,
1923 metrics::CheckReaction::kUnset,
1924 metrics::DownloadErrorCode::kUnset,
1925 nullptr,
1926 nullptr));
1927 string eol_pref;
1928 EXPECT_TRUE(
1929 fake_system_state_.prefs()->GetString(kPrefsOmahaEolStatus, &eol_pref));
1930 // Note that the eol="eol" attribute should be ignored and the _eol should be
1931 // used instead.
1932 EXPECT_EQ("security-only", eol_pref);
1933}
1934
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001935TEST_F(OmahaRequestActionTest, NoUniqueIDTest) {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001936 brillo::Blob post_data;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001937 ASSERT_FALSE(TestUpdateCheck(nullptr, // request_params
Darin Petkov84c763c2010-07-29 16:27:58 -07001938 "invalid xml>",
Darin Petkovedc522e2010-11-05 09:35:17 -07001939 -1,
Darin Petkov265f2902011-05-09 15:17:40 -07001940 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001941 ErrorCode::kOmahaRequestXMLParseError,
David Zeuthen33bae492014-02-25 16:16:18 -08001942 metrics::CheckResult::kParsingError,
1943 metrics::CheckReaction::kUnset,
1944 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001945 nullptr, // response
Darin Petkov84c763c2010-07-29 16:27:58 -07001946 &post_data));
1947 // convert post_data to string
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001948 string post_str(post_data.begin(), post_data.end());
Darin Petkov84c763c2010-07-29 16:27:58 -07001949 EXPECT_EQ(post_str.find("machineid="), string::npos);
1950 EXPECT_EQ(post_str.find("userid="), string::npos);
1951}
1952
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001953TEST_F(OmahaRequestActionTest, NetworkFailureTest) {
Darin Petkovedc522e2010-11-05 09:35:17 -07001954 OmahaResponse response;
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001955 const int http_error_code =
1956 static_cast<int>(ErrorCode::kOmahaRequestHTTPResponseBase) + 501;
Darin Petkovedc522e2010-11-05 09:35:17 -07001957 ASSERT_FALSE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001958 TestUpdateCheck(nullptr, // request_params
Darin Petkovedc522e2010-11-05 09:35:17 -07001959 "",
1960 501,
Darin Petkov265f2902011-05-09 15:17:40 -07001961 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001962 static_cast<ErrorCode>(http_error_code),
David Zeuthen33bae492014-02-25 16:16:18 -08001963 metrics::CheckResult::kDownloadError,
1964 metrics::CheckReaction::kUnset,
1965 static_cast<metrics::DownloadErrorCode>(501),
Darin Petkovedc522e2010-11-05 09:35:17 -07001966 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001967 nullptr));
Darin Petkovedc522e2010-11-05 09:35:17 -07001968 EXPECT_FALSE(response.update_exists);
1969}
1970
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001971TEST_F(OmahaRequestActionTest, NetworkFailureBadHTTPCodeTest) {
Darin Petkovedc522e2010-11-05 09:35:17 -07001972 OmahaResponse response;
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001973 const int http_error_code =
1974 static_cast<int>(ErrorCode::kOmahaRequestHTTPResponseBase) + 999;
Darin Petkovedc522e2010-11-05 09:35:17 -07001975 ASSERT_FALSE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001976 TestUpdateCheck(nullptr, // request_params
Darin Petkovedc522e2010-11-05 09:35:17 -07001977 "",
1978 1500,
Darin Petkov265f2902011-05-09 15:17:40 -07001979 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001980 static_cast<ErrorCode>(http_error_code),
David Zeuthen33bae492014-02-25 16:16:18 -08001981 metrics::CheckResult::kDownloadError,
1982 metrics::CheckReaction::kUnset,
1983 metrics::DownloadErrorCode::kHttpStatusOther,
Darin Petkovedc522e2010-11-05 09:35:17 -07001984 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07001985 nullptr));
Darin Petkovedc522e2010-11-05 09:35:17 -07001986 EXPECT_FALSE(response.update_exists);
1987}
1988
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001989TEST_F(OmahaRequestActionTest, TestUpdateFirstSeenAtGetsPersistedFirstTime) {
Jay Srinivasan34b5d862012-07-23 11:43:22 -07001990 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07001991 OmahaRequestParams params = request_params_;
Jay Srinivasanae4697c2013-03-18 17:08:08 -07001992 params.set_wall_clock_based_wait_enabled(true);
1993 params.set_waiting_period(TimeDelta().FromDays(1));
1994 params.set_update_check_count_wait_enabled(false);
Jay Srinivasan34b5d862012-07-23 11:43:22 -07001995
Sen Jiang7c1171e2016-06-23 11:35:40 -07001996 Time arbitrary_date;
1997 Time::FromString("6/4/1989", &arbitrary_date);
1998 fake_system_state_.fake_clock()->SetWallclockTime(arbitrary_date);
1999 ASSERT_FALSE(TestUpdateCheck(&params,
2000 fake_update_response_.GetUpdateResponse(),
2001 -1,
2002 false, // ping_only
2003 ErrorCode::kOmahaUpdateDeferredPerPolicy,
2004 metrics::CheckResult::kUpdateAvailable,
2005 metrics::CheckReaction::kDeferring,
2006 metrics::DownloadErrorCode::kUnset,
2007 &response,
2008 nullptr));
Jay Srinivasan34b5d862012-07-23 11:43:22 -07002009
Ben Chan9abb7632014-08-07 00:10:53 -07002010 int64_t timestamp = 0;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002011 ASSERT_TRUE(fake_prefs_.GetInt64(kPrefsUpdateFirstSeenAt, &timestamp));
Sen Jiang7c1171e2016-06-23 11:35:40 -07002012 EXPECT_EQ(arbitrary_date.ToInternalValue(), timestamp);
Jay Srinivasan34b5d862012-07-23 11:43:22 -07002013 EXPECT_FALSE(response.update_exists);
Chris Sosa968d0572013-08-23 14:46:02 -07002014
2015 // Verify if we are interactive check we don't defer.
2016 params.set_interactive(true);
Sen Jiang7c1171e2016-06-23 11:35:40 -07002017 ASSERT_TRUE(TestUpdateCheck(&params,
2018 fake_update_response_.GetUpdateResponse(),
2019 -1,
2020 false, // ping_only
2021 ErrorCode::kSuccess,
2022 metrics::CheckResult::kUpdateAvailable,
2023 metrics::CheckReaction::kUpdating,
2024 metrics::DownloadErrorCode::kUnset,
2025 &response,
2026 nullptr));
Chris Sosa968d0572013-08-23 14:46:02 -07002027 EXPECT_TRUE(response.update_exists);
Jay Srinivasan34b5d862012-07-23 11:43:22 -07002028}
2029
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002030TEST_F(OmahaRequestActionTest, TestUpdateFirstSeenAtGetsUsedIfAlreadyPresent) {
Jay Srinivasan34b5d862012-07-23 11:43:22 -07002031 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002032 OmahaRequestParams params = request_params_;
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002033 params.set_wall_clock_based_wait_enabled(true);
2034 params.set_waiting_period(TimeDelta().FromDays(1));
2035 params.set_update_check_count_wait_enabled(false);
Jay Srinivasan34b5d862012-07-23 11:43:22 -07002036
Sen Jiang7c1171e2016-06-23 11:35:40 -07002037 Time t1, t2;
Jay Srinivasan34b5d862012-07-23 11:43:22 -07002038 Time::FromString("1/1/2012", &t1);
Sen Jiang7c1171e2016-06-23 11:35:40 -07002039 Time::FromString("1/3/2012", &t2);
2040 ASSERT_TRUE(
2041 fake_prefs_.SetInt64(kPrefsUpdateFirstSeenAt, t1.ToInternalValue()));
2042 fake_system_state_.fake_clock()->SetWallclockTime(t2);
2043 ASSERT_TRUE(TestUpdateCheck(&params,
2044 fake_update_response_.GetUpdateResponse(),
2045 -1,
2046 false, // ping_only
2047 ErrorCode::kSuccess,
2048 metrics::CheckResult::kUpdateAvailable,
2049 metrics::CheckReaction::kUpdating,
2050 metrics::DownloadErrorCode::kUnset,
2051 &response,
2052 nullptr));
Jay Srinivasan34b5d862012-07-23 11:43:22 -07002053
2054 EXPECT_TRUE(response.update_exists);
2055
2056 // Make sure the timestamp t1 is unchanged showing that it was reused.
Ben Chan9abb7632014-08-07 00:10:53 -07002057 int64_t timestamp = 0;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002058 ASSERT_TRUE(fake_prefs_.GetInt64(kPrefsUpdateFirstSeenAt, &timestamp));
Jay Srinivasan34b5d862012-07-23 11:43:22 -07002059 ASSERT_TRUE(timestamp == t1.ToInternalValue());
2060}
2061
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002062TEST_F(OmahaRequestActionTest, TestChangingToMoreStableChannel) {
Gilad Arnoldeff87cc2013-07-22 18:32:09 -07002063 // Create a uniquely named test directory.
Sen Jiang297e5832016-03-17 14:45:51 -07002064 base::ScopedTempDir tempdir;
2065 ASSERT_TRUE(tempdir.CreateUniqueTempDir());
Gilad Arnoldeff87cc2013-07-22 18:32:09 -07002066
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07002067 brillo::Blob post_data;
Sen Jiang297e5832016-03-17 14:45:51 -07002068 OmahaRequestParams params(&fake_system_state_);
2069 params.set_root(tempdir.path().value());
2070 params.set_app_id("{22222222-2222-2222-2222-222222222222}");
2071 params.set_app_version("1.2.3.4");
2072 params.set_current_channel("canary-channel");
2073 EXPECT_TRUE(params.SetTargetChannel("stable-channel", true, nullptr));
2074 params.UpdateDownloadChannel();
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002075 EXPECT_TRUE(params.to_more_stable_channel());
2076 EXPECT_TRUE(params.is_powerwash_allowed());
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002077 ASSERT_FALSE(TestUpdateCheck(&params,
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002078 "invalid xml>",
2079 -1,
2080 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07002081 ErrorCode::kOmahaRequestXMLParseError,
David Zeuthen33bae492014-02-25 16:16:18 -08002082 metrics::CheckResult::kParsingError,
2083 metrics::CheckReaction::kUnset,
2084 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07002085 nullptr, // response
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002086 &post_data));
2087 // convert post_data to string
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08002088 string post_str(post_data.begin(), post_data.end());
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002089 EXPECT_NE(string::npos, post_str.find(
2090 "appid=\"{22222222-2222-2222-2222-222222222222}\" "
2091 "version=\"0.0.0.0\" from_version=\"1.2.3.4\" "
2092 "track=\"stable-channel\" from_track=\"canary-channel\" "));
2093}
2094
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002095TEST_F(OmahaRequestActionTest, TestChangingToLessStableChannel) {
Gilad Arnoldeff87cc2013-07-22 18:32:09 -07002096 // Create a uniquely named test directory.
Sen Jiang297e5832016-03-17 14:45:51 -07002097 base::ScopedTempDir tempdir;
2098 ASSERT_TRUE(tempdir.CreateUniqueTempDir());
Gilad Arnoldeff87cc2013-07-22 18:32:09 -07002099
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07002100 brillo::Blob post_data;
Sen Jiang297e5832016-03-17 14:45:51 -07002101 OmahaRequestParams params(&fake_system_state_);
2102 params.set_root(tempdir.path().value());
2103 params.set_app_id("{11111111-1111-1111-1111-111111111111}");
2104 params.set_app_version("5.6.7.8");
2105 params.set_current_channel("stable-channel");
2106 EXPECT_TRUE(params.SetTargetChannel("canary-channel", false, nullptr));
2107 params.UpdateDownloadChannel();
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002108 EXPECT_FALSE(params.to_more_stable_channel());
2109 EXPECT_FALSE(params.is_powerwash_allowed());
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002110 ASSERT_FALSE(TestUpdateCheck(&params,
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002111 "invalid xml>",
2112 -1,
2113 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07002114 ErrorCode::kOmahaRequestXMLParseError,
David Zeuthen33bae492014-02-25 16:16:18 -08002115 metrics::CheckResult::kParsingError,
2116 metrics::CheckReaction::kUnset,
2117 metrics::DownloadErrorCode::kUnset,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07002118 nullptr, // response
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002119 &post_data));
2120 // convert post_data to string
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08002121 string post_str(post_data.begin(), post_data.end());
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002122 EXPECT_NE(string::npos, post_str.find(
2123 "appid=\"{11111111-1111-1111-1111-111111111111}\" "
2124 "version=\"5.6.7.8\" "
2125 "track=\"canary-channel\" from_track=\"stable-channel\""));
Alex Vakulenkod2779df2014-06-16 13:19:00 -07002126 EXPECT_EQ(string::npos, post_str.find("from_version"));
Jay Srinivasanae4697c2013-03-18 17:08:08 -07002127}
2128
Alex Deymoebbe7ef2014-10-30 13:02:49 -07002129// Checks that the initial ping with a=-1 r=-1 is not send when the device
2130// was powerwashed.
2131TEST_F(OmahaRequestActionTest, PingWhenPowerwashed) {
2132 fake_prefs_.SetString(kPrefsPreviousVersion, "");
2133
2134 // Flag that the device was powerwashed in the past.
2135 fake_system_state_.fake_hardware()->SetPowerwashCount(1);
2136
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07002137 brillo::Blob post_data;
Alex Deymoebbe7ef2014-10-30 13:02:49 -07002138 ASSERT_TRUE(
2139 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -07002140 fake_update_response_.GetNoUpdateResponse(),
Alex Deymoebbe7ef2014-10-30 13:02:49 -07002141 -1,
2142 false, // ping_only
2143 ErrorCode::kSuccess,
2144 metrics::CheckResult::kNoUpdateAvailable,
2145 metrics::CheckReaction::kUnset,
2146 metrics::DownloadErrorCode::kUnset,
2147 nullptr,
2148 &post_data));
2149 // We shouldn't send a ping in this case since powerwash > 0.
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08002150 string post_str(post_data.begin(), post_data.end());
Alex Deymoebbe7ef2014-10-30 13:02:49 -07002151 EXPECT_EQ(string::npos, post_str.find("<ping"));
2152}
2153
Alex Deymo9fded1e2015-11-05 12:31:19 -08002154// Checks that the event 54 is sent on a reboot to a new update.
2155TEST_F(OmahaRequestActionTest, RebootAfterUpdateEvent) {
2156 // Flag that the device was updated in a previous boot.
2157 fake_prefs_.SetString(kPrefsPreviousVersion, "1.2.3.4");
2158
2159 brillo::Blob post_data;
2160 ASSERT_TRUE(
2161 TestUpdateCheck(nullptr, // request_params
2162 fake_update_response_.GetNoUpdateResponse(),
2163 -1,
2164 false, // ping_only
2165 ErrorCode::kSuccess,
2166 metrics::CheckResult::kNoUpdateAvailable,
2167 metrics::CheckReaction::kUnset,
2168 metrics::DownloadErrorCode::kUnset,
2169 nullptr,
2170 &post_data));
2171 string post_str(post_data.begin(), post_data.end());
2172
2173 // An event 54 is included and has the right version.
2174 EXPECT_NE(string::npos,
2175 post_str.find(base::StringPrintf(
2176 "<event eventtype=\"%d\"",
2177 OmahaEvent::kTypeRebootedAfterUpdate)));
2178 EXPECT_NE(string::npos,
2179 post_str.find("previousversion=\"1.2.3.4\"></event>"));
2180
2181 // The previous version flag should have been removed.
2182 EXPECT_TRUE(fake_prefs_.Exists(kPrefsPreviousVersion));
2183 string prev_version;
2184 EXPECT_TRUE(fake_prefs_.GetString(kPrefsPreviousVersion, &prev_version));
2185 EXPECT_TRUE(prev_version.empty());
2186}
2187
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002188void OmahaRequestActionTest::P2PTest(
2189 bool initial_allow_p2p_for_downloading,
2190 bool initial_allow_p2p_for_sharing,
2191 bool omaha_disable_p2p_for_downloading,
2192 bool omaha_disable_p2p_for_sharing,
2193 bool payload_state_allow_p2p_attempt,
2194 bool expect_p2p_client_lookup,
2195 const string& p2p_client_result_url,
2196 bool expected_allow_p2p_for_downloading,
2197 bool expected_allow_p2p_for_sharing,
2198 const string& expected_p2p_url) {
David Zeuthen8f191b22013-08-06 12:27:50 -07002199 OmahaResponse response;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002200 OmahaRequestParams request_params = request_params_;
Gilad Arnold74b5f552014-10-07 08:17:16 -07002201 bool actual_allow_p2p_for_downloading = initial_allow_p2p_for_downloading;
2202 bool actual_allow_p2p_for_sharing = initial_allow_p2p_for_sharing;
2203 string actual_p2p_url;
David Zeuthen8f191b22013-08-06 12:27:50 -07002204
2205 MockPayloadState mock_payload_state;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002206 fake_system_state_.set_payload_state(&mock_payload_state);
David Zeuthen8f191b22013-08-06 12:27:50 -07002207 EXPECT_CALL(mock_payload_state, P2PAttemptAllowed())
2208 .WillRepeatedly(Return(payload_state_allow_p2p_attempt));
Gilad Arnold74b5f552014-10-07 08:17:16 -07002209 EXPECT_CALL(mock_payload_state, GetUsingP2PForDownloading())
2210 .WillRepeatedly(ReturnPointee(&actual_allow_p2p_for_downloading));
2211 EXPECT_CALL(mock_payload_state, GetUsingP2PForSharing())
2212 .WillRepeatedly(ReturnPointee(&actual_allow_p2p_for_sharing));
2213 EXPECT_CALL(mock_payload_state, SetUsingP2PForDownloading(_))
2214 .WillRepeatedly(SaveArg<0>(&actual_allow_p2p_for_downloading));
2215 EXPECT_CALL(mock_payload_state, SetUsingP2PForSharing(_))
2216 .WillRepeatedly(SaveArg<0>(&actual_allow_p2p_for_sharing));
2217 EXPECT_CALL(mock_payload_state, SetP2PUrl(_))
2218 .WillRepeatedly(SaveArg<0>(&actual_p2p_url));
2219
David Zeuthen8f191b22013-08-06 12:27:50 -07002220 MockP2PManager mock_p2p_manager;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002221 fake_system_state_.set_p2p_manager(&mock_p2p_manager);
David Zeuthen8f191b22013-08-06 12:27:50 -07002222 mock_p2p_manager.fake().SetLookupUrlForFileResult(p2p_client_result_url);
2223
David Zeuthen4cc5ed22014-01-15 12:35:03 -08002224 TimeDelta timeout = TimeDelta::FromSeconds(kMaxP2PNetworkWaitTimeSeconds);
2225 EXPECT_CALL(mock_p2p_manager, LookupUrlForFile(_, _, timeout, _))
David Zeuthen8f191b22013-08-06 12:27:50 -07002226 .Times(expect_p2p_client_lookup ? 1 : 0);
2227
Alex Deymo8e18f932015-03-27 16:16:59 -07002228 fake_update_response_.disable_p2p_for_downloading =
2229 omaha_disable_p2p_for_downloading;
2230 fake_update_response_.disable_p2p_for_sharing = omaha_disable_p2p_for_sharing;
David Zeuthen8f191b22013-08-06 12:27:50 -07002231 ASSERT_TRUE(
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002232 TestUpdateCheck(&request_params,
Alex Deymo8e18f932015-03-27 16:16:59 -07002233 fake_update_response_.GetUpdateResponse(),
David Zeuthen8f191b22013-08-06 12:27:50 -07002234 -1,
2235 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07002236 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08002237 metrics::CheckResult::kUpdateAvailable,
2238 metrics::CheckReaction::kUpdating,
2239 metrics::DownloadErrorCode::kUnset,
David Zeuthen8f191b22013-08-06 12:27:50 -07002240 &response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07002241 nullptr));
David Zeuthen8f191b22013-08-06 12:27:50 -07002242 EXPECT_TRUE(response.update_exists);
2243
Gilad Arnold74b5f552014-10-07 08:17:16 -07002244 EXPECT_EQ(omaha_disable_p2p_for_downloading,
2245 response.disable_p2p_for_downloading);
2246 EXPECT_EQ(omaha_disable_p2p_for_sharing,
2247 response.disable_p2p_for_sharing);
David Zeuthen8f191b22013-08-06 12:27:50 -07002248
Gilad Arnold74b5f552014-10-07 08:17:16 -07002249 EXPECT_EQ(expected_allow_p2p_for_downloading,
2250 actual_allow_p2p_for_downloading);
2251 EXPECT_EQ(expected_allow_p2p_for_sharing, actual_allow_p2p_for_sharing);
2252 EXPECT_EQ(expected_p2p_url, actual_p2p_url);
David Zeuthen8f191b22013-08-06 12:27:50 -07002253}
2254
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002255TEST_F(OmahaRequestActionTest, P2PWithPeer) {
Alex Vakulenkod2779df2014-06-16 13:19:00 -07002256 P2PTest(true, // initial_allow_p2p_for_downloading
2257 true, // initial_allow_p2p_for_sharing
2258 false, // omaha_disable_p2p_for_downloading
2259 false, // omaha_disable_p2p_for_sharing
2260 true, // payload_state_allow_p2p_attempt
2261 true, // expect_p2p_client_lookup
2262 "http://1.3.5.7/p2p", // p2p_client_result_url
2263 true, // expected_allow_p2p_for_downloading
2264 true, // expected_allow_p2p_for_sharing
2265 "http://1.3.5.7/p2p"); // expected_p2p_url
David Zeuthen8f191b22013-08-06 12:27:50 -07002266}
2267
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002268TEST_F(OmahaRequestActionTest, P2PWithoutPeer) {
Alex Vakulenkod2779df2014-06-16 13:19:00 -07002269 P2PTest(true, // initial_allow_p2p_for_downloading
2270 true, // initial_allow_p2p_for_sharing
2271 false, // omaha_disable_p2p_for_downloading
2272 false, // omaha_disable_p2p_for_sharing
2273 true, // payload_state_allow_p2p_attempt
2274 true, // expect_p2p_client_lookup
2275 "", // p2p_client_result_url
2276 false, // expected_allow_p2p_for_downloading
2277 true, // expected_allow_p2p_for_sharing
2278 ""); // expected_p2p_url
David Zeuthen8f191b22013-08-06 12:27:50 -07002279}
2280
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002281TEST_F(OmahaRequestActionTest, P2PDownloadNotAllowed) {
Alex Vakulenkod2779df2014-06-16 13:19:00 -07002282 P2PTest(false, // initial_allow_p2p_for_downloading
2283 true, // initial_allow_p2p_for_sharing
2284 false, // omaha_disable_p2p_for_downloading
2285 false, // omaha_disable_p2p_for_sharing
2286 true, // payload_state_allow_p2p_attempt
2287 false, // expect_p2p_client_lookup
2288 "unset", // p2p_client_result_url
2289 false, // expected_allow_p2p_for_downloading
2290 true, // expected_allow_p2p_for_sharing
2291 ""); // expected_p2p_url
David Zeuthen8f191b22013-08-06 12:27:50 -07002292}
2293
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002294TEST_F(OmahaRequestActionTest, P2PWithPeerDownloadDisabledByOmaha) {
Alex Vakulenkod2779df2014-06-16 13:19:00 -07002295 P2PTest(true, // initial_allow_p2p_for_downloading
2296 true, // initial_allow_p2p_for_sharing
2297 true, // omaha_disable_p2p_for_downloading
2298 false, // omaha_disable_p2p_for_sharing
2299 true, // payload_state_allow_p2p_attempt
2300 false, // expect_p2p_client_lookup
2301 "unset", // p2p_client_result_url
2302 false, // expected_allow_p2p_for_downloading
2303 true, // expected_allow_p2p_for_sharing
2304 ""); // expected_p2p_url
David Zeuthen8f191b22013-08-06 12:27:50 -07002305}
2306
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002307TEST_F(OmahaRequestActionTest, P2PWithPeerSharingDisabledByOmaha) {
Alex Vakulenkod2779df2014-06-16 13:19:00 -07002308 P2PTest(true, // initial_allow_p2p_for_downloading
2309 true, // initial_allow_p2p_for_sharing
2310 false, // omaha_disable_p2p_for_downloading
2311 true, // omaha_disable_p2p_for_sharing
2312 true, // payload_state_allow_p2p_attempt
2313 true, // expect_p2p_client_lookup
2314 "http://1.3.5.7/p2p", // p2p_client_result_url
2315 true, // expected_allow_p2p_for_downloading
2316 false, // expected_allow_p2p_for_sharing
2317 "http://1.3.5.7/p2p"); // expected_p2p_url
David Zeuthen8f191b22013-08-06 12:27:50 -07002318}
2319
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002320TEST_F(OmahaRequestActionTest, P2PWithPeerBothDisabledByOmaha) {
Alex Vakulenkod2779df2014-06-16 13:19:00 -07002321 P2PTest(true, // initial_allow_p2p_for_downloading
2322 true, // initial_allow_p2p_for_sharing
2323 true, // omaha_disable_p2p_for_downloading
2324 true, // omaha_disable_p2p_for_sharing
2325 true, // payload_state_allow_p2p_attempt
2326 false, // expect_p2p_client_lookup
2327 "unset", // p2p_client_result_url
2328 false, // expected_allow_p2p_for_downloading
2329 false, // expected_allow_p2p_for_sharing
2330 ""); // expected_p2p_url
David Zeuthen8f191b22013-08-06 12:27:50 -07002331}
2332
Alex Deymof329b932014-10-30 01:37:48 -07002333bool OmahaRequestActionTest::InstallDateParseHelper(const string &elapsed_days,
2334 OmahaResponse *response) {
Alex Deymo8e18f932015-03-27 16:16:59 -07002335 fake_update_response_.elapsed_days = elapsed_days;
David Zeuthen639aa362014-02-03 16:23:44 -08002336 return
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002337 TestUpdateCheck(nullptr, // request_params
Alex Deymo8e18f932015-03-27 16:16:59 -07002338 fake_update_response_.GetUpdateResponse(),
David Zeuthen639aa362014-02-03 16:23:44 -08002339 -1,
2340 false, // ping_only
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07002341 ErrorCode::kSuccess,
David Zeuthen33bae492014-02-25 16:16:18 -08002342 metrics::CheckResult::kUpdateAvailable,
2343 metrics::CheckReaction::kUpdating,
2344 metrics::DownloadErrorCode::kUnset,
David Zeuthen639aa362014-02-03 16:23:44 -08002345 response,
Alex Vakulenko88b591f2014-08-28 16:48:57 -07002346 nullptr);
David Zeuthen639aa362014-02-03 16:23:44 -08002347}
2348
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002349TEST_F(OmahaRequestActionTest, ParseInstallDateFromResponse) {
David Zeuthen639aa362014-02-03 16:23:44 -08002350 OmahaResponse response;
David Zeuthen639aa362014-02-03 16:23:44 -08002351
Kevin Cernekee2494e282016-03-29 18:03:53 -07002352 // Simulate a successful update check that happens during OOBE. The
2353 // deadline in the response is needed to force the update attempt to
2354 // occur; responses without a deadline seen during OOBE will normally
2355 // return ErrorCode::kNonCriticalUpdateInOOBE.
2356 fake_system_state_.fake_hardware()->UnsetIsOOBEComplete();
2357 fake_update_response_.deadline = "20101020";
2358
David Zeuthen639aa362014-02-03 16:23:44 -08002359 // Check that we parse elapsed_days in the Omaha Response correctly.
2360 // and that the kPrefsInstallDateDays value is written to.
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002361 EXPECT_FALSE(fake_prefs_.Exists(kPrefsInstallDateDays));
2362 EXPECT_TRUE(InstallDateParseHelper("42", &response));
David Zeuthen639aa362014-02-03 16:23:44 -08002363 EXPECT_TRUE(response.update_exists);
2364 EXPECT_EQ(42, response.install_date_days);
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002365 EXPECT_TRUE(fake_prefs_.Exists(kPrefsInstallDateDays));
David Zeuthen639aa362014-02-03 16:23:44 -08002366 int64_t prefs_days;
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002367 EXPECT_TRUE(fake_prefs_.GetInt64(kPrefsInstallDateDays, &prefs_days));
David Zeuthen639aa362014-02-03 16:23:44 -08002368 EXPECT_EQ(prefs_days, 42);
2369
2370 // If there already is a value set, we shouldn't do anything.
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002371 EXPECT_TRUE(InstallDateParseHelper("7", &response));
David Zeuthen639aa362014-02-03 16:23:44 -08002372 EXPECT_TRUE(response.update_exists);
2373 EXPECT_EQ(7, response.install_date_days);
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002374 EXPECT_TRUE(fake_prefs_.GetInt64(kPrefsInstallDateDays, &prefs_days));
David Zeuthen639aa362014-02-03 16:23:44 -08002375 EXPECT_EQ(prefs_days, 42);
2376
2377 // Note that elapsed_days is not necessarily divisible by 7 so check
2378 // that we round down correctly when populating kPrefsInstallDateDays.
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002379 EXPECT_TRUE(fake_prefs_.Delete(kPrefsInstallDateDays));
2380 EXPECT_TRUE(InstallDateParseHelper("23", &response));
David Zeuthen639aa362014-02-03 16:23:44 -08002381 EXPECT_TRUE(response.update_exists);
2382 EXPECT_EQ(23, response.install_date_days);
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002383 EXPECT_TRUE(fake_prefs_.GetInt64(kPrefsInstallDateDays, &prefs_days));
David Zeuthen639aa362014-02-03 16:23:44 -08002384 EXPECT_EQ(prefs_days, 21);
2385
2386 // Check that we correctly handle elapsed_days not being included in
2387 // the Omaha Response.
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002388 EXPECT_TRUE(InstallDateParseHelper("", &response));
David Zeuthen639aa362014-02-03 16:23:44 -08002389 EXPECT_TRUE(response.update_exists);
2390 EXPECT_EQ(-1, response.install_date_days);
David Zeuthen639aa362014-02-03 16:23:44 -08002391}
2392
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002393// If there is no prefs and OOBE is not complete, we should not
2394// report anything to Omaha.
2395TEST_F(OmahaRequestActionTest, GetInstallDateWhenNoPrefsNorOOBE) {
Kevin Cernekee2494e282016-03-29 18:03:53 -07002396 fake_system_state_.fake_hardware()->UnsetIsOOBEComplete();
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002397 EXPECT_EQ(OmahaRequestAction::GetInstallDate(&fake_system_state_), -1);
2398 EXPECT_FALSE(fake_prefs_.Exists(kPrefsInstallDateDays));
2399}
David Zeuthen639aa362014-02-03 16:23:44 -08002400
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002401// If OOBE is complete and happened on a valid date (e.g. after Jan
2402// 1 2007 0:00 PST), that date should be used and written to
2403// prefs. However, first try with an invalid date and check we do
2404// nothing.
2405TEST_F(OmahaRequestActionTest, GetInstallDateWhenOOBECompletedWithInvalidDate) {
2406 Time oobe_date = Time::FromTimeT(42); // Dec 31, 1969 16:00:42 PST.
2407 fake_system_state_.fake_hardware()->SetIsOOBEComplete(oobe_date);
2408 EXPECT_EQ(OmahaRequestAction::GetInstallDate(&fake_system_state_), -1);
2409 EXPECT_FALSE(fake_prefs_.Exists(kPrefsInstallDateDays));
2410}
David Zeuthen639aa362014-02-03 16:23:44 -08002411
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002412// Then check with a valid date. The date Jan 20, 2007 0:00 PST
2413// should yield an InstallDate of 14.
2414TEST_F(OmahaRequestActionTest, GetInstallDateWhenOOBECompletedWithValidDate) {
2415 Time oobe_date = Time::FromTimeT(1169280000); // Jan 20, 2007 0:00 PST.
2416 fake_system_state_.fake_hardware()->SetIsOOBEComplete(oobe_date);
2417 EXPECT_EQ(OmahaRequestAction::GetInstallDate(&fake_system_state_), 14);
2418 EXPECT_TRUE(fake_prefs_.Exists(kPrefsInstallDateDays));
David Zeuthen639aa362014-02-03 16:23:44 -08002419
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002420 int64_t prefs_days;
2421 EXPECT_TRUE(fake_prefs_.GetInt64(kPrefsInstallDateDays, &prefs_days));
2422 EXPECT_EQ(prefs_days, 14);
2423}
David Zeuthen639aa362014-02-03 16:23:44 -08002424
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002425// Now that we have a valid date in prefs, check that we keep using
2426// that even if OOBE date reports something else. The date Jan 30,
2427// 2007 0:00 PST should yield an InstallDate of 28... but since
2428// there's a prefs file, we should still get 14.
2429TEST_F(OmahaRequestActionTest, GetInstallDateWhenOOBECompletedDateChanges) {
2430 // Set a valid date in the prefs first.
2431 EXPECT_TRUE(fake_prefs_.SetInt64(kPrefsInstallDateDays, 14));
David Zeuthen639aa362014-02-03 16:23:44 -08002432
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002433 Time oobe_date = Time::FromTimeT(1170144000); // Jan 30, 2007 0:00 PST.
2434 fake_system_state_.fake_hardware()->SetIsOOBEComplete(oobe_date);
2435 EXPECT_EQ(OmahaRequestAction::GetInstallDate(&fake_system_state_), 14);
David Zeuthen639aa362014-02-03 16:23:44 -08002436
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002437 int64_t prefs_days;
2438 EXPECT_TRUE(fake_prefs_.GetInt64(kPrefsInstallDateDays, &prefs_days));
2439 EXPECT_EQ(prefs_days, 14);
David Zeuthen639aa362014-02-03 16:23:44 -08002440
Alex Deymoe1e3afe2014-10-30 13:02:49 -07002441 // If we delete the prefs file, we should get 28 days.
2442 EXPECT_TRUE(fake_prefs_.Delete(kPrefsInstallDateDays));
2443 EXPECT_EQ(OmahaRequestAction::GetInstallDate(&fake_system_state_), 28);
2444 EXPECT_TRUE(fake_prefs_.GetInt64(kPrefsInstallDateDays, &prefs_days));
2445 EXPECT_EQ(prefs_days, 28);
David Zeuthen639aa362014-02-03 16:23:44 -08002446}
2447
Darin Petkov6a5b3222010-07-13 14:55:28 -07002448} // namespace chromeos_update_engine