src/components/autofill/core/browser/address_field_unittest.cc

   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 "base/memory/scoped_ptr.h"
   6 #include "base/memory/scoped_vector.h"
   7 #include "base/strings/string16.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "components/autofill/core/browser/address_field.h"
  10 #include "components/autofill/core/browser/autofill_field.h"
  11 #include "components/autofill/core/browser/autofill_scanner.h"
  12 #include "components/autofill/core/common/form_field_data.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace autofill {
  16
  17 class AddressFieldTest : public testing::Test {
  18  public:
  19   AddressFieldTest() {}
  20
  21  protected:
  22   ScopedVector<const AutofillField> list_;
  23   scoped_ptr<AddressField> field_;
  24   ServerFieldTypeMap field_type_map_;
  25
  26   // Downcast for tests.
  27   static AddressField* Parse(AutofillScanner* scanner) {
  28     return static_cast<AddressField*>(AddressField::Parse(scanner));
  29   }
  30
  31  private:
  32   DISALLOW_COPY_AND_ASSIGN(AddressFieldTest);
  33 };
  34
  35 TEST_F(AddressFieldTest, Empty) {
  36   AutofillScanner scanner(list_.get());
  37   field_.reset(Parse(&scanner));
  38   ASSERT_EQ(static_cast<AddressField*>(NULL), field_.get());
  39 }
  40
  41 TEST_F(AddressFieldTest, NonParse) {
  42   list_.push_back(new AutofillField);
  43   AutofillScanner scanner(list_.get());
  44   field_.reset(Parse(&scanner));
  45   ASSERT_EQ(static_cast<AddressField*>(NULL), field_.get());
  46 }
  47
  48 TEST_F(AddressFieldTest, ParseOneLineAddress) {
  49   FormFieldData field;
  50   field.form_control_type = "text";
  51
  52   field.label = ASCIIToUTF16("Address");
  53   field.name = ASCIIToUTF16("address");
  54   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr1")));
  55
  56   AutofillScanner scanner(list_.get());
  57   field_.reset(Parse(&scanner));
  58   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
  59   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
  60   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
  61   ASSERT_TRUE(
  62       field_type_map_.find(ASCIIToUTF16("addr1")) != field_type_map_.end());
  63   EXPECT_EQ(ADDRESS_HOME_LINE1, field_type_map_[ASCIIToUTF16("addr1")]);
  64 }
  65
  66 TEST_F(AddressFieldTest, ParseOneLineAddressBilling) {
  67   FormFieldData field;
  68   field.form_control_type = "text";
  69
  70   field.label = ASCIIToUTF16("Address");
  71   field.name = ASCIIToUTF16("billingAddress");
  72   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr1")));
  73
  74   AutofillScanner scanner(list_.get());
  75   field_.reset(Parse(&scanner));
  76   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
  77   EXPECT_EQ(AddressField::kBillingAddress, field_->FindType());
  78   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
  79   ASSERT_TRUE(
  80       field_type_map_.find(ASCIIToUTF16("addr1")) != field_type_map_.end());
  81   EXPECT_EQ(ADDRESS_BILLING_LINE1, field_type_map_[ASCIIToUTF16("addr1")]);
  82 }
  83
  84 TEST_F(AddressFieldTest, ParseOneLineAddressShipping) {
  85   FormFieldData field;
  86   field.form_control_type = "text";
  87
  88   field.label = ASCIIToUTF16("Address");
  89   field.name = ASCIIToUTF16("shippingAddress");
  90   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr1")));
  91
  92   AutofillScanner scanner(list_.get());
  93   field_.reset(Parse(&scanner));
  94   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
  95   EXPECT_EQ(AddressField::kShippingAddress, field_->FindType());
  96   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
  97   ASSERT_TRUE(
  98       field_type_map_.find(ASCIIToUTF16("addr1")) != field_type_map_.end());
  99   EXPECT_EQ(ADDRESS_HOME_LINE1, field_type_map_[ASCIIToUTF16("addr1")]);
 100 }
 101
 102 TEST_F(AddressFieldTest, ParseTwoLineAddress) {
 103   FormFieldData field;
 104   field.form_control_type = "text";
 105
 106   field.label = ASCIIToUTF16("Address");
 107   field.name = ASCIIToUTF16("address");
 108   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr1")));
 109
 110   field.label = base::string16();
 111   field.name = base::string16();
 112   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr2")));
 113
 114   AutofillScanner scanner(list_.get());
 115   field_.reset(Parse(&scanner));
 116   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 117   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 118   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 119   ASSERT_TRUE(
 120       field_type_map_.find(ASCIIToUTF16("addr1")) != field_type_map_.end());
 121   EXPECT_EQ(ADDRESS_HOME_LINE1, field_type_map_[ASCIIToUTF16("addr1")]);
 122   ASSERT_TRUE(
 123       field_type_map_.find(ASCIIToUTF16("addr2")) != field_type_map_.end());
 124   EXPECT_EQ(ADDRESS_HOME_LINE2, field_type_map_[ASCIIToUTF16("addr2")]);
 125 }
 126
 127 TEST_F(AddressFieldTest, ParseThreeLineAddress) {
 128   FormFieldData field;
 129   field.form_control_type = "text";
 130
 131   field.label = ASCIIToUTF16("Address Line1");
 132   field.name = ASCIIToUTF16("Address1");
 133   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr1")));
 134
 135   field.label = ASCIIToUTF16("Address Line2");
 136   field.name = ASCIIToUTF16("Address2");
 137   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr2")));
 138
 139   field.label = ASCIIToUTF16("Address Line3");
 140   field.name = ASCIIToUTF16("Address3");
 141   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr3")));
 142
 143   AutofillScanner scanner(list_.get());
 144   field_.reset(Parse(&scanner));
 145   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 146   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 147   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 148   ASSERT_TRUE(
 149       field_type_map_.find(ASCIIToUTF16("addr1")) != field_type_map_.end());
 150   EXPECT_EQ(ADDRESS_HOME_LINE1, field_type_map_[ASCIIToUTF16("addr1")]);
 151   ASSERT_TRUE(
 152       field_type_map_.find(ASCIIToUTF16("addr2")) != field_type_map_.end());
 153   EXPECT_EQ(ADDRESS_HOME_LINE2, field_type_map_[ASCIIToUTF16("addr2")]);
 154   ASSERT_TRUE(
 155       field_type_map_.find(ASCIIToUTF16("addr3")) == field_type_map_.end());
 156 }
 157
 158 TEST_F(AddressFieldTest, ParseStreetAddressFromTextArea) {
 159   FormFieldData field;
 160   field.form_control_type = "textarea";
 161
 162   field.label = ASCIIToUTF16("Address");
 163   field.name = ASCIIToUTF16("address");
 164   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr")));
 165
 166   AutofillScanner scanner(list_.get());
 167   field_.reset(Parse(&scanner));
 168   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 169   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 170   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 171   ASSERT_TRUE(
 172       field_type_map_.find(ASCIIToUTF16("addr")) != field_type_map_.end());
 173   // TODO(isherman): This should really be a field type that includes all the
 174   // lines of the address.
 175   EXPECT_EQ(ADDRESS_HOME_LINE1, field_type_map_[ASCIIToUTF16("addr")]);
 176 }
 177
 178 TEST_F(AddressFieldTest, ParseCity) {
 179   FormFieldData field;
 180   field.form_control_type = "text";
 181
 182   field.label = ASCIIToUTF16("City");
 183   field.name = ASCIIToUTF16("city");
 184   list_.push_back(new AutofillField(field, ASCIIToUTF16("city1")));
 185
 186   AutofillScanner scanner(list_.get());
 187   field_.reset(Parse(&scanner));
 188   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 189   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 190   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 191   ASSERT_TRUE(
 192       field_type_map_.find(ASCIIToUTF16("city1")) != field_type_map_.end());
 193   EXPECT_EQ(ADDRESS_HOME_CITY, field_type_map_[ASCIIToUTF16("city1")]);
 194 }
 195
 196 TEST_F(AddressFieldTest, ParseState) {
 197   FormFieldData field;
 198   field.form_control_type = "text";
 199
 200   field.label = ASCIIToUTF16("State");
 201   field.name = ASCIIToUTF16("state");
 202   list_.push_back(new AutofillField(field, ASCIIToUTF16("state1")));
 203
 204   AutofillScanner scanner(list_.get());
 205   field_.reset(Parse(&scanner));
 206   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 207   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 208   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 209   ASSERT_TRUE(
 210       field_type_map_.find(ASCIIToUTF16("state1")) != field_type_map_.end());
 211   EXPECT_EQ(ADDRESS_HOME_STATE, field_type_map_[ASCIIToUTF16("state1")]);
 212 }
 213
 214 TEST_F(AddressFieldTest, ParseZip) {
 215   FormFieldData field;
 216   field.form_control_type = "text";
 217
 218   field.label = ASCIIToUTF16("Zip");
 219   field.name = ASCIIToUTF16("zip");
 220   list_.push_back(new AutofillField(field, ASCIIToUTF16("zip1")));
 221
 222   AutofillScanner scanner(list_.get());
 223   field_.reset(Parse(&scanner));
 224   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 225   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 226   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 227   ASSERT_TRUE(
 228       field_type_map_.find(ASCIIToUTF16("zip1")) != field_type_map_.end());
 229   EXPECT_EQ(ADDRESS_HOME_ZIP, field_type_map_[ASCIIToUTF16("zip1")]);
 230 }
 231
 232 TEST_F(AddressFieldTest, ParseStateAndZipOneLabel) {
 233   FormFieldData field;
 234   field.form_control_type = "text";
 235
 236   field.label = ASCIIToUTF16("State/Province, Zip/Postal Code");
 237   field.name = ASCIIToUTF16("state");
 238   list_.push_back(new AutofillField(field, ASCIIToUTF16("state")));
 239
 240   field.label = ASCIIToUTF16("State/Province, Zip/Postal Code");
 241   field.name = ASCIIToUTF16("zip");
 242   list_.push_back(new AutofillField(field, ASCIIToUTF16("zip")));
 243
 244   AutofillScanner scanner(list_.get());
 245   field_.reset(Parse(&scanner));
 246   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 247   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 248   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 249   ASSERT_TRUE(
 250       field_type_map_.find(ASCIIToUTF16("state")) != field_type_map_.end());
 251   EXPECT_EQ(ADDRESS_HOME_STATE, field_type_map_[ASCIIToUTF16("state")]);
 252   ASSERT_TRUE(
 253       field_type_map_.find(ASCIIToUTF16("zip")) != field_type_map_.end());
 254   EXPECT_EQ(ADDRESS_HOME_ZIP, field_type_map_[ASCIIToUTF16("zip")]);
 255 }
 256
 257 TEST_F(AddressFieldTest, ParseCountry) {
 258   FormFieldData field;
 259   field.form_control_type = "text";
 260
 261   field.label = ASCIIToUTF16("Country");
 262   field.name = ASCIIToUTF16("country");
 263   list_.push_back(new AutofillField(field, ASCIIToUTF16("country1")));
 264
 265   AutofillScanner scanner(list_.get());
 266   field_.reset(Parse(&scanner));
 267   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 268   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 269   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 270   ASSERT_TRUE(
 271       field_type_map_.find(ASCIIToUTF16("country1")) != field_type_map_.end());
 272   EXPECT_EQ(ADDRESS_HOME_COUNTRY, field_type_map_[ASCIIToUTF16("country1")]);
 273 }
 274
 275 TEST_F(AddressFieldTest, ParseTwoLineAddressMissingLabel) {
 276   FormFieldData field;
 277   field.form_control_type = "text";
 278
 279   field.label = ASCIIToUTF16("Address");
 280   field.name = ASCIIToUTF16("address");
 281   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr1")));
 282
 283   field.label = base::string16();
 284   field.name = ASCIIToUTF16("bogus");
 285   list_.push_back(new AutofillField(field, ASCIIToUTF16("addr2")));
 286
 287   AutofillScanner scanner(list_.get());
 288   field_.reset(Parse(&scanner));
 289   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 290   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 291   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 292   ASSERT_TRUE(
 293       field_type_map_.find(ASCIIToUTF16("addr1")) != field_type_map_.end());
 294   EXPECT_EQ(ADDRESS_HOME_LINE1, field_type_map_[ASCIIToUTF16("addr1")]);
 295   ASSERT_TRUE(
 296       field_type_map_.find(ASCIIToUTF16("addr2")) != field_type_map_.end());
 297   EXPECT_EQ(ADDRESS_HOME_LINE2, field_type_map_[ASCIIToUTF16("addr2")]);
 298 }
 299
 300 TEST_F(AddressFieldTest, ParseCompany) {
 301   FormFieldData field;
 302   field.form_control_type = "text";
 303
 304   field.label = ASCIIToUTF16("Company");
 305   field.name = ASCIIToUTF16("company");
 306   list_.push_back(new AutofillField(field, ASCIIToUTF16("company1")));
 307
 308   AutofillScanner scanner(list_.get());
 309   field_.reset(Parse(&scanner));
 310   ASSERT_NE(static_cast<AddressField*>(NULL), field_.get());
 311   EXPECT_EQ(AddressField::kGenericAddress, field_->FindType());
 312   ASSERT_TRUE(field_->ClassifyField(&field_type_map_));
 313   ASSERT_TRUE(
 314       field_type_map_.find(ASCIIToUTF16("company1")) != field_type_map_.end());
 315   EXPECT_EQ(COMPANY_NAME, field_type_map_[ASCIIToUTF16("company1")]);
 316 }
 317
 318 }  // namespace autofill