OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/cryptauth/cryptauth_client_impl.h" | 5 #include "components/cryptauth/cryptauth_client_impl.h" |
6 | 6 |
7 #include "base/command_line.h" | 7 #include "base/command_line.h" |
8 #include "base/macros.h" | 8 #include "base/macros.h" |
9 #include "base/memory/ptr_util.h" | 9 #include "base/memory/ptr_util.h" |
10 #include "base/test/null_task_runner.h" | 10 #include "base/test/null_task_runner.h" |
11 #include "components/cryptauth/cryptauth_access_token_fetcher.h" | 11 #include "components/cryptauth/cryptauth_access_token_fetcher.h" |
12 #include "components/cryptauth/cryptauth_api_call_flow.h" | 12 #include "components/cryptauth/cryptauth_api_call_flow.h" |
13 #include "components/cryptauth/proto/cryptauth_api.pb.h" | 13 #include "components/cryptauth/proto/cryptauth_api.pb.h" |
14 #include "components/cryptauth/switches.h" | 14 #include "components/cryptauth/switches.h" |
15 #include "google_apis/gaia/fake_oauth2_token_service.h" | 15 #include "google_apis/gaia/fake_oauth2_token_service.h" |
| 16 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" |
16 #include "net/url_request/test_url_fetcher_factory.h" | 17 #include "net/url_request/test_url_fetcher_factory.h" |
17 #include "net/url_request/url_request_test_util.h" | 18 #include "net/url_request/url_request_test_util.h" |
18 #include "testing/gmock/include/gmock/gmock.h" | 19 #include "testing/gmock/include/gmock/gmock.h" |
19 #include "testing/gtest/include/gtest/gtest.h" | 20 #include "testing/gtest/include/gtest/gtest.h" |
20 #include "url/gurl.h" | 21 #include "url/gurl.h" |
21 | 22 |
22 using testing::_; | 23 using testing::_; |
23 using testing::DoAll; | 24 using testing::DoAll; |
24 using testing::Return; | 25 using testing::Return; |
25 using testing::SaveArg; | 26 using testing::SaveArg; |
(...skipping 30 matching lines...) Expand all Loading... |
56 access_token_ = access_token; | 57 access_token_ = access_token; |
57 }; | 58 }; |
58 | 59 |
59 private: | 60 private: |
60 std::string access_token_; | 61 std::string access_token_; |
61 }; | 62 }; |
62 | 63 |
63 // Mock CryptAuthApiCallFlow, which handles the HTTP requests to CryptAuth. | 64 // Mock CryptAuthApiCallFlow, which handles the HTTP requests to CryptAuth. |
64 class MockCryptAuthApiCallFlow : public CryptAuthApiCallFlow { | 65 class MockCryptAuthApiCallFlow : public CryptAuthApiCallFlow { |
65 public: | 66 public: |
66 MockCryptAuthApiCallFlow() : CryptAuthApiCallFlow() {} | 67 MockCryptAuthApiCallFlow() : CryptAuthApiCallFlow() { |
| 68 SetPartialNetworkTrafficAnnotation(PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
| 69 } |
67 virtual ~MockCryptAuthApiCallFlow() {} | 70 virtual ~MockCryptAuthApiCallFlow() {} |
68 | 71 |
69 MOCK_METHOD6(Start, | 72 MOCK_METHOD6(Start, |
70 void(const GURL&, | 73 void(const GURL&, |
71 net::URLRequestContextGetter* context, | 74 net::URLRequestContextGetter* context, |
72 const std::string& access_token, | 75 const std::string& access_token, |
73 const std::string& serialized_request, | 76 const std::string& serialized_request, |
74 const ResultCallback& result_callback, | 77 const ResultCallback& result_callback, |
75 const ErrorCallback& error_callback)); | 78 const ErrorCallback& error_callback)); |
76 | 79 |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
159 ExpectRequest( | 162 ExpectRequest( |
160 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 163 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
161 "getmydevices?alt=proto"); | 164 "getmydevices?alt=proto"); |
162 | 165 |
163 GetMyDevicesResponse result_proto; | 166 GetMyDevicesResponse result_proto; |
164 GetMyDevicesRequest request_proto; | 167 GetMyDevicesRequest request_proto; |
165 request_proto.set_allow_stale_read(true); | 168 request_proto.set_allow_stale_read(true); |
166 client_->GetMyDevices( | 169 client_->GetMyDevices( |
167 request_proto, | 170 request_proto, |
168 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), | 171 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), |
169 base::Bind(&NotCalled<std::string>)); | 172 base::Bind(&NotCalled<std::string>), |
| 173 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
170 | 174 |
171 GetMyDevicesRequest expected_request; | 175 GetMyDevicesRequest expected_request; |
172 EXPECT_TRUE(expected_request.ParseFromString(serialized_request_)); | 176 EXPECT_TRUE(expected_request.ParseFromString(serialized_request_)); |
173 EXPECT_TRUE(expected_request.allow_stale_read()); | 177 EXPECT_TRUE(expected_request.allow_stale_read()); |
174 | 178 |
175 // Return two devices, one unlock key and one unlockable device. | 179 // Return two devices, one unlock key and one unlockable device. |
176 { | 180 { |
177 GetMyDevicesResponse response_proto; | 181 GetMyDevicesResponse response_proto; |
178 response_proto.add_devices(); | 182 response_proto.add_devices(); |
179 response_proto.mutable_devices(0)->set_public_key(kPublicKey1); | 183 response_proto.mutable_devices(0)->set_public_key(kPublicKey1); |
(...skipping 16 matching lines...) Expand all Loading... |
196 } | 200 } |
197 | 201 |
198 TEST_F(CryptAuthClientTest, GetMyDevicesFailure) { | 202 TEST_F(CryptAuthClientTest, GetMyDevicesFailure) { |
199 ExpectRequest( | 203 ExpectRequest( |
200 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 204 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
201 "getmydevices?alt=proto"); | 205 "getmydevices?alt=proto"); |
202 | 206 |
203 std::string error_message; | 207 std::string error_message; |
204 client_->GetMyDevices(GetMyDevicesRequest(), | 208 client_->GetMyDevices(GetMyDevicesRequest(), |
205 base::Bind(&NotCalled<GetMyDevicesResponse>), | 209 base::Bind(&NotCalled<GetMyDevicesResponse>), |
206 base::Bind(&SaveResult<std::string>, &error_message)); | 210 base::Bind(&SaveResult<std::string>, &error_message), |
| 211 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
207 | 212 |
208 std::string kStatus500Error("HTTP status: 500"); | 213 std::string kStatus500Error("HTTP status: 500"); |
209 FailApiCallFlow(kStatus500Error); | 214 FailApiCallFlow(kStatus500Error); |
210 EXPECT_EQ(kStatus500Error, error_message); | 215 EXPECT_EQ(kStatus500Error, error_message); |
211 } | 216 } |
212 | 217 |
213 TEST_F(CryptAuthClientTest, FindEligibleUnlockDevicesSuccess) { | 218 TEST_F(CryptAuthClientTest, FindEligibleUnlockDevicesSuccess) { |
214 ExpectRequest( | 219 ExpectRequest( |
215 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 220 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
216 "findeligibleunlockdevices?alt=proto"); | 221 "findeligibleunlockdevices?alt=proto"); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
272 } | 277 } |
273 | 278 |
274 TEST_F(CryptAuthClientTest, SendDeviceSyncTickleSuccess) { | 279 TEST_F(CryptAuthClientTest, SendDeviceSyncTickleSuccess) { |
275 ExpectRequest( | 280 ExpectRequest( |
276 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 281 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
277 "senddevicesynctickle?alt=proto"); | 282 "senddevicesynctickle?alt=proto"); |
278 | 283 |
279 SendDeviceSyncTickleResponse result_proto; | 284 SendDeviceSyncTickleResponse result_proto; |
280 client_->SendDeviceSyncTickle( | 285 client_->SendDeviceSyncTickle( |
281 SendDeviceSyncTickleRequest(), | 286 SendDeviceSyncTickleRequest(), |
282 base::Bind(&SaveResult<SendDeviceSyncTickleResponse>, | 287 base::Bind(&SaveResult<SendDeviceSyncTickleResponse>, &result_proto), |
283 &result_proto), | 288 base::Bind(&NotCalled<std::string>), |
284 base::Bind(&NotCalled<std::string>)); | 289 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
285 | 290 |
286 SendDeviceSyncTickleRequest expected_request; | 291 SendDeviceSyncTickleRequest expected_request; |
287 EXPECT_TRUE(expected_request.ParseFromString(serialized_request_)); | 292 EXPECT_TRUE(expected_request.ParseFromString(serialized_request_)); |
288 | 293 |
289 SendDeviceSyncTickleResponse response_proto; | 294 SendDeviceSyncTickleResponse response_proto; |
290 FinishApiCallFlow(&response_proto); | 295 FinishApiCallFlow(&response_proto); |
291 } | 296 } |
292 | 297 |
293 TEST_F(CryptAuthClientTest, ToggleEasyUnlockSuccess) { | 298 TEST_F(CryptAuthClientTest, ToggleEasyUnlockSuccess) { |
294 ExpectRequest( | 299 ExpectRequest( |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
394 } | 399 } |
395 EXPECT_EQ("OK", result_proto.status()); | 400 EXPECT_EQ("OK", result_proto.status()); |
396 } | 401 } |
397 | 402 |
398 TEST_F(CryptAuthClientTest, FetchAccessTokenFailure) { | 403 TEST_F(CryptAuthClientTest, FetchAccessTokenFailure) { |
399 access_token_fetcher_->set_access_token(""); | 404 access_token_fetcher_->set_access_token(""); |
400 | 405 |
401 std::string error_message; | 406 std::string error_message; |
402 client_->GetMyDevices(GetMyDevicesRequest(), | 407 client_->GetMyDevices(GetMyDevicesRequest(), |
403 base::Bind(&NotCalled<GetMyDevicesResponse>), | 408 base::Bind(&NotCalled<GetMyDevicesResponse>), |
404 base::Bind(&SaveResult<std::string>, &error_message)); | 409 base::Bind(&SaveResult<std::string>, &error_message), |
| 410 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
405 | 411 |
406 EXPECT_EQ("Failed to get a valid access token.", error_message); | 412 EXPECT_EQ("Failed to get a valid access token.", error_message); |
407 } | 413 } |
408 | 414 |
409 TEST_F(CryptAuthClientTest, ParseResponseProtoFailure) { | 415 TEST_F(CryptAuthClientTest, ParseResponseProtoFailure) { |
410 ExpectRequest( | 416 ExpectRequest( |
411 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 417 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
412 "getmydevices?alt=proto"); | 418 "getmydevices?alt=proto"); |
413 | 419 |
414 std::string error_message; | 420 std::string error_message; |
415 client_->GetMyDevices(GetMyDevicesRequest(), | 421 client_->GetMyDevices(GetMyDevicesRequest(), |
416 base::Bind(&NotCalled<GetMyDevicesResponse>), | 422 base::Bind(&NotCalled<GetMyDevicesResponse>), |
417 base::Bind(&SaveResult<std::string>, &error_message)); | 423 base::Bind(&SaveResult<std::string>, &error_message), |
| 424 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
418 | 425 |
419 flow_result_callback_.Run("Not a valid serialized response message."); | 426 flow_result_callback_.Run("Not a valid serialized response message."); |
420 EXPECT_EQ("Failed to parse response proto.", error_message); | 427 EXPECT_EQ("Failed to parse response proto.", error_message); |
421 } | 428 } |
422 | 429 |
423 TEST_F(CryptAuthClientTest, | 430 TEST_F(CryptAuthClientTest, |
424 MakeSecondRequestBeforeFirstRequestSucceeds) { | 431 MakeSecondRequestBeforeFirstRequestSucceeds) { |
425 ExpectRequest( | 432 ExpectRequest( |
426 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 433 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
427 "getmydevices?alt=proto"); | 434 "getmydevices?alt=proto"); |
428 | 435 |
429 // Make first request. | 436 // Make first request. |
430 GetMyDevicesResponse result_proto; | 437 GetMyDevicesResponse result_proto; |
431 client_->GetMyDevices( | 438 client_->GetMyDevices( |
432 GetMyDevicesRequest(), | 439 GetMyDevicesRequest(), |
433 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), | 440 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), |
434 base::Bind(&NotCalled<std::string>)); | 441 base::Bind(&NotCalled<std::string>), |
| 442 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
435 | 443 |
436 // With request pending, make second request. | 444 // With request pending, make second request. |
437 { | 445 { |
438 std::string error_message; | 446 std::string error_message; |
439 client_->FindEligibleUnlockDevices( | 447 client_->FindEligibleUnlockDevices( |
440 FindEligibleUnlockDevicesRequest(), | 448 FindEligibleUnlockDevicesRequest(), |
441 base::Bind(&NotCalled<FindEligibleUnlockDevicesResponse>), | 449 base::Bind(&NotCalled<FindEligibleUnlockDevicesResponse>), |
442 base::Bind(&SaveResult<std::string>, &error_message)); | 450 base::Bind(&SaveResult<std::string>, &error_message)); |
443 EXPECT_EQ("Client has been used for another request. Do not reuse.", | 451 EXPECT_EQ("Client has been used for another request. Do not reuse.", |
444 error_message); | 452 error_message); |
(...skipping 14 matching lines...) Expand all Loading... |
459 TEST_F(CryptAuthClientTest, | 467 TEST_F(CryptAuthClientTest, |
460 MakeSecondRequestBeforeFirstRequestFails) { | 468 MakeSecondRequestBeforeFirstRequestFails) { |
461 ExpectRequest( | 469 ExpectRequest( |
462 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 470 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
463 "getmydevices?alt=proto"); | 471 "getmydevices?alt=proto"); |
464 | 472 |
465 // Make first request. | 473 // Make first request. |
466 std::string error_message; | 474 std::string error_message; |
467 client_->GetMyDevices(GetMyDevicesRequest(), | 475 client_->GetMyDevices(GetMyDevicesRequest(), |
468 base::Bind(&NotCalled<GetMyDevicesResponse>), | 476 base::Bind(&NotCalled<GetMyDevicesResponse>), |
469 base::Bind(&SaveResult<std::string>, &error_message)); | 477 base::Bind(&SaveResult<std::string>, &error_message), |
| 478 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
470 | 479 |
471 // With request pending, make second request. | 480 // With request pending, make second request. |
472 { | 481 { |
473 std::string error_message; | 482 std::string error_message; |
474 client_->FindEligibleUnlockDevices( | 483 client_->FindEligibleUnlockDevices( |
475 FindEligibleUnlockDevicesRequest(), | 484 FindEligibleUnlockDevicesRequest(), |
476 base::Bind(&NotCalled<FindEligibleUnlockDevicesResponse>), | 485 base::Bind(&NotCalled<FindEligibleUnlockDevicesResponse>), |
477 base::Bind(&SaveResult<std::string>, &error_message)); | 486 base::Bind(&SaveResult<std::string>, &error_message)); |
478 EXPECT_EQ("Client has been used for another request. Do not reuse.", | 487 EXPECT_EQ("Client has been used for another request. Do not reuse.", |
479 error_message); | 488 error_message); |
480 } | 489 } |
481 | 490 |
482 // Fail first request. | 491 // Fail first request. |
483 std::string kStatus429Error = "HTTP status: 429"; | 492 std::string kStatus429Error = "HTTP status: 429"; |
484 FailApiCallFlow(kStatus429Error); | 493 FailApiCallFlow(kStatus429Error); |
485 EXPECT_EQ(kStatus429Error, error_message); | 494 EXPECT_EQ(kStatus429Error, error_message); |
486 } | 495 } |
487 | 496 |
488 TEST_F(CryptAuthClientTest, | 497 TEST_F(CryptAuthClientTest, |
489 MakeSecondRequestAfterFirstRequestSucceeds) { | 498 MakeSecondRequestAfterFirstRequestSucceeds) { |
490 // Make first request successfully. | 499 // Make first request successfully. |
491 { | 500 { |
492 ExpectRequest( | 501 ExpectRequest( |
493 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 502 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
494 "getmydevices?alt=proto"); | 503 "getmydevices?alt=proto"); |
495 GetMyDevicesResponse result_proto; | 504 GetMyDevicesResponse result_proto; |
496 client_->GetMyDevices( | 505 client_->GetMyDevices( |
497 GetMyDevicesRequest(), | 506 GetMyDevicesRequest(), |
498 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), | 507 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), |
499 base::Bind(&NotCalled<std::string>)); | 508 base::Bind(&NotCalled<std::string>), |
| 509 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
500 | 510 |
501 GetMyDevicesResponse response_proto; | 511 GetMyDevicesResponse response_proto; |
502 response_proto.add_devices(); | 512 response_proto.add_devices(); |
503 response_proto.mutable_devices(0)->set_public_key(kPublicKey1); | 513 response_proto.mutable_devices(0)->set_public_key(kPublicKey1); |
504 FinishApiCallFlow(&response_proto); | 514 FinishApiCallFlow(&response_proto); |
505 ASSERT_EQ(1, result_proto.devices_size()); | 515 ASSERT_EQ(1, result_proto.devices_size()); |
506 EXPECT_EQ(kPublicKey1, result_proto.devices(0).public_key()); | 516 EXPECT_EQ(kPublicKey1, result_proto.devices(0).public_key()); |
507 } | 517 } |
508 | 518 |
509 // Second request fails. | 519 // Second request fails. |
(...skipping 12 matching lines...) Expand all Loading... |
522 ExpectRequest( | 532 ExpectRequest( |
523 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 533 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
524 "getmydevices?alt=proto"); | 534 "getmydevices?alt=proto"); |
525 | 535 |
526 GetMyDevicesResponse result_proto; | 536 GetMyDevicesResponse result_proto; |
527 GetMyDevicesRequest request_proto; | 537 GetMyDevicesRequest request_proto; |
528 request_proto.set_allow_stale_read(true); | 538 request_proto.set_allow_stale_read(true); |
529 client_->GetMyDevices( | 539 client_->GetMyDevices( |
530 request_proto, | 540 request_proto, |
531 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), | 541 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), |
532 base::Bind(&NotCalled<std::string>)); | 542 base::Bind(&NotCalled<std::string>), |
| 543 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
533 GetMyDevicesRequest expected_request; | 544 GetMyDevicesRequest expected_request; |
534 EXPECT_TRUE(expected_request.ParseFromString(serialized_request_)); | 545 EXPECT_TRUE(expected_request.ParseFromString(serialized_request_)); |
535 | 546 |
536 const DeviceClassifier& device_classifier = | 547 const DeviceClassifier& device_classifier = |
537 expected_request.device_classifier(); | 548 expected_request.device_classifier(); |
538 EXPECT_EQ(kDeviceOsVersionCode, device_classifier.device_os_version_code()); | 549 EXPECT_EQ(kDeviceOsVersionCode, device_classifier.device_os_version_code()); |
539 EXPECT_EQ(kDeviceSoftwareVersionCode, | 550 EXPECT_EQ(kDeviceSoftwareVersionCode, |
540 device_classifier.device_software_version_code()); | 551 device_classifier.device_software_version_code()); |
541 EXPECT_EQ(kDeviceSoftwarePackage, | 552 EXPECT_EQ(kDeviceSoftwarePackage, |
542 device_classifier.device_software_package()); | 553 device_classifier.device_software_package()); |
543 EXPECT_EQ(kDeviceType, device_classifier.device_type()); | 554 EXPECT_EQ(kDeviceType, device_classifier.device_type()); |
544 } | 555 } |
545 | 556 |
546 TEST_F(CryptAuthClientTest, GetAccessTokenUsed) { | 557 TEST_F(CryptAuthClientTest, GetAccessTokenUsed) { |
547 EXPECT_TRUE(client_->GetAccessTokenUsed().empty()); | 558 EXPECT_TRUE(client_->GetAccessTokenUsed().empty()); |
548 ExpectRequest( | 559 ExpectRequest( |
549 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" | 560 "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/" |
550 "getmydevices?alt=proto"); | 561 "getmydevices?alt=proto"); |
551 | 562 |
552 GetMyDevicesResponse result_proto; | 563 GetMyDevicesResponse result_proto; |
553 GetMyDevicesRequest request_proto; | 564 GetMyDevicesRequest request_proto; |
554 request_proto.set_allow_stale_read(true); | 565 request_proto.set_allow_stale_read(true); |
555 client_->GetMyDevices( | 566 client_->GetMyDevices( |
556 request_proto, | 567 request_proto, |
557 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), | 568 base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto), |
558 base::Bind(&NotCalled<std::string>)); | 569 base::Bind(&NotCalled<std::string>), |
| 570 PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS); |
559 EXPECT_EQ(kAccessToken, client_->GetAccessTokenUsed()); | 571 EXPECT_EQ(kAccessToken, client_->GetAccessTokenUsed()); |
560 } | 572 } |
561 | 573 |
562 } // namespace cryptauth | 574 } // namespace cryptauth |
OLD | NEW |