| // Copyright 2017 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ios/chrome/browser/payments/payment_request.h" |
| |
| #include <memory> |
| |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/test/scoped_task_environment.h" |
| #include "components/autofill/core/browser/autofill_test_utils.h" |
| #include "components/autofill/core/browser/autofill_type.h" |
| #include "components/autofill/core/browser/field_types.h" |
| #include "components/autofill/core/browser/test_personal_data_manager.h" |
| #include "components/payments/core/autofill_payment_instrument.h" |
| #include "components/payments/core/currency_formatter.h" |
| #include "components/payments/core/features.h" |
| #include "components/payments/core/payment_details.h" |
| #include "components/payments/core/payment_method_data.h" |
| #include "components/payments/core/payment_options.h" |
| #include "components/payments/core/payment_shipping_option.h" |
| #include "components/payments/core/payments_profile_comparator.h" |
| #include "components/payments/core/web_payment_request.h" |
| #include "ios/chrome/browser/application_context.h" |
| #include "ios/chrome/browser/browser_state/test_chrome_browser_state.h" |
| #include "ios/chrome/browser/payments/payment_request_test_util.h" |
| #include "ios/chrome/browser/payments/test_payment_request.h" |
| #import "ios/web/public/test/fakes/test_web_state.h" |
| #include "testing/gmock/include/gmock/gmock-matchers.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "testing/platform_test.h" |
| |
| #if !defined(__has_feature) || !__has_feature(objc_arc) |
| #error "This file requires ARC support." |
| #endif |
| |
| namespace { |
| using ::testing::_; |
| |
| class MockTestPersonalDataManager : public autofill::TestPersonalDataManager { |
| public: |
| MockTestPersonalDataManager() : TestPersonalDataManager() { |
| SetAutofillProfileEnabled(true); |
| SetAutofillCreditCardEnabled(true); |
| SetAutofillWalletImportEnabled(true); |
| } |
| |
| MOCK_METHOD1(RecordUseOf, void(const autofill::AutofillDataModel&)); |
| MOCK_METHOD1(UpdateCreditCard, void(const autofill::CreditCard&)); |
| MOCK_METHOD1(UpdateServerCardMetadata, void(const autofill::CreditCard&)); |
| MOCK_METHOD1(UpdateProfile, void(const autofill::AutofillProfile&)); |
| }; |
| |
| class MockPaymentsProfileComparator |
| : public payments::PaymentsProfileComparator { |
| public: |
| MockPaymentsProfileComparator(const std::string& app_locale, |
| const payments::PaymentOptionsProvider& options) |
| : PaymentsProfileComparator(app_locale, options) {} |
| MOCK_METHOD1(Invalidate, void(const autofill::AutofillProfile&)); |
| }; |
| |
| MATCHER_P(GuidMatches, guid, "") { |
| return arg.guid() == guid; |
| } |
| } // namespace |
| |
| namespace payments { |
| |
| class PaymentRequestTest : public PlatformTest { |
| protected: |
| PaymentRequestTest() |
| : chrome_browser_state_(TestChromeBrowserState::Builder().Build()) { |
| test_personal_data_manager_.SetAutofillProfileEnabled(true); |
| test_personal_data_manager_.SetAutofillCreditCardEnabled(true); |
| test_personal_data_manager_.SetAutofillWalletImportEnabled(true); |
| } |
| |
| // Returns PaymentDetails with one shipping option that's selected. |
| PaymentDetails CreateDetailsWithShippingOption() { |
| PaymentDetails details; |
| std::vector<PaymentShippingOption> shipping_options; |
| PaymentShippingOption option1; |
| option1.id = "option:1"; |
| option1.selected = true; |
| shipping_options.push_back(std::move(option1)); |
| details.shipping_options = std::move(shipping_options); |
| |
| return details; |
| } |
| |
| PaymentOptions CreatePaymentOptions(bool request_payer_name, |
| bool request_payer_phone, |
| bool request_payer_email, |
| bool request_shipping) { |
| PaymentOptions options; |
| options.request_payer_name = request_payer_name; |
| options.request_payer_phone = request_payer_phone; |
| options.request_payer_email = request_payer_email; |
| options.request_shipping = request_shipping; |
| return options; |
| } |
| |
| base::test::ScopedTaskEnvironment scoped_task_environment_; |
| |
| autofill::TestPersonalDataManager test_personal_data_manager_; |
| web::TestWebState web_state_; |
| std::unique_ptr<TestChromeBrowserState> chrome_browser_state_; |
| }; |
| |
| // Tests that the CurrencyFormatter is constructed with the correct |
| // currency code and currency system. |
| TEST_F(PaymentRequestTest, CreatesCurrencyFormatterCorrectly) { |
| WebPaymentRequest web_payment_request; |
| |
| web_payment_request.details.total = std::make_unique<PaymentItem>(); |
| web_payment_request.details.total->amount->currency = "USD"; |
| TestPaymentRequest payment_request1(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| ASSERT_EQ("en", payment_request1.GetApplicationLocale()); |
| CurrencyFormatter* currency_formatter = |
| payment_request1.GetOrCreateCurrencyFormatter(); |
| EXPECT_EQ(base::UTF8ToUTF16("$55.00"), currency_formatter->Format("55.00")); |
| EXPECT_EQ("USD", currency_formatter->formatted_currency_code()); |
| |
| web_payment_request.details.total->amount->currency = "JPY"; |
| TestPaymentRequest payment_request2(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| ASSERT_EQ("en", payment_request2.GetApplicationLocale()); |
| currency_formatter = payment_request2.GetOrCreateCurrencyFormatter(); |
| EXPECT_EQ(base::UTF8ToUTF16("¥55"), currency_formatter->Format("55.00")); |
| EXPECT_EQ("JPY", currency_formatter->formatted_currency_code()); |
| } |
| |
| // Tests that the accepted card networks are identified correctly. |
| TEST_F(PaymentRequestTest, AcceptedPaymentNetworks) { |
| WebPaymentRequest web_payment_request; |
| |
| PaymentMethodData method_datum1; |
| method_datum1.supported_method = "visa"; |
| web_payment_request.method_data.push_back(method_datum1); |
| PaymentMethodData method_datum2; |
| method_datum2.supported_method = "mastercard"; |
| web_payment_request.method_data.push_back(method_datum2); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| ASSERT_EQ(2U, payment_request.supported_card_networks().size()); |
| EXPECT_EQ("visa", payment_request.supported_card_networks()[0]); |
| EXPECT_EQ("mastercard", payment_request.supported_card_networks()[1]); |
| } |
| |
| // Test that parsing supported methods (with invalid values and duplicates) |
| // works as expected. |
| TEST_F(PaymentRequestTest, SupportedMethods) { |
| WebPaymentRequest web_payment_request; |
| |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitAndEnableFeature(features::kWebPaymentsNativeApps); |
| |
| PaymentMethodData method_datum1; |
| method_datum1.supported_method = "visa"; |
| PaymentMethodData method_datum2; |
| method_datum2.supported_method = "mastercard"; |
| PaymentMethodData method_datum3; |
| method_datum3.supported_method = "invalid"; |
| PaymentMethodData method_datum4; |
| method_datum4.supported_method = "visa"; |
| PaymentMethodData method_datum5; |
| method_datum5.supported_method = "https://bobpay.com"; |
| PaymentMethodData method_datum6; |
| method_datum6.supported_method = "http://invalidpay.com"; |
| web_payment_request.method_data.push_back(method_datum1); |
| web_payment_request.method_data.push_back(method_datum2); |
| web_payment_request.method_data.push_back(method_datum3); |
| web_payment_request.method_data.push_back(method_datum4); |
| web_payment_request.method_data.push_back(method_datum5); |
| web_payment_request.method_data.push_back(method_datum6); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| payment_request.ResetParsedPaymentMethodData(); |
| ASSERT_EQ(2U, payment_request.supported_card_networks().size()); |
| EXPECT_EQ("visa", payment_request.supported_card_networks()[0]); |
| EXPECT_EQ("mastercard", payment_request.supported_card_networks()[1]); |
| ASSERT_EQ(1U, payment_request.url_payment_method_identifiers().size()); |
| EXPECT_EQ(GURL("https://bobpay.com"), |
| payment_request.url_payment_method_identifiers()[0]); |
| } |
| |
| // Test that parsing supported methods in different method data entries (with |
| // invalid values and duplicates) works as expected. |
| TEST_F(PaymentRequestTest, SupportedMethods_MultipleEntries) { |
| WebPaymentRequest web_payment_request; |
| |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitAndEnableFeature(features::kWebPaymentsNativeApps); |
| |
| PaymentMethodData method_datum1; |
| method_datum1.supported_method = "visa"; |
| PaymentMethodData method_datum2; |
| method_datum2.supported_method = "https://bobpay.com"; |
| PaymentMethodData method_datum3; |
| method_datum3.supported_method = "mastercard"; |
| PaymentMethodData method_datum4; |
| method_datum4.supported_method = "http://invalidpay.com"; |
| PaymentMethodData method_datum5; |
| method_datum5.supported_method = "visa"; |
| PaymentMethodData method_datum6; |
| method_datum6.supported_method = "https://bobpay.com"; |
| web_payment_request.method_data.push_back(method_datum1); |
| web_payment_request.method_data.push_back(method_datum2); |
| web_payment_request.method_data.push_back(method_datum3); |
| web_payment_request.method_data.push_back(method_datum4); |
| web_payment_request.method_data.push_back(method_datum5); |
| web_payment_request.method_data.push_back(method_datum6); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| payment_request.ResetParsedPaymentMethodData(); |
| ASSERT_EQ(2U, payment_request.supported_card_networks().size()); |
| EXPECT_EQ("visa", payment_request.supported_card_networks()[0]); |
| EXPECT_EQ("mastercard", payment_request.supported_card_networks()[1]); |
| ASSERT_EQ(1U, payment_request.url_payment_method_identifiers().size()); |
| EXPECT_EQ(GURL("https://bobpay.com"), |
| payment_request.url_payment_method_identifiers()[0]); |
| } |
| |
| // Test that only specifying basic-card means that all are supported. |
| TEST_F(PaymentRequestTest, SupportedMethods_OnlyBasicCard) { |
| WebPaymentRequest web_payment_request; |
| |
| PaymentMethodData method_datum1; |
| method_datum1.supported_method = "basic-card"; |
| web_payment_request.method_data.push_back(method_datum1); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| |
| // All of the basic card networks are supported. |
| ASSERT_EQ(8U, payment_request.supported_card_networks().size()); |
| EXPECT_EQ("amex", payment_request.supported_card_networks()[0]); |
| EXPECT_EQ("diners", payment_request.supported_card_networks()[1]); |
| EXPECT_EQ("discover", payment_request.supported_card_networks()[2]); |
| EXPECT_EQ("jcb", payment_request.supported_card_networks()[3]); |
| EXPECT_EQ("mastercard", payment_request.supported_card_networks()[4]); |
| EXPECT_EQ("mir", payment_request.supported_card_networks()[5]); |
| EXPECT_EQ("unionpay", payment_request.supported_card_networks()[6]); |
| EXPECT_EQ("visa", payment_request.supported_card_networks()[7]); |
| |
| EXPECT_TRUE(payment_request.url_payment_method_identifiers().empty()); |
| } |
| |
| // Test that specifying a method AND basic-card means that all are supported, |
| // but with the method as first. |
| TEST_F(PaymentRequestTest, SupportedMethods_BasicCard_WithSpecificMethod) { |
| WebPaymentRequest web_payment_request; |
| |
| PaymentMethodData method_datum1; |
| method_datum1.supported_method = "jcb"; |
| PaymentMethodData method_datum2; |
| method_datum2.supported_method = "basic-card"; |
| web_payment_request.method_data.push_back(method_datum1); |
| web_payment_request.method_data.push_back(method_datum2); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| |
| // All of the basic card networks are supported, but JCB is first because it |
| // was specified first. |
| EXPECT_EQ(8u, payment_request.supported_card_networks().size()); |
| EXPECT_EQ("jcb", payment_request.supported_card_networks()[0]); |
| EXPECT_EQ("amex", payment_request.supported_card_networks()[1]); |
| EXPECT_EQ("diners", payment_request.supported_card_networks()[2]); |
| EXPECT_EQ("discover", payment_request.supported_card_networks()[3]); |
| EXPECT_EQ("mastercard", payment_request.supported_card_networks()[4]); |
| EXPECT_EQ("mir", payment_request.supported_card_networks()[5]); |
| EXPECT_EQ("unionpay", payment_request.supported_card_networks()[6]); |
| EXPECT_EQ("visa", payment_request.supported_card_networks()[7]); |
| } |
| |
| // Test that specifying basic-card with a supported network (with previous |
| // supported methods) will work as expected |
| TEST_F(PaymentRequestTest, SupportedMethods_BasicCard_Overlap) { |
| WebPaymentRequest web_payment_request; |
| |
| PaymentMethodData method_datum1; |
| method_datum1.supported_method = "mastercard"; |
| PaymentMethodData method_datum2; |
| method_datum2.supported_method = "visa"; |
| PaymentMethodData method_datum3; |
| method_datum3.supported_method = "basic-card"; |
| method_datum3.supported_networks.push_back("visa"); |
| method_datum3.supported_networks.push_back("mastercard"); |
| method_datum3.supported_networks.push_back("unionpay"); |
| web_payment_request.method_data.push_back(method_datum1); |
| web_payment_request.method_data.push_back(method_datum2); |
| web_payment_request.method_data.push_back(method_datum3); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| |
| EXPECT_EQ(3u, payment_request.supported_card_networks().size()); |
| EXPECT_EQ("mastercard", payment_request.supported_card_networks()[0]); |
| EXPECT_EQ("visa", payment_request.supported_card_networks()[1]); |
| EXPECT_EQ("unionpay", payment_request.supported_card_networks()[2]); |
| } |
| |
| // Test that specifying basic-card with supported networks after specifying |
| // some methods |
| TEST_F(PaymentRequestTest, SupportedMethods_BasicCard_WithSupportedNetworks) { |
| WebPaymentRequest web_payment_request; |
| |
| PaymentMethodData method_datum1; |
| method_datum1.supported_method = "basic-card"; |
| method_datum1.supported_networks.push_back("visa"); |
| method_datum1.supported_networks.push_back("unionpay"); |
| web_payment_request.method_data.push_back(method_datum1); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| |
| // Only the specified networks are supported. |
| EXPECT_EQ(2u, payment_request.supported_card_networks().size()); |
| EXPECT_EQ("visa", payment_request.supported_card_networks()[0]); |
| EXPECT_EQ("unionpay", payment_request.supported_card_networks()[1]); |
| } |
| |
| TEST_F(PaymentRequestTest, GooglePayCardsInBasicCard_Allowed) { |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitAndEnableFeature(features::kReturnGooglePayInBasicCard); |
| |
| WebPaymentRequest web_payment_request; |
| PaymentMethodData method_datum; |
| method_datum.supported_method = "basic-card"; |
| method_datum.supported_networks.push_back("mastercard"); |
| web_payment_request.method_data.push_back(method_datum); |
| |
| // Add a mastercard with billing address. |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| test_personal_data_manager_.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetMaskedServerCard(); |
| credit_card.set_card_type(autofill::CreditCard::CardType::CARD_TYPE_CREDIT); |
| credit_card.set_billing_address_id(address.guid()); |
| test_personal_data_manager_.AddServerCreditCard(credit_card); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| |
| // The card is available in the payment request, and added to the |
| // PersonalDataManager. |
| EXPECT_EQ(1U, payment_request.payment_methods().size()); |
| // The card is expected to have been added to the PersonalDataManager. |
| EXPECT_EQ(1U, test_personal_data_manager_.GetCreditCards().size()); |
| } |
| |
| TEST_F(PaymentRequestTest, GooglePayCardsInBasicCard_NotAllowed) { |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitAndDisableFeature(features::kReturnGooglePayInBasicCard); |
| |
| WebPaymentRequest web_payment_request; |
| PaymentMethodData method_datum; |
| method_datum.supported_method = "basic-card"; |
| method_datum.supported_networks.push_back("mastercard"); |
| web_payment_request.method_data.push_back(method_datum); |
| |
| // Add a mastercard with billing address. |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| test_personal_data_manager_.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetMaskedServerCard(); |
| credit_card.set_card_type(autofill::CreditCard::CardType::CARD_TYPE_CREDIT); |
| credit_card.set_billing_address_id(address.guid()); |
| test_personal_data_manager_.AddServerCreditCard(credit_card); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| |
| // The card is not available in the payment request, but added to the |
| // PersonalDataManager. |
| EXPECT_TRUE(payment_request.payment_methods().empty()); |
| // The card is expected to have been added to the PersonalDataManager. |
| EXPECT_EQ(1U, test_personal_data_manager_.GetCreditCards().size()); |
| } |
| |
| // Tests that an autofill payment instrumnt e.g., credit cards can be added |
| // to the list of available payment methods. |
| TEST_F(PaymentRequestTest, CreateAndAddAutofillPaymentInstrument) { |
| WebPaymentRequest web_payment_request; |
| PaymentMethodData method_datum; |
| method_datum.supported_method = "basic-card"; |
| method_datum.supported_networks.push_back("visa"); |
| web_payment_request.method_data.push_back(method_datum); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(0U, payment_request.payment_methods().size()); |
| |
| autofill::CreditCard credit_card_1 = autofill::test::GetCreditCard(); |
| AutofillPaymentInstrument* added_credit_card_1 = |
| payment_request.CreateAndAddAutofillPaymentInstrument(credit_card_1); |
| EXPECT_EQ(credit_card_1, *added_credit_card_1->credit_card()); |
| |
| EXPECT_EQ(1U, payment_request.payment_methods().size()); |
| // The card is expected to have been added to the PersonalDataManager. |
| EXPECT_EQ(1U, test_personal_data_manager_.GetCreditCards().size()); |
| } |
| |
| // Tests that an autofill payment instrumnt e.g., credit cards can be added |
| // to the list of available payment methods in incognito mode. |
| TEST_F(PaymentRequestTest, CreateAndAddAutofillPaymentInstrumentIncognito) { |
| WebPaymentRequest web_payment_request; |
| PaymentMethodData method_datum; |
| method_datum.supported_method = "basic-card"; |
| method_datum.supported_networks.push_back("visa"); |
| web_payment_request.method_data.push_back(method_datum); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(0U, payment_request.payment_methods().size()); |
| |
| payment_request.set_is_incognito(true); |
| |
| autofill::CreditCard credit_card_1 = autofill::test::GetCreditCard(); |
| AutofillPaymentInstrument* added_credit_card_1 = |
| payment_request.CreateAndAddAutofillPaymentInstrument(credit_card_1); |
| EXPECT_EQ(credit_card_1, *added_credit_card_1->credit_card()); |
| |
| EXPECT_EQ(1U, payment_request.payment_methods().size()); |
| // The card should not get added to the PersonalDataManager. |
| EXPECT_EQ(0U, test_personal_data_manager_.GetCreditCards().size()); |
| } |
| |
| // Tests updating local and server autofill payment instruments. |
| TEST_F(PaymentRequestTest, UpdateAutofillPaymentInstrument) { |
| WebPaymentRequest web_payment_request; |
| PaymentMethodData method_datum; |
| method_datum.supported_method = "basic-card"; |
| method_datum.supported_networks.push_back("visa"); |
| method_datum.supported_networks.push_back("amex"); |
| web_payment_request.method_data.push_back(method_datum); |
| |
| MockTestPersonalDataManager personal_data_manager; |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &personal_data_manager); |
| |
| // Credit card should get updated in Personal Data Manager. |
| EXPECT_CALL(personal_data_manager, UpdateCreditCard(_)).Times(1); |
| |
| autofill::CreditCard credit_card_1 = autofill::test::GetCreditCard(); |
| payment_request.UpdateAutofillPaymentInstrument(credit_card_1); |
| |
| // Only credit card's meta data should get updated in PersonalDataManager. |
| EXPECT_CALL(personal_data_manager, UpdateServerCardMetadata(_)).Times(1); |
| |
| autofill::CreditCard credit_card_2 = |
| autofill::test::GetMaskedServerCardAmex(); |
| payment_request.UpdateAutofillPaymentInstrument(credit_card_2); |
| } |
| |
| // Tests updating local and server autofill payment instruments in incognito |
| // mode. |
| TEST_F(PaymentRequestTest, UpdateAutofillPaymentInstrumentIncognito) { |
| WebPaymentRequest web_payment_request; |
| PaymentMethodData method_datum; |
| method_datum.supported_method = "basic-card"; |
| method_datum.supported_networks.push_back("visa"); |
| method_datum.supported_networks.push_back("amex"); |
| web_payment_request.method_data.push_back(method_datum); |
| |
| MockTestPersonalDataManager personal_data_manager; |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &personal_data_manager); |
| |
| payment_request.set_is_incognito(true); |
| |
| // Credit card should not get updated in Personal Data Manager. |
| EXPECT_CALL(personal_data_manager, UpdateCreditCard(_)).Times(0); |
| |
| autofill::CreditCard credit_card_1 = autofill::test::GetCreditCard(); |
| payment_request.UpdateAutofillPaymentInstrument(credit_card_1); |
| |
| // Only credit card's meta data should not get updated in PersonalDataManager. |
| EXPECT_CALL(personal_data_manager, UpdateServerCardMetadata(_)).Times(0); |
| |
| autofill::CreditCard credit_card_2 = |
| autofill::test::GetMaskedServerCardAmex(); |
| payment_request.UpdateAutofillPaymentInstrument(credit_card_2); |
| } |
| |
| // Tests that a profile can be added to the list of available profiles. |
| TEST_F(PaymentRequestTest, AddAutofillProfile) { |
| WebPaymentRequest web_payment_request; |
| web_payment_request.options = CreatePaymentOptions( |
| /*request_payer_name=*/true, /*request_payer_phone=*/true, |
| /*request_payer_email=*/true, /*request_shipping=*/true); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(0U, payment_request.shipping_profiles().size()); |
| EXPECT_EQ(0U, payment_request.contact_profiles().size()); |
| |
| autofill::AutofillProfile profile_1 = autofill::test::GetFullProfile(); |
| autofill::AutofillProfile* added_profile_1 = |
| payment_request.AddAutofillProfile(profile_1); |
| EXPECT_EQ(profile_1, *added_profile_1); |
| |
| EXPECT_EQ(1U, payment_request.shipping_profiles().size()); |
| EXPECT_EQ(1U, payment_request.contact_profiles().size()); |
| // The autofill profile should have been added to the PersonalDataManager. |
| EXPECT_EQ(1U, test_personal_data_manager_.GetProfiles().size()); |
| } |
| |
| // Tests that a profile can be added to the list of available profiles in |
| // incognito mode. |
| TEST_F(PaymentRequestTest, AddAutofillProfileIncognito) { |
| WebPaymentRequest web_payment_request; |
| web_payment_request.options = CreatePaymentOptions( |
| /*request_payer_name=*/true, /*request_payer_phone=*/true, |
| /*request_payer_email=*/true, /*request_shipping=*/true); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(0U, payment_request.shipping_profiles().size()); |
| EXPECT_EQ(0U, payment_request.contact_profiles().size()); |
| |
| payment_request.set_is_incognito(true); |
| |
| autofill::AutofillProfile profile_1 = autofill::test::GetFullProfile(); |
| autofill::AutofillProfile* added_profile_1 = |
| payment_request.AddAutofillProfile(profile_1); |
| EXPECT_EQ(profile_1, *added_profile_1); |
| |
| EXPECT_EQ(1U, payment_request.shipping_profiles().size()); |
| EXPECT_EQ(1U, payment_request.contact_profiles().size()); |
| // The autofill profile should not get added to the PersonalDataManager. |
| EXPECT_EQ(0U, test_personal_data_manager_.GetProfiles().size()); |
| } |
| |
| // Tests updating an autofill profile. |
| TEST_F(PaymentRequestTest, UpdateAutofillProfile) { |
| WebPaymentRequest web_payment_request; |
| web_payment_request.options = CreatePaymentOptions( |
| /*request_payer_name=*/true, /*request_payer_phone=*/true, |
| /*request_payer_email=*/true, /*request_shipping=*/true); |
| |
| MockTestPersonalDataManager personal_data_manager; |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &personal_data_manager); |
| |
| MockPaymentsProfileComparator profile_comparator( |
| payment_request.GetApplicationLocale(), payment_request); |
| payment_request.SetProfileComparator(&profile_comparator); |
| |
| // Profile should get updated in PersonalDataManager. |
| EXPECT_CALL(personal_data_manager, UpdateProfile(_)).Times(1); |
| |
| EXPECT_CALL(profile_comparator, Invalidate(_)).Times(1); |
| |
| autofill::AutofillProfile profile = autofill::test::GetFullProfile(); |
| payment_request.UpdateAutofillProfile(profile); |
| } |
| |
| // Tests updating an autofill profile in incognito mode. |
| TEST_F(PaymentRequestTest, UpdateAutofillProfileIncognito) { |
| WebPaymentRequest web_payment_request; |
| web_payment_request.options = CreatePaymentOptions( |
| /*request_payer_name=*/true, /*request_payer_phone=*/true, |
| /*request_payer_email=*/true, /*request_shipping=*/true); |
| |
| MockTestPersonalDataManager personal_data_manager; |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &personal_data_manager); |
| |
| payment_request.set_is_incognito(true); |
| |
| MockPaymentsProfileComparator profile_comparator( |
| payment_request.GetApplicationLocale(), payment_request); |
| payment_request.SetProfileComparator(&profile_comparator); |
| |
| // Profile should not get updated in PersonalDataManager. |
| EXPECT_CALL(personal_data_manager, UpdateProfile(_)).Times(0); |
| |
| EXPECT_CALL(profile_comparator, Invalidate(_)).Times(1); |
| |
| autofill::AutofillProfile profile = autofill::test::GetFullProfile(); |
| payment_request.UpdateAutofillProfile(profile); |
| } |
| |
| // Test that parsing shipping options works as expected. |
| TEST_F(PaymentRequestTest, SelectedShippingOptions) { |
| WebPaymentRequest web_payment_request; |
| |
| PaymentDetails details; |
| details.total = std::make_unique<PaymentItem>(); |
| std::vector<PaymentShippingOption> shipping_options; |
| PaymentShippingOption option1; |
| option1.id = "option:1"; |
| option1.selected = false; |
| shipping_options.push_back(std::move(option1)); |
| PaymentShippingOption option2; |
| option2.id = "option:2"; |
| option2.selected = true; |
| shipping_options.push_back(std::move(option2)); |
| PaymentShippingOption option3; |
| option3.id = "option:3"; |
| option3.selected = true; |
| shipping_options.push_back(std::move(option3)); |
| details.shipping_options = std::move(shipping_options); |
| web_payment_request.details = std::move(details); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| // The last one marked "selected" should be selected. |
| EXPECT_EQ("option:3", payment_request.selected_shipping_option()->id); |
| |
| // Simulate an update that no longer has any shipping options. There is no |
| // longer a selected shipping option. |
| PaymentDetails new_details; |
| payment_request.UpdatePaymentDetails(std::move(new_details)); |
| EXPECT_EQ(nullptr, payment_request.selected_shipping_option()); |
| } |
| |
| // Tests that updating the payment details updates the total amount. |
| TEST_F(PaymentRequestTest, UpdatePaymentDetailsNewTotal) { |
| WebPaymentRequest web_payment_request; |
| |
| PaymentDetails details; |
| details.total = std::make_unique<PaymentItem>(); |
| details.total->amount->value = "10.00"; |
| details.total->amount->currency = "USD"; |
| web_payment_request.details = std::move(details); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| |
| // Simulate an update with a new total amount. |
| PaymentDetails new_details; |
| new_details.total = std::make_unique<PaymentItem>(); |
| new_details.total->amount->value = "20.00"; |
| new_details.total->amount->currency = "CAD"; |
| payment_request.UpdatePaymentDetails(std::move(new_details)); |
| EXPECT_EQ("20.00", payment_request.payment_details().total->amount->value); |
| EXPECT_EQ("CAD", payment_request.payment_details().total->amount->currency); |
| } |
| |
| // Tests that updating the payment details with a PaymentDetails instance that |
| // is missing the total amount, maintains the old total amount. |
| TEST_F(PaymentRequestTest, UpdatePaymentDetailsNoTotal) { |
| WebPaymentRequest web_payment_request; |
| |
| PaymentDetails details; |
| details.total = std::make_unique<PaymentItem>(); |
| details.total->amount->value = "10.00"; |
| details.total->amount->currency = "USD"; |
| web_payment_request.details = std::move(details); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| |
| // Simulate an update with the total amount missing. |
| PaymentDetails new_details; |
| payment_request.UpdatePaymentDetails(std::move(new_details)); |
| EXPECT_EQ("10.00", payment_request.payment_details().total->amount->value); |
| EXPECT_EQ("USD", payment_request.payment_details().total->amount->currency); |
| } |
| |
| // Test that loading profiles when none are available works as expected. |
| TEST_F(PaymentRequestTest, SelectedProfiles_NoProfiles) { |
| WebPaymentRequest web_payment_request; |
| web_payment_request.details = CreateDetailsWithShippingOption(); |
| web_payment_request.options = CreatePaymentOptions( |
| /*request_payer_name=*/true, /*request_payer_phone=*/true, |
| /*request_payer_email=*/true, /*request_shipping=*/true); |
| |
| // No profiles are selected because none are available! |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(nullptr, payment_request.selected_shipping_profile()); |
| EXPECT_EQ(nullptr, payment_request.selected_contact_profile()); |
| } |
| |
| // Test that loading complete shipping and contact profiles works as expected. |
| TEST_F(PaymentRequestTest, SelectedProfiles_Complete) { |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| address.set_use_count(5U); |
| test_personal_data_manager_.AddProfile(address); |
| autofill::AutofillProfile address2 = autofill::test::GetFullProfile2(); |
| address2.set_use_count(15U); |
| test_personal_data_manager_.AddProfile(address2); |
| |
| WebPaymentRequest web_payment_request; |
| web_payment_request.details = CreateDetailsWithShippingOption(); |
| web_payment_request.options = CreatePaymentOptions( |
| /*request_payer_name=*/true, /*request_payer_phone=*/true, |
| /*request_payer_email=*/true, /*request_shipping=*/true); |
| |
| // address2 is selected because it has the most use count (Frecency model). |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(address2.guid(), |
| payment_request.selected_shipping_profile()->guid()); |
| EXPECT_EQ(address2.guid(), |
| payment_request.selected_contact_profile()->guid()); |
| } |
| |
| // Test that loading complete shipping and contact profiles, when there are no |
| // shipping options available, works as expected. |
| TEST_F(PaymentRequestTest, SelectedProfiles_Complete_NoShippingOption) { |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| address.set_use_count(5U); |
| test_personal_data_manager_.AddProfile(address); |
| |
| WebPaymentRequest web_payment_request; |
| // No shipping options. |
| web_payment_request.details = PaymentDetails(); |
| web_payment_request.options = CreatePaymentOptions( |
| /*request_payer_name=*/true, /*request_payer_phone=*/true, |
| /*request_payer_email=*/true, /*request_shipping=*/true); |
| |
| // No shipping profile is selected because the merchant has not selected a |
| // shipping option. However there is a suitable contact profile. |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(nullptr, payment_request.selected_shipping_profile()); |
| EXPECT_EQ(address.guid(), payment_request.selected_contact_profile()->guid()); |
| } |
| |
| // Test that loading incomplete shipping and contact profiles works as expected. |
| TEST_F(PaymentRequestTest, SelectedProfiles_Incomplete) { |
| // Add a profile with no phone (incomplete). |
| autofill::AutofillProfile address1 = autofill::test::GetFullProfile(); |
| address1.SetInfo(autofill::AutofillType(autofill::PHONE_HOME_WHOLE_NUMBER), |
| base::string16(), "en-US"); |
| address1.set_use_count(5U); |
| test_personal_data_manager_.AddProfile(address1); |
| // Add a complete profile, with fewer use counts. |
| autofill::AutofillProfile address2 = autofill::test::GetFullProfile2(); |
| address2.set_use_count(3U); |
| test_personal_data_manager_.AddProfile(address2); |
| |
| WebPaymentRequest web_payment_request; |
| web_payment_request.details = CreateDetailsWithShippingOption(); |
| web_payment_request.options = CreatePaymentOptions( |
| /*request_payer_name=*/true, /*request_payer_phone=*/true, |
| /*request_payer_email=*/true, /*request_shipping=*/true); |
| |
| // Even though address1 has more use counts, address2 is selected because it |
| // is complete. |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(address2.guid(), |
| payment_request.selected_shipping_profile()->guid()); |
| EXPECT_EQ(address2.guid(), |
| payment_request.selected_contact_profile()->guid()); |
| } |
| |
| // Test that loading incomplete contact profiles works as expected when the |
| // merchant is not interested in the missing field. Test that the most complete |
| // shipping profile is selected. |
| TEST_F(PaymentRequestTest, |
| SelectedProfiles_IncompleteContact_NoRequestPayerPhone) { |
| // Add a profile with no phone (incomplete). |
| autofill::AutofillProfile address1 = autofill::test::GetFullProfile(); |
| address1.SetInfo(autofill::AutofillType(autofill::PHONE_HOME_WHOLE_NUMBER), |
| base::string16(), "en-US"); |
| address1.set_use_count(5U); |
| test_personal_data_manager_.AddProfile(address1); |
| // Add a complete profile, with fewer use counts. |
| autofill::AutofillProfile address2 = autofill::test::GetFullProfile(); |
| address2.set_use_count(3U); |
| test_personal_data_manager_.AddProfile(address2); |
| |
| WebPaymentRequest web_payment_request; |
| web_payment_request.details = CreateDetailsWithShippingOption(); |
| // The merchant doesn't care about the phone number. |
| web_payment_request.options = CreatePaymentOptions( |
| /*request_payer_name=*/true, /*request_payer_phone=*/false, |
| /*request_payer_email=*/true, /*request_shipping=*/true); |
| |
| // address1 has more use counts, and even though it has no phone number, it's |
| // still selected as the contact profile because merchant doesn't require |
| // phone. address2 is selected as the shipping profile because it's the most |
| // complete for shipping. |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(address2.guid(), |
| payment_request.selected_shipping_profile()->guid()); |
| EXPECT_EQ(address1.guid(), |
| payment_request.selected_contact_profile()->guid()); |
| } |
| |
| // Test that loading payment methods when none are available works as expected. |
| TEST_F(PaymentRequestTest, SelectedPaymentMethod_NoPaymentMethods) { |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| |
| // No payment methods are selected because none are available! |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(nullptr, payment_request.selected_payment_method()); |
| } |
| |
| // Test that loading expired credit cards works as expected. |
| TEST_F(PaymentRequestTest, SelectedPaymentMethod_ExpiredCard) { |
| autofill::AutofillProfile billing_address = autofill::test::GetFullProfile(); |
| test_personal_data_manager_.AddProfile(billing_address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard(); |
| credit_card.SetExpirationYear(2016); // Expired. |
| credit_card.set_billing_address_id(billing_address.guid()); |
| test_personal_data_manager_.AddCreditCard(credit_card); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| |
| // credit_card is selected because expired cards are valid for payment. |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_EQ(payment_request.selected_payment_method()->type(), |
| PaymentInstrument::Type::AUTOFILL); |
| AutofillPaymentInstrument* payment_instrument = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid()); |
| } |
| |
| // Test that loading complete payment methods works as expected. |
| TEST_F(PaymentRequestTest, SelectedPaymentMethod_Complete) { |
| autofill::AutofillProfile billing_address = autofill::test::GetFullProfile(); |
| test_personal_data_manager_.AddProfile(billing_address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard(); |
| credit_card.set_use_count(5U); |
| credit_card.set_billing_address_id(billing_address.guid()); |
| test_personal_data_manager_.AddCreditCard(credit_card); |
| autofill::CreditCard credit_card2 = autofill::test::GetCreditCard2(); |
| credit_card2.set_use_count(15U); |
| credit_card2.set_billing_address_id(billing_address.guid()); |
| test_personal_data_manager_.AddCreditCard(credit_card2); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| |
| // credit_card2 is selected because it has the most use count (Frecency |
| // model). |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| AutofillPaymentInstrument* payment_instrument = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ(credit_card2.guid(), payment_instrument->credit_card()->guid()); |
| } |
| |
| // Test that loading incomplete payment methods works as expected. |
| TEST_F(PaymentRequestTest, SelectedPaymentMethod_Incomplete) { |
| autofill::AutofillProfile billing_address = autofill::test::GetFullProfile(); |
| test_personal_data_manager_.AddProfile(billing_address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard(); |
| credit_card.set_use_count(5U); |
| credit_card.set_billing_address_id(billing_address.guid()); |
| test_personal_data_manager_.AddCreditCard(credit_card); |
| autofill::CreditCard credit_card2 = autofill::test::GetCreditCard2(); |
| credit_card2.set_use_count(15U); |
| test_personal_data_manager_.AddCreditCard(credit_card2); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| |
| // Even though credit_card2 has more use counts, credit_card is selected |
| // because it is complete. |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| AutofillPaymentInstrument* payment_instrument = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid()); |
| } |
| |
| // Test that the use counts of the data models are updated as expected when |
| // different autofill profiles are used as the shipping address and the contact |
| // info. |
| TEST_F(PaymentRequestTest, RecordUseStats_RequestShippingAndContactInfo) { |
| MockTestPersonalDataManager personal_data_manager; |
| // Add a profile that is incomplete for a contact info, but is used more |
| // frequently so is selected as the default shipping address. |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| address.SetInfo(autofill::AutofillType(autofill::EMAIL_ADDRESS), |
| base::string16(), "en-US"); |
| address.set_use_count(10U); |
| personal_data_manager.AddProfile(address); |
| autofill::AutofillProfile contact_info = autofill::test::GetFullProfile2(); |
| contact_info.set_use_count(5U); |
| personal_data_manager.AddProfile(contact_info); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard(); |
| credit_card.set_billing_address_id(address.guid()); |
| personal_data_manager.AddCreditCard(credit_card); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &personal_data_manager); |
| AutofillPaymentInstrument* payment_instrument = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ(address.guid(), |
| payment_request.selected_shipping_profile()->guid()); |
| EXPECT_EQ(contact_info.guid(), |
| payment_request.selected_contact_profile()->guid()); |
| EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid()); |
| |
| EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid()))) |
| .Times(1); |
| EXPECT_CALL(personal_data_manager, |
| RecordUseOf(GuidMatches(contact_info.guid()))) |
| .Times(1); |
| EXPECT_CALL(personal_data_manager, |
| RecordUseOf(GuidMatches(credit_card.guid()))) |
| .Times(1); |
| |
| payment_request.RecordUseStats(); |
| } |
| |
| // Test that the use counts of the data models are updated as expected when the |
| // same autofill profile is used as the shipping address and the contact info. |
| TEST_F(PaymentRequestTest, RecordUseStats_SameShippingAndContactInfoProfile) { |
| MockTestPersonalDataManager personal_data_manager; |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| personal_data_manager.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard(); |
| credit_card.set_billing_address_id(address.guid()); |
| personal_data_manager.AddCreditCard(credit_card); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &personal_data_manager); |
| AutofillPaymentInstrument* payment_instrument = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ(address.guid(), |
| payment_request.selected_shipping_profile()->guid()); |
| EXPECT_EQ(address.guid(), payment_request.selected_contact_profile()->guid()); |
| EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid()); |
| |
| // Even though |address| is used for contact info, shipping address, and |
| // credit_card's billing address, the stats should be updated only once. |
| EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid()))) |
| .Times(1); |
| EXPECT_CALL(personal_data_manager, |
| RecordUseOf(GuidMatches(credit_card.guid()))) |
| .Times(1); |
| |
| payment_request.RecordUseStats(); |
| } |
| |
| // Test that the use counts of the data models are updated as expected when no |
| // contact information is requested. |
| TEST_F(PaymentRequestTest, RecordUseStats_RequestShippingOnly) { |
| MockTestPersonalDataManager personal_data_manager; |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| personal_data_manager.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard(); |
| credit_card.set_billing_address_id(address.guid()); |
| personal_data_manager.AddCreditCard(credit_card); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| web_payment_request.options.request_payer_name = false; |
| web_payment_request.options.request_payer_email = false; |
| web_payment_request.options.request_payer_phone = false; |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &personal_data_manager); |
| AutofillPaymentInstrument* payment_instrument = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ(address.guid(), |
| payment_request.selected_shipping_profile()->guid()); |
| EXPECT_EQ(nullptr, payment_request.selected_contact_profile()); |
| EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid()); |
| |
| EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid()))) |
| .Times(1); |
| EXPECT_CALL(personal_data_manager, |
| RecordUseOf(GuidMatches(credit_card.guid()))) |
| .Times(1); |
| |
| payment_request.RecordUseStats(); |
| } |
| |
| // Test that the use counts of the data models are updated as expected when no |
| // shipping information is requested. |
| TEST_F(PaymentRequestTest, RecordUseStats_RequestContactInfoOnly) { |
| MockTestPersonalDataManager personal_data_manager; |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| personal_data_manager.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard(); |
| credit_card.set_billing_address_id(address.guid()); |
| personal_data_manager.AddCreditCard(credit_card); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| web_payment_request.options.request_shipping = false; |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &personal_data_manager); |
| AutofillPaymentInstrument* payment_instrument = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ(nullptr, payment_request.selected_shipping_profile()); |
| EXPECT_EQ(address.guid(), payment_request.selected_contact_profile()->guid()); |
| EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid()); |
| |
| EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid()))) |
| .Times(1); |
| EXPECT_CALL(personal_data_manager, |
| RecordUseOf(GuidMatches(credit_card.guid()))) |
| .Times(1); |
| |
| payment_request.RecordUseStats(); |
| } |
| |
| // Test that the use counts of the data models are updated as expected when no |
| // shipping or contact information is requested. |
| TEST_F(PaymentRequestTest, RecordUseStats_NoShippingOrContactInfoRequested) { |
| MockTestPersonalDataManager personal_data_manager; |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| personal_data_manager.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard(); |
| credit_card.set_billing_address_id(address.guid()); |
| personal_data_manager.AddCreditCard(credit_card); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| web_payment_request.options.request_shipping = false; |
| web_payment_request.options.request_payer_name = false; |
| web_payment_request.options.request_payer_email = false; |
| web_payment_request.options.request_payer_phone = false; |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &personal_data_manager); |
| AutofillPaymentInstrument* payment_instrument = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ(nullptr, payment_request.selected_shipping_profile()); |
| EXPECT_EQ(nullptr, payment_request.selected_contact_profile()); |
| EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid()); |
| |
| EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid()))) |
| .Times(0); |
| EXPECT_CALL(personal_data_manager, |
| RecordUseOf(GuidMatches(credit_card.guid()))) |
| .Times(1); |
| |
| payment_request.RecordUseStats(); |
| } |
| |
| // Tests that the modifier should not get applied when the card network is not |
| // supported. |
| TEST_F(PaymentRequestTest, PaymentDetailsModifier_BasicCard_NetworkMismatch) { |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| test_personal_data_manager_.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard(); // Visa. |
| test_personal_data_manager_.AddCreditCard(credit_card); |
| credit_card.set_billing_address_id(address.guid()); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| PaymentDetailsModifier modifier; |
| modifier.method_data.supported_method = "basic-card"; |
| modifier.method_data.supported_networks.push_back("amex"); |
| modifier.total = std::make_unique<payments::PaymentItem>(); |
| modifier.total->label = "Discounted Total"; |
| modifier.total->amount->value = "0.99"; |
| modifier.total->amount->currency = "USD"; |
| payments::PaymentItem additional_display_item; |
| additional_display_item.label = "Amex discount"; |
| additional_display_item.amount->value = "-0.01"; |
| additional_display_item.amount->currency = "USD"; |
| modifier.additional_display_items.push_back(additional_display_item); |
| web_payment_request.details.modifiers.push_back(modifier); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| AutofillPaymentInstrument* selected_payment_method = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ("Total", payment_request.GetTotal(selected_payment_method).label); |
| EXPECT_EQ("1.00", |
| payment_request.GetTotal(selected_payment_method).amount->value); |
| ASSERT_EQ(1U, |
| payment_request.GetDisplayItems(selected_payment_method).size()); |
| } |
| |
| // Tests that the modifier should get applied when the card network is a match. |
| TEST_F(PaymentRequestTest, PaymentDetailsModifier_BasicCard_NetworkMatch) { |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| test_personal_data_manager_.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard2(); // Amex. |
| credit_card.set_billing_address_id(address.guid()); |
| test_personal_data_manager_.AddCreditCard(credit_card); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| PaymentDetailsModifier modifier; |
| modifier.method_data.supported_method = "basic-card"; |
| modifier.method_data.supported_networks.push_back("amex"); |
| modifier.total = std::make_unique<payments::PaymentItem>(); |
| modifier.total->label = "Discounted Total"; |
| modifier.total->amount->value = "0.99"; |
| modifier.total->amount->currency = "USD"; |
| payments::PaymentItem additional_display_item; |
| additional_display_item.label = "Amex discount"; |
| additional_display_item.amount->value = "-0.01"; |
| additional_display_item.amount->currency = "USD"; |
| modifier.additional_display_items.push_back(additional_display_item); |
| web_payment_request.details.modifiers.push_back(modifier); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| AutofillPaymentInstrument* selected_payment_method = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ("Discounted Total", |
| payment_request.GetTotal(selected_payment_method).label); |
| EXPECT_EQ("0.99", |
| payment_request.GetTotal(selected_payment_method).amount->value); |
| ASSERT_EQ(2U, |
| payment_request.GetDisplayItems(selected_payment_method).size()); |
| EXPECT_EQ("Subtotal", |
| payment_request.GetDisplayItems(selected_payment_method)[0].label); |
| EXPECT_EQ("1.00", payment_request.GetDisplayItems(selected_payment_method)[0] |
| .amount->value); |
| EXPECT_EQ("Amex discount", |
| payment_request.GetDisplayItems(selected_payment_method)[1].label); |
| EXPECT_EQ("-0.01", payment_request.GetDisplayItems(selected_payment_method)[1] |
| .amount->value); |
| } |
| |
| // Tests that the modifier should not get applied when the card type is not |
| // supported. |
| TEST_F(PaymentRequestTest, PaymentDetailsModifier_BasicCard_TypeMismatch) { |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| test_personal_data_manager_.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetCreditCard2(); // Amex. |
| test_personal_data_manager_.AddCreditCard(credit_card); |
| credit_card.set_billing_address_id(address.guid()); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| PaymentDetailsModifier modifier; |
| modifier.method_data.supported_method = "basic-card"; |
| modifier.method_data.supported_networks.push_back("amex"); |
| modifier.method_data.supported_types.insert( |
| autofill::CreditCard::CARD_TYPE_CREDIT); |
| modifier.total = std::make_unique<payments::PaymentItem>(); |
| modifier.total->label = "Discounted Total"; |
| modifier.total->amount->value = "0.99"; |
| modifier.total->amount->currency = "USD"; |
| payments::PaymentItem additional_display_item; |
| additional_display_item.label = "Amex discount"; |
| additional_display_item.amount->value = "-0.01"; |
| additional_display_item.amount->currency = "USD"; |
| modifier.additional_display_items.push_back(additional_display_item); |
| web_payment_request.details.modifiers.push_back(modifier); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| AutofillPaymentInstrument* selected_payment_method = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ("Total", payment_request.GetTotal(selected_payment_method).label); |
| EXPECT_EQ("1.00", |
| payment_request.GetTotal(selected_payment_method).amount->value); |
| ASSERT_EQ(1U, |
| payment_request.GetDisplayItems(selected_payment_method).size()); |
| } |
| |
| // Tests that the modifier should get applied when the card network and the type |
| // are both a match. |
| TEST_F(PaymentRequestTest, |
| PaymentDetailsModifier_BasicCard_NetworkAndTypeMatch) { |
| autofill::AutofillProfile address = autofill::test::GetFullProfile(); |
| test_personal_data_manager_.AddProfile(address); |
| autofill::CreditCard credit_card = autofill::test::GetMaskedServerCardAmex(); |
| credit_card.set_card_type(autofill::CreditCard::CardType::CARD_TYPE_CREDIT); |
| credit_card.set_billing_address_id(address.guid()); |
| test_personal_data_manager_.AddServerCreditCard(credit_card); |
| |
| WebPaymentRequest web_payment_request = |
| payment_request_test_util::CreateTestWebPaymentRequest(); |
| PaymentDetailsModifier modifier; |
| modifier.method_data.supported_method = "basic-card"; |
| modifier.method_data.supported_networks.push_back("amex"); |
| modifier.method_data.supported_types.insert( |
| autofill::CreditCard::CARD_TYPE_CREDIT); |
| modifier.total = std::make_unique<payments::PaymentItem>(); |
| modifier.total->label = "Discounted Total"; |
| modifier.total->amount->value = "0.99"; |
| modifier.total->amount->currency = "USD"; |
| payments::PaymentItem additional_display_item; |
| additional_display_item.label = "Amex discount"; |
| additional_display_item.amount->value = "-0.01"; |
| additional_display_item.amount->currency = "USD"; |
| modifier.additional_display_items.push_back(additional_display_item); |
| web_payment_request.details.modifiers.push_back(modifier); |
| |
| TestPaymentRequest payment_request(web_payment_request, |
| chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| AutofillPaymentInstrument* selected_payment_method = |
| static_cast<AutofillPaymentInstrument*>( |
| payment_request.selected_payment_method()); |
| EXPECT_EQ("Discounted Total", |
| payment_request.GetTotal(selected_payment_method).label); |
| EXPECT_EQ("0.99", |
| payment_request.GetTotal(selected_payment_method).amount->value); |
| ASSERT_EQ(2U, |
| payment_request.GetDisplayItems(selected_payment_method).size()); |
| EXPECT_EQ("Subtotal", |
| payment_request.GetDisplayItems(selected_payment_method)[0].label); |
| EXPECT_EQ("1.00", payment_request.GetDisplayItems(selected_payment_method)[0] |
| .amount->value); |
| EXPECT_EQ("Amex discount", |
| payment_request.GetDisplayItems(selected_payment_method)[1].label); |
| EXPECT_EQ("-0.01", payment_request.GetDisplayItems(selected_payment_method)[1] |
| .amount->value); |
| } |
| |
| // Tests that payment_request_util::RequestContactInfo returns true if payer's |
| // name, phone number, or email address are requested and false otherwise. |
| TEST_F(PaymentRequestTest, RequestContactInfo) { |
| payments::WebPaymentRequest web_payment_request; |
| |
| web_payment_request.options.request_payer_name = true; |
| web_payment_request.options.request_payer_phone = true; |
| web_payment_request.options.request_payer_email = true; |
| payments::TestPaymentRequest payment_request1( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_TRUE(payment_request1.RequestContactInfo()); |
| |
| web_payment_request.options.request_payer_name = false; |
| payments::TestPaymentRequest payment_request2( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_TRUE(payment_request2.RequestContactInfo()); |
| |
| web_payment_request.options.request_payer_phone = false; |
| payments::TestPaymentRequest payment_request3( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_TRUE(payment_request3.RequestContactInfo()); |
| |
| web_payment_request.options.request_payer_email = false; |
| payments::TestPaymentRequest payment_request4( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_FALSE(payment_request4.RequestContactInfo()); |
| } |
| |
| // Tests the return value of payment_request_util::CanPay. |
| TEST_F(PaymentRequestTest, CanPay) { |
| payments::WebPaymentRequest web_payment_request; |
| payments::PaymentMethodData method_datum; |
| method_datum.supported_method = "basic-card"; |
| method_datum.supported_networks.push_back("visa"); |
| web_payment_request.method_data.push_back(method_datum); |
| |
| // No selected payment method. |
| payments::TestPaymentRequest payment_request1( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_FALSE(payment_request1.IsAbleToPay()); |
| |
| autofill::AutofillProfile profile = autofill::test::GetFullProfile(); |
| // Make the profile incomplete by removing the name and the phone number so |
| // that it is not selected as the default shipping address or contact info. |
| profile.SetInfo(autofill::AutofillType(autofill::NAME_FULL), base::string16(), |
| "en-US"); |
| profile.SetInfo(autofill::AutofillType(autofill::PHONE_HOME_WHOLE_NUMBER), |
| base::string16(), "en-US"); |
| test_personal_data_manager_.AddProfile(profile); |
| autofill::CreditCard card = autofill::test::GetCreditCard(); // Visa. |
| card.set_billing_address_id(profile.guid()); |
| test_personal_data_manager_.AddCreditCard(card); |
| |
| // Has a selected payment method. |
| payments::TestPaymentRequest payment_request2( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_TRUE(payment_request2.IsAbleToPay()); |
| |
| // No selected contact info. |
| web_payment_request.options.request_payer_phone = true; |
| payments::TestPaymentRequest payment_request3( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_FALSE(payment_request3.IsAbleToPay()); |
| |
| test_personal_data_manager_.GetProfiles()[0]->SetInfo( |
| autofill::AutofillType(autofill::PHONE_HOME_WHOLE_NUMBER), |
| base::ASCIIToUTF16("16502111111"), "en-US"); |
| |
| // Has a selected contact info. |
| payments::TestPaymentRequest payment_request4( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_TRUE(payment_request4.IsAbleToPay()); |
| |
| // No selected shipping address. |
| web_payment_request.options.request_shipping = true; |
| payments::TestPaymentRequest payment_request5( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_FALSE(payment_request5.IsAbleToPay()); |
| |
| profile.SetInfo(autofill::AutofillType(autofill::NAME_FULL), |
| base::ASCIIToUTF16("John Doe"), "en-US"); |
| |
| // Has a selected shipping address, but no selected shipping option. |
| payments::TestPaymentRequest payment_request6( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_FALSE(payment_request6.IsAbleToPay()); |
| |
| std::vector<payments::PaymentShippingOption> shipping_options; |
| payments::PaymentShippingOption option; |
| option.id = "1"; |
| option.selected = true; |
| shipping_options.push_back(std::move(option)); |
| web_payment_request.details.shipping_options = std::move(shipping_options); |
| |
| // Has a selected shipping address and a selected shipping option. |
| payments::TestPaymentRequest payment_request7( |
| web_payment_request, chrome_browser_state_.get(), &web_state_, |
| &test_personal_data_manager_); |
| EXPECT_TRUE(payment_request7.IsAbleToPay()); |
| } |
| |
| } // namespace payments |
