address_field_unittest.cc revision 4e180b6a0b4720a9b8e9e959a882386f690f08ff 
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
15namespace autofill {
16
17class 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
35TEST_F(AddressFieldTest, Empty) {
36  AutofillScanner scanner(list_.get());
37  field_.reset(Parse(&scanner));
38  ASSERT_EQ(static_cast<AddressField*>(NULL), field_.get());
39}
40
41TEST_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
48TEST_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
66TEST_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
84TEST_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
102TEST_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
127TEST_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
158TEST_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
178TEST_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
196TEST_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
214TEST_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
232TEST_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
257TEST_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
275TEST_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
300TEST_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
319