[Payments] Normalize shipping address change on Desktop

components/payments/content/payment_response_helper_unittest.cc

 // 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 "components/payments/content/payment_response_helper.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/test_personal_data_manager.h"
 #include "components/payments/content/payment_request_spec.h"
-#include "components/payments/core/address_normalizer.h"
 #include "components/payments/core/autofill_payment_instrument.h"
-#include "components/payments/core/payment_request_delegate.h"
+#include "components/payments/core/test_payment_request_delegate.h"
 #include "components/payments/mojom/payment_request.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace payments {
 
-class FakeAddressNormalizer : public AddressNormalizer {
- public:
-  FakeAddressNormalizer() {}
-
-  void LoadRulesForRegion(const std::string& region_code) override {}
-
-  bool AreRulesLoadedForRegion(const std::string& region_code) override {
-    return true;
-  }
-
-  void StartAddressNormalization(
-      const autofill::AutofillProfile& profile,
-      const std::string& region_code,
-      int timeout_seconds,
-      AddressNormalizer::Delegate* requester) override {
-    requester->OnAddressNormalized(profile);
-  }
-
-  void OnAddressValidationRulesLoaded(const std::string& region_code,
-                                      bool success) override {}
-};
-
-class FakePaymentRequestDelegate : public PaymentRequestDelegate {
- public:
-  FakePaymentRequestDelegate(
-      autofill::PersonalDataManager* personal_data_manager)
-      : personal_data_manager_(personal_data_manager),
-        locale_("en-US"),
-        last_committed_url_("https://shop.com") {}
-  void ShowDialog(PaymentRequest* request) override {}
-
-  void CloseDialog() override {}
-
-  void ShowErrorMessage() override {}
-
-  autofill::PersonalDataManager* GetPersonalDataManager() override {
-    return personal_data_manager_;
-  }
-
-  const std::string& GetApplicationLocale() const override { return locale_; }
-
-  bool IsIncognito() const override { return false; }
-
-  bool IsSslCertificateValid() override { return true; }
-
-  const GURL& GetLastCommittedURL() const override {
-    return last_committed_url_;
-  }
-
-  void DoFullCardRequest(
-      const autofill::CreditCard& credit_card,
-      base::WeakPtr<autofill::payments::FullCardRequest::ResultDelegate>
-          result_delegate) override {
-    result_delegate->OnFullCardRequestSucceeded(credit_card,
-                                                base::ASCIIToUTF16("123"));
-  }
-
-  AddressNormalizer* GetAddressNormalizer() override {
-    return &address_normalizer_;
-  }
-
-  autofill::RegionDataLoader* GetRegionDataLoader() override { return nullptr; }
-
- private:
-  autofill::PersonalDataManager* personal_data_manager_;
-  std::string locale_;
-  const GURL last_committed_url_;
-  FakeAddressNormalizer address_normalizer_;
-  DISALLOW_COPY_AND_ASSIGN(FakePaymentRequestDelegate);
-};
-
 class PaymentResponseHelperTest : public testing::Test,
                                   public PaymentResponseHelper::Delegate {
  protected:
   PaymentResponseHelperTest()
-      : payment_request_delegate_(&test_personal_data_manager_),
+      : test_payment_request_delegate_(&test_personal_data_manager_),
         address_(autofill::test::GetFullProfile()),
         billing_addresses_({&address_}) {
     test_personal_data_manager_.AddTestingProfile(&address_);
 
     // Setup the autofill payment instrument.
     autofill::CreditCard visa_card = autofill::test::GetCreditCard();
     visa_card.set_billing_address_id(address_.guid());
     visa_card.set_use_count(5u);
     autofill_instrument_ = base::MakeUnique<AutofillPaymentInstrument>(
         "visa", visa_card, billing_addresses_, "en-US",
-        &payment_request_delegate_);
+        &test_payment_request_delegate_);
   }
   ~PaymentResponseHelperTest() override {}
 
   // PaymentRequestState::Delegate:
   void OnPaymentResponseReady(mojom::PaymentResponsePtr response) override {
     payment_response_ = std::move(response);
   };
 
   // Convenience method to create a PaymentRequestSpec with specified |details|
   // and |method_data|.
@@ skipping 30 matching lines @@
     entry->supported_methods.push_back("visa");
     method_data.push_back(std::move(entry));
     return method_data;
   }
 
   PaymentRequestSpec* spec() { return spec_.get(); }
   const mojom::PaymentResponsePtr& response() { return payment_response_; }
   autofill::AutofillProfile* test_address() { return &address_; }
   PaymentInstrument* test_instrument() { return autofill_instrument_.get(); }
   PaymentRequestDelegate* test_payment_request_delegate() {
-    return &payment_request_delegate_;
+    return &test_payment_request_delegate_;
   }
 
  private:
   std::unique_ptr<PaymentRequestSpec> spec_;
   mojom::PaymentResponsePtr payment_response_;
   autofill::TestPersonalDataManager test_personal_data_manager_;
-  FakePaymentRequestDelegate payment_request_delegate_;
+  TestPaymentRequestDelegate test_payment_request_delegate_;
 
   // Test data.
   autofill::AutofillProfile address_;
   const std::vector<autofill::AutofillProfile*> billing_addresses_;
   std::unique_ptr<AutofillPaymentInstrument> autofill_instrument_;
 };
 
 // Test generating a PaymentResponse.
 TEST_F(PaymentResponseHelperTest, GeneratePaymentResponse_SupportedMethod) {
   // Default options (no shipping, no contact info).
@@ skipping 147 matching lines @@
 
   PaymentResponseHelper helper("en-US", spec(), test_instrument(),
                                test_payment_request_delegate(), test_address(),
                                test_address(), this);
 
   // Check that the phone was formatted.
   EXPECT_EQ("+15151231234", response()->payer_phone.value());
 }
 
 }  // namespace payments