rAc: use libaddressinput to validate international addresses.

chrome/browser/ui/autofill/autofill_dialog_controller_unittest.cc

 // Copyright (c) 2012 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 <map>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/tuple.h"
@@ skipping 23 matching lines @@
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/test_personal_data_manager.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "grit/webkit_resources.h"
+#include "third_party/libaddressinput/chromium/cpp/include/libaddressinput/address_data.h"
+#include "third_party/libaddressinput/chromium/cpp/include/libaddressinput/address_validator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OS_WIN)
 #include "ui/base/win/scoped_ole_initializer.h"
 #endif
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 
 namespace autofill {
 
 namespace {
 
+using ::i18n::addressinput::AddressData;
+using ::i18n::addressinput::AddressProblemFilter;
+using ::i18n::addressinput::AddressProblems;
+using ::i18n::addressinput::AddressValidator;
+using testing::AtLeast;
+using testing::Return;
 using testing::_;
 
 const char kFakeEmail[] = "user@chromium.org";
 const char kFakeFingerprintEncoded[] = "CgVaAwiACA==";
 const char kEditedBillingAddress[] = "123 edited billing address";
 const char* kFieldsFromPage[] =
     { "email",
       "cc-name",
       "cc-number",
       "cc-exp-month",
@@ skipping 150 matching lines @@
  private:
   std::map<DialogSection, FieldValueMap> outputs_;
   std::map<DialogSection, size_t> section_updates_;
 
   int updates_started_;
   bool save_details_locally_checked_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillDialogView);
 };
 
+class MockAddressValidator : public AddressValidator {
+ public:
+  MOCK_METHOD1(LoadRules, void(const std::string& country_code));
+  MOCK_CONST_METHOD3(ValidateAddress,
+      ::i18n::addressinput::AddressValidator::Status(
+          const AddressData& address,
+          const AddressProblemFilter& filter,
+          AddressProblems* problems));
+  using ::i18n::addressinput::AddressValidator::RULES_NOT_READY;
+};
+
 class TestAutofillDialogController
     : public AutofillDialogControllerImpl,
       public base::SupportsWeakPtr<TestAutofillDialogController> {
  public:
   TestAutofillDialogController(
       content::WebContents* contents,
       const FormData& form_structure,
       const GURL& source_url,
       const AutofillMetrics& metric_logger,
       const base::Callback<void(const FormStructure*)>& callback,
+      MockAddressValidator* mock_validator,
       MockNewCreditCardBubbleController* mock_new_card_bubble_controller)
       : AutofillDialogControllerImpl(contents,
                                      form_structure,
                                      source_url,
                                      callback),
         metric_logger_(metric_logger),
         mock_wallet_client_(
             Profile::FromBrowserContext(contents->GetBrowserContext())->
                 GetRequestContext(), this, source_url),
+        mock_validator_(mock_validator),
         mock_new_card_bubble_controller_(mock_new_card_bubble_controller),
         submit_button_delay_count_(0) {}
 
   virtual ~TestAutofillDialogController() {}
 
   virtual AutofillDialogView* CreateView() OVERRIDE {
     return new testing::NiceMock<TestAutofillDialogView>();
   }
 
+  using AutofillDialogControllerImpl::GetInfoFromInputs;
+
   void Init(content::BrowserContext* browser_context) {
     test_manager_.Init(
         WebDataServiceFactory::GetAutofillWebDataForProfile(
             Profile::FromBrowserContext(browser_context),
             Profile::EXPLICIT_ACCESS),
         user_prefs::UserPrefs::Get(browser_context),
         browser_context->IsOffTheRecord());
   }
 
   TestAutofillDialogView* GetView() {
@@ skipping 47 matching lines @@
  protected:
   virtual PersonalDataManager* GetManager() const OVERRIDE {
     return const_cast<TestAutofillDialogController*>(this)->
         GetTestingManager();
   }
 
   virtual wallet::WalletClient* GetWalletClient() OVERRIDE {
     return &mock_wallet_client_;
   }
 
+  virtual AddressValidator* GetValidator() {
+    return mock_validator_;
+  }
+
   virtual void OpenTabWithUrl(const GURL& url) OVERRIDE {
     open_tab_url_ = url;
   }
 
   virtual void ShowNewCreditCardBubble(
       scoped_ptr<CreditCard> new_card,
       scoped_ptr<AutofillProfile> billing_profile) OVERRIDE {
     mock_new_card_bubble_controller_->Show(new_card.Pass(),
                                            billing_profile.Pass());
   }
 
   // AutofillDialogControllerImpl calls this method before showing the dialog
   // window.
   virtual void SubmitButtonDelayBegin() OVERRIDE {
     // Do not delay enabling the submit button in testing.
     submit_button_delay_count_++;
   }
 
  private:
   // To specify our own metric logger.
   virtual const AutofillMetrics& GetMetricLogger() const OVERRIDE {
     return metric_logger_;
   }
 
   const AutofillMetrics& metric_logger_;
   TestPersonalDataManager test_manager_;
   testing::NiceMock<wallet::MockWalletClient> mock_wallet_client_;
+  MockAddressValidator* mock_validator_;
   GURL open_tab_url_;
   MockNewCreditCardBubbleController* mock_new_card_bubble_controller_;
 
   // The number of times that the submit button was delayed.
   int submit_button_delay_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillDialogController);
 };
 
 class AutofillDialogControllerTest : public ChromeRenderViewHostTestHarness {
@@ skipping 51 matching lines @@
 
     base::Callback<void(const FormStructure*)> callback =
         base::Bind(&AutofillDialogControllerTest::FinishedCallback,
                    base::Unretained(this));
     controller_ = (new testing::NiceMock<TestAutofillDialogController>(
         web_contents(),
         form_data,
         GURL(),
         metric_logger_,
         callback,
+        mock_validator_.get(),
         mock_new_card_bubble_controller_.get()))->AsWeakPtr();
     controller_->Init(profile());
   }
 
   // Creates a new controller for |form_data| and sets up some initial wallet
   // data for it.
   void SetUpControllerWithFormData(const FormData& form_data) {
     ResetControllerWithFormData(form_data);
     controller()->Show();
     if (!profile()->GetPrefs()->GetBoolean(
@@ skipping 159 matching lines @@
     EXPECT_FALSE(billing_name.empty());
     EXPECT_FALSE(shipping_name.empty());
     EXPECT_EQ(cc_name, billing_name);
     EXPECT_EQ(cc_name, shipping_name);
   }
 
   TestAutofillDialogController* controller() { return controller_.get(); }
 
   const FormStructure* form_structure() { return form_structure_; }
 
+  MockAddressValidator* GetMockValidator() const {
+    return mock_validator_.get();
+  }
+  void SetMockValidator(scoped_ptr<MockAddressValidator> validator) {
+    mock_validator_ = validator.Pass();
+  }
+
   TestGeneratedCreditCardBubbleController* test_generated_bubble_controller() {
     return test_generated_bubble_controller_;
   }
 
   const MockNewCreditCardBubbleController* mock_new_card_bubble_controller() {
     return mock_new_card_bubble_controller_.get();
   }
 
  private:
   void FinishedCallback(const FormStructure* form_structure) {
     form_structure_ = form_structure;
   }
 
 #if defined(OS_WIN)
    // http://crbug.com/227221
    ui::ScopedOleInitializer ole_initializer_;
 #endif
 
   // The controller owns itself.
   base::WeakPtr<TestAutofillDialogController> controller_;
 
   // Must outlive the controller.
   AutofillMetrics metric_logger_;
 
   // Returned when the dialog closes successfully.
   const FormStructure* form_structure_;
 
+  // A mock validator object to prevent network requests and track when
+  // validation rules are loaded or validation attempts occur.
+  scoped_ptr<MockAddressValidator> mock_validator_;
+
   // Used to monitor if the Autofill credit card bubble is shown. Owned by
   // |web_contents()|.
   TestGeneratedCreditCardBubbleController* test_generated_bubble_controller_;
 
   // Used to record when new card bubbles would show. Created in |Reset()|.
   scoped_ptr<MockNewCreditCardBubbleController>
       mock_new_card_bubble_controller_;
 
   scoped_ptr<ScopedTestingLocalState> scoped_local_state_;
 };
@@ skipping 2281 matching lines @@
   };
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   for (size_t i = 0; i < arraysize(kSupportedCardIdrs); ++i) {
     SCOPED_TRACE(base::IntToString(i));
     gfx::Image supported_card_icon = rb.GetImageNamed(kSupportedCardIdrs[i]);
     EXPECT_GE(placeholder_icon.Width(), supported_card_icon.Width());
     EXPECT_GE(placeholder_icon.Height(), supported_card_icon.Height());
   }
 }
 
-TEST_F(AutofillDialogControllerTest, CountryChangeUpdatesSection) {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  command_line->AppendSwitch(::switches::kEnableAutofillAddressI18n);
+class AutofillDialogControllerI18nTest : public AutofillDialogControllerTest {
+ public:
+  // AutofillDialogControllerTest implementation.
+  virtual void SetUp() OVERRIDE {
+    CommandLine* command_line = CommandLine::ForCurrentProcess();
+    command_line->AppendSwitch(::switches::kEnableAutofillAddressI18n);
+    AutofillDialogControllerTest::SetUp();
+  }
+};
 
-  Reset();
-
+TEST_F(AutofillDialogControllerI18nTest, CountryChangeUpdatesSection) {
   TestAutofillDialogView* view = controller()->GetView();
   view->ClearSectionUpdates();
 
   controller()->UserEditedOrActivatedInput(SECTION_SHIPPING,
                                            ADDRESS_HOME_COUNTRY,
                                            gfx::NativeView(),
                                            gfx::Rect(),
                                            ASCIIToUTF16("China"),
                                            true);
   std::map<DialogSection, size_t> updates = view->section_updates();
@@ skipping 19 matching lines @@
                                            ADDRESS_BILLING_COUNTRY,
                                            gfx::NativeView(),
                                            gfx::Rect(),
                                            ASCIIToUTF16("Italy"),
                                            true);
   updates = view->section_updates();
   EXPECT_EQ(1U, updates[SECTION_BILLING]);
   EXPECT_EQ(1U, updates.size());
 }
 
+TEST_F(AutofillDialogControllerI18nTest, CorrectCountryFromInputs) {
+  FieldValueMap inputs;
+  inputs[ADDRESS_BILLING_COUNTRY] = base::ASCIIToUTF16("China");
+  inputs[ADDRESS_HOME_COUNTRY] = base::ASCIIToUTF16("France");
+
+  base::Callback<base::string16(DialogSection, const AutofillType&)> get_info =
+      base::Bind(&TestAutofillDialogController::GetInfoFromInputs,
+                 base::ConstRef(inputs));
+
+  // Ensure that callbacks bound to the billing section only return
+  // billing-specific info from |inputs| (e.g. the billing country).
+  EXPECT_EQ(base::ASCIIToUTF16("China"),
+            get_info.Run(SECTION_BILLING, AutofillType(ADDRESS_HOME_COUNTRY)));
+  EXPECT_EQ(base::ASCIIToUTF16("CN"),
+            get_info.Run(SECTION_BILLING, AutofillType(HTML_TYPE_COUNTRY_CODE,
+                                                       HTML_MODE_SHIPPING)));
+
+  // And conversely that shipping sections only return the shipping country.
+  EXPECT_EQ(
+      base::ASCIIToUTF16("France"),
+      get_info.Run(SECTION_SHIPPING, AutofillType(ADDRESS_BILLING_COUNTRY)));
+  EXPECT_EQ(base::ASCIIToUTF16("FR"),
+            get_info.Run(SECTION_SHIPPING, AutofillType(HTML_TYPE_COUNTRY_CODE,
+                                                        HTML_MODE_BILLING)));
+}
+
+TEST_F(AutofillDialogControllerI18nTest, LoadValidationRules) {
+  SetMockValidator(make_scoped_ptr(new MockAddressValidator));
+  EXPECT_CALL(*GetMockValidator(), ValidateAddress(_, _, _)).
+      WillRepeatedly(Return(MockAddressValidator::RULES_NOT_READY));
+
+  EXPECT_CALL(*GetMockValidator(), LoadRules("US")).Times(AtLeast(1));
+  Reset();
+
+  EXPECT_CALL(*GetMockValidator(), LoadRules("FR"));
+  controller()->UserEditedOrActivatedInput(SECTION_CC_BILLING,
+                                           ADDRESS_BILLING_COUNTRY,
+                                           gfx::NativeView(),
+                                           gfx::Rect(),
+                                           ASCIIToUTF16("France"),
+                                           true);
+}
+
 }  // namespace autofill