form_structure_unittest.cc revision 116680a4aac90f2aa7413d9095a592090648e557
1// Copyright 2013 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 "components/autofill/core/browser/form_structure.h" 6 7#include "base/memory/scoped_ptr.h" 8#include "base/strings/string_util.h" 9#include "base/strings/utf_string_conversions.h" 10#include "components/autofill/core/browser/autofill_metrics.h" 11#include "components/autofill/core/common/form_data.h" 12#include "components/autofill/core/common/form_field_data.h" 13#include "testing/gtest/include/gtest/gtest.h" 14#include "url/gurl.h" 15 16using base::ASCIIToUTF16; 17 18namespace autofill { 19namespace { 20 21// Unlike the base AutofillMetrics, exposes copy and assignment constructors, 22// which are handy for briefer test code. The AutofillMetrics class is 23// stateless, so this is safe. 24class TestAutofillMetrics : public AutofillMetrics { 25 public: 26 TestAutofillMetrics() {} 27 virtual ~TestAutofillMetrics() {} 28}; 29 30} // anonymous namespace 31 32 33namespace content { 34 35std::ostream& operator<<(std::ostream& os, const FormData& form) { 36 os << base::UTF16ToUTF8(form.name) 37 << " " 38 << form.origin.spec() 39 << " " 40 << form.action.spec() 41 << " "; 42 43 for (std::vector<FormFieldData>::const_iterator iter = 44 form.fields.begin(); 45 iter != form.fields.end(); ++iter) { 46 os << *iter 47 << " "; 48 } 49 50 return os; 51} 52 53} // namespace content 54 55class FormStructureTest { 56 public: 57 static std::string Hash64Bit(const std::string& str) { 58 return FormStructure::Hash64Bit(str); 59 } 60}; 61 62TEST(FormStructureTest, FieldCount) { 63 scoped_ptr<FormStructure> form_structure; 64 FormData form; 65 66 FormFieldData field; 67 field.label = ASCIIToUTF16("username"); 68 field.name = ASCIIToUTF16("username"); 69 field.form_control_type = "text"; 70 form.fields.push_back(field); 71 72 field.label = ASCIIToUTF16("password"); 73 field.name = ASCIIToUTF16("password"); 74 field.form_control_type = "password"; 75 form.fields.push_back(field); 76 77 field.label = base::string16(); 78 field.name = ASCIIToUTF16("Submit"); 79 field.form_control_type = "submit"; 80 form.fields.push_back(field); 81 82 field.label = ASCIIToUTF16("address1"); 83 field.name = ASCIIToUTF16("address1"); 84 field.form_control_type = "text"; 85 field.should_autocomplete = false; 86 form.fields.push_back(field); 87 88 // The render process sends all fields to browser including fields with 89 // autocomplete=off 90 form_structure.reset(new FormStructure(form)); 91 EXPECT_EQ(4U, form_structure->field_count()); 92} 93 94TEST(FormStructureTest, AutofillCount) { 95 scoped_ptr<FormStructure> form_structure; 96 FormData form; 97 98 FormFieldData field; 99 field.label = ASCIIToUTF16("username"); 100 field.name = ASCIIToUTF16("username"); 101 field.form_control_type = "text"; 102 form.fields.push_back(field); 103 104 field.label = ASCIIToUTF16("password"); 105 field.name = ASCIIToUTF16("password"); 106 field.form_control_type = "password"; 107 form.fields.push_back(field); 108 109 field.label = ASCIIToUTF16("state"); 110 field.name = ASCIIToUTF16("state"); 111 field.form_control_type = "select-one"; 112 form.fields.push_back(field); 113 114 field.label = base::string16(); 115 field.name = ASCIIToUTF16("Submit"); 116 field.form_control_type = "submit"; 117 form.fields.push_back(field); 118 119 // Only text and select fields that are heuristically matched are counted. 120 form_structure.reset(new FormStructure(form)); 121 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 122 EXPECT_EQ(1U, form_structure->autofill_count()); 123 124 // Add a field with should_autocomplete=false. This should not be considered a 125 // fillable field. 126 field.label = ASCIIToUTF16("address1"); 127 field.name = ASCIIToUTF16("address1"); 128 field.form_control_type = "text"; 129 field.should_autocomplete = false; 130 form.fields.push_back(field); 131 132 form_structure.reset(new FormStructure(form)); 133 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 134 EXPECT_EQ(1U, form_structure->autofill_count()); 135} 136 137TEST(FormStructureTest, SourceURL) { 138 FormData form; 139 form.origin = GURL("http://www.foo.com/"); 140 FormStructure form_structure(form); 141 142 EXPECT_EQ(form.origin, form_structure.source_url()); 143} 144 145TEST(FormStructureTest, IsAutofillable) { 146 scoped_ptr<FormStructure> form_structure; 147 FormData form; 148 149 // We need at least three text fields to be auto-fillable. 150 FormFieldData field; 151 152 field.label = ASCIIToUTF16("username"); 153 field.name = ASCIIToUTF16("username"); 154 field.form_control_type = "text"; 155 form.fields.push_back(field); 156 157 field.label = ASCIIToUTF16("password"); 158 field.name = ASCIIToUTF16("password"); 159 field.form_control_type = "password"; 160 form.fields.push_back(field); 161 162 field.label = base::string16(); 163 field.name = ASCIIToUTF16("Submit"); 164 field.form_control_type = "submit"; 165 form.fields.push_back(field); 166 167 form_structure.reset(new FormStructure(form)); 168 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 169 EXPECT_FALSE(form_structure->IsAutofillable()); 170 171 // We now have three text fields, but only two auto-fillable fields. 172 field.label = ASCIIToUTF16("First Name"); 173 field.name = ASCIIToUTF16("firstname"); 174 field.form_control_type = "text"; 175 form.fields.push_back(field); 176 177 field.label = ASCIIToUTF16("Last Name"); 178 field.name = ASCIIToUTF16("lastname"); 179 field.form_control_type = "text"; 180 form.fields.push_back(field); 181 182 form_structure.reset(new FormStructure(form)); 183 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 184 EXPECT_FALSE(form_structure->IsAutofillable()); 185 186 // We now have three auto-fillable fields. 187 field.label = ASCIIToUTF16("Email"); 188 field.name = ASCIIToUTF16("email"); 189 field.form_control_type = "email"; 190 form.fields.push_back(field); 191 192 form_structure.reset(new FormStructure(form)); 193 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 194 EXPECT_TRUE(form_structure->IsAutofillable()); 195 196 // The target cannot include http(s)://*/search... 197 form.action = GURL("http://google.com/search?q=hello"); 198 form_structure.reset(new FormStructure(form)); 199 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 200 EXPECT_FALSE(form_structure->IsAutofillable()); 201 202 // But search can be in the URL. 203 form.action = GURL("http://search.com/?q=hello"); 204 form_structure.reset(new FormStructure(form)); 205 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 206 EXPECT_TRUE(form_structure->IsAutofillable()); 207} 208 209TEST(FormStructureTest, ShouldBeParsed) { 210 scoped_ptr<FormStructure> form_structure; 211 FormData form; 212 213 // We need at least three text fields to be parseable. 214 FormFieldData field; 215 field.label = ASCIIToUTF16("username"); 216 field.name = ASCIIToUTF16("username"); 217 field.form_control_type = "text"; 218 form.fields.push_back(field); 219 220 FormFieldData checkable_field; 221 checkable_field.is_checkable = true; 222 checkable_field.name = ASCIIToUTF16("radiobtn"); 223 checkable_field.form_control_type = "radio"; 224 form.fields.push_back(checkable_field); 225 226 checkable_field.name = ASCIIToUTF16("checkbox"); 227 checkable_field.form_control_type = "checkbox"; 228 form.fields.push_back(checkable_field); 229 230 // We have only one text field, should not be parsed. 231 form_structure.reset(new FormStructure(form)); 232 EXPECT_FALSE(form_structure->ShouldBeParsed()); 233 234 // We now have three text fields, though only two are auto-fillable. 235 field.label = ASCIIToUTF16("First Name"); 236 field.name = ASCIIToUTF16("firstname"); 237 field.form_control_type = "text"; 238 form.fields.push_back(field); 239 240 field.label = ASCIIToUTF16("Last Name"); 241 field.name = ASCIIToUTF16("lastname"); 242 field.form_control_type = "text"; 243 form.fields.push_back(field); 244 245 form_structure.reset(new FormStructure(form)); 246 EXPECT_TRUE(form_structure->ShouldBeParsed()); 247 248 form_structure.reset(new FormStructure(form)); 249 EXPECT_FALSE(form_structure->IsAutofillable()); 250 EXPECT_TRUE(form_structure->ShouldBeParsed()); 251 252 // The target cannot include http(s)://*/search... 253 form.action = GURL("http://google.com/search?q=hello"); 254 form_structure.reset(new FormStructure(form)); 255 EXPECT_FALSE(form_structure->ShouldBeParsed()); 256 257 // But search can be in the URL. 258 form.action = GURL("http://search.com/?q=hello"); 259 form_structure.reset(new FormStructure(form)); 260 EXPECT_TRUE(form_structure->ShouldBeParsed()); 261 262 // The form need only have three fields, but at least one must be a text 263 // field. 264 form.fields.clear(); 265 266 field.label = ASCIIToUTF16("Email"); 267 field.name = ASCIIToUTF16("email"); 268 field.form_control_type = "email"; 269 form.fields.push_back(field); 270 271 field.label = ASCIIToUTF16("State"); 272 field.name = ASCIIToUTF16("state"); 273 field.form_control_type = "select-one"; 274 form.fields.push_back(field); 275 276 field.label = ASCIIToUTF16("Country"); 277 field.name = ASCIIToUTF16("country"); 278 field.form_control_type = "select-one"; 279 form.fields.push_back(field); 280 281 form_structure.reset(new FormStructure(form)); 282 EXPECT_TRUE(form_structure->ShouldBeParsed()); 283 284 form.fields[0].form_control_type = "select-one"; 285 // Now, no text fields. 286 form_structure.reset(new FormStructure(form)); 287 EXPECT_FALSE(form_structure->ShouldBeParsed()); 288} 289 290TEST(FormStructureTest, HeuristicsContactInfo) { 291 scoped_ptr<FormStructure> form_structure; 292 FormData form; 293 294 FormFieldData field; 295 field.form_control_type = "text"; 296 297 field.label = ASCIIToUTF16("First Name"); 298 field.name = ASCIIToUTF16("firstname"); 299 form.fields.push_back(field); 300 301 field.label = ASCIIToUTF16("Last Name"); 302 field.name = ASCIIToUTF16("lastname"); 303 form.fields.push_back(field); 304 305 field.label = ASCIIToUTF16("Email"); 306 field.name = ASCIIToUTF16("email"); 307 form.fields.push_back(field); 308 309 field.label = ASCIIToUTF16("Phone"); 310 field.name = ASCIIToUTF16("phone"); 311 form.fields.push_back(field); 312 313 field.label = ASCIIToUTF16("Address"); 314 field.name = ASCIIToUTF16("address"); 315 form.fields.push_back(field); 316 317 field.label = ASCIIToUTF16("City"); 318 field.name = ASCIIToUTF16("city"); 319 form.fields.push_back(field); 320 321 field.label = ASCIIToUTF16("Zip code"); 322 field.name = ASCIIToUTF16("zipcode"); 323 form.fields.push_back(field); 324 325 field.label = base::string16(); 326 field.name = ASCIIToUTF16("Submit"); 327 field.form_control_type = "submit"; 328 form.fields.push_back(field); 329 330 form_structure.reset(new FormStructure(form)); 331 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 332 EXPECT_TRUE(form_structure->IsAutofillable()); 333 334 // Expect the correct number of fields. 335 ASSERT_EQ(8U, form_structure->field_count()); 336 ASSERT_EQ(7U, form_structure->autofill_count()); 337 338 // First name. 339 EXPECT_EQ(NAME_FIRST, form_structure->field(0)->heuristic_type()); 340 // Last name. 341 EXPECT_EQ(NAME_LAST, form_structure->field(1)->heuristic_type()); 342 // Email. 343 EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(2)->heuristic_type()); 344 // Phone. 345 EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER, 346 form_structure->field(3)->heuristic_type()); 347 // Address. 348 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(4)->heuristic_type()); 349 // City. 350 EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(5)->heuristic_type()); 351 // Zip. 352 EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(6)->heuristic_type()); 353 // Submit. 354 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(7)->heuristic_type()); 355} 356 357// Verify that we can correctly process the |autocomplete| attribute. 358TEST(FormStructureTest, HeuristicsAutocompleteAttribute) { 359 scoped_ptr<FormStructure> form_structure; 360 FormData form; 361 362 FormFieldData field; 363 field.form_control_type = "text"; 364 365 field.label = base::string16(); 366 field.name = ASCIIToUTF16("field1"); 367 field.autocomplete_attribute = "given-name"; 368 form.fields.push_back(field); 369 370 field.label = base::string16(); 371 field.name = ASCIIToUTF16("field2"); 372 field.autocomplete_attribute = "family-name"; 373 form.fields.push_back(field); 374 375 field.label = base::string16(); 376 field.name = ASCIIToUTF16("field3"); 377 field.autocomplete_attribute = "email"; 378 form.fields.push_back(field); 379 380 form_structure.reset(new FormStructure(form)); 381 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 382 EXPECT_TRUE(form_structure->IsAutofillable()); 383 384 // Expect the correct number of fields. 385 ASSERT_EQ(3U, form_structure->field_count()); 386 ASSERT_EQ(3U, form_structure->autofill_count()); 387 388 EXPECT_EQ(HTML_TYPE_GIVEN_NAME, form_structure->field(0)->html_type()); 389 EXPECT_EQ(HTML_TYPE_FAMILY_NAME, form_structure->field(1)->html_type()); 390 EXPECT_EQ(HTML_TYPE_EMAIL, form_structure->field(2)->html_type()); 391 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(0)->heuristic_type()); 392 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(1)->heuristic_type()); 393 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(2)->heuristic_type()); 394} 395 396// Verify that we can correctly process the 'autocomplete' attribute for phone 397// number types (especially phone prefixes and suffixes). 398TEST(FormStructureTest, HeuristicsAutocompleteAttributePhoneTypes) { 399 scoped_ptr<FormStructure> form_structure; 400 FormData form; 401 402 FormFieldData field; 403 field.form_control_type = "text"; 404 405 field.label = base::string16(); 406 field.name = ASCIIToUTF16("field1"); 407 field.autocomplete_attribute = "tel-local"; 408 form.fields.push_back(field); 409 410 field.label = base::string16(); 411 field.name = ASCIIToUTF16("field2"); 412 field.autocomplete_attribute = "tel-local-prefix"; 413 form.fields.push_back(field); 414 415 field.label = base::string16(); 416 field.name = ASCIIToUTF16("field3"); 417 field.autocomplete_attribute = "tel-local-suffix"; 418 form.fields.push_back(field); 419 420 form_structure.reset(new FormStructure(form)); 421 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 422 EXPECT_TRUE(form_structure->IsAutofillable()); 423 424 // Expect the correct number of fields. 425 ASSERT_EQ(3U, form_structure->field_count()); 426 EXPECT_EQ(3U, form_structure->autofill_count()); 427 428 EXPECT_EQ(HTML_TYPE_TEL_LOCAL, form_structure->field(0)->html_type()); 429 EXPECT_EQ(AutofillField::IGNORED, form_structure->field(0)->phone_part()); 430 EXPECT_EQ(HTML_TYPE_TEL_LOCAL_PREFIX, form_structure->field(1)->html_type()); 431 EXPECT_EQ(AutofillField::PHONE_PREFIX, 432 form_structure->field(1)->phone_part()); 433 EXPECT_EQ(HTML_TYPE_TEL_LOCAL_SUFFIX, form_structure->field(2)->html_type()); 434 EXPECT_EQ(AutofillField::PHONE_SUFFIX, 435 form_structure->field(2)->phone_part()); 436} 437 438// If at least one field includes type hints in the 'autocomplete' attribute, we 439// should not try to apply any other heuristics. 440TEST(FormStructureTest, AutocompleteAttributeOverridesOtherHeuristics) { 441 scoped_ptr<FormStructure> form_structure; 442 FormData form; 443 444 // Start with a regular contact form. 445 FormFieldData field; 446 field.form_control_type = "text"; 447 448 field.label = ASCIIToUTF16("First Name"); 449 field.name = ASCIIToUTF16("firstname"); 450 form.fields.push_back(field); 451 452 field.label = ASCIIToUTF16("Last Name"); 453 field.name = ASCIIToUTF16("lastname"); 454 form.fields.push_back(field); 455 456 field.label = ASCIIToUTF16("Email"); 457 field.name = ASCIIToUTF16("email"); 458 form.fields.push_back(field); 459 460 form_structure.reset(new FormStructure(form)); 461 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 462 EXPECT_TRUE(form_structure->IsAutofillable()); 463 EXPECT_TRUE(form_structure->ShouldBeCrowdsourced()); 464 465 ASSERT_EQ(3U, form_structure->field_count()); 466 ASSERT_EQ(3U, form_structure->autofill_count()); 467 468 EXPECT_EQ(NAME_FIRST, form_structure->field(0)->heuristic_type()); 469 EXPECT_EQ(NAME_LAST, form_structure->field(1)->heuristic_type()); 470 EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(2)->heuristic_type()); 471 472 // Now update the first form field to include an 'autocomplete' attribute. 473 form.fields.front().autocomplete_attribute = "x-other"; 474 form_structure.reset(new FormStructure(form)); 475 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 476 EXPECT_FALSE(form_structure->IsAutofillable()); 477 EXPECT_FALSE(form_structure->ShouldBeCrowdsourced()); 478 479 ASSERT_EQ(3U, form_structure->field_count()); 480 ASSERT_EQ(0U, form_structure->autofill_count()); 481 482 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(0)->heuristic_type()); 483 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(1)->heuristic_type()); 484 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(2)->heuristic_type()); 485} 486 487// Verify that we can correctly process sections listed in the |autocomplete| 488// attribute. 489TEST(FormStructureTest, HeuristicsAutocompleteAttributeWithSections) { 490 FormData form; 491 492 FormFieldData field; 493 field.form_control_type = "text"; 494 495 // Some fields will have no section specified. These fall into the default 496 // section. 497 field.autocomplete_attribute = "email"; 498 form.fields.push_back(field); 499 500 // We allow arbitrary section names. 501 field.autocomplete_attribute = "section-foo email"; 502 form.fields.push_back(field); 503 504 // "shipping" and "billing" are special section tokens that don't require the 505 // "section-" prefix. 506 field.autocomplete_attribute = "shipping email"; 507 form.fields.push_back(field); 508 field.autocomplete_attribute = "billing email"; 509 form.fields.push_back(field); 510 511 // "shipping" and "billing" can be combined with other section names. 512 field.autocomplete_attribute = "section-foo shipping email"; 513 form.fields.push_back(field); 514 field.autocomplete_attribute = "section-foo billing email"; 515 form.fields.push_back(field); 516 517 // We don't do anything clever to try to coalesce sections; it's up to site 518 // authors to avoid typos. 519 field.autocomplete_attribute = "section--foo email"; 520 form.fields.push_back(field); 521 522 // "shipping email" and "section--shipping" email should be parsed as 523 // different sections. This is only an interesting test due to how we 524 // implement implicit section names from attributes like "shipping email"; see 525 // the implementation for more details. 526 field.autocomplete_attribute = "section--shipping email"; 527 form.fields.push_back(field); 528 529 // Credit card fields are implicitly in a separate section from other fields. 530 field.autocomplete_attribute = "section-foo cc-number"; 531 form.fields.push_back(field); 532 533 FormStructure form_structure(form); 534 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 535 EXPECT_TRUE(form_structure.IsAutofillable()); 536 537 // Expect the correct number of fields. 538 ASSERT_EQ(9U, form_structure.field_count()); 539 EXPECT_EQ(9U, form_structure.autofill_count()); 540 541 // All of the fields in this form should be parsed as belonging to different 542 // sections. 543 std::set<std::string> section_names; 544 for (size_t i = 0; i < 9; ++i) { 545 section_names.insert(form_structure.field(i)->section()); 546 } 547 EXPECT_EQ(9U, section_names.size()); 548} 549 550// Verify that we can correctly process a degenerate section listed in the 551// |autocomplete| attribute. 552TEST(FormStructureTest, HeuristicsAutocompleteAttributeWithSectionsDegenerate) { 553 FormData form; 554 555 FormFieldData field; 556 field.form_control_type = "text"; 557 558 // Some fields will have no section specified. These fall into the default 559 // section. 560 field.autocomplete_attribute = "email"; 561 form.fields.push_back(field); 562 563 // Specifying "section-" is equivalent to not specifying a section. 564 field.autocomplete_attribute = "section- email"; 565 form.fields.push_back(field); 566 567 // Invalid tokens should prevent us from setting a section name. 568 field.autocomplete_attribute = "garbage section-foo email"; 569 form.fields.push_back(field); 570 field.autocomplete_attribute = "garbage section-bar email"; 571 form.fields.push_back(field); 572 field.autocomplete_attribute = "garbage shipping email"; 573 form.fields.push_back(field); 574 field.autocomplete_attribute = "garbage billing email"; 575 form.fields.push_back(field); 576 577 FormStructure form_structure(form); 578 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 579 580 // Expect the correct number of fields. 581 ASSERT_EQ(6U, form_structure.field_count()); 582 EXPECT_EQ(2U, form_structure.autofill_count()); 583 584 // All of the fields in this form should be parsed as belonging to the same 585 // section. 586 std::set<std::string> section_names; 587 for (size_t i = 0; i < 6; ++i) { 588 section_names.insert(form_structure.field(i)->section()); 589 } 590 EXPECT_EQ(1U, section_names.size()); 591} 592 593// Verify that we can correctly process repeated sections listed in the 594// |autocomplete| attribute. 595TEST(FormStructureTest, HeuristicsAutocompleteAttributeWithSectionsRepeated) { 596 FormData form; 597 598 FormFieldData field; 599 field.form_control_type = "text"; 600 601 field.autocomplete_attribute = "section-foo email"; 602 form.fields.push_back(field); 603 field.autocomplete_attribute = "section-foo address-line1"; 604 form.fields.push_back(field); 605 606 FormStructure form_structure(form); 607 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 608 609 // Expect the correct number of fields. 610 ASSERT_EQ(2U, form_structure.field_count()); 611 EXPECT_EQ(2U, form_structure.autofill_count()); 612 613 // All of the fields in this form should be parsed as belonging to the same 614 // section. 615 std::set<std::string> section_names; 616 for (size_t i = 0; i < 2; ++i) { 617 section_names.insert(form_structure.field(i)->section()); 618 } 619 EXPECT_EQ(1U, section_names.size()); 620} 621 622// Verify that we do not override the author-specified sections from a form with 623// local heuristics. 624TEST(FormStructureTest, HeuristicsDontOverrideAutocompleteAttributeSections) { 625 FormData form; 626 627 FormFieldData field; 628 field.form_control_type = "text"; 629 630 field.name = ASCIIToUTF16("one"); 631 field.autocomplete_attribute = "address-line1"; 632 form.fields.push_back(field); 633 field.name = base::string16(); 634 field.autocomplete_attribute = "section-foo email"; 635 form.fields.push_back(field); 636 field.name = base::string16(); 637 field.autocomplete_attribute = "name"; 638 form.fields.push_back(field); 639 field.name = ASCIIToUTF16("two"); 640 field.autocomplete_attribute = "address-line1"; 641 form.fields.push_back(field); 642 643 FormStructure form_structure(form); 644 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 645 646 // Expect the correct number of fields. 647 ASSERT_EQ(4U, form_structure.field_count()); 648 EXPECT_EQ(4U, form_structure.autofill_count()); 649 650 // Normally, the two separate address fields would cause us to detect two 651 // separate sections; but because there is an author-specified section in this 652 // form, we do not apply these usual heuristics. 653 EXPECT_EQ(ASCIIToUTF16("one"), form_structure.field(0)->name); 654 EXPECT_EQ(ASCIIToUTF16("two"), form_structure.field(3)->name); 655 EXPECT_EQ(form_structure.field(0)->section(), 656 form_structure.field(3)->section()); 657} 658 659TEST(FormStructureTest, HeuristicsSample8) { 660 scoped_ptr<FormStructure> form_structure; 661 FormData form; 662 663 FormFieldData field; 664 field.form_control_type = "text"; 665 666 field.label = ASCIIToUTF16("Your First Name:"); 667 field.name = ASCIIToUTF16("bill.first"); 668 form.fields.push_back(field); 669 670 field.label = ASCIIToUTF16("Your Last Name:"); 671 field.name = ASCIIToUTF16("bill.last"); 672 form.fields.push_back(field); 673 674 field.label = ASCIIToUTF16("Street Address Line 1:"); 675 field.name = ASCIIToUTF16("bill.street1"); 676 form.fields.push_back(field); 677 678 field.label = ASCIIToUTF16("Street Address Line 2:"); 679 field.name = ASCIIToUTF16("bill.street2"); 680 form.fields.push_back(field); 681 682 field.label = ASCIIToUTF16("City"); 683 field.name = ASCIIToUTF16("bill.city"); 684 form.fields.push_back(field); 685 686 field.label = ASCIIToUTF16("State (U.S.):"); 687 field.name = ASCIIToUTF16("bill.state"); 688 form.fields.push_back(field); 689 690 field.label = ASCIIToUTF16("Zip/Postal Code:"); 691 field.name = ASCIIToUTF16("BillTo.PostalCode"); 692 form.fields.push_back(field); 693 694 field.label = ASCIIToUTF16("Country:"); 695 field.name = ASCIIToUTF16("bill.country"); 696 form.fields.push_back(field); 697 698 field.label = ASCIIToUTF16("Phone Number:"); 699 field.name = ASCIIToUTF16("BillTo.Phone"); 700 form.fields.push_back(field); 701 702 field.label = base::string16(); 703 field.name = ASCIIToUTF16("Submit"); 704 field.form_control_type = "submit"; 705 form.fields.push_back(field); 706 707 form_structure.reset(new FormStructure(form)); 708 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 709 EXPECT_TRUE(form_structure->IsAutofillable()); 710 ASSERT_EQ(10U, form_structure->field_count()); 711 ASSERT_EQ(9U, form_structure->autofill_count()); 712 713 // First name. 714 EXPECT_EQ(NAME_FIRST, form_structure->field(0)->heuristic_type()); 715 // Last name. 716 EXPECT_EQ(NAME_LAST, form_structure->field(1)->heuristic_type()); 717 // Address. 718 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(2)->heuristic_type()); 719 // Address. 720 EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(3)->heuristic_type()); 721 // City. 722 EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(4)->heuristic_type()); 723 // State. 724 EXPECT_EQ(ADDRESS_HOME_STATE, form_structure->field(5)->heuristic_type()); 725 // Zip. 726 EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(6)->heuristic_type()); 727 // Country. 728 EXPECT_EQ(ADDRESS_HOME_COUNTRY, form_structure->field(7)->heuristic_type()); 729 // Phone. 730 EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER, 731 form_structure->field(8)->heuristic_type()); 732 // Submit. 733 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(9)->heuristic_type()); 734} 735 736TEST(FormStructureTest, HeuristicsSample6) { 737 scoped_ptr<FormStructure> form_structure; 738 FormData form; 739 740 FormFieldData field; 741 field.form_control_type = "text"; 742 743 field.label = ASCIIToUTF16("E-mail address"); 744 field.name = ASCIIToUTF16("email"); 745 form.fields.push_back(field); 746 747 field.label = ASCIIToUTF16("Full name"); 748 field.name = ASCIIToUTF16("name"); 749 form.fields.push_back(field); 750 751 field.label = ASCIIToUTF16("Company"); 752 field.name = ASCIIToUTF16("company"); 753 form.fields.push_back(field); 754 755 field.label = ASCIIToUTF16("Address"); 756 field.name = ASCIIToUTF16("address"); 757 form.fields.push_back(field); 758 759 field.label = ASCIIToUTF16("City"); 760 field.name = ASCIIToUTF16("city"); 761 form.fields.push_back(field); 762 763 field.label = ASCIIToUTF16("Zip Code"); 764 field.name = ASCIIToUTF16("Home.PostalCode"); 765 form.fields.push_back(field); 766 767 field.label = base::string16(); 768 field.name = ASCIIToUTF16("Submit"); 769 field.value = ASCIIToUTF16("continue"); 770 field.form_control_type = "submit"; 771 form.fields.push_back(field); 772 773 form_structure.reset(new FormStructure(form)); 774 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 775 EXPECT_TRUE(form_structure->IsAutofillable()); 776 ASSERT_EQ(7U, form_structure->field_count()); 777 ASSERT_EQ(6U, form_structure->autofill_count()); 778 779 // Email. 780 EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(0)->heuristic_type()); 781 // Full name. 782 EXPECT_EQ(NAME_FULL, form_structure->field(1)->heuristic_type()); 783 // Company 784 EXPECT_EQ(COMPANY_NAME, form_structure->field(2)->heuristic_type()); 785 // Address. 786 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(3)->heuristic_type()); 787 // City. 788 EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(4)->heuristic_type()); 789 // Zip. 790 EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(5)->heuristic_type()); 791 // Submit. 792 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(6)->heuristic_type()); 793} 794 795// Tests a sequence of FormFields where only labels are supplied to heuristics 796// for matching. This works because FormFieldData labels are matched in the 797// case that input element ids (or |name| fields) are missing. 798TEST(FormStructureTest, HeuristicsLabelsOnly) { 799 scoped_ptr<FormStructure> form_structure; 800 FormData form; 801 802 FormFieldData field; 803 field.form_control_type = "text"; 804 805 field.label = ASCIIToUTF16("First Name"); 806 field.name = base::string16(); 807 form.fields.push_back(field); 808 809 field.label = ASCIIToUTF16("Last Name"); 810 field.name = base::string16(); 811 form.fields.push_back(field); 812 813 field.label = ASCIIToUTF16("Email"); 814 field.name = base::string16(); 815 form.fields.push_back(field); 816 817 field.label = ASCIIToUTF16("Phone"); 818 field.name = base::string16(); 819 form.fields.push_back(field); 820 821 field.label = ASCIIToUTF16("Address"); 822 field.name = base::string16(); 823 form.fields.push_back(field); 824 825 field.label = ASCIIToUTF16("Address"); 826 field.name = base::string16(); 827 form.fields.push_back(field); 828 829 field.label = ASCIIToUTF16("Zip code"); 830 field.name = base::string16(); 831 form.fields.push_back(field); 832 833 field.label = base::string16(); 834 field.name = ASCIIToUTF16("Submit"); 835 field.form_control_type = "submit"; 836 form.fields.push_back(field); 837 838 form_structure.reset(new FormStructure(form)); 839 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 840 EXPECT_TRUE(form_structure->IsAutofillable()); 841 ASSERT_EQ(8U, form_structure->field_count()); 842 ASSERT_EQ(7U, form_structure->autofill_count()); 843 844 // First name. 845 EXPECT_EQ(NAME_FIRST, form_structure->field(0)->heuristic_type()); 846 // Last name. 847 EXPECT_EQ(NAME_LAST, form_structure->field(1)->heuristic_type()); 848 // Email. 849 EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(2)->heuristic_type()); 850 // Phone. 851 EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER, 852 form_structure->field(3)->heuristic_type()); 853 // Address. 854 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(4)->heuristic_type()); 855 // Address Line 2. 856 EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(5)->heuristic_type()); 857 // Zip. 858 EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(6)->heuristic_type()); 859 // Submit. 860 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(7)->heuristic_type()); 861} 862 863TEST(FormStructureTest, HeuristicsCreditCardInfo) { 864 scoped_ptr<FormStructure> form_structure; 865 FormData form; 866 867 FormFieldData field; 868 field.form_control_type = "text"; 869 870 field.label = ASCIIToUTF16("Name on Card"); 871 field.name = ASCIIToUTF16("name_on_card"); 872 form.fields.push_back(field); 873 874 field.label = ASCIIToUTF16("Card Number"); 875 field.name = ASCIIToUTF16("card_number"); 876 form.fields.push_back(field); 877 878 field.label = ASCIIToUTF16("Exp Month"); 879 field.name = ASCIIToUTF16("ccmonth"); 880 form.fields.push_back(field); 881 882 field.label = ASCIIToUTF16("Exp Year"); 883 field.name = ASCIIToUTF16("ccyear"); 884 form.fields.push_back(field); 885 886 field.label = ASCIIToUTF16("Verification"); 887 field.name = ASCIIToUTF16("verification"); 888 form.fields.push_back(field); 889 890 field.label = base::string16(); 891 field.name = ASCIIToUTF16("Submit"); 892 field.form_control_type = "submit"; 893 form.fields.push_back(field); 894 895 form_structure.reset(new FormStructure(form)); 896 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 897 EXPECT_TRUE(form_structure->IsAutofillable()); 898 ASSERT_EQ(6U, form_structure->field_count()); 899 ASSERT_EQ(5U, form_structure->autofill_count()); 900 901 // Credit card name. 902 EXPECT_EQ(CREDIT_CARD_NAME, form_structure->field(0)->heuristic_type()); 903 // Credit card number. 904 EXPECT_EQ(CREDIT_CARD_NUMBER, form_structure->field(1)->heuristic_type()); 905 // Credit card expiration month. 906 EXPECT_EQ(CREDIT_CARD_EXP_MONTH, form_structure->field(2)->heuristic_type()); 907 // Credit card expiration year. 908 EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR, 909 form_structure->field(3)->heuristic_type()); 910 // CVV. 911 EXPECT_EQ(CREDIT_CARD_VERIFICATION_CODE, 912 form_structure->field(4)->heuristic_type()); 913 // Submit. 914 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(5)->heuristic_type()); 915} 916 917TEST(FormStructureTest, HeuristicsCreditCardInfoWithUnknownCardField) { 918 scoped_ptr<FormStructure> form_structure; 919 FormData form; 920 921 FormFieldData field; 922 field.form_control_type = "text"; 923 924 field.label = ASCIIToUTF16("Name on Card"); 925 field.name = ASCIIToUTF16("name_on_card"); 926 form.fields.push_back(field); 927 928 // This is not a field we know how to process. But we should skip over it 929 // and process the other fields in the card block. 930 field.label = ASCIIToUTF16("Card image"); 931 field.name = ASCIIToUTF16("card_image"); 932 form.fields.push_back(field); 933 934 field.label = ASCIIToUTF16("Card Number"); 935 field.name = ASCIIToUTF16("card_number"); 936 form.fields.push_back(field); 937 938 field.label = ASCIIToUTF16("Exp Month"); 939 field.name = ASCIIToUTF16("ccmonth"); 940 form.fields.push_back(field); 941 942 field.label = ASCIIToUTF16("Exp Year"); 943 field.name = ASCIIToUTF16("ccyear"); 944 form.fields.push_back(field); 945 946 field.label = ASCIIToUTF16("Verification"); 947 field.name = ASCIIToUTF16("verification"); 948 form.fields.push_back(field); 949 950 field.label = base::string16(); 951 field.name = ASCIIToUTF16("Submit"); 952 field.form_control_type = "submit"; 953 form.fields.push_back(field); 954 955 form_structure.reset(new FormStructure(form)); 956 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 957 EXPECT_TRUE(form_structure->IsAutofillable()); 958 ASSERT_EQ(7U, form_structure->field_count()); 959 ASSERT_EQ(5U, form_structure->autofill_count()); 960 961 // Credit card name. 962 EXPECT_EQ(CREDIT_CARD_NAME, form_structure->field(0)->heuristic_type()); 963 // Credit card type. This is an unknown type but related to the credit card. 964 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(1)->heuristic_type()); 965 // Credit card number. 966 EXPECT_EQ(CREDIT_CARD_NUMBER, form_structure->field(2)->heuristic_type()); 967 // Credit card expiration month. 968 EXPECT_EQ(CREDIT_CARD_EXP_MONTH, form_structure->field(3)->heuristic_type()); 969 // Credit card expiration year. 970 EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR, 971 form_structure->field(4)->heuristic_type()); 972 // CVV. 973 EXPECT_EQ(CREDIT_CARD_VERIFICATION_CODE, 974 form_structure->field(5)->heuristic_type()); 975 // Submit. 976 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(6)->heuristic_type()); 977} 978 979TEST(FormStructureTest, ThreeAddressLines) { 980 scoped_ptr<FormStructure> form_structure; 981 FormData form; 982 983 FormFieldData field; 984 field.form_control_type = "text"; 985 986 field.label = ASCIIToUTF16("Address Line1"); 987 field.name = ASCIIToUTF16("Address"); 988 form.fields.push_back(field); 989 990 field.label = ASCIIToUTF16("Address Line2"); 991 field.name = ASCIIToUTF16("Address"); 992 form.fields.push_back(field); 993 994 field.label = ASCIIToUTF16("Address Line3"); 995 field.name = ASCIIToUTF16("Address"); 996 form.fields.push_back(field); 997 998 field.label = ASCIIToUTF16("City"); 999 field.name = ASCIIToUTF16("city"); 1000 form.fields.push_back(field); 1001 1002 form_structure.reset(new FormStructure(form)); 1003 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1004 EXPECT_TRUE(form_structure->IsAutofillable()); 1005 ASSERT_EQ(4U, form_structure->field_count()); 1006 ASSERT_EQ(3U, form_structure->autofill_count()); 1007 1008 // Address Line 1. 1009 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type()); 1010 // Address Line 2. 1011 EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type()); 1012 // Address Line 3. 1013 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(2)->heuristic_type()); 1014 // City. 1015 EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(3)->heuristic_type()); 1016} 1017 1018// Numbered address lines after line two are ignored. 1019TEST(FormStructureTest, SurplusAddressLinesIgnored) { 1020 scoped_ptr<FormStructure> form_structure; 1021 FormData form; 1022 1023 FormFieldData field; 1024 field.form_control_type = "text"; 1025 1026 field.label = ASCIIToUTF16("Address Line1"); 1027 field.name = ASCIIToUTF16("shipping.address.addressLine1"); 1028 form.fields.push_back(field); 1029 1030 field.label = ASCIIToUTF16("Address Line2"); 1031 field.name = ASCIIToUTF16("shipping.address.addressLine2"); 1032 form.fields.push_back(field); 1033 1034 field.label = ASCIIToUTF16("Address Line3"); 1035 field.name = ASCIIToUTF16("billing.address.addressLine3"); 1036 form.fields.push_back(field); 1037 1038 field.label = ASCIIToUTF16("Address Line4"); 1039 field.name = ASCIIToUTF16("billing.address.addressLine4"); 1040 form.fields.push_back(field); 1041 1042 form_structure.reset(new FormStructure(form)); 1043 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1044 ASSERT_EQ(4U, form_structure->field_count()); 1045 ASSERT_EQ(2U, form_structure->autofill_count()); 1046 1047 // Address Line 1. 1048 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type()); 1049 // Address Line 2. 1050 EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type()); 1051 // Address Line 3 (ignored). 1052 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(2)->heuristic_type()); 1053 // Address Line 4 (ignored). 1054 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(3)->heuristic_type()); 1055} 1056 1057// This example comes from expedia.com where they use a "Suite" label to 1058// indicate a suite or apartment number. We interpret this as address line 2. 1059// And the following "Street address second line" we interpret as address line 1060// 3 and discard. 1061// See http://crbug.com/48197 for details. 1062TEST(FormStructureTest, ThreeAddressLinesExpedia) { 1063 scoped_ptr<FormStructure> form_structure; 1064 FormData form; 1065 1066 FormFieldData field; 1067 field.form_control_type = "text"; 1068 1069 field.label = ASCIIToUTF16("Street:"); 1070 field.name = ASCIIToUTF16("FOPIH_RgWebCC_0_IHAddress_ads1"); 1071 form.fields.push_back(field); 1072 1073 field.label = ASCIIToUTF16("Suite or Apt:"); 1074 field.name = ASCIIToUTF16("FOPIH_RgWebCC_0_IHAddress_adap"); 1075 form.fields.push_back(field); 1076 1077 field.label = ASCIIToUTF16("Street address second line"); 1078 field.name = ASCIIToUTF16("FOPIH_RgWebCC_0_IHAddress_ads2"); 1079 form.fields.push_back(field); 1080 1081 field.label = ASCIIToUTF16("City:"); 1082 field.name = ASCIIToUTF16("FOPIH_RgWebCC_0_IHAddress_adct"); 1083 form.fields.push_back(field); 1084 1085 form_structure.reset(new FormStructure(form)); 1086 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1087 EXPECT_TRUE(form_structure->IsAutofillable()); 1088 ASSERT_EQ(4U, form_structure->field_count()); 1089 EXPECT_EQ(3U, form_structure->autofill_count()); 1090 1091 // Address Line 1. 1092 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type()); 1093 // Suite / Apt. 1094 EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type()); 1095 // Address Line 3. 1096 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(2)->heuristic_type()); 1097 // City. 1098 EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(3)->heuristic_type()); 1099} 1100 1101// This example comes from ebay.com where the word "suite" appears in the label 1102// and the name "address2" clearly indicates that this is the address line 2. 1103// See http://crbug.com/48197 for details. 1104TEST(FormStructureTest, TwoAddressLinesEbay) { 1105 scoped_ptr<FormStructure> form_structure; 1106 FormData form; 1107 1108 FormFieldData field; 1109 field.form_control_type = "text"; 1110 1111 field.label = ASCIIToUTF16("Address Line1"); 1112 field.name = ASCIIToUTF16("address1"); 1113 form.fields.push_back(field); 1114 1115 field.label = ASCIIToUTF16("Floor number, suite number, etc"); 1116 field.name = ASCIIToUTF16("address2"); 1117 form.fields.push_back(field); 1118 1119 field.label = ASCIIToUTF16("City:"); 1120 field.name = ASCIIToUTF16("city"); 1121 form.fields.push_back(field); 1122 1123 form_structure.reset(new FormStructure(form)); 1124 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1125 EXPECT_TRUE(form_structure->IsAutofillable()); 1126 ASSERT_EQ(3U, form_structure->field_count()); 1127 ASSERT_EQ(3U, form_structure->autofill_count()); 1128 1129 // Address Line 1. 1130 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type()); 1131 // Address Line 2. 1132 EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type()); 1133 // City. 1134 EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(2)->heuristic_type()); 1135} 1136 1137TEST(FormStructureTest, HeuristicsStateWithProvince) { 1138 scoped_ptr<FormStructure> form_structure; 1139 FormData form; 1140 1141 FormFieldData field; 1142 field.form_control_type = "text"; 1143 1144 field.label = ASCIIToUTF16("Address Line1"); 1145 field.name = ASCIIToUTF16("Address"); 1146 form.fields.push_back(field); 1147 1148 field.label = ASCIIToUTF16("Address Line2"); 1149 field.name = ASCIIToUTF16("Address"); 1150 form.fields.push_back(field); 1151 1152 field.label = ASCIIToUTF16("State/Province/Region"); 1153 field.name = ASCIIToUTF16("State"); 1154 form.fields.push_back(field); 1155 1156 form_structure.reset(new FormStructure(form)); 1157 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1158 EXPECT_TRUE(form_structure->IsAutofillable()); 1159 ASSERT_EQ(3U, form_structure->field_count()); 1160 ASSERT_EQ(3U, form_structure->autofill_count()); 1161 1162 // Address Line 1. 1163 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type()); 1164 // Address Line 2. 1165 EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type()); 1166 // State. 1167 EXPECT_EQ(ADDRESS_HOME_STATE, form_structure->field(2)->heuristic_type()); 1168} 1169 1170// This example comes from lego.com's checkout page. 1171TEST(FormStructureTest, HeuristicsWithBilling) { 1172 scoped_ptr<FormStructure> form_structure; 1173 FormData form; 1174 1175 FormFieldData field; 1176 field.form_control_type = "text"; 1177 1178 field.label = ASCIIToUTF16("First Name*:"); 1179 field.name = ASCIIToUTF16("editBillingAddress$firstNameBox"); 1180 form.fields.push_back(field); 1181 1182 field.label = ASCIIToUTF16("Last Name*:"); 1183 field.name = ASCIIToUTF16("editBillingAddress$lastNameBox"); 1184 form.fields.push_back(field); 1185 1186 field.label = ASCIIToUTF16("Company Name:"); 1187 field.name = ASCIIToUTF16("editBillingAddress$companyBox"); 1188 form.fields.push_back(field); 1189 1190 field.label = ASCIIToUTF16("Address*:"); 1191 field.name = ASCIIToUTF16("editBillingAddress$addressLine1Box"); 1192 form.fields.push_back(field); 1193 1194 field.label = ASCIIToUTF16("Apt/Suite :"); 1195 field.name = ASCIIToUTF16("editBillingAddress$addressLine2Box"); 1196 form.fields.push_back(field); 1197 1198 field.label = ASCIIToUTF16("City*:"); 1199 field.name = ASCIIToUTF16("editBillingAddress$cityBox"); 1200 form.fields.push_back(field); 1201 1202 field.label = ASCIIToUTF16("State/Province*:"); 1203 field.name = ASCIIToUTF16("editBillingAddress$stateDropDown"); 1204 form.fields.push_back(field); 1205 1206 field.label = ASCIIToUTF16("Country*:"); 1207 field.name = ASCIIToUTF16("editBillingAddress$countryDropDown"); 1208 form.fields.push_back(field); 1209 1210 field.label = ASCIIToUTF16("Postal Code*:"); 1211 field.name = ASCIIToUTF16("editBillingAddress$zipCodeBox"); 1212 form.fields.push_back(field); 1213 1214 field.label = ASCIIToUTF16("Phone*:"); 1215 field.name = ASCIIToUTF16("editBillingAddress$phoneBox"); 1216 form.fields.push_back(field); 1217 1218 field.label = ASCIIToUTF16("Email Address*:"); 1219 field.name = ASCIIToUTF16("email$emailBox"); 1220 form.fields.push_back(field); 1221 1222 form_structure.reset(new FormStructure(form)); 1223 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1224 EXPECT_TRUE(form_structure->IsAutofillable()); 1225 ASSERT_EQ(11U, form_structure->field_count()); 1226 ASSERT_EQ(11U, form_structure->autofill_count()); 1227 1228 EXPECT_EQ(NAME_FIRST, form_structure->field(0)->heuristic_type()); 1229 EXPECT_EQ(NAME_LAST, form_structure->field(1)->heuristic_type()); 1230 EXPECT_EQ(COMPANY_NAME, form_structure->field(2)->heuristic_type()); 1231 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(3)->heuristic_type()); 1232 EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(4)->heuristic_type()); 1233 EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(5)->heuristic_type()); 1234 EXPECT_EQ(ADDRESS_HOME_STATE, form_structure->field(6)->heuristic_type()); 1235 EXPECT_EQ(ADDRESS_HOME_COUNTRY, form_structure->field(7)->heuristic_type()); 1236 EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(8)->heuristic_type()); 1237 EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER, 1238 form_structure->field(9)->heuristic_type()); 1239 EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(10)->heuristic_type()); 1240} 1241 1242TEST(FormStructureTest, ThreePartPhoneNumber) { 1243 scoped_ptr<FormStructure> form_structure; 1244 FormData form; 1245 1246 FormFieldData field; 1247 field.form_control_type = "text"; 1248 1249 field.label = ASCIIToUTF16("Phone:"); 1250 field.name = ASCIIToUTF16("dayphone1"); 1251 field.max_length = 0; 1252 form.fields.push_back(field); 1253 1254 field.label = ASCIIToUTF16("-"); 1255 field.name = ASCIIToUTF16("dayphone2"); 1256 field.max_length = 3; // Size of prefix is 3. 1257 form.fields.push_back(field); 1258 1259 field.label = ASCIIToUTF16("-"); 1260 field.name = ASCIIToUTF16("dayphone3"); 1261 field.max_length = 4; // Size of suffix is 4. If unlimited size is 1262 // passed, phone will be parsed as 1263 // <country code> - <area code> - <phone>. 1264 form.fields.push_back(field); 1265 1266 field.label = ASCIIToUTF16("ext.:"); 1267 field.name = ASCIIToUTF16("dayphone4"); 1268 field.max_length = 0; 1269 form.fields.push_back(field); 1270 1271 form_structure.reset(new FormStructure(form)); 1272 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1273 EXPECT_TRUE(form_structure->IsAutofillable()); 1274 ASSERT_EQ(4U, form_structure->field_count()); 1275 ASSERT_EQ(3U, form_structure->autofill_count()); 1276 1277 // Area code. 1278 EXPECT_EQ(PHONE_HOME_CITY_CODE, form_structure->field(0)->heuristic_type()); 1279 // Phone number suffix. 1280 EXPECT_EQ(PHONE_HOME_NUMBER, 1281 form_structure->field(1)->heuristic_type()); 1282 // Phone number suffix. 1283 EXPECT_EQ(PHONE_HOME_NUMBER, 1284 form_structure->field(2)->heuristic_type()); 1285 // Unknown. 1286 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(3)->heuristic_type()); 1287} 1288 1289TEST(FormStructureTest, HeuristicsInfernoCC) { 1290 scoped_ptr<FormStructure> form_structure; 1291 FormData form; 1292 1293 FormFieldData field; 1294 field.form_control_type = "text"; 1295 1296 field.label = ASCIIToUTF16("Name on Card"); 1297 field.name = ASCIIToUTF16("name_on_card"); 1298 form.fields.push_back(field); 1299 1300 field.label = ASCIIToUTF16("Address"); 1301 field.name = ASCIIToUTF16("billing_address"); 1302 form.fields.push_back(field); 1303 1304 field.label = ASCIIToUTF16("Card Number"); 1305 field.name = ASCIIToUTF16("card_number"); 1306 form.fields.push_back(field); 1307 1308 field.label = ASCIIToUTF16("Expiration Date"); 1309 field.name = ASCIIToUTF16("expiration_month"); 1310 form.fields.push_back(field); 1311 1312 field.label = ASCIIToUTF16("Expiration Year"); 1313 field.name = ASCIIToUTF16("expiration_year"); 1314 form.fields.push_back(field); 1315 1316 form_structure.reset(new FormStructure(form)); 1317 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1318 EXPECT_TRUE(form_structure->IsAutofillable()); 1319 1320 // Expect the correct number of fields. 1321 ASSERT_EQ(5U, form_structure->field_count()); 1322 EXPECT_EQ(5U, form_structure->autofill_count()); 1323 1324 // Name on Card. 1325 EXPECT_EQ(CREDIT_CARD_NAME, form_structure->field(0)->heuristic_type()); 1326 // Address. 1327 EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(1)->heuristic_type()); 1328 // Card Number. 1329 EXPECT_EQ(CREDIT_CARD_NUMBER, form_structure->field(2)->heuristic_type()); 1330 // Expiration Date. 1331 EXPECT_EQ(CREDIT_CARD_EXP_MONTH, form_structure->field(3)->heuristic_type()); 1332 // Expiration Year. 1333 EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR, 1334 form_structure->field(4)->heuristic_type()); 1335} 1336 1337TEST(FormStructureTest, CVCCodeClash) { 1338 scoped_ptr<FormStructure> form_structure; 1339 FormData form; 1340 1341 FormFieldData field; 1342 field.form_control_type = "text"; 1343 1344 field.label = ASCIIToUTF16("Card number"); 1345 field.name = ASCIIToUTF16("ccnumber"); 1346 form.fields.push_back(field); 1347 1348 field.label = ASCIIToUTF16("First name"); 1349 field.name = ASCIIToUTF16("first_name"); 1350 form.fields.push_back(field); 1351 1352 field.label = ASCIIToUTF16("Last name"); 1353 field.name = ASCIIToUTF16("last_name"); 1354 form.fields.push_back(field); 1355 1356 field.label = ASCIIToUTF16("Expiration date"); 1357 field.name = ASCIIToUTF16("ccexpiresmonth"); 1358 form.fields.push_back(field); 1359 1360 field.label = base::string16(); 1361 field.name = ASCIIToUTF16("ccexpiresyear"); 1362 form.fields.push_back(field); 1363 1364 field.label = ASCIIToUTF16("cvc number"); 1365 field.name = ASCIIToUTF16("csc"); 1366 form.fields.push_back(field); 1367 1368 form_structure.reset(new FormStructure(form)); 1369 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1370 EXPECT_TRUE(form_structure->IsAutofillable()); 1371 1372 // Expect the correct number of fields. 1373 ASSERT_EQ(6U, form_structure->field_count()); 1374 ASSERT_EQ(5U, form_structure->autofill_count()); 1375 1376 // Card Number. 1377 EXPECT_EQ(CREDIT_CARD_NUMBER, form_structure->field(0)->heuristic_type()); 1378 // First name, taken as name on card. 1379 EXPECT_EQ(CREDIT_CARD_NAME, form_structure->field(1)->heuristic_type()); 1380 // Last name is not merged. 1381 EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(2)->heuristic_type()); 1382 // Expiration Date. 1383 EXPECT_EQ(CREDIT_CARD_EXP_MONTH, form_structure->field(3)->heuristic_type()); 1384 // Expiration Year. 1385 EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR, 1386 form_structure->field(4)->heuristic_type()); 1387 // CVC code. 1388 EXPECT_EQ(CREDIT_CARD_VERIFICATION_CODE, 1389 form_structure->field(5)->heuristic_type()); 1390} 1391 1392TEST(FormStructureTest, EncodeQueryRequest) { 1393 FormData form; 1394 1395 FormFieldData field; 1396 field.form_control_type = "text"; 1397 1398 field.label = ASCIIToUTF16("Name on Card"); 1399 field.name = ASCIIToUTF16("name_on_card"); 1400 form.fields.push_back(field); 1401 1402 field.label = ASCIIToUTF16("Address"); 1403 field.name = ASCIIToUTF16("billing_address"); 1404 form.fields.push_back(field); 1405 1406 field.label = ASCIIToUTF16("Card Number"); 1407 field.name = ASCIIToUTF16("card_number"); 1408 form.fields.push_back(field); 1409 1410 field.label = ASCIIToUTF16("Expiration Date"); 1411 field.name = ASCIIToUTF16("expiration_month"); 1412 form.fields.push_back(field); 1413 1414 field.label = ASCIIToUTF16("Expiration Year"); 1415 field.name = ASCIIToUTF16("expiration_year"); 1416 form.fields.push_back(field); 1417 1418 // Add checkable field. 1419 FormFieldData checkable_field; 1420 checkable_field.is_checkable = true; 1421 checkable_field.label = ASCIIToUTF16("Checkable1"); 1422 checkable_field.name = ASCIIToUTF16("Checkable1"); 1423 form.fields.push_back(checkable_field); 1424 1425 ScopedVector<FormStructure> forms; 1426 forms.push_back(new FormStructure(form)); 1427 std::vector<std::string> encoded_signatures; 1428 std::string encoded_xml; 1429 const char kSignature1[] = "11337937696949187602"; 1430 const char kResponse1[] = 1431 "<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 1432 "<autofillquery clientversion=\"6.1.1715.1442/en (GGLL)\">" 1433 "<form signature=\"11337937696949187602\">" 1434 "<field signature=\"412125936\"/>" 1435 "<field signature=\"1917667676\"/>" 1436 "<field signature=\"2226358947\"/>" 1437 "<field signature=\"747221617\"/>" 1438 "<field signature=\"4108155786\"/>" 1439 "</form>" 1440 "</autofillquery>"; 1441 ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms.get(), 1442 &encoded_signatures, 1443 &encoded_xml)); 1444 ASSERT_EQ(1U, encoded_signatures.size()); 1445 EXPECT_EQ(kSignature1, encoded_signatures[0]); 1446 EXPECT_EQ(kResponse1, encoded_xml); 1447 1448 // Add the same form, only one will be encoded, so EncodeQueryRequest() should 1449 // return the same data. 1450 forms.push_back(new FormStructure(form)); 1451 ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms.get(), 1452 &encoded_signatures, 1453 &encoded_xml)); 1454 ASSERT_EQ(1U, encoded_signatures.size()); 1455 EXPECT_EQ(kSignature1, encoded_signatures[0]); 1456 EXPECT_EQ(kResponse1, encoded_xml); 1457 // Add 5 address fields - this should be still a valid form. 1458 for (size_t i = 0; i < 5; ++i) { 1459 field.label = ASCIIToUTF16("Address"); 1460 field.name = ASCIIToUTF16("address"); 1461 form.fields.push_back(field); 1462 } 1463 1464 forms.push_back(new FormStructure(form)); 1465 ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms.get(), 1466 &encoded_signatures, 1467 &encoded_xml)); 1468 ASSERT_EQ(2U, encoded_signatures.size()); 1469 EXPECT_EQ(kSignature1, encoded_signatures[0]); 1470 const char kSignature2[] = "8308881815906226214"; 1471 EXPECT_EQ(kSignature2, encoded_signatures[1]); 1472 const char kResponse2[] = 1473 "<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 1474 "<autofillquery clientversion=\"6.1.1715.1442/en (GGLL)\">" 1475 "<form signature=\"11337937696949187602\">" 1476 "<field signature=\"412125936\"/>" 1477 "<field signature=\"1917667676\"/>" 1478 "<field signature=\"2226358947\"/>" 1479 "<field signature=\"747221617\"/>" 1480 "<field signature=\"4108155786\"/>" 1481 "</form>" 1482 "<form signature=\"8308881815906226214\">" 1483 "<field signature=\"412125936\"/>" 1484 "<field signature=\"1917667676\"/>" 1485 "<field signature=\"2226358947\"/>" 1486 "<field signature=\"747221617\"/>" 1487 "<field signature=\"4108155786\"/>" 1488 "<field signature=\"509334676\"/>" 1489 "<field signature=\"509334676\"/>" 1490 "<field signature=\"509334676\"/>" 1491 "<field signature=\"509334676\"/>" 1492 "<field signature=\"509334676\"/>" 1493 "</form>" 1494 "</autofillquery>"; 1495 EXPECT_EQ(kResponse2, encoded_xml); 1496 1497 FormData malformed_form(form); 1498 // Add 50 address fields - the form is not valid anymore, but previous ones 1499 // are. The result should be the same as in previous test. 1500 for (size_t i = 0; i < 50; ++i) { 1501 field.label = ASCIIToUTF16("Address"); 1502 field.name = ASCIIToUTF16("address"); 1503 malformed_form.fields.push_back(field); 1504 } 1505 1506 forms.push_back(new FormStructure(malformed_form)); 1507 ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms.get(), 1508 &encoded_signatures, 1509 &encoded_xml)); 1510 ASSERT_EQ(2U, encoded_signatures.size()); 1511 EXPECT_EQ(kSignature1, encoded_signatures[0]); 1512 EXPECT_EQ(kSignature2, encoded_signatures[1]); 1513 EXPECT_EQ(kResponse2, encoded_xml); 1514 1515 // Check that we fail if there are only bad form(s). 1516 ScopedVector<FormStructure> bad_forms; 1517 bad_forms.push_back(new FormStructure(malformed_form)); 1518 EXPECT_FALSE(FormStructure::EncodeQueryRequest(bad_forms.get(), 1519 &encoded_signatures, 1520 &encoded_xml)); 1521 EXPECT_EQ(0U, encoded_signatures.size()); 1522 EXPECT_EQ("", encoded_xml); 1523} 1524 1525TEST(FormStructureTest, EncodeUploadRequest) { 1526 scoped_ptr<FormStructure> form_structure; 1527 std::vector<ServerFieldTypeSet> possible_field_types; 1528 FormData form; 1529 form_structure.reset(new FormStructure(form)); 1530 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1531 1532 FormFieldData field; 1533 field.form_control_type = "text"; 1534 1535 field.label = ASCIIToUTF16("First Name"); 1536 field.name = ASCIIToUTF16("firstname"); 1537 form.fields.push_back(field); 1538 possible_field_types.push_back(ServerFieldTypeSet()); 1539 possible_field_types.back().insert(NAME_FIRST); 1540 1541 field.label = ASCIIToUTF16("Last Name"); 1542 field.name = ASCIIToUTF16("lastname"); 1543 form.fields.push_back(field); 1544 possible_field_types.push_back(ServerFieldTypeSet()); 1545 possible_field_types.back().insert(NAME_LAST); 1546 1547 field.label = ASCIIToUTF16("Email"); 1548 field.name = ASCIIToUTF16("email"); 1549 field.form_control_type = "email"; 1550 form.fields.push_back(field); 1551 possible_field_types.push_back(ServerFieldTypeSet()); 1552 possible_field_types.back().insert(EMAIL_ADDRESS); 1553 1554 field.label = ASCIIToUTF16("Phone"); 1555 field.name = ASCIIToUTF16("phone"); 1556 field.form_control_type = "number"; 1557 form.fields.push_back(field); 1558 possible_field_types.push_back(ServerFieldTypeSet()); 1559 possible_field_types.back().insert(PHONE_HOME_WHOLE_NUMBER); 1560 1561 field.label = ASCIIToUTF16("Country"); 1562 field.name = ASCIIToUTF16("country"); 1563 field.form_control_type = "select-one"; 1564 form.fields.push_back(field); 1565 possible_field_types.push_back(ServerFieldTypeSet()); 1566 possible_field_types.back().insert(ADDRESS_HOME_COUNTRY); 1567 1568 // Add checkable field. 1569 FormFieldData checkable_field; 1570 checkable_field.is_checkable = true; 1571 checkable_field.label = ASCIIToUTF16("Checkable1"); 1572 checkable_field.name = ASCIIToUTF16("Checkable1"); 1573 form.fields.push_back(checkable_field); 1574 possible_field_types.push_back(ServerFieldTypeSet()); 1575 possible_field_types.back().insert(ADDRESS_HOME_COUNTRY); 1576 1577 form_structure.reset(new FormStructure(form)); 1578 1579 ASSERT_EQ(form_structure->field_count(), possible_field_types.size()); 1580 for (size_t i = 0; i < form_structure->field_count(); ++i) 1581 form_structure->field(i)->set_possible_types(possible_field_types[i]); 1582 1583 ServerFieldTypeSet available_field_types; 1584 available_field_types.insert(NAME_FIRST); 1585 available_field_types.insert(NAME_LAST); 1586 available_field_types.insert(ADDRESS_HOME_LINE1); 1587 available_field_types.insert(ADDRESS_HOME_LINE2); 1588 available_field_types.insert(ADDRESS_HOME_COUNTRY); 1589 available_field_types.insert(ADDRESS_BILLING_LINE1); 1590 available_field_types.insert(ADDRESS_BILLING_LINE2); 1591 available_field_types.insert(EMAIL_ADDRESS); 1592 available_field_types.insert(PHONE_HOME_WHOLE_NUMBER); 1593 1594 std::string encoded_xml; 1595 EXPECT_TRUE(form_structure->EncodeUploadRequest(available_field_types, false, 1596 &encoded_xml)); 1597 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 1598 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\" " 1599 "formsignature=\"8736493185895608956\" autofillused=\"false\" " 1600 "datapresent=\"144200030e\">" 1601 "<field signature=\"3763331450\" autofilltype=\"3\"/>" 1602 "<field signature=\"3494530716\" autofilltype=\"5\"/>" 1603 "<field signature=\"1029417091\" autofilltype=\"9\"/>" 1604 "<field signature=\"466116101\" autofilltype=\"14\"/>" 1605 "<field signature=\"2799270304\" autofilltype=\"36\"/>" 1606 "</autofillupload>", 1607 encoded_xml); 1608 EXPECT_TRUE(form_structure->EncodeUploadRequest(available_field_types, true, 1609 &encoded_xml)); 1610 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 1611 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\" " 1612 "formsignature=\"8736493185895608956\" autofillused=\"true\" " 1613 "datapresent=\"144200030e\">" 1614 "<field signature=\"3763331450\" autofilltype=\"3\"/>" 1615 "<field signature=\"3494530716\" autofilltype=\"5\"/>" 1616 "<field signature=\"1029417091\" autofilltype=\"9\"/>" 1617 "<field signature=\"466116101\" autofilltype=\"14\"/>" 1618 "<field signature=\"2799270304\" autofilltype=\"36\"/>" 1619 "</autofillupload>", 1620 encoded_xml); 1621 1622 // Add 2 address fields - this should be still a valid form. 1623 for (size_t i = 0; i < 2; ++i) { 1624 field.label = ASCIIToUTF16("Address"); 1625 field.name = ASCIIToUTF16("address"); 1626 field.form_control_type = "text"; 1627 form.fields.push_back(field); 1628 possible_field_types.push_back(ServerFieldTypeSet()); 1629 possible_field_types.back().insert(ADDRESS_HOME_LINE1); 1630 possible_field_types.back().insert(ADDRESS_HOME_LINE2); 1631 possible_field_types.back().insert(ADDRESS_BILLING_LINE1); 1632 possible_field_types.back().insert(ADDRESS_BILLING_LINE2); 1633 } 1634 1635 form_structure.reset(new FormStructure(form)); 1636 ASSERT_EQ(form_structure->field_count(), possible_field_types.size()); 1637 for (size_t i = 0; i < form_structure->field_count(); ++i) 1638 form_structure->field(i)->set_possible_types(possible_field_types[i]); 1639 1640 EXPECT_TRUE(form_structure->EncodeUploadRequest(available_field_types, false, 1641 &encoded_xml)); 1642 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 1643 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\" " 1644 "formsignature=\"7816485729218079147\" autofillused=\"false\" " 1645 "datapresent=\"144200030e\">" 1646 "<field signature=\"3763331450\" autofilltype=\"3\"/>" 1647 "<field signature=\"3494530716\" autofilltype=\"5\"/>" 1648 "<field signature=\"1029417091\" autofilltype=\"9\"/>" 1649 "<field signature=\"466116101\" autofilltype=\"14\"/>" 1650 "<field signature=\"2799270304\" autofilltype=\"36\"/>" 1651 "<field signature=\"509334676\" autofilltype=\"30\"/>" 1652 "<field signature=\"509334676\" autofilltype=\"31\"/>" 1653 "<field signature=\"509334676\" autofilltype=\"37\"/>" 1654 "<field signature=\"509334676\" autofilltype=\"38\"/>" 1655 "<field signature=\"509334676\" autofilltype=\"30\"/>" 1656 "<field signature=\"509334676\" autofilltype=\"31\"/>" 1657 "<field signature=\"509334676\" autofilltype=\"37\"/>" 1658 "<field signature=\"509334676\" autofilltype=\"38\"/>" 1659 "</autofillupload>", 1660 encoded_xml); 1661 1662 // Add 50 address fields - now the form is invalid, as it has too many fields. 1663 for (size_t i = 0; i < 50; ++i) { 1664 field.label = ASCIIToUTF16("Address"); 1665 field.name = ASCIIToUTF16("address"); 1666 field.form_control_type = "text"; 1667 form.fields.push_back(field); 1668 possible_field_types.push_back(ServerFieldTypeSet()); 1669 possible_field_types.back().insert(ADDRESS_HOME_LINE1); 1670 possible_field_types.back().insert(ADDRESS_HOME_LINE2); 1671 possible_field_types.back().insert(ADDRESS_BILLING_LINE1); 1672 possible_field_types.back().insert(ADDRESS_BILLING_LINE2); 1673 } 1674 form_structure.reset(new FormStructure(form)); 1675 ASSERT_EQ(form_structure->field_count(), possible_field_types.size()); 1676 for (size_t i = 0; i < form_structure->field_count(); ++i) 1677 form_structure->field(i)->set_possible_types(possible_field_types[i]); 1678 EXPECT_FALSE(form_structure->EncodeUploadRequest(available_field_types, false, 1679 &encoded_xml)); 1680} 1681 1682TEST(FormStructureTest, EncodeFieldAssignments) { 1683 scoped_ptr<FormStructure> form_structure; 1684 std::vector<ServerFieldTypeSet> possible_field_types; 1685 FormData form; 1686 form_structure.reset(new FormStructure(form)); 1687 form_structure->DetermineHeuristicTypes(TestAutofillMetrics()); 1688 1689 FormFieldData field; 1690 field.form_control_type = "text"; 1691 1692 field.label = ASCIIToUTF16("First Name"); 1693 field.name = ASCIIToUTF16("firstname"); 1694 form.fields.push_back(field); 1695 possible_field_types.push_back(ServerFieldTypeSet()); 1696 possible_field_types.back().insert(NAME_FIRST); 1697 1698 field.label = ASCIIToUTF16("Last Name"); 1699 field.name = ASCIIToUTF16("lastname"); 1700 form.fields.push_back(field); 1701 possible_field_types.push_back(ServerFieldTypeSet()); 1702 possible_field_types.back().insert(NAME_LAST); 1703 1704 field.label = ASCIIToUTF16("Email"); 1705 field.name = ASCIIToUTF16("email"); 1706 field.form_control_type = "email"; 1707 form.fields.push_back(field); 1708 possible_field_types.push_back(ServerFieldTypeSet()); 1709 possible_field_types.back().insert(EMAIL_ADDRESS); 1710 1711 field.label = ASCIIToUTF16("Phone"); 1712 field.name = ASCIIToUTF16("phone"); 1713 field.form_control_type = "number"; 1714 form.fields.push_back(field); 1715 possible_field_types.push_back(ServerFieldTypeSet()); 1716 possible_field_types.back().insert(PHONE_HOME_WHOLE_NUMBER); 1717 1718 field.label = ASCIIToUTF16("Country"); 1719 field.name = ASCIIToUTF16("country"); 1720 field.form_control_type = "select-one"; 1721 form.fields.push_back(field); 1722 possible_field_types.push_back(ServerFieldTypeSet()); 1723 possible_field_types.back().insert(ADDRESS_HOME_COUNTRY); 1724 1725 // Add checkable field. 1726 FormFieldData checkable_field; 1727 checkable_field.is_checkable = true; 1728 checkable_field.label = ASCIIToUTF16("Checkable1"); 1729 checkable_field.name = ASCIIToUTF16("Checkable1"); 1730 form.fields.push_back(checkable_field); 1731 possible_field_types.push_back(ServerFieldTypeSet()); 1732 possible_field_types.back().insert(ADDRESS_HOME_COUNTRY); 1733 1734 form_structure.reset(new FormStructure(form)); 1735 1736 ASSERT_EQ(form_structure->field_count(), possible_field_types.size()); 1737 for (size_t i = 0; i < form_structure->field_count(); ++i) 1738 form_structure->field(i)->set_possible_types(possible_field_types[i]); 1739 1740 ServerFieldTypeSet available_field_types; 1741 available_field_types.insert(NAME_FIRST); 1742 available_field_types.insert(NAME_LAST); 1743 available_field_types.insert(ADDRESS_HOME_LINE1); 1744 available_field_types.insert(ADDRESS_HOME_LINE2); 1745 available_field_types.insert(ADDRESS_HOME_COUNTRY); 1746 available_field_types.insert(ADDRESS_BILLING_LINE1); 1747 available_field_types.insert(ADDRESS_BILLING_LINE2); 1748 available_field_types.insert(EMAIL_ADDRESS); 1749 available_field_types.insert(PHONE_HOME_WHOLE_NUMBER); 1750 1751 std::string encoded_xml; 1752 EXPECT_TRUE(form_structure->EncodeFieldAssignments( 1753 available_field_types, &encoded_xml)); 1754 EXPECT_EQ( 1755 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" 1756 "<fieldassignments formsignature=\"8736493185895608956\">" 1757 "<fields fieldid=\"3763331450\" fieldtype=\"3\" name=\"firstname\"/>" 1758 "<fields fieldid=\"3494530716\" fieldtype=\"5\" name=\"lastname\"/>" 1759 "<fields fieldid=\"1029417091\" fieldtype=\"9\" name=\"email\"/>" 1760 "<fields fieldid=\"466116101\" fieldtype=\"14\" name=\"phone\"/>" 1761 "<fields fieldid=\"2799270304\" fieldtype=\"36\" name=\"country\"/>" 1762 "<fields fieldid=\"3410250678\" fieldtype=\"36\" name=\"Checkable1\"/>" 1763 "</fieldassignments>", 1764 encoded_xml); 1765 1766 // Add 2 address fields - this should be still a valid form. 1767 for (size_t i = 0; i < 2; ++i) { 1768 field.label = ASCIIToUTF16("Address"); 1769 field.name = ASCIIToUTF16("address"); 1770 field.form_control_type = "text"; 1771 form.fields.push_back(field); 1772 possible_field_types.push_back(ServerFieldTypeSet()); 1773 possible_field_types.back().insert(ADDRESS_HOME_LINE1); 1774 possible_field_types.back().insert(ADDRESS_HOME_LINE2); 1775 possible_field_types.back().insert(ADDRESS_BILLING_LINE1); 1776 possible_field_types.back().insert(ADDRESS_BILLING_LINE2); 1777 } 1778 1779 form_structure.reset(new FormStructure(form)); 1780 ASSERT_EQ(form_structure->field_count(), possible_field_types.size()); 1781 for (size_t i = 0; i < form_structure->field_count(); ++i) 1782 form_structure->field(i)->set_possible_types(possible_field_types[i]); 1783 1784 EXPECT_TRUE(form_structure->EncodeFieldAssignments( 1785 available_field_types, &encoded_xml)); 1786 EXPECT_EQ( 1787 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" 1788 "<fieldassignments formsignature=\"7816485729218079147\">" 1789 "<fields fieldid=\"3763331450\" fieldtype=\"3\" name=\"firstname\"/>" 1790 "<fields fieldid=\"3494530716\" fieldtype=\"5\" name=\"lastname\"/>" 1791 "<fields fieldid=\"1029417091\" fieldtype=\"9\" name=\"email\"/>" 1792 "<fields fieldid=\"466116101\" fieldtype=\"14\" name=\"phone\"/>" 1793 "<fields fieldid=\"2799270304\" fieldtype=\"36\" name=\"country\"/>" 1794 "<fields fieldid=\"3410250678\" fieldtype=\"36\" name=\"Checkable1\"/>" 1795 "<fields fieldid=\"509334676\" fieldtype=\"30\" name=\"address\"/>" 1796 "<fields fieldid=\"509334676\" fieldtype=\"31\" name=\"address\"/>" 1797 "<fields fieldid=\"509334676\" fieldtype=\"37\" name=\"address\"/>" 1798 "<fields fieldid=\"509334676\" fieldtype=\"38\" name=\"address\"/>" 1799 "<fields fieldid=\"509334676\" fieldtype=\"30\" name=\"address\"/>" 1800 "<fields fieldid=\"509334676\" fieldtype=\"31\" name=\"address\"/>" 1801 "<fields fieldid=\"509334676\" fieldtype=\"37\" name=\"address\"/>" 1802 "<fields fieldid=\"509334676\" fieldtype=\"38\" name=\"address\"/>" 1803 "</fieldassignments>", 1804 encoded_xml); 1805} 1806 1807// Check that we compute the "datapresent" string correctly for the given 1808// |available_types|. 1809TEST(FormStructureTest, CheckDataPresence) { 1810 FormData form; 1811 1812 FormFieldData field; 1813 field.form_control_type = "text"; 1814 1815 field.label = ASCIIToUTF16("First Name"); 1816 field.name = ASCIIToUTF16("first"); 1817 form.fields.push_back(field); 1818 1819 field.label = ASCIIToUTF16("Last Name"); 1820 field.name = ASCIIToUTF16("last"); 1821 form.fields.push_back(field); 1822 1823 field.label = ASCIIToUTF16("Email"); 1824 field.name = ASCIIToUTF16("email"); 1825 form.fields.push_back(field); 1826 1827 FormStructure form_structure(form); 1828 1829 ServerFieldTypeSet unknown_type; 1830 unknown_type.insert(UNKNOWN_TYPE); 1831 for (size_t i = 0; i < form_structure.field_count(); ++i) 1832 form_structure.field(i)->set_possible_types(unknown_type); 1833 1834 // No available types. 1835 // datapresent should be "" == trimmmed(0x0000000000000000) == 1836 // 0b0000000000000000000000000000000000000000000000000000000000000000 1837 ServerFieldTypeSet available_field_types; 1838 1839 std::string encoded_xml; 1840 EXPECT_TRUE(form_structure.EncodeUploadRequest(available_field_types, false, 1841 &encoded_xml)); 1842 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 1843 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\"" 1844 " formsignature=\"6402244543831589061\" autofillused=\"false\"" 1845 " datapresent=\"\">" 1846 "<field signature=\"1089846351\" autofilltype=\"1\"/>" 1847 "<field signature=\"2404144663\" autofilltype=\"1\"/>" 1848 "<field signature=\"420638584\" autofilltype=\"1\"/>" 1849 "</autofillupload>", 1850 encoded_xml); 1851 1852 // Only a few types available. 1853 // datapresent should be "1540000240" == trimmmed(0x1540000240000000) == 1854 // 0b0001010101000000000000000000001001000000000000000000000000000000 1855 // The set bits are: 1856 // 3 == NAME_FIRST 1857 // 5 == NAME_LAST 1858 // 7 == NAME_FULL 1859 // 9 == EMAIL_ADDRESS 1860 // 30 == ADDRESS_HOME_LINE1 1861 // 33 == ADDRESS_HOME_CITY 1862 available_field_types.clear(); 1863 available_field_types.insert(NAME_FIRST); 1864 available_field_types.insert(NAME_LAST); 1865 available_field_types.insert(NAME_FULL); 1866 available_field_types.insert(EMAIL_ADDRESS); 1867 available_field_types.insert(ADDRESS_HOME_LINE1); 1868 available_field_types.insert(ADDRESS_HOME_CITY); 1869 1870 EXPECT_TRUE(form_structure.EncodeUploadRequest(available_field_types, false, 1871 &encoded_xml)); 1872 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 1873 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\"" 1874 " formsignature=\"6402244543831589061\" autofillused=\"false\"" 1875 " datapresent=\"1540000240\">" 1876 "<field signature=\"1089846351\" autofilltype=\"1\"/>" 1877 "<field signature=\"2404144663\" autofilltype=\"1\"/>" 1878 "<field signature=\"420638584\" autofilltype=\"1\"/>" 1879 "</autofillupload>", 1880 encoded_xml); 1881 1882 // All supported non-credit card types available. 1883 // datapresent should be "1f7e000378000008" == trimmmed(0x1f7e000378000008) == 1884 // 0b0001111101111110000000000000001101111000000000000000000000001000 1885 // The set bits are: 1886 // 3 == NAME_FIRST 1887 // 4 == NAME_MIDDLE 1888 // 5 == NAME_LAST 1889 // 6 == NAME_MIDDLE_INITIAL 1890 // 7 == NAME_FULL 1891 // 9 == EMAIL_ADDRESS 1892 // 10 == PHONE_HOME_NUMBER, 1893 // 11 == PHONE_HOME_CITY_CODE, 1894 // 12 == PHONE_HOME_COUNTRY_CODE, 1895 // 13 == PHONE_HOME_CITY_AND_NUMBER, 1896 // 14 == PHONE_HOME_WHOLE_NUMBER, 1897 // 30 == ADDRESS_HOME_LINE1 1898 // 31 == ADDRESS_HOME_LINE2 1899 // 33 == ADDRESS_HOME_CITY 1900 // 34 == ADDRESS_HOME_STATE 1901 // 35 == ADDRESS_HOME_ZIP 1902 // 36 == ADDRESS_HOME_COUNTRY 1903 // 60 == COMPANY_NAME 1904 available_field_types.clear(); 1905 available_field_types.insert(NAME_FIRST); 1906 available_field_types.insert(NAME_MIDDLE); 1907 available_field_types.insert(NAME_LAST); 1908 available_field_types.insert(NAME_MIDDLE_INITIAL); 1909 available_field_types.insert(NAME_FULL); 1910 available_field_types.insert(EMAIL_ADDRESS); 1911 available_field_types.insert(PHONE_HOME_NUMBER); 1912 available_field_types.insert(PHONE_HOME_CITY_CODE); 1913 available_field_types.insert(PHONE_HOME_COUNTRY_CODE); 1914 available_field_types.insert(PHONE_HOME_CITY_AND_NUMBER); 1915 available_field_types.insert(PHONE_HOME_WHOLE_NUMBER); 1916 available_field_types.insert(ADDRESS_HOME_LINE1); 1917 available_field_types.insert(ADDRESS_HOME_LINE2); 1918 available_field_types.insert(ADDRESS_HOME_CITY); 1919 available_field_types.insert(ADDRESS_HOME_STATE); 1920 available_field_types.insert(ADDRESS_HOME_ZIP); 1921 available_field_types.insert(ADDRESS_HOME_COUNTRY); 1922 available_field_types.insert(COMPANY_NAME); 1923 1924 EXPECT_TRUE(form_structure.EncodeUploadRequest(available_field_types, false, 1925 &encoded_xml)); 1926 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 1927 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\"" 1928 " formsignature=\"6402244543831589061\" autofillused=\"false\"" 1929 " datapresent=\"1f7e000378000008\">" 1930 "<field signature=\"1089846351\" autofilltype=\"1\"/>" 1931 "<field signature=\"2404144663\" autofilltype=\"1\"/>" 1932 "<field signature=\"420638584\" autofilltype=\"1\"/>" 1933 "</autofillupload>", 1934 encoded_xml); 1935 1936 // All supported credit card types available. 1937 // datapresent should be "0000000000001fc0" == trimmmed(0x0000000000001fc0) == 1938 // 0b0000000000000000000000000000000000000000000000000001111111000000 1939 // The set bits are: 1940 // 51 == CREDIT_CARD_NAME 1941 // 52 == CREDIT_CARD_NUMBER 1942 // 53 == CREDIT_CARD_EXP_MONTH 1943 // 54 == CREDIT_CARD_EXP_2_DIGIT_YEAR 1944 // 55 == CREDIT_CARD_EXP_4_DIGIT_YEAR 1945 // 56 == CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR 1946 // 57 == CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR 1947 available_field_types.clear(); 1948 available_field_types.insert(CREDIT_CARD_NAME); 1949 available_field_types.insert(CREDIT_CARD_NUMBER); 1950 available_field_types.insert(CREDIT_CARD_EXP_MONTH); 1951 available_field_types.insert(CREDIT_CARD_EXP_2_DIGIT_YEAR); 1952 available_field_types.insert(CREDIT_CARD_EXP_4_DIGIT_YEAR); 1953 available_field_types.insert(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR); 1954 available_field_types.insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR); 1955 1956 EXPECT_TRUE(form_structure.EncodeUploadRequest(available_field_types, false, 1957 &encoded_xml)); 1958 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 1959 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\"" 1960 " formsignature=\"6402244543831589061\" autofillused=\"false\"" 1961 " datapresent=\"0000000000001fc0\">" 1962 "<field signature=\"1089846351\" autofilltype=\"1\"/>" 1963 "<field signature=\"2404144663\" autofilltype=\"1\"/>" 1964 "<field signature=\"420638584\" autofilltype=\"1\"/>" 1965 "</autofillupload>", 1966 encoded_xml); 1967 1968 // All supported types available. 1969 // datapresent should be "1f7e000378001fc8" == trimmmed(0x1f7e000378001fc8) == 1970 // 0b0001111101111110000000000000001101111000000000000001111111001000 1971 // The set bits are: 1972 // 3 == NAME_FIRST 1973 // 4 == NAME_MIDDLE 1974 // 5 == NAME_LAST 1975 // 6 == NAME_MIDDLE_INITIAL 1976 // 7 == NAME_FULL 1977 // 9 == EMAIL_ADDRESS 1978 // 10 == PHONE_HOME_NUMBER, 1979 // 11 == PHONE_HOME_CITY_CODE, 1980 // 12 == PHONE_HOME_COUNTRY_CODE, 1981 // 13 == PHONE_HOME_CITY_AND_NUMBER, 1982 // 14 == PHONE_HOME_WHOLE_NUMBER, 1983 // 30 == ADDRESS_HOME_LINE1 1984 // 31 == ADDRESS_HOME_LINE2 1985 // 33 == ADDRESS_HOME_CITY 1986 // 34 == ADDRESS_HOME_STATE 1987 // 35 == ADDRESS_HOME_ZIP 1988 // 36 == ADDRESS_HOME_COUNTRY 1989 // 51 == CREDIT_CARD_NAME 1990 // 52 == CREDIT_CARD_NUMBER 1991 // 53 == CREDIT_CARD_EXP_MONTH 1992 // 54 == CREDIT_CARD_EXP_2_DIGIT_YEAR 1993 // 55 == CREDIT_CARD_EXP_4_DIGIT_YEAR 1994 // 56 == CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR 1995 // 57 == CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR 1996 // 60 == COMPANY_NAME 1997 available_field_types.clear(); 1998 available_field_types.insert(NAME_FIRST); 1999 available_field_types.insert(NAME_MIDDLE); 2000 available_field_types.insert(NAME_LAST); 2001 available_field_types.insert(NAME_MIDDLE_INITIAL); 2002 available_field_types.insert(NAME_FULL); 2003 available_field_types.insert(EMAIL_ADDRESS); 2004 available_field_types.insert(PHONE_HOME_NUMBER); 2005 available_field_types.insert(PHONE_HOME_CITY_CODE); 2006 available_field_types.insert(PHONE_HOME_COUNTRY_CODE); 2007 available_field_types.insert(PHONE_HOME_CITY_AND_NUMBER); 2008 available_field_types.insert(PHONE_HOME_WHOLE_NUMBER); 2009 available_field_types.insert(ADDRESS_HOME_LINE1); 2010 available_field_types.insert(ADDRESS_HOME_LINE2); 2011 available_field_types.insert(ADDRESS_HOME_CITY); 2012 available_field_types.insert(ADDRESS_HOME_STATE); 2013 available_field_types.insert(ADDRESS_HOME_ZIP); 2014 available_field_types.insert(ADDRESS_HOME_COUNTRY); 2015 available_field_types.insert(CREDIT_CARD_NAME); 2016 available_field_types.insert(CREDIT_CARD_NUMBER); 2017 available_field_types.insert(CREDIT_CARD_EXP_MONTH); 2018 available_field_types.insert(CREDIT_CARD_EXP_2_DIGIT_YEAR); 2019 available_field_types.insert(CREDIT_CARD_EXP_4_DIGIT_YEAR); 2020 available_field_types.insert(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR); 2021 available_field_types.insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR); 2022 available_field_types.insert(COMPANY_NAME); 2023 2024 EXPECT_TRUE(form_structure.EncodeUploadRequest(available_field_types, false, 2025 &encoded_xml)); 2026 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 2027 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\"" 2028 " formsignature=\"6402244543831589061\" autofillused=\"false\"" 2029 " datapresent=\"1f7e000378001fc8\">" 2030 "<field signature=\"1089846351\" autofilltype=\"1\"/>" 2031 "<field signature=\"2404144663\" autofilltype=\"1\"/>" 2032 "<field signature=\"420638584\" autofilltype=\"1\"/>" 2033 "</autofillupload>", 2034 encoded_xml); 2035} 2036 2037TEST(FormStructureTest, CheckMultipleTypes) { 2038 // Throughout this test, datapresent should be 2039 // 0x1440000360000008 == 2040 // 0b0001010001000000000000000000001101100000000000000000000000001000 2041 // The set bits are: 2042 // 3 == NAME_FIRST 2043 // 5 == NAME_LAST 2044 // 9 == EMAIL_ADDRESS 2045 // 30 == ADDRESS_HOME_LINE1 2046 // 31 == ADDRESS_HOME_LINE2 2047 // 33 == ADDRESS_HOME_CITY 2048 // 34 == ADDRESS_HOME_STATE 2049 // 60 == COMPANY_NAME 2050 ServerFieldTypeSet available_field_types; 2051 available_field_types.insert(NAME_FIRST); 2052 available_field_types.insert(NAME_LAST); 2053 available_field_types.insert(EMAIL_ADDRESS); 2054 available_field_types.insert(ADDRESS_HOME_LINE1); 2055 available_field_types.insert(ADDRESS_HOME_LINE2); 2056 available_field_types.insert(ADDRESS_HOME_CITY); 2057 available_field_types.insert(ADDRESS_HOME_STATE); 2058 available_field_types.insert(COMPANY_NAME); 2059 2060 // Check that multiple types for the field are processed correctly. 2061 scoped_ptr<FormStructure> form_structure; 2062 std::vector<ServerFieldTypeSet> possible_field_types; 2063 FormData form; 2064 2065 FormFieldData field; 2066 field.form_control_type = "text"; 2067 2068 field.label = ASCIIToUTF16("email"); 2069 field.name = ASCIIToUTF16("email"); 2070 form.fields.push_back(field); 2071 possible_field_types.push_back(ServerFieldTypeSet()); 2072 possible_field_types.back().insert(EMAIL_ADDRESS); 2073 2074 field.label = ASCIIToUTF16("First Name"); 2075 field.name = ASCIIToUTF16("first"); 2076 form.fields.push_back(field); 2077 possible_field_types.push_back(ServerFieldTypeSet()); 2078 possible_field_types.back().insert(NAME_FIRST); 2079 2080 field.label = ASCIIToUTF16("Last Name"); 2081 field.name = ASCIIToUTF16("last"); 2082 form.fields.push_back(field); 2083 possible_field_types.push_back(ServerFieldTypeSet()); 2084 possible_field_types.back().insert(NAME_LAST); 2085 2086 field.label = ASCIIToUTF16("Address"); 2087 field.name = ASCIIToUTF16("address"); 2088 form.fields.push_back(field); 2089 possible_field_types.push_back(ServerFieldTypeSet()); 2090 possible_field_types.back().insert(ADDRESS_HOME_LINE1); 2091 2092 form_structure.reset(new FormStructure(form)); 2093 2094 for (size_t i = 0; i < form_structure->field_count(); ++i) 2095 form_structure->field(i)->set_possible_types(possible_field_types[i]); 2096 std::string encoded_xml; 2097 2098 // Now we matched both fields singularly. 2099 EXPECT_TRUE(form_structure->EncodeUploadRequest(available_field_types, false, 2100 &encoded_xml)); 2101 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 2102 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\"" 2103 " formsignature=\"18062476096658145866\" autofillused=\"false\"" 2104 " datapresent=\"1440000360000008\">" 2105 "<field signature=\"420638584\" autofilltype=\"9\"/>" 2106 "<field signature=\"1089846351\" autofilltype=\"3\"/>" 2107 "<field signature=\"2404144663\" autofilltype=\"5\"/>" 2108 "<field signature=\"509334676\" autofilltype=\"30\"/>" 2109 "</autofillupload>", 2110 encoded_xml); 2111 // Match third field as both first and last. 2112 possible_field_types[2].insert(NAME_FIRST); 2113 form_structure->field(2)->set_possible_types(possible_field_types[2]); 2114 EXPECT_TRUE(form_structure->EncodeUploadRequest(available_field_types, false, 2115 &encoded_xml)); 2116 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 2117 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\"" 2118 " formsignature=\"18062476096658145866\" autofillused=\"false\"" 2119 " datapresent=\"1440000360000008\">" 2120 "<field signature=\"420638584\" autofilltype=\"9\"/>" 2121 "<field signature=\"1089846351\" autofilltype=\"3\"/>" 2122 "<field signature=\"2404144663\" autofilltype=\"3\"/>" 2123 "<field signature=\"2404144663\" autofilltype=\"5\"/>" 2124 "<field signature=\"509334676\" autofilltype=\"30\"/>" 2125 "</autofillupload>", 2126 encoded_xml); 2127 possible_field_types[3].insert(ADDRESS_HOME_LINE2); 2128 form_structure->field(form_structure->field_count() - 1)->set_possible_types( 2129 possible_field_types[form_structure->field_count() - 1]); 2130 EXPECT_TRUE(form_structure->EncodeUploadRequest(available_field_types, false, 2131 &encoded_xml)); 2132 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 2133 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\"" 2134 " formsignature=\"18062476096658145866\" autofillused=\"false\"" 2135 " datapresent=\"1440000360000008\">" 2136 "<field signature=\"420638584\" autofilltype=\"9\"/>" 2137 "<field signature=\"1089846351\" autofilltype=\"3\"/>" 2138 "<field signature=\"2404144663\" autofilltype=\"3\"/>" 2139 "<field signature=\"2404144663\" autofilltype=\"5\"/>" 2140 "<field signature=\"509334676\" autofilltype=\"30\"/>" 2141 "<field signature=\"509334676\" autofilltype=\"31\"/>" 2142 "</autofillupload>", 2143 encoded_xml); 2144 possible_field_types[3].clear(); 2145 possible_field_types[3].insert(ADDRESS_HOME_LINE1); 2146 possible_field_types[3].insert(COMPANY_NAME); 2147 form_structure->field(form_structure->field_count() - 1)->set_possible_types( 2148 possible_field_types[form_structure->field_count() - 1]); 2149 EXPECT_TRUE(form_structure->EncodeUploadRequest(available_field_types, false, 2150 &encoded_xml)); 2151 EXPECT_EQ("<\?xml version=\"1.0\" encoding=\"UTF-8\"\?>" 2152 "<autofillupload clientversion=\"6.1.1715.1442/en (GGLL)\"" 2153 " formsignature=\"18062476096658145866\" autofillused=\"false\"" 2154 " datapresent=\"1440000360000008\">" 2155 "<field signature=\"420638584\" autofilltype=\"9\"/>" 2156 "<field signature=\"1089846351\" autofilltype=\"3\"/>" 2157 "<field signature=\"2404144663\" autofilltype=\"3\"/>" 2158 "<field signature=\"2404144663\" autofilltype=\"5\"/>" 2159 "<field signature=\"509334676\" autofilltype=\"30\"/>" 2160 "<field signature=\"509334676\" autofilltype=\"60\"/>" 2161 "</autofillupload>", 2162 encoded_xml); 2163} 2164 2165TEST(FormStructureTest, CheckFormSignature) { 2166 // Check that form signature is created correctly. 2167 scoped_ptr<FormStructure> form_structure; 2168 FormData form; 2169 2170 FormFieldData field; 2171 field.form_control_type = "text"; 2172 2173 field.label = ASCIIToUTF16("email"); 2174 field.name = ASCIIToUTF16("email"); 2175 form.fields.push_back(field); 2176 2177 field.label = ASCIIToUTF16("First Name"); 2178 field.name = ASCIIToUTF16("first"); 2179 form.fields.push_back(field); 2180 2181 // Checkable fields shouldn't affect the signature. 2182 field.label = ASCIIToUTF16("Select"); 2183 field.name = ASCIIToUTF16("Select"); 2184 field.form_control_type = "checkbox"; 2185 field.is_checkable = true; 2186 form.fields.push_back(field); 2187 2188 form_structure.reset(new FormStructure(form)); 2189 2190 EXPECT_EQ(FormStructureTest::Hash64Bit( 2191 std::string("://&&email&first")), 2192 form_structure->FormSignature()); 2193 2194 form.origin = GURL(std::string("http://www.facebook.com")); 2195 form_structure.reset(new FormStructure(form)); 2196 EXPECT_EQ(FormStructureTest::Hash64Bit( 2197 std::string("http://www.facebook.com&&email&first")), 2198 form_structure->FormSignature()); 2199 2200 form.action = GURL(std::string("https://login.facebook.com/path")); 2201 form_structure.reset(new FormStructure(form)); 2202 EXPECT_EQ(FormStructureTest::Hash64Bit( 2203 std::string("https://login.facebook.com&&email&first")), 2204 form_structure->FormSignature()); 2205 2206 form.name = ASCIIToUTF16("login_form"); 2207 form_structure.reset(new FormStructure(form)); 2208 EXPECT_EQ(FormStructureTest::Hash64Bit( 2209 std::string("https://login.facebook.com&login_form&email&first")), 2210 form_structure->FormSignature()); 2211 2212 field.is_checkable = false; 2213 field.label = ASCIIToUTF16("Random Field label"); 2214 field.name = ASCIIToUTF16("random1234"); 2215 field.form_control_type = "text"; 2216 form.fields.push_back(field); 2217 field.label = ASCIIToUTF16("Random Field label2"); 2218 field.name = ASCIIToUTF16("random12345"); 2219 form.fields.push_back(field); 2220 field.label = ASCIIToUTF16("Random Field label3"); 2221 field.name = ASCIIToUTF16("1random12345678"); 2222 form.fields.push_back(field); 2223 field.label = ASCIIToUTF16("Random Field label3"); 2224 field.name = ASCIIToUTF16("12345random"); 2225 form.fields.push_back(field); 2226 form_structure.reset(new FormStructure(form)); 2227 EXPECT_EQ(FormStructureTest::Hash64Bit( 2228 std::string("https://login.facebook.com&login_form&email&first&" 2229 "random1234&random&1random&random")), 2230 form_structure->FormSignature()); 2231 2232} 2233 2234TEST(FormStructureTest, ToFormData) { 2235 FormData form; 2236 form.name = ASCIIToUTF16("the-name"); 2237 form.origin = GURL("http://cool.com"); 2238 form.action = form.origin.Resolve("/login"); 2239 2240 FormFieldData field; 2241 field.label = ASCIIToUTF16("username"); 2242 field.name = ASCIIToUTF16("username"); 2243 field.form_control_type = "text"; 2244 form.fields.push_back(field); 2245 2246 field.label = ASCIIToUTF16("password"); 2247 field.name = ASCIIToUTF16("password"); 2248 field.form_control_type = "password"; 2249 form.fields.push_back(field); 2250 2251 field.label = base::string16(); 2252 field.name = ASCIIToUTF16("Submit"); 2253 field.form_control_type = "submit"; 2254 form.fields.push_back(field); 2255 2256 EXPECT_EQ(form, FormStructure(form).ToFormData()); 2257 2258 // Currently |FormStructure(form_data)ToFormData().user_submitted| is always 2259 // false. This forces a future author that changes this to update this test. 2260 form.user_submitted = true; 2261 EXPECT_NE(form, FormStructure(form).ToFormData()); 2262} 2263 2264TEST(FormStructureTest, SkipFieldTest) { 2265 FormData form; 2266 form.name = ASCIIToUTF16("the-name"); 2267 form.origin = GURL("http://cool.com"); 2268 form.action = form.origin.Resolve("/login"); 2269 2270 FormFieldData field; 2271 field.label = ASCIIToUTF16("username"); 2272 field.name = ASCIIToUTF16("username"); 2273 field.form_control_type = "text"; 2274 form.fields.push_back(field); 2275 2276 field.label = ASCIIToUTF16("select"); 2277 field.name = ASCIIToUTF16("select"); 2278 field.form_control_type = "checkbox"; 2279 field.is_checkable = true; 2280 form.fields.push_back(field); 2281 2282 field.label = base::string16(); 2283 field.name = ASCIIToUTF16("email"); 2284 field.form_control_type = "text"; 2285 field.is_checkable = false; 2286 form.fields.push_back(field); 2287 2288 ScopedVector<FormStructure> forms; 2289 forms.push_back(new FormStructure(form)); 2290 std::vector<std::string> encoded_signatures; 2291 std::string encoded_xml; 2292 2293 const char kSignature[] = "18006745212084723782"; 2294 const char kResponse[] = 2295 "<\?xml version=\"1.0\" encoding=\"UTF-8\"?>" 2296 "<autofillquery clientversion=\"6.1.1715.1442/en (GGLL)\">" 2297 "<form signature=\"18006745212084723782\">" 2298 "<field signature=\"239111655\"/>" 2299 "<field signature=\"420638584\"/>" 2300 "</form>" 2301 "</autofillquery>"; 2302 ASSERT_TRUE(FormStructure::EncodeQueryRequest(forms.get(), 2303 &encoded_signatures, 2304 &encoded_xml)); 2305 ASSERT_EQ(1U, encoded_signatures.size()); 2306 EXPECT_EQ(kSignature, encoded_signatures[0]); 2307 EXPECT_EQ(kResponse, encoded_xml); 2308} 2309 2310TEST(FormStructureTest, PossibleValues) { 2311 FormData form_data; 2312 FormFieldData field; 2313 field.autocomplete_attribute = "billing country"; 2314 field.option_contents.push_back(ASCIIToUTF16("Down Under")); 2315 field.option_values.push_back(ASCIIToUTF16("AU")); 2316 field.option_contents.push_back(ASCIIToUTF16("Fr")); 2317 field.option_values.push_back(ASCIIToUTF16("")); 2318 field.option_contents.push_back(ASCIIToUTF16("Germany")); 2319 field.option_values.push_back(ASCIIToUTF16("GRMNY")); 2320 form_data.fields.push_back(field); 2321 FormStructure form_structure(form_data); 2322 2323 bool unused; 2324 form_structure.ParseFieldTypesFromAutocompleteAttributes(&unused, &unused); 2325 2326 // All values in <option> value= or contents are returned, set to upper case. 2327 std::set<base::string16> possible_values = 2328 form_structure.PossibleValues(ADDRESS_BILLING_COUNTRY); 2329 EXPECT_EQ(5U, possible_values.size()); 2330 EXPECT_EQ(1U, possible_values.count(ASCIIToUTF16("AU"))); 2331 EXPECT_EQ(1U, possible_values.count(ASCIIToUTF16("FR"))); 2332 EXPECT_EQ(1U, possible_values.count(ASCIIToUTF16("DOWN UNDER"))); 2333 EXPECT_EQ(1U, possible_values.count(ASCIIToUTF16("GERMANY"))); 2334 EXPECT_EQ(1U, possible_values.count(ASCIIToUTF16("GRMNY"))); 2335 EXPECT_EQ(0U, possible_values.count(ASCIIToUTF16("Fr"))); 2336 EXPECT_EQ(0U, possible_values.count(ASCIIToUTF16("DE"))); 2337 2338 // No field for the given type; empty value set. 2339 EXPECT_EQ(0U, form_structure.PossibleValues(ADDRESS_HOME_COUNTRY).size()); 2340 2341 // A freeform input (<input>) allows any value (overriding other <select>s). 2342 FormFieldData freeform_field; 2343 freeform_field.autocomplete_attribute = "billing country"; 2344 form_data.fields.push_back(freeform_field); 2345 FormStructure form_structure2(form_data); 2346 form_structure2.ParseFieldTypesFromAutocompleteAttributes(&unused, &unused); 2347 EXPECT_EQ(0U, form_structure2.PossibleValues(ADDRESS_BILLING_COUNTRY).size()); 2348} 2349 2350} // namespace autofill 2351