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