1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/json/json_reader.h" 6 #include "base/json/json_writer.h" 7 #include "base/logging.h" 8 #include "base/memory/scoped_ptr.h" 9 #include "base/run_loop.h" 10 #include "base/strings/string_number_conversions.h" 11 #include "base/strings/string_split.h" 12 #include "base/strings/string_util.h" 13 #include "base/strings/stringprintf.h" 14 #include "base/values.h" 15 #include "chrome/test/base/testing_profile.h" 16 #include "components/autofill/content/browser/autocheckout_steps.h" 17 #include "components/autofill/content/browser/wallet/full_wallet.h" 18 #include "components/autofill/content/browser/wallet/instrument.h" 19 #include "components/autofill/content/browser/wallet/wallet_client.h" 20 #include "components/autofill/content/browser/wallet/wallet_client_delegate.h" 21 #include "components/autofill/content/browser/wallet/wallet_items.h" 22 #include "components/autofill/content/browser/wallet/wallet_test_util.h" 23 #include "components/autofill/core/browser/autofill_metrics.h" 24 #include "components/autofill/core/common/autocheckout_status.h" 25 #include "content/public/test/test_browser_thread_bundle.h" 26 #include "net/base/escape.h" 27 #include "net/base/net_errors.h" 28 #include "net/http/http_request_headers.h" 29 #include "net/http/http_status_code.h" 30 #include "net/url_request/test_url_fetcher_factory.h" 31 #include "net/url_request/url_fetcher_delegate.h" 32 #include "net/url_request/url_request_status.h" 33 #include "testing/gmock/include/gmock/gmock.h" 34 #include "testing/gtest/include/gtest/gtest.h" 35 #include "url/gurl.h" 36 37 namespace autofill { 38 namespace wallet { 39 40 namespace { 41 42 const char kGoogleTransactionId[] = "google-transaction-id"; 43 const char kMerchantUrl[] = "https://example.com/path?key=value"; 44 45 const char kGetFullWalletValidResponse[] = 46 "{" 47 " \"expiration_month\":12," 48 " \"expiration_year\":3000," 49 " \"iin\":\"iin\"," 50 " \"rest\":\"rest\"," 51 " \"billing_address\":" 52 " {" 53 " \"id\":\"id\"," 54 " \"phone_number\":\"phone_number\"," 55 " \"postal_address\":" 56 " {" 57 " \"recipient_name\":\"recipient_name\"," 58 " \"address_line\":" 59 " [" 60 " \"address_line_1\"," 61 " \"address_line_2\"" 62 " ]," 63 " \"locality_name\":\"locality_name\"," 64 " \"administrative_area_name\":\"administrative_area_name\"," 65 " \"postal_code_number\":\"postal_code_number\"," 66 " \"country_name_code\":\"US\"" 67 " }" 68 " }," 69 " \"shipping_address\":" 70 " {" 71 " \"id\":\"ship_id\"," 72 " \"phone_number\":\"ship_phone_number\"," 73 " \"postal_address\":" 74 " {" 75 " \"recipient_name\":\"ship_recipient_name\"," 76 " \"address_line\":" 77 " [" 78 " \"ship_address_line_1\"," 79 " \"ship_address_line_2\"" 80 " ]," 81 " \"locality_name\":\"ship_locality_name\"," 82 " \"administrative_area_name\":\"ship_administrative_area_name\"," 83 " \"postal_code_number\":\"ship_postal_code_number\"," 84 " \"country_name_code\":\"US\"" 85 " }" 86 " }," 87 " \"required_action\":" 88 " [" 89 " ]" 90 "}"; 91 92 const char kGetFullWalletInvalidResponse[] = 93 "{" 94 " \"garbage\":123" 95 "}"; 96 97 const char kGetWalletItemsValidResponse[] = 98 "{" 99 " \"required_action\":" 100 " [" 101 " ]," 102 " \"google_transaction_id\":\"google_transaction_id\"," 103 " \"instrument\":" 104 " [" 105 " {" 106 " \"descriptive_name\":\"descriptive_name\"," 107 " \"type\":\"VISA\"," 108 " \"supported_currency\":\"currency_code\"," 109 " \"last_four_digits\":\"4111\"," 110 " \"expiration_month\":12," 111 " \"expiration_year\":3000," 112 " \"brand\":\"monkeys\"," 113 " \"billing_address\":" 114 " {" 115 " \"name\":\"name\"," 116 " \"address1\":\"address1\"," 117 " \"address2\":\"address2\"," 118 " \"city\":\"city\"," 119 " \"state\":\"state\"," 120 " \"postal_code\":\"postal_code\"," 121 " \"phone_number\":\"phone_number\"," 122 " \"country_code\":\"country_code\"" 123 " }," 124 " \"status\":\"VALID\"," 125 " \"object_id\":\"default_instrument_id\"" 126 " }" 127 " ]," 128 " \"default_instrument_id\":\"default_instrument_id\"," 129 " \"obfuscated_gaia_id\":\"obfuscated_gaia_id\"," 130 " \"address\":" 131 " [" 132 " ]," 133 " \"default_address_id\":\"default_address_id\"," 134 " \"required_legal_document\":" 135 " [" 136 " ]" 137 "}"; 138 139 const char kSaveAddressValidResponse[] = 140 "{" 141 " \"shipping_address_id\":\"saved_address_id\"" 142 "}"; 143 144 const char kSaveAddressWithRequiredActionsValidResponse[] = 145 "{" 146 " \"form_field_error\":" 147 " [" 148 " {" 149 " \"location\":\"SHIPPING_ADDRESS\"," 150 " \"type\":\"INVALID_POSTAL_CODE\"" 151 " }" 152 " ]," 153 " \"required_action\":" 154 " [" 155 " \" \\treqUIRE_PhOnE_number \\n\\r\"," 156 " \"INVALID_form_field\"" 157 " ]" 158 "}"; 159 160 const char kSaveWithInvalidRequiredActionsResponse[] = 161 "{" 162 " \"required_action\":" 163 " [" 164 " \" setup_wallet\"," 165 " \" \\treqUIRE_PhOnE_number \\n\\r\"," 166 " \"INVALID_form_field\"" 167 " ]" 168 "}"; 169 170 const char kSaveInvalidResponse[] = 171 "{" 172 " \"garbage\":123" 173 "}"; 174 175 const char kSaveInstrumentValidResponse[] = 176 "{" 177 " \"instrument_id\":\"instrument_id\"" 178 "}"; 179 180 const char kSaveInstrumentWithRequiredActionsValidResponse[] = 181 "{" 182 " \"form_field_error\":" 183 " [" 184 " {" 185 " \"location\":\"SHIPPING_ADDRESS\"," 186 " \"type\":\"INVALID_POSTAL_CODE\"" 187 " }" 188 " ]," 189 " \"required_action\":" 190 " [" 191 " \" \\treqUIRE_PhOnE_number \\n\\r\"," 192 " \"INVALID_form_field\"" 193 " ]" 194 "}"; 195 196 const char kSaveInstrumentAndAddressValidResponse[] = 197 "{" 198 " \"shipping_address_id\":\"saved_address_id\"," 199 " \"instrument_id\":\"saved_instrument_id\"" 200 "}"; 201 202 const char kSaveInstrumentAndAddressWithRequiredActionsValidResponse[] = 203 "{" 204 " \"form_field_error\":" 205 " [" 206 " {" 207 " \"location\":\"SHIPPING_ADDRESS\"," 208 " \"type\":\"INVALID_POSTAL_CODE\"" 209 " }" 210 " ]," 211 " \"required_action\":" 212 " [" 213 " \" \\treqUIRE_PhOnE_number \\n\\r\"," 214 " \"INVALID_form_field\"" 215 " ]" 216 "}"; 217 218 const char kUpdateInstrumentValidResponse[] = 219 "{" 220 " \"instrument_id\":\"instrument_id\"" 221 "}"; 222 223 const char kUpdateAddressValidResponse[] = 224 "{" 225 " \"shipping_address_id\":\"shipping_address_id\"" 226 "}"; 227 228 const char kUpdateWithRequiredActionsValidResponse[] = 229 "{" 230 " \"form_field_error\":" 231 " [" 232 " {" 233 " \"location\":\"SHIPPING_ADDRESS\"," 234 " \"type\":\"INVALID_POSTAL_CODE\"" 235 " }" 236 " ]," 237 " \"required_action\":" 238 " [" 239 " \" \\treqUIRE_PhOnE_number \\n\\r\"," 240 " \"INVALID_form_field\"" 241 " ]" 242 "}"; 243 244 const char kUpdateMalformedResponse[] = 245 "{" 246 " \"cheese\":\"monkeys\"" 247 "}"; 248 249 const char kAuthenticateInstrumentFailureResponse[] = 250 "{" 251 " \"auth_result\":\"anything else\"" 252 "}"; 253 254 const char kAuthenticateInstrumentSuccessResponse[] = 255 "{" 256 " \"auth_result\":\"SUCCESS\"" 257 "}"; 258 259 const char kErrorResponse[] = 260 "{" 261 " \"error_type\":\"APPLICATION_ERROR\"," 262 " \"error_detail\":\"error_detail\"," 263 " \"application_error\":\"application_error\"," 264 " \"debug_data\":" 265 " {" 266 " \"debug_message\":\"debug_message\"," 267 " \"stack_trace\":\"stack_trace\"" 268 " }," 269 " \"application_error_data\":\"application_error_data\"," 270 " \"wallet_error\":" 271 " {" 272 " \"error_type\":\"SERVICE_UNAVAILABLE\"," 273 " \"error_detail\":\"error_detail\"," 274 " \"message_for_user\":" 275 " {" 276 " \"text\":\"text\"," 277 " \"subtext\":\"subtext\"," 278 " \"details\":\"details\"" 279 " }" 280 " }" 281 "}"; 282 283 const char kErrorTypeMissingInResponse[] = 284 "{" 285 " \"error_type\":\"Not APPLICATION_ERROR\"," 286 " \"error_detail\":\"error_detail\"," 287 " \"application_error\":\"application_error\"," 288 " \"debug_data\":" 289 " {" 290 " \"debug_message\":\"debug_message\"," 291 " \"stack_trace\":\"stack_trace\"" 292 " }," 293 " \"application_error_data\":\"application_error_data\"" 294 "}"; 295 296 // The JSON below is used to test against the request payload being sent to 297 // Online Wallet. It's indented differently since JSONWriter creates compact 298 // JSON from DictionaryValues. 299 300 const char kAcceptLegalDocumentsValidRequest[] = 301 "{" 302 "\"accepted_legal_document\":" 303 "[" 304 "\"doc_id_1\"," 305 "\"doc_id_2\"" 306 "]," 307 "\"google_transaction_id\":\"google-transaction-id\"," 308 "\"merchant_domain\":\"https://example.com/\"" 309 "}"; 310 311 const char kAuthenticateInstrumentValidRequest[] = 312 "{" 313 "\"instrument_id\":\"instrument_id\"," 314 "\"risk_params\":\"risky business\"" 315 "}"; 316 317 const char kGetFullWalletValidRequest[] = 318 "{" 319 "\"feature\":\"REQUEST_AUTOCOMPLETE\"," 320 "\"google_transaction_id\":\"google_transaction_id\"," 321 "\"merchant_domain\":\"https://example.com/\"," 322 "\"phone_number_required\":true," 323 "\"risk_params\":\"risky business\"," 324 "\"selected_address_id\":\"shipping_address_id\"," 325 "\"selected_instrument_id\":\"instrument_id\"," 326 "\"supported_risk_challenge\":" 327 "[" 328 "]," 329 "\"use_minimal_addresses\":false" 330 "}"; 331 332 const char kGetFullWalletWithRiskCapabilitesValidRequest[] = 333 "{" 334 "\"feature\":\"REQUEST_AUTOCOMPLETE\"," 335 "\"google_transaction_id\":\"google_transaction_id\"," 336 "\"merchant_domain\":\"https://example.com/\"," 337 "\"phone_number_required\":true," 338 "\"risk_params\":\"risky business\"," 339 "\"selected_address_id\":\"shipping_address_id\"," 340 "\"selected_instrument_id\":\"instrument_id\"," 341 "\"supported_risk_challenge\":" 342 "[" 343 "\"VERIFY_CVC\"" 344 "]," 345 "\"use_minimal_addresses\":false" 346 "}"; 347 348 const char kGetWalletItemsValidRequest[] = 349 "{" 350 "\"merchant_domain\":\"https://example.com/\"," 351 "\"phone_number_required\":true," 352 "\"shipping_address_required\":true," 353 "\"use_minimal_addresses\":false" 354 "}"; 355 356 const char kGetWalletItemsNoShippingRequest[] = 357 "{" 358 "\"merchant_domain\":\"https://example.com/\"," 359 "\"phone_number_required\":true," 360 "\"shipping_address_required\":false," 361 "\"use_minimal_addresses\":false" 362 "}"; 363 364 const char kSaveAddressValidRequest[] = 365 "{" 366 "\"merchant_domain\":\"https://example.com/\"," 367 "\"phone_number_required\":true," 368 "\"risk_params\":\"risky business\"," 369 "\"shipping_address\":" 370 "{" 371 "\"phone_number\":\"save_phone_number\"," 372 "\"postal_address\":" 373 "{" 374 "\"address_line\":" 375 "[" 376 "\"save_address_line_1\"," 377 "\"save_address_line_2\"" 378 "]," 379 "\"administrative_area_name\":\"save_admin_area_name\"," 380 "\"country_name_code\":\"US\"," 381 "\"locality_name\":\"save_locality_name\"," 382 "\"postal_code_number\":\"save_postal_code_number\"," 383 "\"recipient_name\":\"save_recipient_name\"" 384 "}" 385 "}," 386 "\"use_minimal_addresses\":false" 387 "}"; 388 389 const char kSaveInstrumentValidRequest[] = 390 "{" 391 "\"instrument\":" 392 "{" 393 "\"credit_card\":" 394 "{" 395 "\"address\":" 396 "{" 397 "\"address_line\":" 398 "[" 399 "\"address_line_1\"," 400 "\"address_line_2\"" 401 "]," 402 "\"administrative_area_name\":\"admin_area_name\"," 403 "\"country_name_code\":\"US\"," 404 "\"locality_name\":\"locality_name\"," 405 "\"postal_code_number\":\"postal_code_number\"," 406 "\"recipient_name\":\"recipient_name\"" 407 "}," 408 "\"exp_month\":12," 409 "\"exp_year\":3000," 410 "\"fop_type\":\"VISA\"," 411 "\"last_4_digits\":\"4448\"" 412 "}," 413 "\"type\":\"CREDIT_CARD\"" 414 "}," 415 "\"instrument_phone_number\":\"phone_number\"," 416 "\"merchant_domain\":\"https://example.com/\"," 417 "\"phone_number_required\":true," 418 "\"risk_params\":\"risky business\"," 419 "\"use_minimal_addresses\":false" 420 "}"; 421 422 const char kSaveInstrumentAndAddressValidRequest[] = 423 "{" 424 "\"instrument\":" 425 "{" 426 "\"credit_card\":" 427 "{" 428 "\"address\":" 429 "{" 430 "\"address_line\":" 431 "[" 432 "\"address_line_1\"," 433 "\"address_line_2\"" 434 "]," 435 "\"administrative_area_name\":\"admin_area_name\"," 436 "\"country_name_code\":\"US\"," 437 "\"locality_name\":\"locality_name\"," 438 "\"postal_code_number\":\"postal_code_number\"," 439 "\"recipient_name\":\"recipient_name\"" 440 "}," 441 "\"exp_month\":12," 442 "\"exp_year\":3000," 443 "\"fop_type\":\"VISA\"," 444 "\"last_4_digits\":\"4448\"" 445 "}," 446 "\"type\":\"CREDIT_CARD\"" 447 "}," 448 "\"instrument_phone_number\":\"phone_number\"," 449 "\"merchant_domain\":\"https://example.com/\"," 450 "\"phone_number_required\":true," 451 "\"risk_params\":\"risky business\"," 452 "\"shipping_address\":" 453 "{" 454 "\"phone_number\":\"save_phone_number\"," 455 "\"postal_address\":" 456 "{" 457 "\"address_line\":" 458 "[" 459 "\"save_address_line_1\"," 460 "\"save_address_line_2\"" 461 "]," 462 "\"administrative_area_name\":\"save_admin_area_name\"," 463 "\"country_name_code\":\"US\"," 464 "\"locality_name\":\"save_locality_name\"," 465 "\"postal_code_number\":\"save_postal_code_number\"," 466 "\"recipient_name\":\"save_recipient_name\"" 467 "}" 468 "}," 469 "\"use_minimal_addresses\":false" 470 "}"; 471 472 const char kSendAutocheckoutStatusOfSuccessValidRequest[] = 473 "{" 474 "\"google_transaction_id\":\"google_transaction_id\"," 475 "\"merchant_domain\":\"https://example.com/\"," 476 "\"success\":true" 477 "}"; 478 479 const char kSendAutocheckoutStatusWithStatisticsValidRequest[] = 480 "{" 481 "\"google_transaction_id\":\"google_transaction_id\"," 482 "\"merchant_domain\":\"https://example.com/\"," 483 "\"steps\":[{\"step_description\":\"1_AUTOCHECKOUT_STEP_SHIPPING\"" 484 ",\"time_taken\":100}]," 485 "\"success\":true" 486 "}"; 487 488 const char kSendAutocheckoutStatusOfFailureValidRequest[] = 489 "{" 490 "\"google_transaction_id\":\"google_transaction_id\"," 491 "\"merchant_domain\":\"https://example.com/\"," 492 "\"reason\":\"CANNOT_PROCEED\"," 493 "\"success\":false" 494 "}"; 495 496 const char kUpdateAddressValidRequest[] = 497 "{" 498 "\"merchant_domain\":\"https://example.com/\"," 499 "\"phone_number_required\":true," 500 "\"risk_params\":\"risky business\"," 501 "\"shipping_address\":" 502 "{" 503 "\"id\":\"shipping_address_id\"," 504 "\"phone_number\":\"ship_phone_number\"," 505 "\"postal_address\":" 506 "{" 507 "\"address_line\":" 508 "[" 509 "\"ship_address_line_1\"," 510 "\"ship_address_line_2\"" 511 "]," 512 "\"administrative_area_name\":\"ship_admin_area_name\"," 513 "\"country_name_code\":\"US\"," 514 "\"locality_name\":\"ship_locality_name\"," 515 "\"postal_code_number\":\"ship_postal_code_number\"," 516 "\"recipient_name\":\"ship_recipient_name\"" 517 "}" 518 "}," 519 "\"use_minimal_addresses\":false" 520 "}"; 521 522 const char kUpdateInstrumentAddressValidRequest[] = 523 "{" 524 "\"instrument_phone_number\":\"phone_number\"," 525 "\"merchant_domain\":\"https://example.com/\"," 526 "\"phone_number_required\":true," 527 "\"risk_params\":\"risky business\"," 528 "\"upgraded_billing_address\":" 529 "{" 530 "\"address_line\":" 531 "[" 532 "\"address_line_1\"," 533 "\"address_line_2\"" 534 "]," 535 "\"administrative_area_name\":\"admin_area_name\"," 536 "\"country_name_code\":\"US\"," 537 "\"locality_name\":\"locality_name\"," 538 "\"postal_code_number\":\"postal_code_number\"," 539 "\"recipient_name\":\"recipient_name\"" 540 "}," 541 "\"upgraded_instrument_id\":\"instrument_id\"," 542 "\"use_minimal_addresses\":false" 543 "}"; 544 545 const char kUpdateInstrumentAddressWithNameChangeValidRequest[] = 546 "{" 547 "\"instrument_phone_number\":\"phone_number\"," 548 "\"merchant_domain\":\"https://example.com/\"," 549 "\"phone_number_required\":true," 550 "\"risk_params\":\"risky business\"," 551 "\"upgraded_billing_address\":" 552 "{" 553 "\"address_line\":" 554 "[" 555 "\"address_line_1\"," 556 "\"address_line_2\"" 557 "]," 558 "\"administrative_area_name\":\"admin_area_name\"," 559 "\"country_name_code\":\"US\"," 560 "\"locality_name\":\"locality_name\"," 561 "\"postal_code_number\":\"postal_code_number\"," 562 "\"recipient_name\":\"recipient_name\"" 563 "}," 564 "\"upgraded_instrument_id\":\"instrument_id\"," 565 "\"use_minimal_addresses\":false" 566 "}"; 567 568 const char kUpdateInstrumentExpirationDateValidRequest[] = 569 "{" 570 "\"instrument\":" 571 "{" 572 "\"credit_card\":" 573 "{" 574 "\"exp_month\":12," 575 "\"exp_year\":3000" 576 "}," 577 "\"type\":\"CREDIT_CARD\"" 578 "}," 579 "\"merchant_domain\":\"https://example.com/\"," 580 "\"phone_number_required\":true," 581 "\"risk_params\":\"risky business\"," 582 "\"upgraded_instrument_id\":\"instrument_id\"," 583 "\"use_minimal_addresses\":false" 584 "}"; 585 586 class MockAutofillMetrics : public AutofillMetrics { 587 public: 588 MockAutofillMetrics() {} 589 MOCK_CONST_METHOD2(LogWalletApiCallDuration, 590 void(WalletApiCallMetric metric, 591 const base::TimeDelta& duration)); 592 MOCK_CONST_METHOD2(LogWalletErrorMetric, 593 void(DialogType dialog_type, WalletErrorMetric metric)); 594 MOCK_CONST_METHOD2(LogWalletRequiredActionMetric, 595 void(DialogType dialog_type, 596 WalletRequiredActionMetric action)); 597 private: 598 DISALLOW_COPY_AND_ASSIGN(MockAutofillMetrics); 599 }; 600 601 class MockWalletClientDelegate : public WalletClientDelegate { 602 public: 603 MockWalletClientDelegate() 604 : full_wallets_received_(0), 605 wallet_items_received_(0), 606 is_shipping_required_(true) {} 607 ~MockWalletClientDelegate() {} 608 609 virtual const AutofillMetrics& GetMetricLogger() const OVERRIDE { 610 return metric_logger_; 611 } 612 613 virtual DialogType GetDialogType() const OVERRIDE { 614 return DIALOG_TYPE_REQUEST_AUTOCOMPLETE; 615 } 616 617 virtual std::string GetRiskData() const OVERRIDE { 618 return "risky business"; 619 } 620 621 virtual std::string GetWalletCookieValue() const OVERRIDE { 622 return "gdToken"; 623 } 624 625 virtual bool IsShippingAddressRequired() const OVERRIDE { 626 return is_shipping_required_; 627 } 628 629 void SetIsShippingAddressRequired(bool is_shipping_required) { 630 is_shipping_required_ = is_shipping_required; 631 } 632 633 void ExpectLogWalletApiCallDuration( 634 AutofillMetrics::WalletApiCallMetric metric, 635 size_t times) { 636 EXPECT_CALL(metric_logger_, 637 LogWalletApiCallDuration(metric, testing::_)).Times(times); 638 } 639 640 void ExpectWalletErrorMetric(AutofillMetrics::WalletErrorMetric metric) { 641 EXPECT_CALL( 642 metric_logger_, 643 LogWalletErrorMetric( 644 DIALOG_TYPE_REQUEST_AUTOCOMPLETE, metric)).Times(1); 645 } 646 647 void ExpectWalletRequiredActionMetric( 648 AutofillMetrics::WalletRequiredActionMetric metric) { 649 EXPECT_CALL( 650 metric_logger_, 651 LogWalletRequiredActionMetric( 652 DIALOG_TYPE_REQUEST_AUTOCOMPLETE, metric)).Times(1); 653 } 654 655 void ExpectBaselineMetrics() { 656 EXPECT_CALL( 657 metric_logger_, 658 LogWalletErrorMetric( 659 DIALOG_TYPE_REQUEST_AUTOCOMPLETE, 660 AutofillMetrics::WALLET_ERROR_BASELINE_ISSUED_REQUEST)) 661 .Times(1); 662 ExpectWalletRequiredActionMetric( 663 AutofillMetrics::WALLET_REQUIRED_ACTION_BASELINE_ISSUED_REQUEST); 664 } 665 666 MockAutofillMetrics* metric_logger() { 667 return &metric_logger_; 668 } 669 670 MOCK_METHOD0(OnDidAcceptLegalDocuments, void()); 671 MOCK_METHOD1(OnDidAuthenticateInstrument, void(bool success)); 672 MOCK_METHOD4(OnDidSaveToWallet, 673 void(const std::string& instrument_id, 674 const std::string& shipping_address_id, 675 const std::vector<RequiredAction>& required_actions, 676 const std::vector<FormFieldError>& form_field_errors)); 677 MOCK_METHOD1(OnWalletError, void(WalletClient::ErrorType error_type)); 678 679 virtual void OnDidGetFullWallet(scoped_ptr<FullWallet> full_wallet) OVERRIDE { 680 EXPECT_TRUE(full_wallet); 681 ++full_wallets_received_; 682 } 683 virtual void OnDidGetWalletItems(scoped_ptr<WalletItems> wallet_items) 684 OVERRIDE { 685 EXPECT_TRUE(wallet_items); 686 ++wallet_items_received_; 687 } 688 size_t full_wallets_received() const { return full_wallets_received_; } 689 size_t wallet_items_received() const { return wallet_items_received_; } 690 691 private: 692 size_t full_wallets_received_; 693 size_t wallet_items_received_; 694 bool is_shipping_required_; 695 696 testing::StrictMock<MockAutofillMetrics> metric_logger_; 697 }; 698 699 } // namespace 700 701 class WalletClientTest : public testing::Test { 702 public: 703 virtual void SetUp() OVERRIDE { 704 wallet_client_.reset( 705 new WalletClient(browser_context_.GetRequestContext(), &delegate_)); 706 } 707 708 virtual void TearDown() OVERRIDE { 709 wallet_client_.reset(); 710 } 711 712 void VerifyAndFinishRequest(net::HttpStatusCode response_code, 713 const std::string& request_body, 714 const std::string& response_body) { 715 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 716 ASSERT_TRUE(fetcher); 717 718 const std::string& upload_data = fetcher->upload_data(); 719 EXPECT_EQ(request_body, GetData(upload_data)); 720 net::HttpRequestHeaders request_headers; 721 fetcher->GetExtraRequestHeaders(&request_headers); 722 std::string auth_header_value; 723 EXPECT_TRUE(request_headers.GetHeader( 724 net::HttpRequestHeaders::kAuthorization, 725 &auth_header_value)); 726 EXPECT_EQ("GoogleLogin auth=gdToken", auth_header_value); 727 728 fetcher->set_response_code(response_code); 729 fetcher->SetResponseString(response_body); 730 fetcher->delegate()->OnURLFetchComplete(fetcher); 731 732 // Pump the message loop to catch up to any asynchronous tasks that might 733 // have been posted from OnURLFetchComplete(). 734 base::RunLoop().RunUntilIdle(); 735 } 736 737 void VerifyAndFinishFormEncodedRequest(net::HttpStatusCode response_code, 738 const std::string& json_payload, 739 const std::string& response_body, 740 size_t expected_parameter_number) { 741 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 742 ASSERT_TRUE(fetcher); 743 744 net::HttpRequestHeaders request_headers; 745 fetcher->GetExtraRequestHeaders(&request_headers); 746 std::string auth_header_value; 747 EXPECT_TRUE(request_headers.GetHeader( 748 net::HttpRequestHeaders::kAuthorization, 749 &auth_header_value)); 750 EXPECT_EQ("GoogleLogin auth=gdToken", auth_header_value); 751 752 const std::string& upload_data = fetcher->upload_data(); 753 std::vector<std::pair<std::string, std::string> > tokens; 754 base::SplitStringIntoKeyValuePairs(upload_data, '=', '&', &tokens); 755 EXPECT_EQ(tokens.size(), expected_parameter_number); 756 757 size_t num_params = 0U; 758 for (size_t i = 0; i < tokens.size(); ++i) { 759 const std::string& key = tokens[i].first; 760 const std::string& value = tokens[i].second; 761 762 if (key == "request_content_type") { 763 EXPECT_EQ("application/json", value); 764 num_params++; 765 } 766 767 if (key == "request") { 768 EXPECT_EQ(json_payload, 769 GetData( 770 net::UnescapeURLComponent( 771 value, net::UnescapeRule::URL_SPECIAL_CHARS | 772 net::UnescapeRule::REPLACE_PLUS_WITH_SPACE))); 773 num_params++; 774 } 775 776 if (key == "cvn") { 777 EXPECT_EQ("123", value); 778 num_params++; 779 } 780 781 if (key == "card_number") { 782 EXPECT_EQ("4444444444444448", value); 783 num_params++; 784 } 785 786 if (key == "otp") { 787 EXPECT_FALSE(value.empty()); 788 num_params++; 789 } 790 } 791 EXPECT_EQ(expected_parameter_number, num_params); 792 793 fetcher->set_response_code(response_code); 794 fetcher->SetResponseString(response_body); 795 fetcher->delegate()->OnURLFetchComplete(fetcher); 796 } 797 798 void TestWalletErrorCode( 799 const std::string& error_type_string, 800 const std::string& buyer_error_type_string, 801 WalletClient::ErrorType expected_error_type, 802 AutofillMetrics::WalletErrorMetric expected_autofill_metric) { 803 static const char kResponseTemplate[] = 804 "{" 805 " \"error_type\":\"APPLICATION_ERROR\"," 806 " \"error_detail\":\"error_detail\"," 807 " \"application_error\":\"application_error\"," 808 " \"debug_data\":" 809 " {" 810 " \"debug_message\":\"debug_message\"," 811 " \"stack_trace\":\"stack_trace\"" 812 " }," 813 " \"application_error_data\":\"application_error_data\"," 814 " \"wallet_error\":" 815 " {" 816 " \"error_type\":\"%s\"," 817 " %s" // Placeholder for |user_error_type|. 818 " \"error_detail\":\"error_detail\"," 819 " \"message_for_user\":" 820 " {" 821 " \"text\":\"text\"," 822 " \"subtext\":\"subtext\"," 823 " \"details\":\"details\"" 824 " }" 825 " }" 826 "}"; 827 EXPECT_CALL(delegate_, OnWalletError(expected_error_type)).Times(1); 828 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SEND_STATUS, 1); 829 delegate_.ExpectBaselineMetrics(); 830 delegate_.ExpectWalletErrorMetric(expected_autofill_metric); 831 832 std::vector<AutocheckoutStatistic> statistics; 833 wallet_client_->SendAutocheckoutStatus(autofill::SUCCESS, 834 GURL(kMerchantUrl), 835 statistics, 836 "google_transaction_id"); 837 std::string buyer_error; 838 if (!buyer_error_type_string.empty()) { 839 buyer_error = base::StringPrintf("\"buyer_error_type\":\"%s\",", 840 buyer_error_type_string.c_str()); 841 } 842 std::string response = base::StringPrintf(kResponseTemplate, 843 error_type_string.c_str(), 844 buyer_error.c_str()); 845 VerifyAndFinishRequest(net::HTTP_INTERNAL_SERVER_ERROR, 846 kSendAutocheckoutStatusOfSuccessValidRequest, 847 response); 848 } 849 850 protected: 851 content::TestBrowserThreadBundle thread_bundle_; 852 scoped_ptr<WalletClient> wallet_client_; 853 TestingProfile browser_context_; 854 MockWalletClientDelegate delegate_; 855 856 private: 857 std::string GetData(const std::string& upload_data) { 858 scoped_ptr<Value> root(base::JSONReader::Read(upload_data)); 859 860 // If this is not a JSON dictionary, return plain text. 861 if (!root || !root->IsType(Value::TYPE_DICTIONARY)) 862 return upload_data; 863 864 // Remove api_key entry (to prevent accidental leak), return JSON as text. 865 DictionaryValue* dict = static_cast<DictionaryValue*>(root.get()); 866 dict->Remove("api_key", NULL); 867 std::string clean_upload_data; 868 base::JSONWriter::Write(dict, &clean_upload_data); 869 return clean_upload_data; 870 } 871 872 net::TestURLFetcherFactory factory_; 873 }; 874 875 TEST_F(WalletClientTest, WalletErrorCodes) { 876 struct { 877 std::string error_type_string; 878 std::string buyer_error_type_string; 879 WalletClient::ErrorType expected_error_type; 880 AutofillMetrics::WalletErrorMetric expected_autofill_metric; 881 } test_cases[] = { 882 // General |BUYER_ACCOUNT_ERROR| with no |buyer_error_type_string|. 883 { 884 "buyer_account_error", 885 "", 886 WalletClient::BUYER_ACCOUNT_ERROR, 887 AutofillMetrics::WALLET_BUYER_ACCOUNT_ERROR 888 }, 889 // |BUYER_ACCOUNT_ERROR| with "buyer_legal_address_not_supported" in 890 // buyer_error_type field. 891 { 892 "buyer_account_error", 893 "bla_country_not_supported", 894 WalletClient::BUYER_LEGAL_ADDRESS_NOT_SUPPORTED, 895 AutofillMetrics::WALLET_BUYER_LEGAL_ADDRESS_NOT_SUPPORTED 896 }, 897 // |BUYER_ACCOUNT_ERROR| with KYC error code in buyer_error_type field. 898 { 899 "buyer_account_error", 900 "buyer_kyc_error", 901 WalletClient::UNVERIFIED_KNOW_YOUR_CUSTOMER_STATUS, 902 AutofillMetrics::WALLET_UNVERIFIED_KNOW_YOUR_CUSTOMER_STATUS 903 }, 904 // |BUYER_ACCOUNT_ERROR| with un-recognizable |buyer_error_type|. 905 { 906 "buyer_account_error", 907 "random_string", 908 WalletClient::BUYER_ACCOUNT_ERROR, 909 AutofillMetrics::WALLET_BUYER_ACCOUNT_ERROR 910 }, 911 // The following are other error types we could get from Wallet. 912 { 913 "unsupported_merchant", 914 "", 915 WalletClient::UNSUPPORTED_MERCHANT, 916 AutofillMetrics::WALLET_UNSUPPORTED_MERCHANT 917 }, 918 { 919 "internal_error", 920 "", 921 WalletClient::INTERNAL_ERROR, 922 AutofillMetrics::WALLET_INTERNAL_ERROR 923 }, 924 { 925 "invalid_params", 926 "", 927 WalletClient::INVALID_PARAMS, 928 AutofillMetrics::WALLET_INVALID_PARAMS 929 }, 930 { 931 "service_unavailable", 932 "", 933 WalletClient::SERVICE_UNAVAILABLE, 934 AutofillMetrics::WALLET_SERVICE_UNAVAILABLE 935 }, 936 { 937 "unsupported_api_version", 938 "", 939 WalletClient::UNSUPPORTED_API_VERSION, 940 AutofillMetrics::WALLET_UNSUPPORTED_API_VERSION 941 }, 942 // Any un-recognizable |error_type| is a |UNKNOWN_ERROR|. 943 { 944 "random_string_1", 945 "", 946 WalletClient::UNKNOWN_ERROR, 947 AutofillMetrics::WALLET_UNKNOWN_ERROR 948 }, 949 { 950 "random_string_2", 951 "", 952 WalletClient::UNKNOWN_ERROR, 953 AutofillMetrics::WALLET_UNKNOWN_ERROR 954 }, 955 }; 956 957 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) { 958 SCOPED_TRACE( 959 base::StringPrintf("%s - %s", 960 test_cases[i].error_type_string.c_str(), 961 test_cases[i].buyer_error_type_string.c_str())); 962 TestWalletErrorCode(test_cases[i].error_type_string, 963 test_cases[i].buyer_error_type_string, 964 test_cases[i].expected_error_type, 965 test_cases[i].expected_autofill_metric); 966 } 967 } 968 969 TEST_F(WalletClientTest, WalletErrorResponseMissing) { 970 EXPECT_CALL(delegate_, OnWalletError( 971 WalletClient::UNKNOWN_ERROR)).Times(1); 972 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SEND_STATUS, 1); 973 delegate_.ExpectBaselineMetrics(); 974 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_UNKNOWN_ERROR); 975 976 std::vector<AutocheckoutStatistic> statistics; 977 wallet_client_->SendAutocheckoutStatus(autofill::SUCCESS, 978 GURL(kMerchantUrl), 979 statistics, 980 "google_transaction_id"); 981 VerifyAndFinishRequest(net::HTTP_INTERNAL_SERVER_ERROR, 982 kSendAutocheckoutStatusOfSuccessValidRequest, 983 kErrorTypeMissingInResponse); 984 } 985 986 TEST_F(WalletClientTest, NetworkFailureOnExpectedVoidResponse) { 987 EXPECT_CALL(delegate_, OnWalletError(WalletClient::NETWORK_ERROR)).Times(1); 988 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SEND_STATUS, 1); 989 delegate_.ExpectBaselineMetrics(); 990 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_NETWORK_ERROR); 991 992 std::vector<AutocheckoutStatistic> statistics; 993 wallet_client_->SendAutocheckoutStatus(autofill::SUCCESS, 994 GURL(kMerchantUrl), 995 statistics, 996 "google_transaction_id"); 997 VerifyAndFinishRequest(net::HTTP_UNAUTHORIZED, 998 kSendAutocheckoutStatusOfSuccessValidRequest, 999 std::string()); 1000 } 1001 1002 TEST_F(WalletClientTest, NetworkFailureOnExpectedResponse) { 1003 EXPECT_CALL(delegate_, OnWalletError(WalletClient::NETWORK_ERROR)).Times(1); 1004 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_WALLET_ITEMS, 1005 1); 1006 delegate_.ExpectBaselineMetrics(); 1007 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_NETWORK_ERROR); 1008 1009 wallet_client_->GetWalletItems(GURL(kMerchantUrl)); 1010 VerifyAndFinishRequest(net::HTTP_UNAUTHORIZED, 1011 kGetWalletItemsValidRequest, 1012 std::string()); 1013 } 1014 1015 TEST_F(WalletClientTest, RequestError) { 1016 EXPECT_CALL(delegate_, OnWalletError(WalletClient::BAD_REQUEST)).Times(1); 1017 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SEND_STATUS, 1); 1018 delegate_.ExpectBaselineMetrics(); 1019 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_BAD_REQUEST); 1020 1021 std::vector<AutocheckoutStatistic> statistics; 1022 wallet_client_->SendAutocheckoutStatus(autofill::SUCCESS, 1023 GURL(kMerchantUrl), 1024 statistics, 1025 "google_transaction_id"); 1026 VerifyAndFinishRequest(net::HTTP_BAD_REQUEST, 1027 kSendAutocheckoutStatusOfSuccessValidRequest, 1028 std::string()); 1029 } 1030 1031 TEST_F(WalletClientTest, GetFullWalletSuccess) { 1032 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_FULL_WALLET, 1); 1033 delegate_.ExpectBaselineMetrics(); 1034 1035 WalletClient::FullWalletRequest full_wallet_request( 1036 "instrument_id", 1037 "shipping_address_id", 1038 GURL(kMerchantUrl), 1039 "google_transaction_id", 1040 std::vector<WalletClient::RiskCapability>()); 1041 wallet_client_->GetFullWallet(full_wallet_request); 1042 1043 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1044 kGetFullWalletValidRequest, 1045 kGetFullWalletValidResponse, 1046 3U); 1047 EXPECT_EQ(1U, delegate_.full_wallets_received()); 1048 } 1049 1050 TEST_F(WalletClientTest, GetFullWalletWithRiskCapabilitesSuccess) { 1051 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_FULL_WALLET, 1); 1052 delegate_.ExpectBaselineMetrics(); 1053 1054 std::vector<WalletClient::RiskCapability> risk_capabilities; 1055 risk_capabilities.push_back(WalletClient::VERIFY_CVC); 1056 WalletClient::FullWalletRequest full_wallet_request( 1057 "instrument_id", 1058 "shipping_address_id", 1059 GURL(kMerchantUrl), 1060 "google_transaction_id", 1061 risk_capabilities); 1062 wallet_client_->GetFullWallet(full_wallet_request); 1063 1064 VerifyAndFinishFormEncodedRequest( 1065 net::HTTP_OK, 1066 kGetFullWalletWithRiskCapabilitesValidRequest, 1067 kGetFullWalletValidResponse, 1068 3U); 1069 EXPECT_EQ(1U, delegate_.full_wallets_received()); 1070 } 1071 1072 1073 TEST_F(WalletClientTest, GetFullWalletMalformedResponse) { 1074 EXPECT_CALL(delegate_, 1075 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1076 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_FULL_WALLET, 1); 1077 delegate_.ExpectBaselineMetrics(); 1078 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1079 1080 WalletClient::FullWalletRequest full_wallet_request( 1081 "instrument_id", 1082 "shipping_address_id", 1083 GURL(kMerchantUrl), 1084 "google_transaction_id", 1085 std::vector<WalletClient::RiskCapability>()); 1086 wallet_client_->GetFullWallet(full_wallet_request); 1087 1088 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1089 kGetFullWalletValidRequest, 1090 kGetFullWalletInvalidResponse, 1091 3U); 1092 EXPECT_EQ(0U, delegate_.full_wallets_received()); 1093 } 1094 1095 TEST_F(WalletClientTest, AcceptLegalDocuments) { 1096 EXPECT_CALL(delegate_, OnDidAcceptLegalDocuments()).Times(1); 1097 delegate_.ExpectLogWalletApiCallDuration( 1098 AutofillMetrics::ACCEPT_LEGAL_DOCUMENTS, 1099 1); 1100 delegate_.ExpectBaselineMetrics(); 1101 1102 ScopedVector<WalletItems::LegalDocument> docs; 1103 base::DictionaryValue document; 1104 document.SetString("legal_document_id", "doc_id_1"); 1105 document.SetString("display_name", "doc_1"); 1106 docs.push_back( 1107 WalletItems::LegalDocument::CreateLegalDocument(document).release()); 1108 document.SetString("legal_document_id", "doc_id_2"); 1109 document.SetString("display_name", "doc_2"); 1110 docs.push_back( 1111 WalletItems::LegalDocument::CreateLegalDocument(document).release()); 1112 docs.push_back( 1113 WalletItems::LegalDocument::CreatePrivacyPolicyDocument().release()); 1114 wallet_client_->AcceptLegalDocuments(docs.get(), 1115 kGoogleTransactionId, 1116 GURL(kMerchantUrl)); 1117 VerifyAndFinishRequest(net::HTTP_OK, 1118 kAcceptLegalDocumentsValidRequest, 1119 ")}'"); // Invalid JSON. Should be ignored. 1120 } 1121 1122 TEST_F(WalletClientTest, AuthenticateInstrumentSucceeded) { 1123 EXPECT_CALL(delegate_, OnDidAuthenticateInstrument(true)).Times(1); 1124 delegate_.ExpectLogWalletApiCallDuration( 1125 AutofillMetrics::AUTHENTICATE_INSTRUMENT, 1126 1); 1127 delegate_.ExpectBaselineMetrics(); 1128 1129 wallet_client_->AuthenticateInstrument("instrument_id", "123"); 1130 1131 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1132 kAuthenticateInstrumentValidRequest, 1133 kAuthenticateInstrumentSuccessResponse, 1134 3U); 1135 } 1136 1137 TEST_F(WalletClientTest, AuthenticateInstrumentFailed) { 1138 EXPECT_CALL(delegate_, OnDidAuthenticateInstrument(false)).Times(1); 1139 delegate_.ExpectLogWalletApiCallDuration( 1140 AutofillMetrics::AUTHENTICATE_INSTRUMENT, 1141 1); 1142 delegate_.ExpectBaselineMetrics(); 1143 1144 wallet_client_->AuthenticateInstrument("instrument_id", "123"); 1145 1146 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1147 kAuthenticateInstrumentValidRequest, 1148 kAuthenticateInstrumentFailureResponse, 1149 3U); 1150 } 1151 1152 TEST_F(WalletClientTest, AuthenticateInstrumentFailedMalformedResponse) { 1153 EXPECT_CALL(delegate_, 1154 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1155 delegate_.ExpectLogWalletApiCallDuration( 1156 AutofillMetrics::AUTHENTICATE_INSTRUMENT, 1157 1); 1158 delegate_.ExpectBaselineMetrics(); 1159 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1160 1161 wallet_client_->AuthenticateInstrument("instrument_id", "123"); 1162 1163 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1164 kAuthenticateInstrumentValidRequest, 1165 kSaveInvalidResponse, 1166 3U); 1167 } 1168 1169 // TODO(ahutter): Add failure tests for GetWalletItems. 1170 1171 TEST_F(WalletClientTest, GetWalletItems) { 1172 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_WALLET_ITEMS, 1173 1); 1174 delegate_.ExpectBaselineMetrics(); 1175 1176 wallet_client_->GetWalletItems(GURL(kMerchantUrl)); 1177 1178 VerifyAndFinishRequest(net::HTTP_OK, 1179 kGetWalletItemsValidRequest, 1180 kGetWalletItemsValidResponse); 1181 EXPECT_EQ(1U, delegate_.wallet_items_received()); 1182 } 1183 1184 TEST_F(WalletClientTest, GetWalletItemsRespectsDelegateForShippingRequired) { 1185 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_WALLET_ITEMS, 1186 1); 1187 delegate_.ExpectBaselineMetrics(); 1188 delegate_.SetIsShippingAddressRequired(false); 1189 1190 wallet_client_->GetWalletItems(GURL(kMerchantUrl)); 1191 1192 VerifyAndFinishRequest(net::HTTP_OK, 1193 kGetWalletItemsNoShippingRequest, 1194 kGetWalletItemsValidResponse); 1195 EXPECT_EQ(1U, delegate_.wallet_items_received()); 1196 } 1197 1198 TEST_F(WalletClientTest, SaveAddressSucceeded) { 1199 EXPECT_CALL(delegate_, 1200 OnDidSaveToWallet(std::string(), 1201 "saved_address_id", 1202 std::vector<RequiredAction>(), 1203 std::vector<FormFieldError>())).Times(1); 1204 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1205 delegate_.ExpectBaselineMetrics(); 1206 1207 scoped_ptr<Address> address = GetTestSaveableAddress(); 1208 wallet_client_->SaveToWallet(scoped_ptr<Instrument>(), 1209 address.Pass(), 1210 GURL(kMerchantUrl)); 1211 VerifyAndFinishRequest(net::HTTP_OK, 1212 kSaveAddressValidRequest, 1213 kSaveAddressValidResponse); 1214 } 1215 1216 TEST_F(WalletClientTest, SaveAddressWithRequiredActionsSucceeded) { 1217 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1218 delegate_.ExpectBaselineMetrics(); 1219 delegate_.ExpectWalletRequiredActionMetric( 1220 AutofillMetrics::REQUIRE_PHONE_NUMBER); 1221 delegate_.ExpectWalletRequiredActionMetric( 1222 AutofillMetrics::INVALID_FORM_FIELD); 1223 1224 std::vector<RequiredAction> required_actions; 1225 required_actions.push_back(REQUIRE_PHONE_NUMBER); 1226 required_actions.push_back(INVALID_FORM_FIELD); 1227 1228 std::vector<FormFieldError> form_errors; 1229 form_errors.push_back(FormFieldError(FormFieldError::INVALID_POSTAL_CODE, 1230 FormFieldError::SHIPPING_ADDRESS)); 1231 1232 EXPECT_CALL(delegate_, 1233 OnDidSaveToWallet(std::string(), 1234 std::string(), 1235 required_actions, 1236 form_errors)).Times(1); 1237 1238 scoped_ptr<Address> address = GetTestSaveableAddress(); 1239 wallet_client_->SaveToWallet(scoped_ptr<Instrument>(), 1240 address.Pass(), 1241 GURL(kMerchantUrl)); 1242 VerifyAndFinishRequest(net::HTTP_OK, 1243 kSaveAddressValidRequest, 1244 kSaveAddressWithRequiredActionsValidResponse); 1245 } 1246 1247 TEST_F(WalletClientTest, SaveAddressFailedInvalidRequiredAction) { 1248 EXPECT_CALL(delegate_, 1249 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1250 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1251 delegate_.ExpectBaselineMetrics(); 1252 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1253 1254 scoped_ptr<Address> address = GetTestSaveableAddress(); 1255 wallet_client_->SaveToWallet(scoped_ptr<Instrument>(), 1256 address.Pass(), 1257 GURL(kMerchantUrl)); 1258 VerifyAndFinishRequest(net::HTTP_OK, 1259 kSaveAddressValidRequest, 1260 kSaveWithInvalidRequiredActionsResponse); 1261 } 1262 1263 TEST_F(WalletClientTest, SaveAddressFailedMalformedResponse) { 1264 EXPECT_CALL(delegate_, 1265 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1266 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1267 delegate_.ExpectBaselineMetrics(); 1268 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1269 1270 scoped_ptr<Address> address = GetTestSaveableAddress(); 1271 wallet_client_->SaveToWallet(scoped_ptr<Instrument>(), 1272 address.Pass(), 1273 GURL(kMerchantUrl)); 1274 VerifyAndFinishRequest(net::HTTP_OK, 1275 kSaveAddressValidRequest, 1276 kSaveInvalidResponse); 1277 } 1278 1279 TEST_F(WalletClientTest, SaveInstrumentSucceeded) { 1280 EXPECT_CALL(delegate_, 1281 OnDidSaveToWallet("instrument_id", 1282 std::string(), 1283 std::vector<RequiredAction>(), 1284 std::vector<FormFieldError>())).Times(1); 1285 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1286 delegate_.ExpectBaselineMetrics(); 1287 1288 scoped_ptr<Instrument> instrument = GetTestInstrument(); 1289 wallet_client_->SaveToWallet(instrument.Pass(), 1290 scoped_ptr<Address>(), 1291 GURL(kMerchantUrl)); 1292 1293 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1294 kSaveInstrumentValidRequest, 1295 kSaveInstrumentValidResponse, 1296 4U); 1297 } 1298 1299 TEST_F(WalletClientTest, SaveInstrumentWithRequiredActionsSucceeded) { 1300 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1301 delegate_.ExpectBaselineMetrics(); 1302 delegate_.ExpectWalletRequiredActionMetric( 1303 AutofillMetrics::REQUIRE_PHONE_NUMBER); 1304 delegate_.ExpectWalletRequiredActionMetric( 1305 AutofillMetrics::INVALID_FORM_FIELD); 1306 1307 std::vector<RequiredAction> required_actions; 1308 required_actions.push_back(REQUIRE_PHONE_NUMBER); 1309 required_actions.push_back(INVALID_FORM_FIELD); 1310 1311 std::vector<FormFieldError> form_errors; 1312 form_errors.push_back(FormFieldError(FormFieldError::INVALID_POSTAL_CODE, 1313 FormFieldError::SHIPPING_ADDRESS)); 1314 1315 EXPECT_CALL(delegate_, 1316 OnDidSaveToWallet(std::string(), 1317 std::string(), 1318 required_actions, 1319 form_errors)).Times(1); 1320 1321 scoped_ptr<Instrument> instrument = GetTestInstrument(); 1322 wallet_client_->SaveToWallet(instrument.Pass(), 1323 scoped_ptr<Address>(), 1324 GURL(kMerchantUrl)); 1325 1326 VerifyAndFinishFormEncodedRequest( 1327 net::HTTP_OK, 1328 kSaveInstrumentValidRequest, 1329 kSaveInstrumentWithRequiredActionsValidResponse, 1330 4U); 1331 } 1332 1333 TEST_F(WalletClientTest, SaveInstrumentFailedInvalidRequiredActions) { 1334 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1335 delegate_.ExpectBaselineMetrics(); 1336 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1337 1338 EXPECT_CALL(delegate_, 1339 OnWalletError(WalletClient::MALFORMED_RESPONSE)); 1340 1341 scoped_ptr<Instrument> instrument = GetTestInstrument(); 1342 wallet_client_->SaveToWallet(instrument.Pass(), 1343 scoped_ptr<Address>(), 1344 GURL(kMerchantUrl)); 1345 1346 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1347 kSaveInstrumentValidRequest, 1348 kSaveWithInvalidRequiredActionsResponse, 1349 4U); 1350 } 1351 1352 TEST_F(WalletClientTest, SaveInstrumentFailedMalformedResponse) { 1353 EXPECT_CALL(delegate_, 1354 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1355 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1356 delegate_.ExpectBaselineMetrics(); 1357 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1358 1359 scoped_ptr<Instrument> instrument = GetTestInstrument(); 1360 wallet_client_->SaveToWallet(instrument.Pass(), 1361 scoped_ptr<Address>(), 1362 GURL(kMerchantUrl)); 1363 1364 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1365 kSaveInstrumentValidRequest, 1366 kSaveInvalidResponse, 1367 4U); 1368 } 1369 1370 TEST_F(WalletClientTest, SaveInstrumentAndAddressSucceeded) { 1371 EXPECT_CALL(delegate_, 1372 OnDidSaveToWallet("saved_instrument_id", 1373 "saved_address_id", 1374 std::vector<RequiredAction>(), 1375 std::vector<FormFieldError>())).Times(1); 1376 delegate_.ExpectLogWalletApiCallDuration( 1377 AutofillMetrics::SAVE_TO_WALLET, 1378 1); 1379 delegate_.ExpectBaselineMetrics(); 1380 1381 scoped_ptr<Instrument> instrument = GetTestInstrument(); 1382 scoped_ptr<Address> address = GetTestSaveableAddress(); 1383 wallet_client_->SaveToWallet(instrument.Pass(), 1384 address.Pass(), 1385 GURL(kMerchantUrl)); 1386 1387 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1388 kSaveInstrumentAndAddressValidRequest, 1389 kSaveInstrumentAndAddressValidResponse, 1390 4U); 1391 } 1392 1393 TEST_F(WalletClientTest, SaveInstrumentAndAddressWithRequiredActionsSucceeded) { 1394 delegate_.ExpectLogWalletApiCallDuration( 1395 AutofillMetrics::SAVE_TO_WALLET, 1396 1); 1397 delegate_.ExpectBaselineMetrics(); 1398 delegate_.ExpectWalletRequiredActionMetric( 1399 AutofillMetrics::REQUIRE_PHONE_NUMBER); 1400 delegate_.ExpectWalletRequiredActionMetric( 1401 AutofillMetrics::INVALID_FORM_FIELD); 1402 1403 std::vector<RequiredAction> required_actions; 1404 required_actions.push_back(REQUIRE_PHONE_NUMBER); 1405 required_actions.push_back(INVALID_FORM_FIELD); 1406 1407 std::vector<FormFieldError> form_errors; 1408 form_errors.push_back(FormFieldError(FormFieldError::INVALID_POSTAL_CODE, 1409 FormFieldError::SHIPPING_ADDRESS)); 1410 1411 EXPECT_CALL(delegate_, 1412 OnDidSaveToWallet(std::string(), 1413 std::string(), 1414 required_actions, 1415 form_errors)).Times(1); 1416 1417 scoped_ptr<Instrument> instrument = GetTestInstrument(); 1418 scoped_ptr<Address> address = GetTestSaveableAddress(); 1419 wallet_client_->SaveToWallet(instrument.Pass(), 1420 address.Pass(), 1421 GURL(kMerchantUrl)); 1422 1423 VerifyAndFinishFormEncodedRequest( 1424 net::HTTP_OK, 1425 kSaveInstrumentAndAddressValidRequest, 1426 kSaveInstrumentAndAddressWithRequiredActionsValidResponse, 1427 4U); 1428 } 1429 1430 TEST_F(WalletClientTest, SaveInstrumentAndAddressFailedInvalidRequiredAction) { 1431 EXPECT_CALL(delegate_, 1432 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1433 delegate_.ExpectLogWalletApiCallDuration( 1434 AutofillMetrics::SAVE_TO_WALLET, 1435 1); 1436 delegate_.ExpectBaselineMetrics(); 1437 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1438 1439 scoped_ptr<Instrument> instrument = GetTestInstrument(); 1440 scoped_ptr<Address> address = GetTestSaveableAddress(); 1441 wallet_client_->SaveToWallet(instrument.Pass(), 1442 address.Pass(), 1443 GURL(kMerchantUrl)); 1444 1445 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1446 kSaveInstrumentAndAddressValidRequest, 1447 kSaveWithInvalidRequiredActionsResponse, 1448 4U); 1449 } 1450 1451 TEST_F(WalletClientTest, UpdateAddressSucceeded) { 1452 EXPECT_CALL(delegate_, 1453 OnDidSaveToWallet(std::string(), 1454 "shipping_address_id", 1455 std::vector<RequiredAction>(), 1456 std::vector<FormFieldError>())).Times(1); 1457 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1458 delegate_.ExpectBaselineMetrics(); 1459 1460 scoped_ptr<Address> address = GetTestShippingAddress(); 1461 address->set_object_id("shipping_address_id"); 1462 1463 wallet_client_->SaveToWallet(scoped_ptr<Instrument>(), 1464 address.Pass(), 1465 GURL(kMerchantUrl)); 1466 VerifyAndFinishRequest(net::HTTP_OK, 1467 kUpdateAddressValidRequest, 1468 kUpdateAddressValidResponse); 1469 } 1470 1471 TEST_F(WalletClientTest, UpdateAddressWithRequiredActionsSucceeded) { 1472 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1473 delegate_.ExpectBaselineMetrics(); 1474 delegate_.ExpectWalletRequiredActionMetric( 1475 AutofillMetrics::REQUIRE_PHONE_NUMBER); 1476 delegate_.ExpectWalletRequiredActionMetric( 1477 AutofillMetrics::INVALID_FORM_FIELD); 1478 1479 std::vector<RequiredAction> required_actions; 1480 required_actions.push_back(REQUIRE_PHONE_NUMBER); 1481 required_actions.push_back(INVALID_FORM_FIELD); 1482 1483 std::vector<FormFieldError> form_errors; 1484 form_errors.push_back(FormFieldError(FormFieldError::INVALID_POSTAL_CODE, 1485 FormFieldError::SHIPPING_ADDRESS)); 1486 1487 EXPECT_CALL(delegate_, OnDidSaveToWallet(std::string(), 1488 std::string(), 1489 required_actions, 1490 form_errors)).Times(1); 1491 1492 scoped_ptr<Address> address = GetTestShippingAddress(); 1493 address->set_object_id("shipping_address_id"); 1494 1495 wallet_client_->SaveToWallet(scoped_ptr<Instrument>(), 1496 address.Pass(), 1497 GURL(kMerchantUrl)); 1498 VerifyAndFinishRequest(net::HTTP_OK, 1499 kUpdateAddressValidRequest, 1500 kUpdateWithRequiredActionsValidResponse); 1501 } 1502 1503 TEST_F(WalletClientTest, UpdateAddressFailedInvalidRequiredAction) { 1504 EXPECT_CALL(delegate_, 1505 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1506 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1507 delegate_.ExpectBaselineMetrics(); 1508 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1509 1510 scoped_ptr<Address> address = GetTestShippingAddress(); 1511 address->set_object_id("shipping_address_id"); 1512 1513 wallet_client_->SaveToWallet(scoped_ptr<Instrument>(), 1514 address.Pass(), 1515 GURL(kMerchantUrl)); 1516 VerifyAndFinishRequest(net::HTTP_OK, 1517 kUpdateAddressValidRequest, 1518 kSaveWithInvalidRequiredActionsResponse); 1519 } 1520 1521 TEST_F(WalletClientTest, UpdateAddressMalformedResponse) { 1522 EXPECT_CALL(delegate_, 1523 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1524 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1); 1525 delegate_.ExpectBaselineMetrics(); 1526 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1527 1528 scoped_ptr<Address> address = GetTestShippingAddress(); 1529 address->set_object_id("shipping_address_id"); 1530 1531 wallet_client_->SaveToWallet(scoped_ptr<Instrument>(), 1532 address.Pass(), 1533 GURL(kMerchantUrl)); 1534 VerifyAndFinishRequest(net::HTTP_OK, 1535 kUpdateAddressValidRequest, 1536 kUpdateMalformedResponse); 1537 } 1538 1539 TEST_F(WalletClientTest, UpdateInstrumentAddressSucceeded) { 1540 EXPECT_CALL(delegate_, 1541 OnDidSaveToWallet("instrument_id", 1542 std::string(), 1543 std::vector<RequiredAction>(), 1544 std::vector<FormFieldError>())).Times(1); 1545 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1546 1); 1547 delegate_.ExpectBaselineMetrics(); 1548 1549 wallet_client_->SaveToWallet(GetTestAddressUpgradeInstrument(), 1550 scoped_ptr<Address>(), 1551 GURL(kMerchantUrl)); 1552 1553 VerifyAndFinishRequest(net::HTTP_OK, 1554 kUpdateInstrumentAddressValidRequest, 1555 kUpdateInstrumentValidResponse); 1556 } 1557 1558 TEST_F(WalletClientTest, UpdateInstrumentExpirationDateSuceeded) { 1559 EXPECT_CALL(delegate_, 1560 OnDidSaveToWallet("instrument_id", 1561 std::string(), 1562 std::vector<RequiredAction>(), 1563 std::vector<FormFieldError>())).Times(1); 1564 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1565 1); 1566 delegate_.ExpectBaselineMetrics(); 1567 1568 wallet_client_->SaveToWallet(GetTestExpirationDateChangeInstrument(), 1569 scoped_ptr<Address>(), 1570 GURL(kMerchantUrl)); 1571 1572 VerifyAndFinishFormEncodedRequest(net::HTTP_OK, 1573 kUpdateInstrumentExpirationDateValidRequest, 1574 kUpdateInstrumentValidResponse, 1575 3U); 1576 } 1577 1578 TEST_F(WalletClientTest, UpdateInstrumentAddressWithNameChangeSucceeded) { 1579 EXPECT_CALL(delegate_, 1580 OnDidSaveToWallet("instrument_id", 1581 std::string(), 1582 std::vector<RequiredAction>(), 1583 std::vector<FormFieldError>())).Times(1); 1584 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1585 1); 1586 delegate_.ExpectBaselineMetrics(); 1587 1588 wallet_client_->SaveToWallet(GetTestAddressNameChangeInstrument(), 1589 scoped_ptr<Address>(), 1590 GURL(kMerchantUrl)); 1591 1592 VerifyAndFinishFormEncodedRequest( 1593 net::HTTP_OK, 1594 kUpdateInstrumentAddressWithNameChangeValidRequest, 1595 kUpdateInstrumentValidResponse, 1596 3U); 1597 } 1598 1599 TEST_F(WalletClientTest, UpdateInstrumentWithRequiredActionsSucceeded) { 1600 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1601 1); 1602 delegate_.ExpectBaselineMetrics(); 1603 delegate_.ExpectWalletRequiredActionMetric( 1604 AutofillMetrics::REQUIRE_PHONE_NUMBER); 1605 delegate_.ExpectWalletRequiredActionMetric( 1606 AutofillMetrics::INVALID_FORM_FIELD); 1607 1608 std::vector<RequiredAction> required_actions; 1609 required_actions.push_back(REQUIRE_PHONE_NUMBER); 1610 required_actions.push_back(INVALID_FORM_FIELD); 1611 1612 std::vector<FormFieldError> form_errors; 1613 form_errors.push_back(FormFieldError(FormFieldError::INVALID_POSTAL_CODE, 1614 FormFieldError::SHIPPING_ADDRESS)); 1615 1616 EXPECT_CALL(delegate_, 1617 OnDidSaveToWallet(std::string(), 1618 std::string(), 1619 required_actions, 1620 form_errors)).Times(1); 1621 1622 wallet_client_->SaveToWallet(GetTestAddressUpgradeInstrument(), 1623 scoped_ptr<Address>(), 1624 GURL(kMerchantUrl)); 1625 1626 VerifyAndFinishRequest(net::HTTP_OK, 1627 kUpdateInstrumentAddressValidRequest, 1628 kUpdateWithRequiredActionsValidResponse); 1629 } 1630 1631 TEST_F(WalletClientTest, UpdateInstrumentFailedInvalidRequiredAction) { 1632 EXPECT_CALL(delegate_, 1633 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1634 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1635 1); 1636 delegate_.ExpectBaselineMetrics(); 1637 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1638 1639 wallet_client_->SaveToWallet(GetTestAddressUpgradeInstrument(), 1640 scoped_ptr<Address>(), 1641 GURL(kMerchantUrl)); 1642 1643 VerifyAndFinishRequest(net::HTTP_OK, 1644 kUpdateInstrumentAddressValidRequest, 1645 kSaveWithInvalidRequiredActionsResponse); 1646 } 1647 1648 TEST_F(WalletClientTest, UpdateInstrumentMalformedResponse) { 1649 EXPECT_CALL(delegate_, 1650 OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1); 1651 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1652 1); 1653 delegate_.ExpectBaselineMetrics(); 1654 delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE); 1655 1656 wallet_client_->SaveToWallet(GetTestAddressUpgradeInstrument(), 1657 scoped_ptr<Address>(), 1658 GURL(kMerchantUrl)); 1659 1660 VerifyAndFinishRequest(net::HTTP_OK, 1661 kUpdateInstrumentAddressValidRequest, 1662 kUpdateMalformedResponse); 1663 } 1664 1665 TEST_F(WalletClientTest, SendAutocheckoutOfStatusSuccess) { 1666 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SEND_STATUS, 1); 1667 delegate_.ExpectBaselineMetrics(); 1668 1669 AutocheckoutStatistic statistic; 1670 statistic.page_number = 1; 1671 statistic.steps.push_back(AUTOCHECKOUT_STEP_SHIPPING); 1672 statistic.time_taken = base::TimeDelta::FromMilliseconds(100); 1673 std::vector<AutocheckoutStatistic> statistics; 1674 statistics.push_back(statistic); 1675 wallet_client_->SendAutocheckoutStatus(autofill::SUCCESS, 1676 GURL(kMerchantUrl), 1677 statistics, 1678 "google_transaction_id"); 1679 VerifyAndFinishRequest(net::HTTP_OK, 1680 kSendAutocheckoutStatusWithStatisticsValidRequest, 1681 ")]}"); // Invalid JSON. Should be ignored. 1682 } 1683 1684 TEST_F(WalletClientTest, SendAutocheckoutStatusOfFailure) { 1685 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SEND_STATUS, 1); 1686 delegate_.ExpectBaselineMetrics(); 1687 1688 std::vector<AutocheckoutStatistic> statistics; 1689 wallet_client_->SendAutocheckoutStatus(autofill::CANNOT_PROCEED, 1690 GURL(kMerchantUrl), 1691 statistics, 1692 "google_transaction_id"); 1693 VerifyAndFinishRequest(net::HTTP_OK, 1694 kSendAutocheckoutStatusOfFailureValidRequest, 1695 ")]}"); // Invalid JSON. Should be ignored. 1696 } 1697 1698 TEST_F(WalletClientTest, HasRequestInProgress) { 1699 EXPECT_FALSE(wallet_client_->HasRequestInProgress()); 1700 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_WALLET_ITEMS, 1701 1); 1702 delegate_.ExpectBaselineMetrics(); 1703 1704 wallet_client_->GetWalletItems(GURL(kMerchantUrl)); 1705 EXPECT_TRUE(wallet_client_->HasRequestInProgress()); 1706 1707 VerifyAndFinishRequest(net::HTTP_OK, 1708 kGetWalletItemsValidRequest, 1709 kGetWalletItemsValidResponse); 1710 EXPECT_FALSE(wallet_client_->HasRequestInProgress()); 1711 } 1712 1713 TEST_F(WalletClientTest, PendingRequest) { 1714 EXPECT_EQ(0U, wallet_client_->pending_requests_.size()); 1715 1716 // Shouldn't queue the first request. 1717 delegate_.ExpectBaselineMetrics(); 1718 wallet_client_->GetWalletItems(GURL(kMerchantUrl)); 1719 EXPECT_EQ(0U, wallet_client_->pending_requests_.size()); 1720 testing::Mock::VerifyAndClear(delegate_.metric_logger()); 1721 1722 wallet_client_->GetWalletItems(GURL(kMerchantUrl)); 1723 EXPECT_EQ(1U, wallet_client_->pending_requests_.size()); 1724 1725 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_WALLET_ITEMS, 1726 1); 1727 delegate_.ExpectBaselineMetrics(); 1728 VerifyAndFinishRequest(net::HTTP_OK, 1729 kGetWalletItemsValidRequest, 1730 kGetWalletItemsValidResponse); 1731 EXPECT_EQ(0U, wallet_client_->pending_requests_.size()); 1732 testing::Mock::VerifyAndClear(delegate_.metric_logger()); 1733 1734 EXPECT_CALL(delegate_, OnWalletError( 1735 WalletClient::SERVICE_UNAVAILABLE)).Times(1); 1736 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_WALLET_ITEMS, 1737 1); 1738 delegate_.ExpectWalletErrorMetric( 1739 AutofillMetrics::WALLET_SERVICE_UNAVAILABLE); 1740 1741 // Finish the second request. 1742 VerifyAndFinishRequest(net::HTTP_INTERNAL_SERVER_ERROR, 1743 kGetWalletItemsValidRequest, 1744 kErrorResponse); 1745 } 1746 1747 TEST_F(WalletClientTest, CancelRequests) { 1748 ASSERT_EQ(0U, wallet_client_->pending_requests_.size()); 1749 delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_WALLET_ITEMS, 1750 0); 1751 delegate_.ExpectBaselineMetrics(); 1752 1753 wallet_client_->GetWalletItems(GURL(kMerchantUrl)); 1754 wallet_client_->GetWalletItems(GURL(kMerchantUrl)); 1755 wallet_client_->GetWalletItems(GURL(kMerchantUrl)); 1756 EXPECT_EQ(2U, wallet_client_->pending_requests_.size()); 1757 1758 wallet_client_->CancelRequests(); 1759 EXPECT_EQ(0U, wallet_client_->pending_requests_.size()); 1760 EXPECT_FALSE(wallet_client_->HasRequestInProgress()); 1761 } 1762 1763 } // namespace wallet 1764 } // namespace autofill 1765
