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>();
   }
 
   void Init(content::BrowserContext* browser_context) {
@@ skipping 56 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(&AutofillDialogControllerImpl::GetInfoFromInputs,

[Evan Stade, 2014/01/31 04:09:52]

I feel like you should be able to test this function without exposing it in the
header. Can't you set some input text then switch countries? Or run
InputsAreValid on some FieldValueMap, and make sure the address passed to
mock_validator has the country you expect?

[Dan Beam, 2014/02/01 00:43:22]

Done.

+                 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