| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <stddef.h> | |
| 6 | |
| 7 #include <map> | |
| 8 #include <memory> | |
| 9 #include <utility> | |
| 10 | |
| 11 #include "base/bind.h" | |
| 12 #include "base/bind_helpers.h" | |
| 13 #include "base/callback.h" | |
| 14 #include "base/command_line.h" | |
| 15 #include "base/guid.h" | |
| 16 #include "base/macros.h" | |
| 17 #include "base/message_loop/message_loop.h" | |
| 18 #include "base/run_loop.h" | |
| 19 #include "base/strings/string_number_conversions.h" | |
| 20 #include "base/strings/string_piece.h" | |
| 21 #include "base/strings/utf_string_conversions.h" | |
| 22 #include "build/build_config.h" | |
| 23 #include "chrome/browser/signin/account_tracker_service_factory.h" | |
| 24 #include "chrome/browser/signin/signin_manager_factory.h" | |
| 25 #include "chrome/browser/ui/autofill/autofill_dialog_controller_impl.h" | |
| 26 #include "chrome/browser/ui/autofill/autofill_dialog_i18n_input.h" | |
| 27 #include "chrome/browser/ui/autofill/autofill_dialog_view.h" | |
| 28 #include "chrome/browser/ui/autofill/mock_address_validator.h" | |
| 29 #include "chrome/browser/web_data_service_factory.h" | |
| 30 #include "chrome/common/chrome_switches.h" | |
| 31 #include "chrome/common/pref_names.h" | |
| 32 #include "chrome/grit/generated_resources.h" | |
| 33 #include "chrome/test/base/chrome_render_view_host_test_harness.h" | |
| 34 #include "chrome/test/base/scoped_testing_local_state.h" | |
| 35 #include "chrome/test/base/testing_browser_process.h" | |
| 36 #include "chrome/test/base/testing_profile.h" | |
| 37 #include "components/autofill/content/browser/risk/proto/fingerprint.pb.h" | |
| 38 #include "components/autofill/core/browser/autofill_metrics.h" | |
| 39 #include "components/autofill/core/browser/autofill_test_utils.h" | |
| 40 #include "components/autofill/core/browser/country_names.h" | |
| 41 #include "components/autofill/core/browser/test_personal_data_manager.h" | |
| 42 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h" | |
| 43 #include "components/autofill/core/common/autofill_constants.h" | |
| 44 #include "components/autofill/core/common/autofill_pref_names.h" | |
| 45 #include "components/autofill/core/common/autofill_switches.h" | |
| 46 #include "components/autofill/core/common/form_data.h" | |
| 47 #include "components/bookmarks/common/bookmark_pref_names.h" | |
| 48 #include "components/prefs/pref_service.h" | |
| 49 #include "components/signin/core/browser/account_tracker_service.h" | |
| 50 #include "components/signin/core/browser/signin_manager.h" | |
| 51 #include "components/user_prefs/user_prefs.h" | |
| 52 #include "content/public/browser/web_contents.h" | |
| 53 #include "content/public/test/mock_render_process_host.h" | |
| 54 #include "google_apis/gaia/google_service_auth_error.h" | |
| 55 #include "grit/components_scaled_resources.h" | |
| 56 #include "grit/components_strings.h" | |
| 57 #include "testing/gmock/include/gmock/gmock.h" | |
| 58 #include "testing/gtest/include/gtest/gtest.h" | |
| 59 #include "third_party/libaddressinput/chromium/chrome_address_validator.h" | |
| 60 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_fi
eld.h" | |
| 61 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_pr
oblem.h" | |
| 62 #include "ui/base/l10n/l10n_util.h" | |
| 63 #include "ui/base/resource/resource_bundle.h" | |
| 64 | |
| 65 #if defined(OS_WIN) | |
| 66 #include "ui/base/win/scoped_ole_initializer.h" | |
| 67 #endif | |
| 68 | |
| 69 using base::ASCIIToUTF16; | |
| 70 using base::UTF8ToUTF16; | |
| 71 | |
| 72 namespace autofill { | |
| 73 | |
| 74 namespace { | |
| 75 | |
| 76 using ::i18n::addressinput::FieldProblemMap; | |
| 77 using testing::AtLeast; | |
| 78 using testing::DoAll; | |
| 79 using testing::Return; | |
| 80 using testing::SetArgPointee; | |
| 81 using testing::_; | |
| 82 | |
| 83 const char kSourceUrl[] = "http://localbike.shop"; | |
| 84 const char kFakeEmail[] = "user@chromium.org"; | |
| 85 const char* kFieldsFromPage[] = | |
| 86 { "email", | |
| 87 "cc-name", | |
| 88 "cc-number", | |
| 89 "cc-exp-month", | |
| 90 "cc-exp-year", | |
| 91 "cc-csc", | |
| 92 "billing name", | |
| 93 "billing address-line1", | |
| 94 "billing address-level2", | |
| 95 "billing address-level1", | |
| 96 "billing postal-code", | |
| 97 "billing country", | |
| 98 "billing tel", | |
| 99 "shipping name", | |
| 100 "shipping address-line1", | |
| 101 "shipping address-level2", | |
| 102 "shipping address-level1", | |
| 103 "shipping postal-code", | |
| 104 "shipping country", | |
| 105 "shipping tel", | |
| 106 }; | |
| 107 const char kTestCCNumberAmex[] = "376200000000002"; | |
| 108 const char kTestCCNumberVisa[] = "4111111111111111"; | |
| 109 const char kTestCCNumberMaster[] = "5555555555554444"; | |
| 110 const char kTestCCNumberDiscover[] = "6011111111111117"; | |
| 111 const char kTestCCNumberIncomplete[] = "4111111111"; | |
| 112 // Credit card number fails Luhn check. | |
| 113 const char kTestCCNumberInvalid[] = "4111111111111112"; | |
| 114 | |
| 115 bool HasAnyError(const ValidityMessages& messages, ServerFieldType field) { | |
| 116 return !messages.GetMessageOrDefault(field).text.empty(); | |
| 117 } | |
| 118 | |
| 119 bool HasUnsureError(const ValidityMessages& messages, ServerFieldType field) { | |
| 120 const ValidityMessage& message = messages.GetMessageOrDefault(field); | |
| 121 return !message.text.empty() && !message.sure; | |
| 122 } | |
| 123 | |
| 124 class TestAutofillDialogView : public AutofillDialogView { | |
| 125 public: | |
| 126 TestAutofillDialogView() | |
| 127 : updates_started_(0), save_details_locally_checked_(true) {} | |
| 128 ~TestAutofillDialogView() override {} | |
| 129 | |
| 130 void Show() override {} | |
| 131 void Hide() override {} | |
| 132 | |
| 133 void UpdatesStarted() override { | |
| 134 updates_started_++; | |
| 135 } | |
| 136 | |
| 137 void UpdatesFinished() override { | |
| 138 updates_started_--; | |
| 139 EXPECT_GE(updates_started_, 0); | |
| 140 } | |
| 141 | |
| 142 void UpdateNotificationArea() override { | |
| 143 EXPECT_GE(updates_started_, 1); | |
| 144 } | |
| 145 | |
| 146 void UpdateButtonStrip() override { | |
| 147 EXPECT_GE(updates_started_, 1); | |
| 148 } | |
| 149 | |
| 150 void UpdateDetailArea() override { | |
| 151 EXPECT_GE(updates_started_, 1); | |
| 152 } | |
| 153 | |
| 154 void UpdateSection(DialogSection section) override { | |
| 155 section_updates_[section]++; | |
| 156 EXPECT_GE(updates_started_, 1); | |
| 157 } | |
| 158 | |
| 159 void UpdateErrorBubble() override { | |
| 160 EXPECT_GE(updates_started_, 1); | |
| 161 } | |
| 162 | |
| 163 void FillSection(DialogSection section, | |
| 164 ServerFieldType originating_type) override {} | |
| 165 void GetUserInput(DialogSection section, FieldValueMap* output) override { | |
| 166 *output = outputs_[section]; | |
| 167 } | |
| 168 | |
| 169 base::string16 GetCvc() override { return base::string16(); } | |
| 170 | |
| 171 bool SaveDetailsLocally() override { return save_details_locally_checked_; } | |
| 172 | |
| 173 MOCK_METHOD0(ModelChanged, void()); | |
| 174 MOCK_METHOD0(UpdateForErrors, void()); | |
| 175 | |
| 176 void ValidateSection(DialogSection) override {} | |
| 177 | |
| 178 void SetUserInput(DialogSection section, const FieldValueMap& map) { | |
| 179 outputs_[section] = map; | |
| 180 } | |
| 181 | |
| 182 void CheckSaveDetailsLocallyCheckbox(bool checked) { | |
| 183 save_details_locally_checked_ = checked; | |
| 184 } | |
| 185 | |
| 186 void ClearSectionUpdates() { | |
| 187 section_updates_.clear(); | |
| 188 } | |
| 189 | |
| 190 std::map<DialogSection, size_t> section_updates() const { | |
| 191 return section_updates_; | |
| 192 } | |
| 193 | |
| 194 private: | |
| 195 std::map<DialogSection, FieldValueMap> outputs_; | |
| 196 std::map<DialogSection, size_t> section_updates_; | |
| 197 | |
| 198 int updates_started_; | |
| 199 bool save_details_locally_checked_; | |
| 200 | |
| 201 DISALLOW_COPY_AND_ASSIGN(TestAutofillDialogView); | |
| 202 }; | |
| 203 | |
| 204 class TestAutofillDialogController | |
| 205 : public AutofillDialogControllerImpl, | |
| 206 public base::SupportsWeakPtr<TestAutofillDialogController> { | |
| 207 public: | |
| 208 TestAutofillDialogController( | |
| 209 content::WebContents* contents, | |
| 210 const FormData& form_structure, | |
| 211 const GURL& source_url, | |
| 212 const AutofillClient::ResultCallback& callback) | |
| 213 : AutofillDialogControllerImpl(contents, | |
| 214 form_structure, | |
| 215 source_url, | |
| 216 callback), | |
| 217 submit_button_delay_count_(0) {} | |
| 218 | |
| 219 ~TestAutofillDialogController() override {} | |
| 220 | |
| 221 AutofillDialogView* CreateView() override { | |
| 222 return new testing::NiceMock<TestAutofillDialogView>(); | |
| 223 } | |
| 224 | |
| 225 void Init(content::BrowserContext* browser_context) { | |
| 226 Profile* profile = Profile::FromBrowserContext(browser_context); | |
| 227 test_manager_.Init(WebDataServiceFactory::GetAutofillWebDataForProfile( | |
| 228 profile, | |
| 229 ServiceAccessType::EXPLICIT_ACCESS), | |
| 230 user_prefs::UserPrefs::Get(browser_context), | |
| 231 AccountTrackerServiceFactory::GetForProfile(profile), | |
| 232 SigninManagerFactory::GetForProfile(profile), | |
| 233 browser_context->IsOffTheRecord()); | |
| 234 } | |
| 235 | |
| 236 TestAutofillDialogView* GetView() { | |
| 237 return static_cast<TestAutofillDialogView*>(view()); | |
| 238 } | |
| 239 | |
| 240 TestPersonalDataManager* GetTestingManager() { | |
| 241 return &test_manager_; | |
| 242 } | |
| 243 | |
| 244 MockAddressValidator* GetMockValidator() { | |
| 245 return &mock_validator_; | |
| 246 } | |
| 247 | |
| 248 const GURL& open_tab_url() { return open_tab_url_; } | |
| 249 | |
| 250 void SimulateSubmitButtonDelayBegin() { | |
| 251 AutofillDialogControllerImpl::SubmitButtonDelayBegin(); | |
| 252 } | |
| 253 | |
| 254 void SimulateSubmitButtonDelayEnd() { | |
| 255 AutofillDialogControllerImpl::SubmitButtonDelayEndForTesting(); | |
| 256 } | |
| 257 | |
| 258 // Returns the number of times that the submit button was delayed. | |
| 259 int get_submit_button_delay_count() const { | |
| 260 return submit_button_delay_count_; | |
| 261 } | |
| 262 | |
| 263 MOCK_METHOD0(LoadRiskFingerprintData, void()); | |
| 264 using AutofillDialogControllerImpl::IsEditingExistingData; | |
| 265 using AutofillDialogControllerImpl::IsManuallyEditingSection; | |
| 266 using AutofillDialogControllerImpl::popup_input_type; | |
| 267 | |
| 268 protected: | |
| 269 PersonalDataManager* GetManager() const override { | |
| 270 return const_cast<TestAutofillDialogController*>(this)-> | |
| 271 GetTestingManager(); | |
| 272 } | |
| 273 | |
| 274 AddressValidator* GetValidator() override { | |
| 275 return &mock_validator_; | |
| 276 } | |
| 277 | |
| 278 void OpenTabWithUrl(const GURL& url) override { | |
| 279 open_tab_url_ = url; | |
| 280 } | |
| 281 | |
| 282 // AutofillDialogControllerImpl calls this method before showing the dialog | |
| 283 // window. | |
| 284 void SubmitButtonDelayBegin() override { | |
| 285 // Do not delay enabling the submit button in testing. | |
| 286 submit_button_delay_count_++; | |
| 287 } | |
| 288 | |
| 289 private: | |
| 290 TestPersonalDataManager test_manager_; | |
| 291 | |
| 292 // A mock validator object to prevent network requests and track when | |
| 293 // validation rules are loaded or validation attempts occur. | |
| 294 testing::NiceMock<MockAddressValidator> mock_validator_; | |
| 295 | |
| 296 GURL open_tab_url_; | |
| 297 | |
| 298 // The number of times that the submit button was delayed. | |
| 299 int submit_button_delay_count_; | |
| 300 | |
| 301 DISALLOW_COPY_AND_ASSIGN(TestAutofillDialogController); | |
| 302 }; | |
| 303 | |
| 304 class AutofillDialogControllerTest : public ChromeRenderViewHostTestHarness { | |
| 305 protected: | |
| 306 AutofillDialogControllerTest() : form_structure_(NULL) { | |
| 307 CountryNames::SetLocaleString("en-US"); | |
| 308 } | |
| 309 | |
| 310 // testing::Test implementation: | |
| 311 void SetUp() override { | |
| 312 ChromeRenderViewHostTestHarness::SetUp(); | |
| 313 Reset(); | |
| 314 } | |
| 315 | |
| 316 void TearDown() override { | |
| 317 if (controller_) | |
| 318 controller_->ViewClosed(); | |
| 319 ChromeRenderViewHostTestHarness::TearDown(); | |
| 320 } | |
| 321 | |
| 322 void Reset() { | |
| 323 if (controller_) | |
| 324 controller_->ViewClosed(); | |
| 325 | |
| 326 profile()->GetPrefs()->ClearPref(::prefs::kAutofillDialogSaveData); | |
| 327 | |
| 328 // We have to clear the old local state before creating a new one. | |
| 329 scoped_local_state_.reset(); | |
| 330 scoped_local_state_.reset(new ScopedTestingLocalState( | |
| 331 TestingBrowserProcess::GetGlobal())); | |
| 332 | |
| 333 SetUpControllerWithFormData(DefaultFormData()); | |
| 334 } | |
| 335 | |
| 336 FormData DefaultFormData() { | |
| 337 FormData form_data; | |
| 338 for (size_t i = 0; i < arraysize(kFieldsFromPage); ++i) { | |
| 339 FormFieldData field; | |
| 340 field.autocomplete_attribute = kFieldsFromPage[i]; | |
| 341 form_data.fields.push_back(field); | |
| 342 } | |
| 343 return form_data; | |
| 344 } | |
| 345 | |
| 346 // Creates a new controller for |form_data|. | |
| 347 void ResetControllerWithFormData(const FormData& form_data) { | |
| 348 if (controller_) | |
| 349 controller_->ViewClosed(); | |
| 350 | |
| 351 AutofillClient::ResultCallback callback = | |
| 352 base::Bind(&AutofillDialogControllerTest::FinishedCallback, | |
| 353 base::Unretained(this)); | |
| 354 controller_ = (new testing::NiceMock<TestAutofillDialogController>( | |
| 355 web_contents(), | |
| 356 form_data, | |
| 357 GURL(kSourceUrl), | |
| 358 callback))->AsWeakPtr(); | |
| 359 controller_->Init(profile()); | |
| 360 } | |
| 361 | |
| 362 // Creates a new controller for |form_data|. | |
| 363 void SetUpControllerWithFormData(const FormData& form_data) { | |
| 364 ResetControllerWithFormData(form_data); | |
| 365 controller()->Show(); | |
| 366 } | |
| 367 | |
| 368 // Fills the inputs in SECTION_CC with data. | |
| 369 void FillCreditCardInputs() { | |
| 370 FieldValueMap cc_outputs; | |
| 371 const DetailInputs& cc_inputs = | |
| 372 controller()->RequestedFieldsForSection(SECTION_CC); | |
| 373 for (size_t i = 0; i < cc_inputs.size(); ++i) { | |
| 374 cc_outputs[cc_inputs[i].type] = cc_inputs[i].type == CREDIT_CARD_NUMBER ? | |
| 375 ASCIIToUTF16(kTestCCNumberVisa) : ASCIIToUTF16("11"); | |
| 376 } | |
| 377 controller()->GetView()->SetUserInput(SECTION_CC, cc_outputs); | |
| 378 } | |
| 379 | |
| 380 // Activates the 'Add new foo' option from the |section|'s suggestions | |
| 381 // dropdown and fills the |section|'s inputs with the data from the | |
| 382 // |data_model|. If |section| is SECTION_CC, also fills in '123' for the CVC. | |
| 383 void FillInputs(DialogSection section, const AutofillDataModel& data_model) { | |
| 384 // Select the 'Add new foo' option. | |
| 385 ui::MenuModel* model = GetMenuModelForSection(section); | |
| 386 if (model) | |
| 387 model->ActivatedAt(model->GetItemCount() - 2); | |
| 388 | |
| 389 // Fill the inputs. | |
| 390 FieldValueMap outputs; | |
| 391 const DetailInputs& inputs = | |
| 392 controller()->RequestedFieldsForSection(section); | |
| 393 for (size_t i = 0; i < inputs.size(); ++i) { | |
| 394 ServerFieldType type = inputs[i].type; | |
| 395 base::string16 output; | |
| 396 if (type == CREDIT_CARD_VERIFICATION_CODE) | |
| 397 output = ASCIIToUTF16("123"); | |
| 398 else | |
| 399 output = data_model.GetInfo(AutofillType(type), "en-US"); | |
| 400 outputs[inputs[i].type] = output; | |
| 401 } | |
| 402 controller()->GetView()->SetUserInput(section, outputs); | |
| 403 } | |
| 404 | |
| 405 std::vector<DialogNotification> NotificationsOfType( | |
| 406 DialogNotification::Type type) { | |
| 407 std::vector<DialogNotification> right_type; | |
| 408 const std::vector<DialogNotification>& notifications = | |
| 409 controller()->CurrentNotifications(); | |
| 410 for (size_t i = 0; i < notifications.size(); ++i) { | |
| 411 if (notifications[i].type() == type) | |
| 412 right_type.push_back(notifications[i]); | |
| 413 } | |
| 414 return right_type; | |
| 415 } | |
| 416 | |
| 417 void UseBillingForShipping() { | |
| 418 controller()->MenuModelForSection(SECTION_SHIPPING)->ActivatedAt(0); | |
| 419 } | |
| 420 | |
| 421 base::string16 ValidateCCNumber(DialogSection section, | |
| 422 const std::string& cc_number, | |
| 423 bool should_pass) { | |
| 424 FieldValueMap outputs; | |
| 425 outputs[ADDRESS_BILLING_COUNTRY] = ASCIIToUTF16("United States"); | |
| 426 outputs[CREDIT_CARD_NUMBER] = UTF8ToUTF16(cc_number); | |
| 427 ValidityMessages messages = | |
| 428 controller()->InputsAreValid(section, outputs); | |
| 429 EXPECT_EQ(should_pass, !messages.HasSureError(CREDIT_CARD_NUMBER)); | |
| 430 return messages.GetMessageOrDefault(CREDIT_CARD_NUMBER).text; | |
| 431 } | |
| 432 | |
| 433 // Returns true if the given |section| contains a field of the given |type|. | |
| 434 bool SectionContainsField(DialogSection section, ServerFieldType type) { | |
| 435 const DetailInputs& inputs = | |
| 436 controller()->RequestedFieldsForSection(section); | |
| 437 for (DetailInputs::const_iterator it = inputs.begin(); it != inputs.end(); | |
| 438 ++it) { | |
| 439 if (it->type == type) | |
| 440 return true; | |
| 441 } | |
| 442 return false; | |
| 443 } | |
| 444 | |
| 445 SuggestionsMenuModel* GetMenuModelForSection(DialogSection section) { | |
| 446 ui::MenuModel* model = controller()->MenuModelForSection(section); | |
| 447 return static_cast<SuggestionsMenuModel*>(model); | |
| 448 } | |
| 449 | |
| 450 void SubmitAndVerifyShippingAndBillingResults() { | |
| 451 // Test after setting use billing for shipping. | |
| 452 UseBillingForShipping(); | |
| 453 | |
| 454 controller()->OnAccept(); | |
| 455 | |
| 456 ASSERT_EQ(20U, form_structure()->field_count()); | |
| 457 EXPECT_EQ(ADDRESS_HOME_COUNTRY, | |
| 458 form_structure()->field(11)->Type().GetStorableType()); | |
| 459 EXPECT_EQ(ADDRESS_BILLING, form_structure()->field(11)->Type().group()); | |
| 460 EXPECT_EQ(ADDRESS_HOME_COUNTRY, | |
| 461 form_structure()->field(18)->Type().GetStorableType()); | |
| 462 EXPECT_EQ(ADDRESS_HOME, form_structure()->field(18)->Type().group()); | |
| 463 base::string16 billing_country = form_structure()->field(11)->value; | |
| 464 EXPECT_EQ(2U, billing_country.size()); | |
| 465 base::string16 shipping_country = form_structure()->field(18)->value; | |
| 466 EXPECT_EQ(2U, shipping_country.size()); | |
| 467 EXPECT_FALSE(billing_country.empty()); | |
| 468 EXPECT_FALSE(shipping_country.empty()); | |
| 469 EXPECT_EQ(billing_country, shipping_country); | |
| 470 | |
| 471 EXPECT_EQ(CREDIT_CARD_NAME_FULL, | |
| 472 form_structure()->field(1)->Type().GetStorableType()); | |
| 473 base::string16 cc_name = form_structure()->field(1)->value; | |
| 474 EXPECT_EQ(NAME_FULL, form_structure()->field(6)->Type().GetStorableType()); | |
| 475 EXPECT_EQ(NAME_BILLING, form_structure()->field(6)->Type().group()); | |
| 476 base::string16 billing_name = form_structure()->field(6)->value; | |
| 477 EXPECT_EQ(NAME_FULL, form_structure()->field(13)->Type().GetStorableType()); | |
| 478 EXPECT_EQ(NAME, form_structure()->field(13)->Type().group()); | |
| 479 base::string16 shipping_name = form_structure()->field(13)->value; | |
| 480 | |
| 481 EXPECT_FALSE(cc_name.empty()); | |
| 482 EXPECT_FALSE(billing_name.empty()); | |
| 483 EXPECT_FALSE(shipping_name.empty()); | |
| 484 EXPECT_EQ(cc_name, billing_name); | |
| 485 EXPECT_EQ(cc_name, shipping_name); | |
| 486 } | |
| 487 | |
| 488 TestAutofillDialogController* controller() { return controller_.get(); } | |
| 489 | |
| 490 const FormStructure* form_structure() { return form_structure_; } | |
| 491 | |
| 492 private: | |
| 493 void FinishedCallback(AutofillClient::RequestAutocompleteResult result, | |
| 494 const base::string16& debug_message, | |
| 495 const FormStructure* form_structure) { | |
| 496 form_structure_ = form_structure; | |
| 497 } | |
| 498 | |
| 499 #if defined(OS_WIN) | |
| 500 // http://crbug.com/227221 | |
| 501 ui::ScopedOleInitializer ole_initializer_; | |
| 502 #endif | |
| 503 | |
| 504 // The controller owns itself. | |
| 505 base::WeakPtr<TestAutofillDialogController> controller_; | |
| 506 | |
| 507 // Returned when the dialog closes successfully. | |
| 508 const FormStructure* form_structure_; | |
| 509 | |
| 510 std::unique_ptr<ScopedTestingLocalState> scoped_local_state_; | |
| 511 }; | |
| 512 | |
| 513 } // namespace | |
| 514 | |
| 515 TEST_F(AutofillDialogControllerTest, RefuseToShowWithNoAutocompleteAttributes) { | |
| 516 FormFieldData email_field; | |
| 517 email_field.name = ASCIIToUTF16("email"); | |
| 518 FormFieldData cc_field; | |
| 519 cc_field.name = ASCIIToUTF16("cc"); | |
| 520 FormFieldData billing_field; | |
| 521 billing_field.name = ASCIIToUTF16("billing name"); | |
| 522 | |
| 523 FormData form_data; | |
| 524 form_data.fields.push_back(email_field); | |
| 525 form_data.fields.push_back(cc_field); | |
| 526 form_data.fields.push_back(billing_field); | |
| 527 | |
| 528 SetUpControllerWithFormData(form_data); | |
| 529 EXPECT_FALSE(controller()); | |
| 530 } | |
| 531 | |
| 532 TEST_F(AutofillDialogControllerTest, RefuseToShowWithNoCcField) { | |
| 533 FormFieldData shipping_tel; | |
| 534 shipping_tel.autocomplete_attribute = "shipping tel"; | |
| 535 | |
| 536 FormData form_data; | |
| 537 form_data.fields.push_back(shipping_tel); | |
| 538 | |
| 539 SetUpControllerWithFormData(form_data); | |
| 540 EXPECT_FALSE(controller()); | |
| 541 | |
| 542 // Any cc- field will do. | |
| 543 FormFieldData cc_field; | |
| 544 cc_field.autocomplete_attribute = "cc-csc"; | |
| 545 form_data.fields.push_back(cc_field); | |
| 546 | |
| 547 SetUpControllerWithFormData(form_data); | |
| 548 EXPECT_TRUE(controller()); | |
| 549 } | |
| 550 | |
| 551 // Ensure the default ValidityMessage has the expected values. | |
| 552 TEST_F(AutofillDialogControllerTest, DefaultValidityMessage) { | |
| 553 ValidityMessages messages; | |
| 554 ValidityMessage message = messages.GetMessageOrDefault(UNKNOWN_TYPE); | |
| 555 EXPECT_FALSE(message.sure); | |
| 556 EXPECT_TRUE(message.text.empty()); | |
| 557 } | |
| 558 | |
| 559 // This test makes sure nothing falls over when fields are being validity- | |
| 560 // checked. | |
| 561 TEST_F(AutofillDialogControllerTest, ValidityCheck) { | |
| 562 for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) { | |
| 563 DialogSection section = static_cast<DialogSection>(i); | |
| 564 const DetailInputs& shipping_inputs = | |
| 565 controller()->RequestedFieldsForSection(section); | |
| 566 for (DetailInputs::const_iterator iter = shipping_inputs.begin(); | |
| 567 iter != shipping_inputs.end(); ++iter) { | |
| 568 controller()->InputValidityMessage(section, iter->type, base::string16()); | |
| 569 } | |
| 570 } | |
| 571 } | |
| 572 | |
| 573 // Test for phone number validation. | |
| 574 TEST_F(AutofillDialogControllerTest, PhoneNumberValidation) { | |
| 575 for (size_t i = 0; i < 2; ++i) { | |
| 576 ServerFieldType phone = i == 0 ? PHONE_HOME_WHOLE_NUMBER : | |
| 577 PHONE_BILLING_WHOLE_NUMBER; | |
| 578 ServerFieldType address = i == 0 ? ADDRESS_HOME_COUNTRY : | |
| 579 ADDRESS_BILLING_COUNTRY; | |
| 580 DialogSection section = i == 0 ? SECTION_SHIPPING : SECTION_BILLING; | |
| 581 | |
| 582 FieldValueMap outputs; | |
| 583 const DetailInputs& inputs = | |
| 584 controller()->RequestedFieldsForSection(section); | |
| 585 AutofillProfile full_profile(test::GetVerifiedProfile()); | |
| 586 for (size_t j = 0; j < inputs.size(); ++j) { | |
| 587 const ServerFieldType type = inputs[j].type; | |
| 588 outputs[type] = full_profile.GetInfo(AutofillType(type), "en-US"); | |
| 589 } | |
| 590 | |
| 591 // Make sure country is United States. | |
| 592 outputs[address] = ASCIIToUTF16("United States"); | |
| 593 | |
| 594 // Existing data should have no errors. | |
| 595 ValidityMessages messages = controller()->InputsAreValid(section, outputs); | |
| 596 EXPECT_FALSE(HasAnyError(messages, phone)); | |
| 597 | |
| 598 // Input an empty phone number. | |
| 599 outputs[phone] = base::string16(); | |
| 600 messages = controller()->InputsAreValid(section, outputs); | |
| 601 EXPECT_TRUE(HasUnsureError(messages, phone)); | |
| 602 | |
| 603 // Input an invalid phone number. | |
| 604 outputs[phone] = ASCIIToUTF16("ABC"); | |
| 605 messages = controller()->InputsAreValid(section, outputs); | |
| 606 EXPECT_TRUE(messages.HasSureError(phone)); | |
| 607 | |
| 608 // Input a local phone number. | |
| 609 outputs[phone] = ASCIIToUTF16("2155546699"); | |
| 610 messages = controller()->InputsAreValid(section, outputs); | |
| 611 EXPECT_FALSE(HasAnyError(messages, phone)); | |
| 612 | |
| 613 // Input an invalid local phone number. | |
| 614 outputs[phone] = ASCIIToUTF16("215554669"); | |
| 615 messages = controller()->InputsAreValid(section, outputs); | |
| 616 EXPECT_TRUE(messages.HasSureError(phone)); | |
| 617 | |
| 618 // Input an international phone number. | |
| 619 outputs[phone] = ASCIIToUTF16("+33 892 70 12 39"); | |
| 620 messages = controller()->InputsAreValid(section, outputs); | |
| 621 EXPECT_FALSE(HasAnyError(messages, phone)); | |
| 622 | |
| 623 // Input an invalid international phone number. | |
| 624 outputs[phone] = ASCIIToUTF16("+112333 892 70 12 39"); | |
| 625 messages = controller()->InputsAreValid(section, outputs); | |
| 626 EXPECT_TRUE(messages.HasSureError(phone)); | |
| 627 | |
| 628 // Input a valid Canadian number. | |
| 629 outputs[phone] = ASCIIToUTF16("+1 506 887 1234"); | |
| 630 messages = controller()->InputsAreValid(section, outputs); | |
| 631 EXPECT_FALSE(HasAnyError(messages, phone)); | |
| 632 | |
| 633 // Input a valid Canadian number without the country code. | |
| 634 outputs[phone] = ASCIIToUTF16("506 887 1234"); | |
| 635 messages = controller()->InputsAreValid(section, outputs); | |
| 636 EXPECT_TRUE(HasAnyError(messages, phone)); | |
| 637 | |
| 638 // Input a valid Canadian toll-free number. | |
| 639 outputs[phone] = ASCIIToUTF16("310 1234"); | |
| 640 messages = controller()->InputsAreValid(section, outputs); | |
| 641 EXPECT_TRUE(HasAnyError(messages, phone)); | |
| 642 } | |
| 643 } | |
| 644 | |
| 645 TEST_F(AutofillDialogControllerTest, ExpirationDateValidity) { | |
| 646 ui::ComboboxModel* exp_year_model = | |
| 647 controller()->ComboboxModelForAutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR); | |
| 648 ui::ComboboxModel* exp_month_model = | |
| 649 controller()->ComboboxModelForAutofillType(CREDIT_CARD_EXP_MONTH); | |
| 650 | |
| 651 base::string16 default_year_value = | |
| 652 exp_year_model->GetItemAt(exp_year_model->GetDefaultIndex()); | |
| 653 base::string16 default_month_value = | |
| 654 exp_month_model->GetItemAt(exp_month_model->GetDefaultIndex()); | |
| 655 | |
| 656 base::string16 other_year_value = | |
| 657 exp_year_model->GetItemAt(exp_year_model->GetItemCount() - 1); | |
| 658 base::string16 other_month_value = | |
| 659 exp_month_model->GetItemAt(exp_month_model->GetItemCount() - 1); | |
| 660 | |
| 661 FieldValueMap outputs; | |
| 662 outputs[CREDIT_CARD_EXP_MONTH] = default_month_value; | |
| 663 outputs[CREDIT_CARD_EXP_4_DIGIT_YEAR] = default_year_value; | |
| 664 | |
| 665 // Expiration default values generate unsure validation errors (but not sure). | |
| 666 ValidityMessages messages = controller()->InputsAreValid(SECTION_CC, outputs); | |
| 667 EXPECT_TRUE(HasUnsureError(messages, CREDIT_CARD_EXP_4_DIGIT_YEAR)); | |
| 668 EXPECT_TRUE(HasUnsureError(messages, CREDIT_CARD_EXP_MONTH)); | |
| 669 | |
| 670 // Expiration date with default month fails. | |
| 671 outputs[CREDIT_CARD_EXP_4_DIGIT_YEAR] = other_year_value; | |
| 672 messages = controller()->InputsAreValid(SECTION_CC, outputs); | |
| 673 EXPECT_FALSE(HasUnsureError(messages, CREDIT_CARD_EXP_4_DIGIT_YEAR)); | |
| 674 EXPECT_TRUE(HasUnsureError(messages, CREDIT_CARD_EXP_MONTH)); | |
| 675 | |
| 676 // Expiration date with default year fails. | |
| 677 outputs[CREDIT_CARD_EXP_MONTH] = other_month_value; | |
| 678 outputs[CREDIT_CARD_EXP_4_DIGIT_YEAR] = default_year_value; | |
| 679 messages = controller()->InputsAreValid(SECTION_CC, outputs); | |
| 680 EXPECT_TRUE(HasUnsureError(messages, CREDIT_CARD_EXP_4_DIGIT_YEAR)); | |
| 681 EXPECT_FALSE(HasUnsureError(messages, CREDIT_CARD_EXP_MONTH)); | |
| 682 } | |
| 683 | |
| 684 TEST_F(AutofillDialogControllerTest, BillingNameValidation) { | |
| 685 FieldValueMap outputs; | |
| 686 outputs[ADDRESS_BILLING_COUNTRY] = ASCIIToUTF16("United States"); | |
| 687 | |
| 688 // Input an empty billing name. | |
| 689 outputs[NAME_BILLING_FULL] = base::string16(); | |
| 690 ValidityMessages messages = controller()->InputsAreValid(SECTION_BILLING, | |
| 691 outputs); | |
| 692 EXPECT_TRUE(HasUnsureError(messages, NAME_BILLING_FULL)); | |
| 693 | |
| 694 // Input a non-empty billing name. | |
| 695 outputs[NAME_BILLING_FULL] = ASCIIToUTF16("Bob"); | |
| 696 messages = controller()->InputsAreValid(SECTION_BILLING, outputs); | |
| 697 EXPECT_FALSE(HasAnyError(messages, NAME_BILLING_FULL)); | |
| 698 } | |
| 699 | |
| 700 TEST_F(AutofillDialogControllerTest, CreditCardNumberValidation) { | |
| 701 // Should accept AMEX, Visa, Master and Discover. | |
| 702 ValidateCCNumber(SECTION_CC, kTestCCNumberVisa, true); | |
| 703 ValidateCCNumber(SECTION_CC, kTestCCNumberMaster, true); | |
| 704 ValidateCCNumber(SECTION_CC, kTestCCNumberDiscover, true); | |
| 705 ValidateCCNumber(SECTION_CC, kTestCCNumberAmex, true); | |
| 706 ValidateCCNumber(SECTION_CC, kTestCCNumberIncomplete, false); | |
| 707 ValidateCCNumber(SECTION_CC, kTestCCNumberInvalid, false); | |
| 708 } | |
| 709 | |
| 710 TEST_F(AutofillDialogControllerTest, AutofillProfiles) { | |
| 711 ui::MenuModel* shipping_model = | |
| 712 controller()->MenuModelForSection(SECTION_SHIPPING); | |
| 713 // Since the PersonalDataManager is empty, this should only have the | |
| 714 // "use billing", "add new" and "manage" menu items. | |
| 715 ASSERT_TRUE(shipping_model); | |
| 716 EXPECT_EQ(3, shipping_model->GetItemCount()); | |
| 717 // On the other hand, the other models should be NULL when there's no | |
| 718 // suggestion. | |
| 719 EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC)); | |
| 720 EXPECT_FALSE(controller()->MenuModelForSection(SECTION_BILLING)); | |
| 721 | |
| 722 EXPECT_CALL(*controller()->GetView(), ModelChanged()).Times(3); | |
| 723 | |
| 724 // Empty profiles are ignored. | |
| 725 AutofillProfile empty_profile(base::GenerateGUID(), kSettingsOrigin); | |
| 726 empty_profile.SetRawInfo(NAME_FULL, ASCIIToUTF16("John Doe")); | |
| 727 controller()->GetTestingManager()->AddTestingProfile(&empty_profile); | |
| 728 shipping_model = controller()->MenuModelForSection(SECTION_SHIPPING); | |
| 729 ASSERT_TRUE(shipping_model); | |
| 730 EXPECT_EQ(3, shipping_model->GetItemCount()); | |
| 731 | |
| 732 // An otherwise full but unverified profile should be ignored. | |
| 733 AutofillProfile full_profile(test::GetFullProfile()); | |
| 734 full_profile.set_origin("https://www.example.com"); | |
| 735 full_profile.SetRawInfo(ADDRESS_HOME_LINE2, base::string16()); | |
| 736 controller()->GetTestingManager()->AddTestingProfile(&full_profile); | |
| 737 shipping_model = controller()->MenuModelForSection(SECTION_SHIPPING); | |
| 738 ASSERT_TRUE(shipping_model); | |
| 739 EXPECT_EQ(3, shipping_model->GetItemCount()); | |
| 740 | |
| 741 // A full, verified profile should be picked up. | |
| 742 AutofillProfile verified_profile(test::GetVerifiedProfile()); | |
| 743 verified_profile.SetRawInfo(ADDRESS_HOME_LINE2, base::string16()); | |
| 744 controller()->GetTestingManager()->AddTestingProfile(&verified_profile); | |
| 745 shipping_model = controller()->MenuModelForSection(SECTION_SHIPPING); | |
| 746 ASSERT_TRUE(shipping_model); | |
| 747 EXPECT_EQ(4, shipping_model->GetItemCount()); | |
| 748 } | |
| 749 | |
| 750 // Checks that a valid profile is selected by default, but if invalid is | |
| 751 // popped into edit mode. | |
| 752 TEST_F(AutofillDialogControllerTest, AutofillProfilesPopInvalidIntoEdit) { | |
| 753 SuggestionsMenuModel* shipping_model = | |
| 754 GetMenuModelForSection(SECTION_SHIPPING); | |
| 755 EXPECT_EQ(3, shipping_model->GetItemCount()); | |
| 756 // "Same as billing" is selected. | |
| 757 EXPECT_FALSE(controller()->IsManuallyEditingSection(SECTION_SHIPPING)); | |
| 758 EXPECT_TRUE(controller()->IsManuallyEditingSection(SECTION_BILLING)); | |
| 759 | |
| 760 AutofillProfile verified_profile(test::GetVerifiedProfile()); | |
| 761 controller()->GetTestingManager()->AddTestingProfile(&verified_profile); | |
| 762 EXPECT_EQ(4, shipping_model->GetItemCount()); | |
| 763 EXPECT_FALSE(controller()->IsManuallyEditingSection(SECTION_SHIPPING)); | |
| 764 EXPECT_FALSE(controller()->IsManuallyEditingSection(SECTION_BILLING)); | |
| 765 | |
| 766 // Now make up a problem and make sure the profile isn't in the list. | |
| 767 Reset(); | |
| 768 FieldProblemMap problems; | |
| 769 problems.insert(std::make_pair(::i18n::addressinput::POSTAL_CODE, | |
| 770 ::i18n::addressinput::MISMATCHING_VALUE)); | |
| 771 EXPECT_CALL(*controller()->GetMockValidator(), | |
| 772 ValidateAddress(CountryCodeMatcher("US"), _, _)). | |
| 773 WillRepeatedly(DoAll(SetArgPointee<2>(problems), | |
| 774 Return(AddressValidator::SUCCESS))); | |
| 775 | |
| 776 controller()->GetTestingManager()->AddTestingProfile(&verified_profile); | |
| 777 shipping_model = GetMenuModelForSection(SECTION_SHIPPING); | |
| 778 EXPECT_EQ(4, shipping_model->GetItemCount()); | |
| 779 EXPECT_TRUE(controller()->IsManuallyEditingSection(SECTION_SHIPPING)); | |
| 780 EXPECT_TRUE(controller()->IsManuallyEditingSection(SECTION_BILLING)); | |
| 781 } | |
| 782 | |
| 783 // Makes sure suggestion profiles are re-validated when validation rules load. | |
| 784 TEST_F(AutofillDialogControllerTest, AutofillProfilesRevalidateAfterRulesLoad) { | |
| 785 SuggestionsMenuModel* shipping_model = | |
| 786 GetMenuModelForSection(SECTION_SHIPPING); | |
| 787 EXPECT_EQ(3, shipping_model->GetItemCount()); | |
| 788 // "Same as billing" is selected. | |
| 789 EXPECT_FALSE(controller()->IsManuallyEditingSection(SECTION_SHIPPING)); | |
| 790 EXPECT_TRUE(controller()->IsManuallyEditingSection(SECTION_BILLING)); | |
| 791 AutofillProfile verified_profile(test::GetVerifiedProfile()); | |
| 792 controller()->GetTestingManager()->AddTestingProfile(&verified_profile); | |
| 793 EXPECT_EQ(4, shipping_model->GetItemCount()); | |
| 794 EXPECT_FALSE(controller()->IsManuallyEditingSection(SECTION_SHIPPING)); | |
| 795 EXPECT_FALSE(controller()->IsManuallyEditingSection(SECTION_BILLING)); | |
| 796 | |
| 797 FieldProblemMap problems; | |
| 798 problems.insert(std::make_pair(::i18n::addressinput::POSTAL_CODE, | |
| 799 ::i18n::addressinput::MISMATCHING_VALUE)); | |
| 800 EXPECT_CALL(*controller()->GetMockValidator(), | |
| 801 ValidateAddress(CountryCodeMatcher("US"), _, _)). | |
| 802 WillRepeatedly(DoAll(SetArgPointee<2>(problems), | |
| 803 Return(AddressValidator::SUCCESS))); | |
| 804 | |
| 805 controller()->OnAddressValidationRulesLoaded("US", true); | |
| 806 EXPECT_EQ(4, shipping_model->GetItemCount()); | |
| 807 EXPECT_TRUE(controller()->IsManuallyEditingSection(SECTION_SHIPPING)); | |
| 808 EXPECT_TRUE(controller()->IsManuallyEditingSection(SECTION_BILLING)); | |
| 809 } | |
| 810 | |
| 811 // Makes sure that the choice of which Autofill profile to use for each section | |
| 812 // is sticky. | |
| 813 TEST_F(AutofillDialogControllerTest, AutofillProfileDefaults) { | |
| 814 AutofillProfile profile(test::GetVerifiedProfile()); | |
| 815 AutofillProfile profile2(test::GetVerifiedProfile2()); | |
| 816 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 817 controller()->GetTestingManager()->AddTestingProfile(&profile2); | |
| 818 | |
| 819 // Until a selection has been made, the default shipping suggestion is the | |
| 820 // first one (after "use billing"). | |
| 821 SuggestionsMenuModel* shipping_model = | |
| 822 GetMenuModelForSection(SECTION_SHIPPING); | |
| 823 EXPECT_EQ(1, shipping_model->checked_item()); | |
| 824 | |
| 825 for (int i = 2; i >= 0; --i) { | |
| 826 shipping_model = GetMenuModelForSection(SECTION_SHIPPING); | |
| 827 shipping_model->ExecuteCommand(i, 0); | |
| 828 FillCreditCardInputs(); | |
| 829 controller()->OnAccept(); | |
| 830 | |
| 831 Reset(); | |
| 832 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 833 controller()->GetTestingManager()->AddTestingProfile(&profile2); | |
| 834 shipping_model = GetMenuModelForSection(SECTION_SHIPPING); | |
| 835 EXPECT_EQ(i, shipping_model->checked_item()); | |
| 836 } | |
| 837 | |
| 838 // Try again, but don't add the default profile to the PDM. The dialog | |
| 839 // should fall back to the first profile. | |
| 840 shipping_model->ExecuteCommand(2, 0); | |
| 841 FillCreditCardInputs(); | |
| 842 controller()->OnAccept(); | |
| 843 Reset(); | |
| 844 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 845 shipping_model = GetMenuModelForSection(SECTION_SHIPPING); | |
| 846 EXPECT_EQ(1, shipping_model->checked_item()); | |
| 847 } | |
| 848 | |
| 849 // Makes sure that a newly added Autofill profile becomes set as the default | |
| 850 // choice for the next run. | |
| 851 TEST_F(AutofillDialogControllerTest, NewAutofillProfileIsDefault) { | |
| 852 | |
| 853 AutofillProfile profile(test::GetVerifiedProfile()); | |
| 854 CreditCard credit_card(test::GetVerifiedCreditCard()); | |
| 855 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 856 controller()->GetTestingManager()->AddTestingCreditCard(&credit_card); | |
| 857 | |
| 858 // Until a selection has been made, the default suggestion is the first one. | |
| 859 // For the shipping section, this follows the "use billing" suggestion. | |
| 860 EXPECT_EQ(0, GetMenuModelForSection(SECTION_CC)->checked_item()); | |
| 861 EXPECT_EQ(1, GetMenuModelForSection(SECTION_SHIPPING)->checked_item()); | |
| 862 | |
| 863 // Fill in the shipping and credit card sections with new data. | |
| 864 AutofillProfile new_profile(test::GetVerifiedProfile2()); | |
| 865 CreditCard new_credit_card(test::GetVerifiedCreditCard2()); | |
| 866 FillInputs(SECTION_SHIPPING, new_profile); | |
| 867 FillInputs(SECTION_CC, new_credit_card); | |
| 868 controller()->GetView()->CheckSaveDetailsLocallyCheckbox(true); | |
| 869 controller()->OnAccept(); | |
| 870 | |
| 871 // Update the |new_profile| and |new_credit_card|'s guids to the saved ones. | |
| 872 new_profile.set_guid( | |
| 873 controller()->GetTestingManager()->imported_profile().guid()); | |
| 874 new_credit_card.set_guid( | |
| 875 controller()->GetTestingManager()->imported_credit_card().guid()); | |
| 876 | |
| 877 // Reload the dialog. The newly added address should now be set as the | |
| 878 // default. | |
| 879 Reset(); | |
| 880 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 881 controller()->GetTestingManager()->AddTestingProfile(&new_profile); | |
| 882 controller()->GetTestingManager()->AddTestingCreditCard(&credit_card); | |
| 883 | |
| 884 // Until a selection has been made, the default suggestion is the first one. | |
| 885 // For the shipping section, this follows the "use billing" suggestion. | |
| 886 EXPECT_EQ(2, GetMenuModelForSection(SECTION_SHIPPING)->checked_item()); | |
| 887 } | |
| 888 | |
| 889 TEST_F(AutofillDialogControllerTest, SuggestValidEmail) { | |
| 890 AutofillProfile profile(test::GetVerifiedProfile()); | |
| 891 const base::string16 kValidEmail = ASCIIToUTF16(kFakeEmail); | |
| 892 profile.SetRawInfo(EMAIL_ADDRESS, kValidEmail); | |
| 893 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 894 | |
| 895 // "add", "manage", and 1 suggestion. | |
| 896 EXPECT_EQ( | |
| 897 3, controller()->MenuModelForSection(SECTION_BILLING)->GetItemCount()); | |
| 898 // "add", "manage", 1 suggestion, and "same as billing". | |
| 899 EXPECT_EQ( | |
| 900 4, controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount()); | |
| 901 } | |
| 902 | |
| 903 TEST_F(AutofillDialogControllerTest, DoNotSuggestInvalidEmail) { | |
| 904 AutofillProfile profile(test::GetVerifiedProfile()); | |
| 905 profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16(".!#$%&'*+/=?^_`-@-..")); | |
| 906 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 907 | |
| 908 EXPECT_FALSE(!!controller()->MenuModelForSection(SECTION_BILLING)); | |
| 909 // "add", "manage", 1 suggestion, and "same as billing". | |
| 910 EXPECT_EQ( | |
| 911 4, controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount()); | |
| 912 } | |
| 913 | |
| 914 TEST_F(AutofillDialogControllerTest, SuggestValidAddress) { | |
| 915 AutofillProfile full_profile(test::GetVerifiedProfile()); | |
| 916 full_profile.set_origin(kSettingsOrigin); | |
| 917 controller()->GetTestingManager()->AddTestingProfile(&full_profile); | |
| 918 // "add", "manage", and 1 suggestion. | |
| 919 EXPECT_EQ( | |
| 920 3, controller()->MenuModelForSection(SECTION_BILLING)->GetItemCount()); | |
| 921 } | |
| 922 | |
| 923 TEST_F(AutofillDialogControllerTest, DoNotSuggestInvalidAddress) { | |
| 924 AutofillProfile full_profile(test::GetVerifiedProfile()); | |
| 925 full_profile.set_origin(kSettingsOrigin); | |
| 926 full_profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("C")); | |
| 927 controller()->GetTestingManager()->AddTestingProfile(&full_profile); | |
| 928 } | |
| 929 | |
| 930 TEST_F(AutofillDialogControllerTest, DoNotSuggestIncompleteAddress) { | |
| 931 AutofillProfile profile(test::GetVerifiedProfile()); | |
| 932 profile.SetRawInfo(ADDRESS_HOME_STATE, base::string16()); | |
| 933 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 934 | |
| 935 // Same as shipping, manage, add new. | |
| 936 EXPECT_EQ(3, | |
| 937 controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount()); | |
| 938 EXPECT_FALSE(!!controller()->MenuModelForSection(SECTION_BILLING)); | |
| 939 } | |
| 940 | |
| 941 TEST_F(AutofillDialogControllerTest, DoSuggestShippingAddressWithoutEmail) { | |
| 942 AutofillProfile profile(test::GetVerifiedProfile()); | |
| 943 profile.SetRawInfo(EMAIL_ADDRESS, base::string16()); | |
| 944 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 945 | |
| 946 // Same as shipping, manage, add new, profile with missing email. | |
| 947 EXPECT_EQ(4, | |
| 948 controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount()); | |
| 949 // Billing addresses require email. | |
| 950 EXPECT_FALSE(!!controller()->MenuModelForSection(SECTION_BILLING)); | |
| 951 } | |
| 952 | |
| 953 TEST_F(AutofillDialogControllerTest, AutofillCreditCards) { | |
| 954 // Since the PersonalDataManager is empty, this should only have the | |
| 955 // default menu items. | |
| 956 EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC)); | |
| 957 | |
| 958 EXPECT_CALL(*controller()->GetView(), ModelChanged()).Times(3); | |
| 959 | |
| 960 // Empty cards are ignored. | |
| 961 CreditCard empty_card(base::GenerateGUID(), kSettingsOrigin); | |
| 962 empty_card.SetRawInfo(CREDIT_CARD_NAME_FULL, ASCIIToUTF16("John Doe")); | |
| 963 controller()->GetTestingManager()->AddTestingCreditCard(&empty_card); | |
| 964 EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC)); | |
| 965 | |
| 966 // An otherwise full but unverified card should be ignored. | |
| 967 CreditCard full_card(test::GetCreditCard()); | |
| 968 full_card.set_origin("https://www.example.com"); | |
| 969 controller()->GetTestingManager()->AddTestingCreditCard(&full_card); | |
| 970 EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC)); | |
| 971 | |
| 972 // A full, verified card should be picked up. | |
| 973 CreditCard verified_card(test::GetCreditCard()); | |
| 974 verified_card.set_origin(kSettingsOrigin); | |
| 975 controller()->GetTestingManager()->AddTestingCreditCard(&verified_card); | |
| 976 ui::MenuModel* credit_card_model = | |
| 977 controller()->MenuModelForSection(SECTION_CC); | |
| 978 ASSERT_TRUE(credit_card_model); | |
| 979 EXPECT_EQ(3, credit_card_model->GetItemCount()); | |
| 980 } | |
| 981 | |
| 982 // Test selecting a shipping address different from billing as address. | |
| 983 TEST_F(AutofillDialogControllerTest, DontUseBillingAsShipping) { | |
| 984 AutofillProfile full_profile(test::GetVerifiedProfile()); | |
| 985 AutofillProfile full_profile2(test::GetVerifiedProfile2()); | |
| 986 CreditCard credit_card(test::GetVerifiedCreditCard()); | |
| 987 controller()->GetTestingManager()->AddTestingProfile(&full_profile); | |
| 988 controller()->GetTestingManager()->AddTestingProfile(&full_profile2); | |
| 989 controller()->GetTestingManager()->AddTestingCreditCard(&credit_card); | |
| 990 ui::MenuModel* shipping_model = | |
| 991 controller()->MenuModelForSection(SECTION_SHIPPING); | |
| 992 shipping_model->ActivatedAt(2); | |
| 993 | |
| 994 controller()->OnAccept(); | |
| 995 ASSERT_EQ(20U, form_structure()->field_count()); | |
| 996 EXPECT_EQ(ADDRESS_HOME_STATE, | |
| 997 form_structure()->field(9)->Type().GetStorableType()); | |
| 998 EXPECT_EQ(ADDRESS_BILLING, form_structure()->field(9)->Type().group()); | |
| 999 EXPECT_EQ(ADDRESS_HOME_STATE, | |
| 1000 form_structure()->field(16)->Type().GetStorableType()); | |
| 1001 EXPECT_EQ(ADDRESS_HOME, form_structure()->field(16)->Type().group()); | |
| 1002 base::string16 billing_state = form_structure()->field(9)->value; | |
| 1003 base::string16 shipping_state = form_structure()->field(16)->value; | |
| 1004 EXPECT_FALSE(billing_state.empty()); | |
| 1005 EXPECT_FALSE(shipping_state.empty()); | |
| 1006 EXPECT_NE(billing_state, shipping_state); | |
| 1007 | |
| 1008 EXPECT_EQ(CREDIT_CARD_NAME_FULL, | |
| 1009 form_structure()->field(1)->Type().GetStorableType()); | |
| 1010 base::string16 cc_name = form_structure()->field(1)->value; | |
| 1011 EXPECT_EQ(NAME_FULL, form_structure()->field(6)->Type().GetStorableType()); | |
| 1012 EXPECT_EQ(NAME_BILLING, form_structure()->field(6)->Type().group()); | |
| 1013 base::string16 billing_name = form_structure()->field(6)->value; | |
| 1014 EXPECT_EQ(NAME_FULL, form_structure()->field(13)->Type().GetStorableType()); | |
| 1015 EXPECT_EQ(NAME, form_structure()->field(13)->Type().group()); | |
| 1016 base::string16 shipping_name = form_structure()->field(13)->value; | |
| 1017 | |
| 1018 EXPECT_FALSE(cc_name.empty()); | |
| 1019 EXPECT_FALSE(billing_name.empty()); | |
| 1020 EXPECT_FALSE(shipping_name.empty()); | |
| 1021 // Billing name should always be the same as cardholder name. | |
| 1022 EXPECT_EQ(cc_name, billing_name); | |
| 1023 EXPECT_NE(cc_name, shipping_name); | |
| 1024 } | |
| 1025 | |
| 1026 // Test selecting UseBillingForShipping. | |
| 1027 TEST_F(AutofillDialogControllerTest, UseBillingAsShipping) { | |
| 1028 AutofillProfile full_profile(test::GetVerifiedProfile()); | |
| 1029 controller()->GetTestingManager()->AddTestingProfile(&full_profile); | |
| 1030 | |
| 1031 AutofillProfile full_profile2(test::GetVerifiedProfile2()); | |
| 1032 controller()->GetTestingManager()->AddTestingProfile(&full_profile2); | |
| 1033 | |
| 1034 CreditCard credit_card(test::GetVerifiedCreditCard()); | |
| 1035 controller()->GetTestingManager()->AddTestingCreditCard(&credit_card); | |
| 1036 | |
| 1037 ASSERT_FALSE(controller()->IsManuallyEditingSection(SECTION_CC)); | |
| 1038 ASSERT_FALSE(controller()->IsManuallyEditingSection(SECTION_BILLING)); | |
| 1039 | |
| 1040 SubmitAndVerifyShippingAndBillingResults(); | |
| 1041 } | |
| 1042 | |
| 1043 TEST_F(AutofillDialogControllerTest, UseBillingAsShippingManualInput) { | |
| 1044 ASSERT_TRUE(controller()->IsManuallyEditingSection(SECTION_CC)); | |
| 1045 ASSERT_TRUE(controller()->IsManuallyEditingSection(SECTION_BILLING)); | |
| 1046 | |
| 1047 CreditCard credit_card(test::GetVerifiedCreditCard()); | |
| 1048 FillInputs(SECTION_CC, credit_card); | |
| 1049 | |
| 1050 AutofillProfile full_profile(test::GetVerifiedProfile()); | |
| 1051 FillInputs(SECTION_BILLING, full_profile); | |
| 1052 | |
| 1053 SubmitAndVerifyShippingAndBillingResults(); | |
| 1054 } | |
| 1055 | |
| 1056 // Tests that shipping and billing telephone fields are supported, and filled | |
| 1057 // in by their respective profiles. http://crbug.com/244515 | |
| 1058 TEST_F(AutofillDialogControllerTest, BillingVsShippingPhoneNumber) { | |
| 1059 FormFieldData shipping_tel; | |
| 1060 shipping_tel.autocomplete_attribute = "shipping tel"; | |
| 1061 FormFieldData billing_tel; | |
| 1062 billing_tel.autocomplete_attribute = "billing tel"; | |
| 1063 FormFieldData cc_field; | |
| 1064 cc_field.autocomplete_attribute = "cc-csc"; | |
| 1065 | |
| 1066 FormData form_data; | |
| 1067 form_data.fields.push_back(shipping_tel); | |
| 1068 form_data.fields.push_back(billing_tel); | |
| 1069 form_data.fields.push_back(cc_field); | |
| 1070 SetUpControllerWithFormData(form_data); | |
| 1071 | |
| 1072 // The profile that will be chosen for the shipping section. | |
| 1073 AutofillProfile shipping_profile(test::GetVerifiedProfile()); | |
| 1074 // The profile that will be chosen for the billing section. | |
| 1075 AutofillProfile billing_profile(test::GetVerifiedProfile2()); | |
| 1076 CreditCard credit_card(test::GetVerifiedCreditCard()); | |
| 1077 controller()->GetTestingManager()->AddTestingProfile(&shipping_profile); | |
| 1078 controller()->GetTestingManager()->AddTestingProfile(&billing_profile); | |
| 1079 controller()->GetTestingManager()->AddTestingCreditCard(&credit_card); | |
| 1080 ui::MenuModel* billing_model = | |
| 1081 controller()->MenuModelForSection(SECTION_BILLING); | |
| 1082 billing_model->ActivatedAt(1); | |
| 1083 | |
| 1084 controller()->OnAccept(); | |
| 1085 ASSERT_EQ(3U, form_structure()->field_count()); | |
| 1086 EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER, | |
| 1087 form_structure()->field(0)->Type().GetStorableType()); | |
| 1088 EXPECT_EQ(PHONE_HOME, form_structure()->field(0)->Type().group()); | |
| 1089 EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER, | |
| 1090 form_structure()->field(1)->Type().GetStorableType()); | |
| 1091 EXPECT_EQ(PHONE_BILLING, form_structure()->field(1)->Type().group()); | |
| 1092 EXPECT_EQ(shipping_profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER), | |
| 1093 form_structure()->field(0)->value); | |
| 1094 EXPECT_EQ(billing_profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER), | |
| 1095 form_structure()->field(1)->value); | |
| 1096 EXPECT_NE(form_structure()->field(1)->value, | |
| 1097 form_structure()->field(0)->value); | |
| 1098 } | |
| 1099 | |
| 1100 // Similar to the above, but tests that street-address (i.e. all lines of the | |
| 1101 // street address) is successfully filled for both shipping and billing | |
| 1102 // sections. | |
| 1103 TEST_F(AutofillDialogControllerTest, BillingVsShippingStreetAddress) { | |
| 1104 FormFieldData shipping_address; | |
| 1105 shipping_address.autocomplete_attribute = "shipping street-address"; | |
| 1106 FormFieldData billing_address; | |
| 1107 billing_address.autocomplete_attribute = "billing street-address"; | |
| 1108 FormFieldData shipping_address_textarea; | |
| 1109 shipping_address_textarea.autocomplete_attribute = "shipping street-address"; | |
| 1110 shipping_address_textarea.form_control_type = "textarea"; | |
| 1111 FormFieldData billing_address_textarea; | |
| 1112 billing_address_textarea.autocomplete_attribute = "billing street-address"; | |
| 1113 billing_address_textarea.form_control_type = "textarea"; | |
| 1114 FormFieldData cc_field; | |
| 1115 cc_field.autocomplete_attribute = "cc-csc"; | |
| 1116 | |
| 1117 FormData form_data; | |
| 1118 form_data.fields.push_back(shipping_address); | |
| 1119 form_data.fields.push_back(billing_address); | |
| 1120 form_data.fields.push_back(shipping_address_textarea); | |
| 1121 form_data.fields.push_back(billing_address_textarea); | |
| 1122 form_data.fields.push_back(cc_field); | |
| 1123 SetUpControllerWithFormData(form_data); | |
| 1124 | |
| 1125 // The profile that will be chosen for the shipping section. | |
| 1126 AutofillProfile shipping_profile(test::GetVerifiedProfile()); | |
| 1127 // The profile that will be chosen for the billing section. | |
| 1128 AutofillProfile billing_profile(test::GetVerifiedProfile2()); | |
| 1129 CreditCard credit_card(test::GetVerifiedCreditCard()); | |
| 1130 controller()->GetTestingManager()->AddTestingProfile(&shipping_profile); | |
| 1131 controller()->GetTestingManager()->AddTestingProfile(&billing_profile); | |
| 1132 controller()->GetTestingManager()->AddTestingCreditCard(&credit_card); | |
| 1133 ui::MenuModel* billing_model = | |
| 1134 controller()->MenuModelForSection(SECTION_BILLING); | |
| 1135 billing_model->ActivatedAt(1); | |
| 1136 | |
| 1137 controller()->OnAccept(); | |
| 1138 ASSERT_EQ(5U, form_structure()->field_count()); | |
| 1139 EXPECT_EQ(ADDRESS_HOME_STREET_ADDRESS, | |
| 1140 form_structure()->field(0)->Type().GetStorableType()); | |
| 1141 EXPECT_EQ(ADDRESS_HOME, form_structure()->field(0)->Type().group()); | |
| 1142 EXPECT_EQ(ADDRESS_HOME_STREET_ADDRESS, | |
| 1143 form_structure()->field(1)->Type().GetStorableType()); | |
| 1144 EXPECT_EQ(ADDRESS_BILLING, form_structure()->field(1)->Type().group()); | |
| 1145 // Inexact matching; single-line inputs get the address data concatenated but | |
| 1146 // separated by commas. | |
| 1147 EXPECT_TRUE(base::StartsWith(form_structure()->field(0)->value, | |
| 1148 shipping_profile.GetRawInfo(ADDRESS_HOME_LINE1), | |
| 1149 base::CompareCase::SENSITIVE)); | |
| 1150 EXPECT_TRUE(base::EndsWith(form_structure()->field(0)->value, | |
| 1151 shipping_profile.GetRawInfo(ADDRESS_HOME_LINE2), | |
| 1152 base::CompareCase::SENSITIVE)); | |
| 1153 EXPECT_TRUE(base::StartsWith(form_structure()->field(1)->value, | |
| 1154 billing_profile.GetRawInfo(ADDRESS_HOME_LINE1), | |
| 1155 base::CompareCase::SENSITIVE)); | |
| 1156 EXPECT_TRUE(base::EndsWith(form_structure()->field(1)->value, | |
| 1157 billing_profile.GetRawInfo(ADDRESS_HOME_LINE2), | |
| 1158 base::CompareCase::SENSITIVE)); | |
| 1159 // The textareas should be an exact match. | |
| 1160 EXPECT_EQ(shipping_profile.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS), | |
| 1161 form_structure()->field(2)->value); | |
| 1162 EXPECT_EQ(billing_profile.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS), | |
| 1163 form_structure()->field(3)->value); | |
| 1164 | |
| 1165 EXPECT_NE(form_structure()->field(1)->value, | |
| 1166 form_structure()->field(0)->value); | |
| 1167 EXPECT_NE(form_structure()->field(3)->value, | |
| 1168 form_structure()->field(2)->value); | |
| 1169 } | |
| 1170 | |
| 1171 // Test asking for different pieces of the name. | |
| 1172 TEST_F(AutofillDialogControllerTest, NamePieces) { | |
| 1173 const char* const attributes[] = { | |
| 1174 "shipping name", | |
| 1175 "billing name", | |
| 1176 "billing given-name", | |
| 1177 "billing family-name", | |
| 1178 "billing additional-name", | |
| 1179 "cc-csc" | |
| 1180 }; | |
| 1181 | |
| 1182 FormData form_data; | |
| 1183 for (size_t i = 0; i < arraysize(attributes); ++i) { | |
| 1184 FormFieldData field; | |
| 1185 field.autocomplete_attribute.assign(attributes[i]); | |
| 1186 form_data.fields.push_back(field); | |
| 1187 } | |
| 1188 | |
| 1189 SetUpControllerWithFormData(form_data); | |
| 1190 | |
| 1191 // Billing. | |
| 1192 AutofillProfile test_profile(test::GetVerifiedProfile()); | |
| 1193 test_profile.SetInfo(AutofillType(NAME_FULL), | |
| 1194 ASCIIToUTF16("Fabian Jackson von Nacho"), | |
| 1195 "en-US"); | |
| 1196 controller()->GetTestingManager()->AddTestingProfile(&test_profile); | |
| 1197 | |
| 1198 // Credit card. | |
| 1199 CreditCard credit_card(test::GetVerifiedCreditCard()); | |
| 1200 controller()->GetTestingManager()->AddTestingCreditCard(&credit_card); | |
| 1201 | |
| 1202 // Make shipping name different from billing. | |
| 1203 AutofillProfile test_profile2(test::GetVerifiedProfile2()); | |
| 1204 test_profile2.SetInfo(AutofillType(NAME_FULL), | |
| 1205 ASCIIToUTF16("Don Ford"), | |
| 1206 "en-US"); | |
| 1207 controller()->GetTestingManager()->AddTestingProfile(&test_profile2); | |
| 1208 ui::MenuModel* shipping_model = | |
| 1209 controller()->MenuModelForSection(SECTION_SHIPPING); | |
| 1210 shipping_model->ActivatedAt(2); | |
| 1211 | |
| 1212 controller()->OnAccept(); | |
| 1213 | |
| 1214 EXPECT_EQ(NAME_FULL, form_structure()->field(0)->Type().GetStorableType()); | |
| 1215 EXPECT_EQ(ASCIIToUTF16("Don Ford"), | |
| 1216 form_structure()->field(0)->value); | |
| 1217 | |
| 1218 EXPECT_EQ(NAME_FULL, form_structure()->field(1)->Type().GetStorableType()); | |
| 1219 EXPECT_EQ(ASCIIToUTF16("Fabian Jackson von Nacho"), | |
| 1220 form_structure()->field(1)->value); | |
| 1221 | |
| 1222 EXPECT_EQ(NAME_FIRST, form_structure()->field(2)->Type().GetStorableType()); | |
| 1223 EXPECT_EQ(ASCIIToUTF16("Fabian"), | |
| 1224 form_structure()->field(2)->value); | |
| 1225 | |
| 1226 EXPECT_EQ(NAME_LAST, form_structure()->field(3)->Type().GetStorableType()); | |
| 1227 EXPECT_EQ(ASCIIToUTF16("von Nacho"), | |
| 1228 form_structure()->field(3)->value); | |
| 1229 | |
| 1230 EXPECT_EQ(NAME_MIDDLE, form_structure()->field(4)->Type().GetStorableType()); | |
| 1231 EXPECT_EQ(ASCIIToUTF16("Jackson"), | |
| 1232 form_structure()->field(4)->value); | |
| 1233 } | |
| 1234 | |
| 1235 // Tests that adding an autofill profile and then submitting works. | |
| 1236 TEST_F(AutofillDialogControllerTest, AddAutofillProfile) { | |
| 1237 EXPECT_CALL(*controller()->GetView(), ModelChanged()).Times(2); | |
| 1238 | |
| 1239 AutofillProfile full_profile(test::GetVerifiedProfile()); | |
| 1240 CreditCard credit_card(test::GetVerifiedCreditCard()); | |
| 1241 controller()->GetTestingManager()->AddTestingProfile(&full_profile); | |
| 1242 controller()->GetTestingManager()->AddTestingCreditCard(&credit_card); | |
| 1243 | |
| 1244 ui::MenuModel* model = controller()->MenuModelForSection(SECTION_BILLING); | |
| 1245 // Activate the "Add billing address" menu item. | |
| 1246 model->ActivatedAt(model->GetItemCount() - 2); | |
| 1247 | |
| 1248 // Fill in the inputs from the profile. | |
| 1249 FieldValueMap outputs; | |
| 1250 const DetailInputs& inputs = | |
| 1251 controller()->RequestedFieldsForSection(SECTION_BILLING); | |
| 1252 AutofillProfile full_profile2(test::GetVerifiedProfile2()); | |
| 1253 for (size_t i = 0; i < inputs.size(); ++i) { | |
| 1254 const ServerFieldType type = inputs[i].type; | |
| 1255 outputs[type] = full_profile2.GetInfo(AutofillType(type), "en-US"); | |
| 1256 } | |
| 1257 controller()->GetView()->SetUserInput(SECTION_BILLING, outputs); | |
| 1258 | |
| 1259 controller()->OnAccept(); | |
| 1260 const AutofillProfile& added_profile = | |
| 1261 controller()->GetTestingManager()->imported_profile(); | |
| 1262 | |
| 1263 const DetailInputs& shipping_inputs = | |
| 1264 controller()->RequestedFieldsForSection(SECTION_SHIPPING); | |
| 1265 for (size_t i = 0; i < shipping_inputs.size(); ++i) { | |
| 1266 const ServerFieldType type = shipping_inputs[i].type; | |
| 1267 EXPECT_EQ(full_profile2.GetInfo(AutofillType(type), "en-US"), | |
| 1268 added_profile.GetInfo(AutofillType(type), "en-US")); | |
| 1269 } | |
| 1270 } | |
| 1271 | |
| 1272 TEST_F(AutofillDialogControllerTest, SaveDetailsInChrome) { | |
| 1273 EXPECT_CALL(*controller()->GetView(), ModelChanged()).Times(4); | |
| 1274 | |
| 1275 AutofillProfile full_profile(test::GetVerifiedProfile()); | |
| 1276 controller()->GetTestingManager()->AddTestingProfile(&full_profile); | |
| 1277 | |
| 1278 CreditCard card(test::GetVerifiedCreditCard()); | |
| 1279 controller()->GetTestingManager()->AddTestingCreditCard(&card); | |
| 1280 EXPECT_FALSE(controller()->ShouldOfferToSaveInChrome()); | |
| 1281 | |
| 1282 controller()->MenuModelForSection(SECTION_BILLING)->ActivatedAt(0); | |
| 1283 EXPECT_FALSE(controller()->ShouldOfferToSaveInChrome()); | |
| 1284 | |
| 1285 controller()->MenuModelForSection(SECTION_BILLING)->ActivatedAt(1); | |
| 1286 EXPECT_TRUE(controller()->ShouldOfferToSaveInChrome()); | |
| 1287 | |
| 1288 profile()->GetPrefs()->SetBoolean(prefs::kAutofillEnabled, false); | |
| 1289 EXPECT_FALSE(controller()->ShouldOfferToSaveInChrome()); | |
| 1290 | |
| 1291 profile()->GetPrefs()->SetBoolean(prefs::kAutofillEnabled, true); | |
| 1292 controller()->MenuModelForSection(SECTION_BILLING)->ActivatedAt(1); | |
| 1293 EXPECT_TRUE(controller()->ShouldOfferToSaveInChrome()); | |
| 1294 | |
| 1295 profile()->ForceIncognito(true); | |
| 1296 EXPECT_FALSE(controller()->ShouldOfferToSaveInChrome()); | |
| 1297 } | |
| 1298 | |
| 1299 TEST_F(AutofillDialogControllerTest, DisabledAutofill) { | |
| 1300 ASSERT_TRUE(profile()->GetPrefs()->GetBoolean(prefs::kAutofillEnabled)); | |
| 1301 | |
| 1302 AutofillProfile verified_profile(test::GetVerifiedProfile()); | |
| 1303 controller()->GetTestingManager()->AddTestingProfile(&verified_profile); | |
| 1304 | |
| 1305 CreditCard credit_card(test::GetVerifiedCreditCard()); | |
| 1306 controller()->GetTestingManager()->AddTestingCreditCard(&credit_card); | |
| 1307 | |
| 1308 // Verify suggestions menus should be showing when Autofill is enabled. | |
| 1309 EXPECT_TRUE(controller()->MenuModelForSection(SECTION_CC)); | |
| 1310 EXPECT_TRUE(controller()->MenuModelForSection(SECTION_BILLING)); | |
| 1311 EXPECT_EQ( | |
| 1312 4, controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount()); | |
| 1313 | |
| 1314 EXPECT_CALL(*controller()->GetView(), ModelChanged()); | |
| 1315 profile()->GetPrefs()->SetBoolean(prefs::kAutofillEnabled, false); | |
| 1316 | |
| 1317 // Verify billing and credit card suggestions menus are hidden when Autofill | |
| 1318 // is disabled. | |
| 1319 EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC)); | |
| 1320 EXPECT_FALSE(controller()->MenuModelForSection(SECTION_BILLING)); | |
| 1321 // And that the shipping suggestions menu has less selections. | |
| 1322 EXPECT_EQ( | |
| 1323 2, controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount()); | |
| 1324 | |
| 1325 // Additionally, editing fields should not show Autofill popups. | |
| 1326 ASSERT_NO_FATAL_FAILURE(controller()->UserEditedOrActivatedInput( | |
| 1327 SECTION_BILLING, NAME_BILLING_FULL, gfx::NativeView(), gfx::Rect(), | |
| 1328 verified_profile.GetInfo(AutofillType(NAME_FULL), "en-US").substr(0, 1), | |
| 1329 true)); | |
| 1330 EXPECT_EQ(UNKNOWN_TYPE, controller()->popup_input_type()); | |
| 1331 } | |
| 1332 | |
| 1333 TEST_F(AutofillDialogControllerTest, ShippingSectionCanBeHidden) { | |
| 1334 FormFieldData email_field; | |
| 1335 email_field.autocomplete_attribute = "email"; | |
| 1336 FormFieldData cc_field; | |
| 1337 cc_field.autocomplete_attribute = "cc-number"; | |
| 1338 FormFieldData billing_field; | |
| 1339 billing_field.autocomplete_attribute = "billing address-level1"; | |
| 1340 | |
| 1341 FormData form_data; | |
| 1342 form_data.fields.push_back(email_field); | |
| 1343 form_data.fields.push_back(cc_field); | |
| 1344 form_data.fields.push_back(billing_field); | |
| 1345 | |
| 1346 AutofillProfile full_profile(test::GetVerifiedProfile()); | |
| 1347 controller()->GetTestingManager()->AddTestingProfile(&full_profile); | |
| 1348 SetUpControllerWithFormData(form_data); | |
| 1349 | |
| 1350 EXPECT_FALSE(controller()->SectionIsActive(SECTION_SHIPPING)); | |
| 1351 | |
| 1352 FillCreditCardInputs(); | |
| 1353 controller()->OnAccept(); | |
| 1354 EXPECT_TRUE(form_structure()); | |
| 1355 } | |
| 1356 | |
| 1357 TEST_F(AutofillDialogControllerTest, SaveInChromeByDefault) { | |
| 1358 EXPECT_TRUE(controller()->ShouldSaveInChrome()); | |
| 1359 FillCreditCardInputs(); | |
| 1360 controller()->OnAccept(); | |
| 1361 EXPECT_TRUE(controller()->ShouldSaveInChrome()); | |
| 1362 } | |
| 1363 | |
| 1364 TEST_F(AutofillDialogControllerTest, | |
| 1365 SaveInChromePreferenceNotRememberedOnCancel) { | |
| 1366 EXPECT_TRUE(controller()->ShouldSaveInChrome()); | |
| 1367 controller()->GetView()->CheckSaveDetailsLocallyCheckbox(false); | |
| 1368 controller()->OnCancel(); | |
| 1369 EXPECT_TRUE(controller()->ShouldSaveInChrome()); | |
| 1370 } | |
| 1371 | |
| 1372 TEST_F(AutofillDialogControllerTest, | |
| 1373 SaveInChromePreferenceRememberedOnSuccess) { | |
| 1374 EXPECT_TRUE(controller()->ShouldSaveInChrome()); | |
| 1375 FillCreditCardInputs(); | |
| 1376 controller()->GetView()->CheckSaveDetailsLocallyCheckbox(false); | |
| 1377 controller()->OnAccept(); | |
| 1378 EXPECT_FALSE(controller()->ShouldSaveInChrome()); | |
| 1379 } | |
| 1380 | |
| 1381 TEST_F(AutofillDialogControllerTest, SubmitButtonIsDisabled) { | |
| 1382 EXPECT_EQ(1, controller()->get_submit_button_delay_count()); | |
| 1383 | |
| 1384 // Begin the submit button delay. | |
| 1385 controller()->SimulateSubmitButtonDelayBegin(); | |
| 1386 EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK)); | |
| 1387 | |
| 1388 // End the submit button delay. | |
| 1389 controller()->SimulateSubmitButtonDelayEnd(); | |
| 1390 EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK)); | |
| 1391 } | |
| 1392 | |
| 1393 TEST_F(AutofillDialogControllerTest, IconsForFields_NoCreditCard) { | |
| 1394 FieldValueMap values; | |
| 1395 values[EMAIL_ADDRESS] = ASCIIToUTF16(kFakeEmail); | |
| 1396 FieldIconMap icons = controller()->IconsForFields(values); | |
| 1397 EXPECT_TRUE(icons.empty()); | |
| 1398 } | |
| 1399 | |
| 1400 TEST_F(AutofillDialogControllerTest, IconsForFields_CreditCardNumberOnly) { | |
| 1401 FieldValueMap values; | |
| 1402 values[EMAIL_ADDRESS] = ASCIIToUTF16(kFakeEmail); | |
| 1403 values[CREDIT_CARD_NUMBER] = ASCIIToUTF16(kTestCCNumberVisa); | |
| 1404 FieldIconMap icons = controller()->IconsForFields(values); | |
| 1405 EXPECT_EQ(1UL, icons.size()); | |
| 1406 EXPECT_EQ(1UL, icons.count(CREDIT_CARD_NUMBER)); | |
| 1407 } | |
| 1408 | |
| 1409 TEST_F(AutofillDialogControllerTest, IconsForFields_CvcOnly) { | |
| 1410 FieldValueMap values; | |
| 1411 values[EMAIL_ADDRESS] = ASCIIToUTF16(kFakeEmail); | |
| 1412 values[CREDIT_CARD_VERIFICATION_CODE] = ASCIIToUTF16("123"); | |
| 1413 FieldIconMap icons = controller()->IconsForFields(values); | |
| 1414 EXPECT_EQ(1UL, icons.size()); | |
| 1415 EXPECT_EQ(1UL, icons.count(CREDIT_CARD_VERIFICATION_CODE)); | |
| 1416 } | |
| 1417 | |
| 1418 TEST_F(AutofillDialogControllerTest, IconsForFields_BothCreditCardAndCvc) { | |
| 1419 FieldValueMap values; | |
| 1420 values[EMAIL_ADDRESS] = ASCIIToUTF16(kFakeEmail); | |
| 1421 values[CREDIT_CARD_NUMBER] = ASCIIToUTF16(kTestCCNumberVisa); | |
| 1422 values[CREDIT_CARD_VERIFICATION_CODE] = ASCIIToUTF16("123"); | |
| 1423 FieldIconMap icons = controller()->IconsForFields(values); | |
| 1424 EXPECT_EQ(2UL, icons.size()); | |
| 1425 EXPECT_EQ(1UL, icons.count(CREDIT_CARD_VERIFICATION_CODE)); | |
| 1426 EXPECT_EQ(1UL, icons.count(CREDIT_CARD_NUMBER)); | |
| 1427 } | |
| 1428 | |
| 1429 TEST_F(AutofillDialogControllerTest, FieldControlsIcons) { | |
| 1430 EXPECT_TRUE(controller()->FieldControlsIcons(CREDIT_CARD_NUMBER)); | |
| 1431 EXPECT_FALSE(controller()->FieldControlsIcons(CREDIT_CARD_VERIFICATION_CODE)); | |
| 1432 EXPECT_FALSE(controller()->FieldControlsIcons(EMAIL_ADDRESS)); | |
| 1433 } | |
| 1434 | |
| 1435 // Verifies that a call to the IconsForFields() method before the card type is | |
| 1436 // known returns a placeholder image that is at least as large as the icons for | |
| 1437 // all of the supported major credit card issuers. | |
| 1438 TEST_F(AutofillDialogControllerTest, IconReservedForCreditCardField) { | |
| 1439 FieldValueMap inputs; | |
| 1440 inputs[CREDIT_CARD_NUMBER] = base::string16(); | |
| 1441 | |
| 1442 FieldIconMap icons = controller()->IconsForFields(inputs); | |
| 1443 EXPECT_EQ(1U, icons.size()); | |
| 1444 | |
| 1445 ASSERT_EQ(1U, icons.count(CREDIT_CARD_NUMBER)); | |
| 1446 gfx::Image placeholder_icon = icons[CREDIT_CARD_NUMBER]; | |
| 1447 | |
| 1448 // Verify that the placeholder icon is at least as large as the icons for the | |
| 1449 // supported credit card issuers. | |
| 1450 const int kSupportedCardIdrs[] = { | |
| 1451 IDR_AUTOFILL_CC_AMEX, | |
| 1452 IDR_AUTOFILL_CC_DISCOVER, | |
| 1453 IDR_AUTOFILL_CC_GENERIC, | |
| 1454 IDR_AUTOFILL_CC_MASTERCARD, | |
| 1455 IDR_AUTOFILL_CC_VISA, | |
| 1456 }; | |
| 1457 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); | |
| 1458 for (size_t i = 0; i < arraysize(kSupportedCardIdrs); ++i) { | |
| 1459 SCOPED_TRACE(base::SizeTToString(i)); | |
| 1460 gfx::Image supported_card_icon = rb.GetImageNamed(kSupportedCardIdrs[i]); | |
| 1461 EXPECT_GE(placeholder_icon.Width(), supported_card_icon.Width()); | |
| 1462 EXPECT_GE(placeholder_icon.Height(), supported_card_icon.Height()); | |
| 1463 } | |
| 1464 } | |
| 1465 | |
| 1466 TEST_F(AutofillDialogControllerTest, CountryChangeUpdatesSection) { | |
| 1467 TestAutofillDialogView* view = controller()->GetView(); | |
| 1468 view->ClearSectionUpdates(); | |
| 1469 | |
| 1470 controller()->UserEditedOrActivatedInput(SECTION_SHIPPING, | |
| 1471 ADDRESS_HOME_COUNTRY, | |
| 1472 gfx::NativeView(), | |
| 1473 gfx::Rect(), | |
| 1474 ASCIIToUTF16("Belarus"), | |
| 1475 true); | |
| 1476 std::map<DialogSection, size_t> updates = view->section_updates(); | |
| 1477 EXPECT_EQ(1U, updates[SECTION_SHIPPING]); | |
| 1478 EXPECT_EQ(1U, updates.size()); | |
| 1479 | |
| 1480 view->ClearSectionUpdates(); | |
| 1481 | |
| 1482 controller()->UserEditedOrActivatedInput(SECTION_BILLING, | |
| 1483 ADDRESS_BILLING_COUNTRY, | |
| 1484 gfx::NativeView(), | |
| 1485 gfx::Rect(), | |
| 1486 ASCIIToUTF16("Italy"), | |
| 1487 true); | |
| 1488 updates = view->section_updates(); | |
| 1489 EXPECT_EQ(1U, updates[SECTION_BILLING]); | |
| 1490 EXPECT_EQ(1U, updates.size()); | |
| 1491 } | |
| 1492 | |
| 1493 TEST_F(AutofillDialogControllerTest, CorrectCountryFromInputs) { | |
| 1494 EXPECT_CALL(*controller()->GetMockValidator(), | |
| 1495 ValidateAddress(CountryCodeMatcher("DE"), _, _)); | |
| 1496 | |
| 1497 FieldValueMap billing_inputs; | |
| 1498 billing_inputs[ADDRESS_BILLING_COUNTRY] = ASCIIToUTF16("Germany"); | |
| 1499 controller()->InputsAreValid(SECTION_BILLING, billing_inputs); | |
| 1500 | |
| 1501 EXPECT_CALL(*controller()->GetMockValidator(), | |
| 1502 ValidateAddress(CountryCodeMatcher("FR"), _, _)); | |
| 1503 | |
| 1504 FieldValueMap shipping_inputs; | |
| 1505 shipping_inputs[ADDRESS_HOME_COUNTRY] = ASCIIToUTF16("France"); | |
| 1506 controller()->InputsAreValid(SECTION_SHIPPING, shipping_inputs); | |
| 1507 } | |
| 1508 | |
| 1509 TEST_F(AutofillDialogControllerTest, ValidationRulesLoadedOnCountryChange) { | |
| 1510 ResetControllerWithFormData(DefaultFormData()); | |
| 1511 EXPECT_CALL(*controller()->GetMockValidator(), | |
| 1512 LoadRules("US")).Times(AtLeast(1)); | |
| 1513 controller()->Show(); | |
| 1514 | |
| 1515 EXPECT_CALL(*controller()->GetMockValidator(), LoadRules("FR")); | |
| 1516 controller()->UserEditedOrActivatedInput(SECTION_BILLING, | |
| 1517 ADDRESS_BILLING_COUNTRY, | |
| 1518 gfx::NativeView(), | |
| 1519 gfx::Rect(), | |
| 1520 ASCIIToUTF16("France"), | |
| 1521 true); | |
| 1522 } | |
| 1523 | |
| 1524 TEST_F(AutofillDialogControllerTest, UsValidationRulesLoadedForJpOnlyProfile) { | |
| 1525 ResetControllerWithFormData(DefaultFormData()); | |
| 1526 AutofillProfile jp_profile(base::GenerateGUID(), kSettingsOrigin); | |
| 1527 jp_profile.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("JP")); | |
| 1528 controller()->GetTestingManager()->AddTestingProfile(&jp_profile); | |
| 1529 EXPECT_CALL(*controller()->GetMockValidator(), LoadRules("US")).Times(0); | |
| 1530 EXPECT_CALL(*controller()->GetMockValidator(), | |
| 1531 LoadRules("JP")).Times(AtLeast(1)); | |
| 1532 controller()->Show(); | |
| 1533 } | |
| 1534 | |
| 1535 TEST_F(AutofillDialogControllerTest, InvalidWhenRulesNotReady) { | |
| 1536 // Select "Add new shipping address...". | |
| 1537 controller()->MenuModelForSection(SECTION_SHIPPING)->ActivatedAt(1); | |
| 1538 | |
| 1539 // If the rules haven't loaded yet, validation errors should show on submit. | |
| 1540 EXPECT_CALL(*controller()->GetMockValidator(), | |
| 1541 ValidateAddress(CountryCodeMatcher("US"), _, _)). | |
| 1542 WillRepeatedly(Return(AddressValidator::RULES_NOT_READY)); | |
| 1543 | |
| 1544 FieldValueMap inputs; | |
| 1545 inputs[ADDRESS_HOME_ZIP] = ASCIIToUTF16("1234"); | |
| 1546 inputs[ADDRESS_HOME_COUNTRY] = ASCIIToUTF16("United States"); | |
| 1547 | |
| 1548 ValidityMessages messages = | |
| 1549 controller()->InputsAreValid(SECTION_SHIPPING, inputs); | |
| 1550 EXPECT_FALSE(messages.GetMessageOrDefault(ADDRESS_HOME_ZIP).text.empty()); | |
| 1551 EXPECT_FALSE(messages.HasSureError(ADDRESS_HOME_ZIP)); | |
| 1552 // Country should never show an error message as it's always valid. | |
| 1553 EXPECT_TRUE(messages.GetMessageOrDefault(ADDRESS_HOME_COUNTRY).text.empty()); | |
| 1554 } | |
| 1555 | |
| 1556 TEST_F(AutofillDialogControllerTest, ValidButUnverifiedWhenRulesFail) { | |
| 1557 // Add suggestions so the credit card and billing sections aren't showing | |
| 1558 // their manual inputs (to isolate to just shipping). | |
| 1559 AutofillProfile verified_profile(test::GetVerifiedProfile()); | |
| 1560 controller()->GetTestingManager()->AddTestingProfile(&verified_profile); | |
| 1561 CreditCard verified_card(test::GetVerifiedCreditCard()); | |
| 1562 controller()->GetTestingManager()->AddTestingCreditCard(&verified_card); | |
| 1563 | |
| 1564 // Select "Add new shipping address...". | |
| 1565 controller()->MenuModelForSection(SECTION_SHIPPING)->ActivatedAt(2); | |
| 1566 | |
| 1567 // If the rules are unavailable, validation errors should not show. | |
| 1568 EXPECT_CALL(*controller()->GetMockValidator(), | |
| 1569 ValidateAddress(CountryCodeMatcher("US"), _, _)). | |
| 1570 WillRepeatedly(Return(AddressValidator::RULES_UNAVAILABLE)); | |
| 1571 | |
| 1572 FieldValueMap outputs; | |
| 1573 AutofillProfile full_profile(test::GetFullProfile()); | |
| 1574 const DetailInputs& inputs = | |
| 1575 controller()->RequestedFieldsForSection(SECTION_SHIPPING); | |
| 1576 for (size_t i = 0; i < inputs.size(); ++i) { | |
| 1577 const ServerFieldType type = inputs[i].type; | |
| 1578 outputs[type] = full_profile.GetInfo(AutofillType(type), "en-US"); | |
| 1579 } | |
| 1580 controller()->GetView()->SetUserInput(SECTION_SHIPPING, outputs); | |
| 1581 controller()->GetView()->CheckSaveDetailsLocallyCheckbox(true); | |
| 1582 controller()->OnAccept(); | |
| 1583 | |
| 1584 // Profiles saved while rules are unavailable shouldn't be verified. | |
| 1585 const AutofillProfile& imported_profile = | |
| 1586 controller()->GetTestingManager()->imported_profile(); | |
| 1587 ASSERT_EQ(imported_profile.GetInfo(AutofillType(NAME_FULL), "en-US"), | |
| 1588 full_profile.GetInfo(AutofillType(NAME_FULL), "en-US")); | |
| 1589 EXPECT_EQ(imported_profile.origin(), GURL(kSourceUrl).GetOrigin().spec()); | |
| 1590 EXPECT_FALSE(imported_profile.IsVerified()); | |
| 1591 } | |
| 1592 | |
| 1593 TEST_F(AutofillDialogControllerTest, LimitedCountryChoices) { | |
| 1594 ui::ComboboxModel* shipping_country_model = | |
| 1595 controller()->ComboboxModelForAutofillType(ADDRESS_HOME_COUNTRY); | |
| 1596 const int default_number_of_countries = | |
| 1597 shipping_country_model->GetItemCount(); | |
| 1598 // We show a lot of countries by default, but the exact number doesn't matter. | |
| 1599 EXPECT_GT(default_number_of_countries, 50); | |
| 1600 | |
| 1601 // Create a form data that simulates: | |
| 1602 // <select autocomplete="billing country"> | |
| 1603 // <option value="AU">Down Under</option> | |
| 1604 // <option value="">fR</option> <!-- Case doesn't matter --> | |
| 1605 // <option value="GRMNY">Germany</option> | |
| 1606 // </select> | |
| 1607 // Only country codes are respected, whether they're in value or the option's | |
| 1608 // text content. Thus the first two options should be recognized. | |
| 1609 FormData form_data; | |
| 1610 FormFieldData field; | |
| 1611 field.autocomplete_attribute = "billing country"; | |
| 1612 field.option_contents.push_back(ASCIIToUTF16("Down Under")); | |
| 1613 field.option_values.push_back(ASCIIToUTF16("AU")); | |
| 1614 field.option_contents.push_back(ASCIIToUTF16("Fr")); | |
| 1615 field.option_values.push_back(ASCIIToUTF16("")); | |
| 1616 field.option_contents.push_back(ASCIIToUTF16("Germany")); | |
| 1617 field.option_values.push_back(ASCIIToUTF16("GRMNY")); | |
| 1618 | |
| 1619 FormFieldData cc_field; | |
| 1620 cc_field.autocomplete_attribute = "cc-csc"; | |
| 1621 | |
| 1622 form_data.fields.push_back(field); | |
| 1623 form_data.fields.push_back(cc_field); | |
| 1624 ResetControllerWithFormData(form_data); | |
| 1625 controller()->Show(); | |
| 1626 | |
| 1627 // Shipping model shouldn't have changed. | |
| 1628 shipping_country_model = | |
| 1629 controller()->ComboboxModelForAutofillType(ADDRESS_HOME_COUNTRY); | |
| 1630 EXPECT_EQ(default_number_of_countries, | |
| 1631 shipping_country_model->GetItemCount()); | |
| 1632 // Billing model now only has two items. | |
| 1633 ui::ComboboxModel* billing_country_model = | |
| 1634 controller()->ComboboxModelForAutofillType(ADDRESS_BILLING_COUNTRY); | |
| 1635 ASSERT_EQ(2, billing_country_model->GetItemCount()); | |
| 1636 EXPECT_EQ(billing_country_model->GetItemAt(0), ASCIIToUTF16("Australia")); | |
| 1637 EXPECT_EQ(billing_country_model->GetItemAt(1), ASCIIToUTF16("France")); | |
| 1638 | |
| 1639 // Make sure it also applies to profile suggestions. | |
| 1640 AutofillProfile us_profile(test::GetVerifiedProfile()); | |
| 1641 us_profile.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US")); | |
| 1642 controller()->GetTestingManager()->AddTestingProfile(&us_profile); | |
| 1643 // Don't show a suggestion if the only one that exists is disabled. | |
| 1644 EXPECT_FALSE( | |
| 1645 controller()->SuggestionStateForSection(SECTION_BILLING).visible); | |
| 1646 | |
| 1647 // Add a profile with an acceptable country; suggestion should be shown. | |
| 1648 ResetControllerWithFormData(form_data); | |
| 1649 controller()->Show(); | |
| 1650 AutofillProfile au_profile(test::GetVerifiedProfile2()); | |
| 1651 au_profile.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("AU")); | |
| 1652 controller()->GetTestingManager()->AddTestingProfile(&us_profile); | |
| 1653 controller()->GetTestingManager()->AddTestingProfile(&au_profile); | |
| 1654 ui::MenuModel* model = controller()->MenuModelForSection(SECTION_BILLING); | |
| 1655 ASSERT_TRUE(model); | |
| 1656 EXPECT_EQ(4, model->GetItemCount()); | |
| 1657 EXPECT_FALSE(model->IsEnabledAt(0)); | |
| 1658 EXPECT_TRUE(model->IsEnabledAt(1)); | |
| 1659 | |
| 1660 // Add <input type="text" autocomplete="billing country"></input> | |
| 1661 // This should open up selection of all countries again. | |
| 1662 FormFieldData field2; | |
| 1663 field2.autocomplete_attribute = "billing country"; | |
| 1664 form_data.fields.push_back(field2); | |
| 1665 ResetControllerWithFormData(form_data); | |
| 1666 controller()->Show(); | |
| 1667 | |
| 1668 billing_country_model = | |
| 1669 controller()->ComboboxModelForAutofillType(ADDRESS_BILLING_COUNTRY); | |
| 1670 EXPECT_EQ(default_number_of_countries, | |
| 1671 billing_country_model->GetItemCount()); | |
| 1672 } | |
| 1673 | |
| 1674 // http://crbug.com/388018 | |
| 1675 TEST_F(AutofillDialogControllerTest, NoCountryChoices) { | |
| 1676 // Create a form data that simulates: | |
| 1677 // <select autocomplete="billing country"> | |
| 1678 // <option value="ATL">Atlantis</option> | |
| 1679 // <option value="ELD">Eldorado</option> | |
| 1680 // </select> | |
| 1681 // i.e. contains a list of no valid countries. | |
| 1682 FormData form_data; | |
| 1683 FormFieldData field; | |
| 1684 field.autocomplete_attribute = "billing country"; | |
| 1685 field.option_contents.push_back(ASCIIToUTF16("Atlantis")); | |
| 1686 field.option_values.push_back(ASCIIToUTF16("ATL")); | |
| 1687 field.option_contents.push_back(ASCIIToUTF16("Eldorado")); | |
| 1688 field.option_values.push_back(ASCIIToUTF16("ELD")); | |
| 1689 | |
| 1690 FormFieldData cc_field; | |
| 1691 cc_field.autocomplete_attribute = "cc-csc"; | |
| 1692 | |
| 1693 form_data.fields.push_back(field); | |
| 1694 form_data.fields.push_back(cc_field); | |
| 1695 ResetControllerWithFormData(form_data); | |
| 1696 controller()->Show(); | |
| 1697 | |
| 1698 // Controller aborts and self destructs. | |
| 1699 EXPECT_EQ(0, controller()); | |
| 1700 } | |
| 1701 | |
| 1702 TEST_F(AutofillDialogControllerTest, LimitedCcChoices) { | |
| 1703 // Typically, MC and Visa are both valid. | |
| 1704 ValidateCCNumber(SECTION_CC, kTestCCNumberMaster, true); | |
| 1705 ValidateCCNumber(SECTION_CC, kTestCCNumberVisa, true); | |
| 1706 | |
| 1707 FormData form_data; | |
| 1708 FormFieldData field; | |
| 1709 field.autocomplete_attribute = "billing cc-type"; | |
| 1710 field.option_contents.push_back(ASCIIToUTF16("Visa")); | |
| 1711 field.option_values.push_back(ASCIIToUTF16("V")); | |
| 1712 field.option_contents.push_back(ASCIIToUTF16("Amex")); | |
| 1713 field.option_values.push_back(ASCIIToUTF16("AX")); | |
| 1714 form_data.fields.push_back(field); | |
| 1715 ResetControllerWithFormData(form_data); | |
| 1716 controller()->Show(); | |
| 1717 | |
| 1718 // MC is not valid because it's missing from FormData. | |
| 1719 EXPECT_EQ(l10n_util::GetStringUTF16( | |
| 1720 IDS_AUTOFILL_DIALOG_VALIDATION_UNACCEPTED_MASTERCARD), | |
| 1721 ValidateCCNumber(SECTION_CC, kTestCCNumberMaster, false)); | |
| 1722 ValidateCCNumber(SECTION_CC, kTestCCNumberVisa, true); | |
| 1723 | |
| 1724 CreditCard visa_card(test::GetVerifiedCreditCard()); | |
| 1725 CreditCard amex_card(test::GetVerifiedCreditCard2()); | |
| 1726 | |
| 1727 CreditCard master_card(base::GenerateGUID(), kSettingsOrigin); | |
| 1728 test::SetCreditCardInfo( | |
| 1729 &master_card, "Mr Foo", "5105105105105100", "07", "2099"); | |
| 1730 | |
| 1731 controller()->GetTestingManager()->AddTestingCreditCard(&visa_card); | |
| 1732 controller()->GetTestingManager()->AddTestingCreditCard(&amex_card); | |
| 1733 controller()->GetTestingManager()->AddTestingCreditCard(&master_card); | |
| 1734 | |
| 1735 // The stored MC is disabled in the dropdown. | |
| 1736 ui::MenuModel* model = controller()->MenuModelForSection(SECTION_CC); | |
| 1737 ASSERT_TRUE(model); | |
| 1738 ASSERT_EQ(5, model->GetItemCount()); | |
| 1739 EXPECT_TRUE(model->IsEnabledAt(0)); | |
| 1740 EXPECT_TRUE(model->IsEnabledAt(1)); | |
| 1741 EXPECT_FALSE(model->IsEnabledAt(2)); | |
| 1742 EXPECT_TRUE(model->IsEnabledAt(3)); | |
| 1743 EXPECT_TRUE(model->IsEnabledAt(4)); | |
| 1744 | |
| 1745 SetUpControllerWithFormData(form_data); | |
| 1746 | |
| 1747 // Discover is disallowed because it's not in FormData. | |
| 1748 ValidateCCNumber(SECTION_CC, kTestCCNumberDiscover, false); | |
| 1749 } | |
| 1750 | |
| 1751 TEST_F(AutofillDialogControllerTest, SuggestCountrylessProfiles) { | |
| 1752 FieldValueMap outputs; | |
| 1753 outputs[ADDRESS_HOME_COUNTRY] = ASCIIToUTF16("US"); | |
| 1754 controller()->GetView()->SetUserInput(SECTION_SHIPPING, outputs); | |
| 1755 | |
| 1756 AutofillProfile profile(test::GetVerifiedProfile()); | |
| 1757 profile.SetRawInfo(NAME_FULL, ASCIIToUTF16("The Man Without a Country")); | |
| 1758 profile.SetRawInfo(ADDRESS_HOME_COUNTRY, base::string16()); | |
| 1759 controller()->GetTestingManager()->AddTestingProfile(&profile); | |
| 1760 | |
| 1761 controller()->UserEditedOrActivatedInput( | |
| 1762 SECTION_SHIPPING, | |
| 1763 NAME_FULL, | |
| 1764 gfx::NativeView(), | |
| 1765 gfx::Rect(), | |
| 1766 profile.GetRawInfo(NAME_FULL).substr(0, 1), | |
| 1767 true); | |
| 1768 EXPECT_EQ(NAME_FULL, controller()->popup_input_type()); | |
| 1769 } | |
| 1770 | |
| 1771 } // namespace autofill | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1931043002:
Remove requestAutocomplete (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master