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 25 matching lines @@
 #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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/libaddressinput/chromium/cpp/include/libaddressinput/address_data.h"
+#include "third_party/libaddressinput/chromium/cpp/include/libaddressinput/address_validator.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:
+  MockAddressValidator() {
+    ON_CALL(*this, ValidateAddress(_, _, _)).WillByDefault(Return(SUCCESS));
+  }
+
+  virtual ~MockAddressValidator() {}
+
+  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));
+};
+
 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,
@@ skipping 25 matching lines @@
   }
 
   TestAutofillDialogView* GetView() {
     return static_cast<TestAutofillDialogView*>(view());
   }
 
   TestPersonalDataManager* GetTestingManager() {
     return &test_manager_;
   }
 
+  MockAddressValidator* GetMockValidator() {
+    return &mock_validator_;
+  }
+
   wallet::MockWalletClient* GetTestingWalletClient() {
     return &mock_wallet_client_;
   }
 
   const GURL& open_tab_url() { return open_tab_url_; }
 
   void SimulateSigninError() {
     OnWalletSigninError();
   }
 
@@ skipping 26 matching lines @@
   using AutofillDialogControllerImpl::IsSubmitPausedOn;
   using AutofillDialogControllerImpl::NOT_CHECKED;
   using AutofillDialogControllerImpl::SignedInState;
 
  protected:
   virtual PersonalDataManager* GetManager() const OVERRIDE {
     return const_cast<TestAutofillDialogController*>(this)->
         GetTestingManager();
   }
 
+  virtual AddressValidator* GetValidator() OVERRIDE {
+    return &mock_validator_;
+  }
+
   virtual wallet::WalletClient* GetWalletClient() OVERRIDE {
     return &mock_wallet_client_;
   }
 
   virtual void OpenTabWithUrl(const GURL& url) OVERRIDE {
     open_tab_url_ = url;
   }
 
   virtual void ShowNewCreditCardBubble(
       scoped_ptr<CreditCard> new_card,
@@ skipping 11 matching lines @@
 
  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_;
+
+  // A mock validator object to prevent network requests and track when
+  // validation rules are loaded or validation attempts occur.
+  testing::NiceMock<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 2558 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());
 }
 
+MATCHER_P(CountryCode, country_code, "Checks country code of an AddressData") {
+  // |arg| is an AddressData object.
+  return arg.country_code == country_code;
+}
+
+TEST_F(AutofillDialogControllerI18nTest, CorrectCountryFromInputs) {
+  EXPECT_CALL(*controller()->GetMockValidator(),
+              ValidateAddress(CountryCode("CN"), _, _));
+
+  FieldValueMap billing_inputs;
+  billing_inputs[ADDRESS_BILLING_COUNTRY] = ASCIIToUTF16("China");
+  controller()->InputsAreValid(SECTION_BILLING, billing_inputs);
+
+  EXPECT_CALL(*controller()->GetMockValidator(),
+              ValidateAddress(CountryCode("FR"), _, _));
+
+  FieldValueMap shipping_inputs;
+  shipping_inputs[ADDRESS_HOME_COUNTRY] = ASCIIToUTF16("France");
+  controller()->InputsAreValid(SECTION_SHIPPING, shipping_inputs);
+}
+
+TEST_F(AutofillDialogControllerI18nTest, LoadValidationRules) {
+  ResetControllerWithFormData(DefaultFormData());
+  EXPECT_CALL(*controller()->GetMockValidator(), LoadRules("US"));
+  controller()->Show();
+
+  EXPECT_CALL(*controller()->GetMockValidator(), LoadRules("FR"));
+  controller()->UserEditedOrActivatedInput(SECTION_CC_BILLING,
+                                           ADDRESS_BILLING_COUNTRY,
+                                           gfx::NativeView(),
+                                           gfx::Rect(),
+                                           ASCIIToUTF16("France"),
+                                           true);
+}
+
 }  // namespace autofill