src/components/autofill/content/browser/wallet/wallet_address_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/json/json_reader.h"
   6 #include "base/logging.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "base/values.h"
  10 #include "components/autofill/content/browser/wallet/wallet_address.h"
  11 #include "components/autofill/core/browser/autofill_common_test.h"
  12 #include "components/autofill/core/browser/autofill_profile.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace {
  16
  17 const char kAddressMissingObjectId[] =
  18     "{"
  19     "  \"phone_number\":\"phone_number\","
  20     "  \"postal_address\":"
  21     "  {"
  22     "    \"recipient_name\":\"recipient_name\","
  23     "    \"address_line\":"
  24     "    ["
  25     "      \"address_line_1\","
  26     "      \"address_line_2\""
  27     "    ],"
  28     "    \"locality_name\":\"locality_name\","
  29     "    \"administrative_area_name\":\"administrative_area_name\","
  30     "    \"postal_code_number\":\"postal_code_number\","
  31     "    \"country_name_code\":\"US\""
  32     "  }"
  33     "}";
  34
  35 const char kAddressMissingCountryNameCode[] =
  36     "{"
  37     "  \"id\":\"id\","
  38     "  \"phone_number\":\"phone_number\","
  39     "  \"postal_address\":"
  40     "  {"
  41     "    \"recipient_name\":\"recipient_name\","
  42     "    \"address_line\":"
  43     "    ["
  44     "      \"address_line_1\","
  45     "      \"address_line_2\""
  46     "    ],"
  47     "    \"locality_name\":\"locality_name\","
  48     "    \"administrative_area_name\":\"administrative_area_name\","
  49     "    \"postal_code_number\":\"postal_code_number\""
  50     "  }"
  51     "}";
  52
  53 const char kAddressMissingRecipientName[] =
  54     "{"
  55     "  \"id\":\"id\","
  56     "  \"phone_number\":\"phone_number\","
  57     "  \"postal_address\":"
  58     "  {"
  59     "    \"address_line\":"
  60     "    ["
  61     "      \"address_line_1\","
  62     "      \"address_line_2\""
  63     "    ],"
  64     "    \"locality_name\":\"locality_name\","
  65     "    \"administrative_area_name\":\"administrative_area_name\","
  66     "    \"postal_code_number\":\"postal_code_number\","
  67     "    \"country_name_code\":\"US\""
  68     "  }"
  69     "}";
  70
  71 const char kAddressMissingPostalCodeNumber[] =
  72     "{"
  73     "  \"id\":\"id\","
  74     "  \"phone_number\":\"phone_number\","
  75     "  \"postal_address\":"
  76     "  {"
  77     "    \"recipient_name\":\"recipient_name\","
  78     "    \"address_line\":"
  79     "    ["
  80     "      \"address_line_1\","
  81     "      \"address_line_2\""
  82     "    ],"
  83     "    \"locality_name\":\"locality_name\","
  84     "    \"administrative_area_name\":\"administrative_area_name\","
  85     "    \"country_name_code\":\"US\""
  86     "  }"
  87     "}";
  88
  89 const char kValidAddress[] =
  90     "{"
  91     "  \"id\":\"id\","
  92     "  \"phone_number\":\"phone_number\","
  93     "  \"is_minimal_address\":true,"
  94     "  \"postal_address\":"
  95     "  {"
  96     "    \"recipient_name\":\"recipient_name\","
  97     "    \"address_line\":"
  98     "    ["
  99     "      \"address_line_1\","
 100     "      \"address_line_2\""
 101     "    ],"
 102     "    \"locality_name\":\"locality_name\","
 103     "    \"administrative_area_name\":\"administrative_area_name\","
 104     "    \"country_name_code\":\"US\","
 105     "    \"postal_code_number\":\"postal_code_number\""
 106     "  }"
 107     "}";
 108
 109 const char kClientAddressMissingCountryCode[] =
 110   "{"
 111   "  \"name\":\"name\","
 112   "  \"address1\":\"address1\","
 113   "  \"address2\":\"address2\","
 114   "  \"city\":\"city\","
 115   "  \"state\":\"state\","
 116   "  \"postal_code\":\"postal_code\","
 117   "  \"phone_number\":\"phone_number\""
 118   "}";
 119
 120 const char kClientAddressMissingPostalCode[] =
 121   "{"
 122   "  \"name\":\"name\","
 123   "  \"address1\":\"address1\","
 124   "  \"address2\":\"address2\","
 125   "  \"city\":\"city\","
 126   "  \"state\":\"state\","
 127   "  \"phone_number\":\"phone_number\","
 128   "  \"country_code\":\"US\""
 129   "}";
 130
 131 const char kClientAddressMissingName[] =
 132   "{"
 133   "  \"address1\":\"address1\","
 134   "  \"address2\":\"address2\","
 135   "  \"city\":\"city\","
 136   "  \"state\":\"state\","
 137   "  \"postal_code\":\"postal_code\","
 138   "  \"phone_number\":\"phone_number\","
 139   "  \"country_code\":\"US\""
 140   "}";
 141
 142 const char kClientValidAddress[] =
 143   "{"
 144   "  \"name\":\"name\","
 145   "  \"address1\":\"address1\","
 146   "  \"address2\":\"address2\","
 147   "  \"city\":\"city\","
 148   "  \"state\":\"state\","
 149   "  \"postal_code\":\"postal_code\","
 150   "  \"phone_number\":\"phone_number\","
 151   "  \"country_code\":\"US\","
 152   "  \"type\":\"FULL\""
 153   "}";
 154
 155 }  // anonymous namespace
 156
 157 namespace autofill {
 158 namespace wallet {
 159
 160 class WalletAddressTest : public testing::Test {
 161  public:
 162   WalletAddressTest() {}
 163  protected:
 164   void SetUpDictionary(const std::string& json) {
 165     scoped_ptr<Value> value(base::JSONReader::Read(json));
 166     DCHECK(value.get());
 167     DCHECK(value->IsType(Value::TYPE_DICTIONARY));
 168     dict_.reset(static_cast<DictionaryValue*>(value.release()));
 169   }
 170   scoped_ptr<const DictionaryValue> dict_;
 171 };
 172
 173 TEST_F(WalletAddressTest, AddressEqualsIgnoreID) {
 174   Address address1("US",
 175                    ASCIIToUTF16("recipient_name"),
 176                    ASCIIToUTF16("address_line_1"),
 177                    ASCIIToUTF16("address_line_2"),
 178                    ASCIIToUTF16("locality_name"),
 179                    ASCIIToUTF16("administrative_area_name"),
 180                    ASCIIToUTF16("postal_code_number"),
 181                    ASCIIToUTF16("phone_number"),
 182                    "id1");
 183   // Same as address1, only id is different.
 184   Address address2("US",
 185                    ASCIIToUTF16("recipient_name"),
 186                    ASCIIToUTF16("address_line_1"),
 187                    ASCIIToUTF16("address_line_2"),
 188                    ASCIIToUTF16("locality_name"),
 189                    ASCIIToUTF16("administrative_area_name"),
 190                    ASCIIToUTF16("postal_code_number"),
 191                    ASCIIToUTF16("phone_number"),
 192                    "id2");
 193   // Has same id as address1, but name is different.
 194   Address address3("US",
 195                    ASCIIToUTF16("a_different_name"),
 196                    ASCIIToUTF16("address_line_1"),
 197                    ASCIIToUTF16("address_line_2"),
 198                    ASCIIToUTF16("locality_name"),
 199                    ASCIIToUTF16("administrative_area_name"),
 200                    ASCIIToUTF16("postal_code_number"),
 201                    ASCIIToUTF16("phone_number"),
 202                    "id1");
 203   // Same as address1, but no id.
 204   Address address4("US",
 205                    ASCIIToUTF16("recipient_name"),
 206                    ASCIIToUTF16("address_line_1"),
 207                    ASCIIToUTF16("address_line_2"),
 208                    ASCIIToUTF16("locality_name"),
 209                    ASCIIToUTF16("administrative_area_name"),
 210                    ASCIIToUTF16("postal_code_number"),
 211                    ASCIIToUTF16("phone_number"),
 212                    std::string());
 213
 214   // Compare the address has id field to itself.
 215   EXPECT_EQ(address1, address1);
 216   EXPECT_TRUE(address1.EqualsIgnoreID(address1));
 217
 218   // Compare the address has no id field to itself
 219   EXPECT_EQ(address4, address4);
 220   EXPECT_TRUE(address4.EqualsIgnoreID(address4));
 221
 222   // Compare two addresses with different id.
 223   EXPECT_NE(address1, address2);
 224   EXPECT_TRUE(address1.EqualsIgnoreID(address2));
 225   EXPECT_TRUE(address2.EqualsIgnoreID(address1));
 226
 227   // Compare two different addresses.
 228   EXPECT_NE(address1, address3);
 229   EXPECT_FALSE(address1.EqualsIgnoreID(address3));
 230   EXPECT_FALSE(address3.EqualsIgnoreID(address1));
 231
 232   // Compare two same addresses, one has id, the other doesn't.
 233   EXPECT_NE(address1, address4);
 234   EXPECT_TRUE(address1.EqualsIgnoreID(address4));
 235   EXPECT_TRUE(address4.EqualsIgnoreID(address1));
 236 }
 237
 238 TEST_F(WalletAddressTest, CreateAddressMissingObjectId) {
 239   SetUpDictionary(kAddressMissingObjectId);
 240   Address address("US",
 241                   ASCIIToUTF16("recipient_name"),
 242                   ASCIIToUTF16("address_line_1"),
 243                   ASCIIToUTF16("address_line_2"),
 244                   ASCIIToUTF16("locality_name"),
 245                   ASCIIToUTF16("administrative_area_name"),
 246                   ASCIIToUTF16("postal_code_number"),
 247                   ASCIIToUTF16("phone_number"),
 248                   std::string());
 249   EXPECT_EQ(address, *Address::CreateAddress(*dict_));
 250 }
 251
 252 TEST_F(WalletAddressTest, CreateAddressWithIDMissingObjectId) {
 253   SetUpDictionary(kAddressMissingObjectId);
 254   EXPECT_EQ(NULL, Address::CreateAddressWithID(*dict_).get());
 255 }
 256
 257 TEST_F(WalletAddressTest, CreateAddressMissingCountryNameCode) {
 258   SetUpDictionary(kAddressMissingCountryNameCode);
 259   EXPECT_EQ(NULL, Address::CreateAddress(*dict_).get());
 260   EXPECT_EQ(NULL, Address::CreateAddressWithID(*dict_).get());
 261 }
 262
 263 TEST_F(WalletAddressTest, CreateAddressMissingRecipientName) {
 264   SetUpDictionary(kAddressMissingRecipientName);
 265   EXPECT_EQ(NULL, Address::CreateAddress(*dict_).get());
 266   EXPECT_EQ(NULL, Address::CreateAddressWithID(*dict_).get());
 267 }
 268
 269 TEST_F(WalletAddressTest, CreateAddressMissingPostalCodeNumber) {
 270   SetUpDictionary(kAddressMissingPostalCodeNumber);
 271   EXPECT_EQ(NULL, Address::CreateAddress(*dict_).get());
 272   EXPECT_EQ(NULL, Address::CreateAddressWithID(*dict_).get());
 273 }
 274
 275 TEST_F(WalletAddressTest, CreateAddressWithID) {
 276   SetUpDictionary(kValidAddress);
 277   Address address("US",
 278                   ASCIIToUTF16("recipient_name"),
 279                   ASCIIToUTF16("address_line_1"),
 280                   ASCIIToUTF16("address_line_2"),
 281                   ASCIIToUTF16("locality_name"),
 282                   ASCIIToUTF16("administrative_area_name"),
 283                   ASCIIToUTF16("postal_code_number"),
 284                   ASCIIToUTF16("phone_number"),
 285                   "id");
 286   address.set_is_complete_address(false);
 287   EXPECT_EQ(address, *Address::CreateAddress(*dict_));
 288   EXPECT_EQ(address, *Address::CreateAddressWithID(*dict_));
 289 }
 290
 291 TEST_F(WalletAddressTest, CreateDisplayAddressMissingCountryNameCode) {
 292   SetUpDictionary(kClientAddressMissingCountryCode);
 293   EXPECT_EQ(NULL, Address::CreateDisplayAddress(*dict_).get());
 294 }
 295
 296 TEST_F(WalletAddressTest, CreateDisplayAddressMissingName) {
 297   SetUpDictionary(kClientAddressMissingName);
 298   EXPECT_EQ(NULL, Address::CreateDisplayAddress(*dict_).get());
 299 }
 300
 301 TEST_F(WalletAddressTest, CreateDisplayAddressMissingPostalCode) {
 302   SetUpDictionary(kClientAddressMissingPostalCode);
 303   EXPECT_EQ(NULL, Address::CreateDisplayAddress(*dict_).get());
 304 }
 305
 306 TEST_F(WalletAddressTest, CreateDisplayAddress) {
 307   SetUpDictionary(kClientValidAddress);
 308   Address address("US",
 309                   ASCIIToUTF16("name"),
 310                   ASCIIToUTF16("address1"),
 311                   ASCIIToUTF16("address2"),
 312                   ASCIIToUTF16("city"),
 313                   ASCIIToUTF16("state"),
 314                   ASCIIToUTF16("postal_code"),
 315                   ASCIIToUTF16("phone_number"),
 316                   std::string());
 317   EXPECT_EQ(address, *Address::CreateDisplayAddress(*dict_));
 318 }
 319
 320 TEST_F(WalletAddressTest, ToDictionaryWithoutID) {
 321   base::DictionaryValue expected;
 322   expected.SetString("country_name_code",
 323                      "US");
 324   expected.SetString("recipient_name",
 325                      "recipient_name");
 326   expected.SetString("locality_name",
 327                      "locality_name");
 328   expected.SetString("administrative_area_name",
 329                      "administrative_area_name");
 330   expected.SetString("postal_code_number",
 331                      "postal_code_number");
 332   base::ListValue* address_lines = new base::ListValue();
 333   address_lines->AppendString("address_line_1");
 334   address_lines->AppendString("address_line_2");
 335   expected.Set("address_line", address_lines);
 336
 337   Address address("US",
 338                   ASCIIToUTF16("recipient_name"),
 339                   ASCIIToUTF16("address_line_1"),
 340                   ASCIIToUTF16("address_line_2"),
 341                   ASCIIToUTF16("locality_name"),
 342                   ASCIIToUTF16("administrative_area_name"),
 343                   ASCIIToUTF16("postal_code_number"),
 344                   ASCIIToUTF16("phone_number"),
 345                   std::string());
 346
 347   EXPECT_TRUE(expected.Equals(address.ToDictionaryWithoutID().get()));
 348 }
 349
 350 TEST_F(WalletAddressTest, ToDictionaryWithID) {
 351   base::DictionaryValue expected;
 352   expected.SetString("id", "id");
 353   expected.SetString("phone_number", "phone_number");
 354   expected.SetString("postal_address.country_name_code",
 355                      "US");
 356   expected.SetString("postal_address.recipient_name",
 357                      "recipient_name");
 358   expected.SetString("postal_address.locality_name",
 359                      "locality_name");
 360   expected.SetString("postal_address.administrative_area_name",
 361                      "administrative_area_name");
 362   expected.SetString("postal_address.postal_code_number",
 363                      "postal_code_number");
 364   base::ListValue* address_lines = new base::ListValue();
 365   address_lines->AppendString("address_line_1");
 366   address_lines->AppendString("address_line_2");
 367   expected.Set("postal_address.address_line", address_lines);
 368
 369   Address address("US",
 370                   ASCIIToUTF16("recipient_name"),
 371                   ASCIIToUTF16("address_line_1"),
 372                   ASCIIToUTF16("address_line_2"),
 373                   ASCIIToUTF16("locality_name"),
 374                   ASCIIToUTF16("administrative_area_name"),
 375                   ASCIIToUTF16("postal_code_number"),
 376                   ASCIIToUTF16("phone_number"),
 377                   "id");
 378
 379   EXPECT_TRUE(expected.Equals(address.ToDictionaryWithID().get()));
 380 }
 381
 382 TEST_F(WalletAddressTest, FromAutofillProfile) {
 383   {
 384     AutofillProfile profile(test::GetFullProfile());
 385     profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("tx"));
 386     Address address(profile);
 387     EXPECT_EQ(ASCIIToUTF16("TX"), address.administrative_area_name());
 388   }
 389
 390   {
 391     AutofillProfile profile(test::GetFullProfile());
 392     profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("Texas"));
 393     Address address(profile);
 394     EXPECT_EQ(ASCIIToUTF16("TX"), address.administrative_area_name());
 395   }
 396
 397   {
 398     AutofillProfile profile(test::GetFullProfile());
 399     profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("TX"));
 400     Address address(profile);
 401     EXPECT_EQ(ASCIIToUTF16("TX"), address.administrative_area_name());
 402   }
 403
 404   {
 405     AutofillProfile profile(test::GetFullProfile());
 406     profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("txeas"));
 407     Address address(profile);
 408     EXPECT_TRUE(address.administrative_area_name().empty());
 409   }
 410 }
 411
 412 // Verifies that WalletAddress::GetInfo() can correctly return both country
 413 // codes and localized country names.
 414 TEST_F(WalletAddressTest, GetCountryInfo) {
 415   Address address("FR",
 416                   ASCIIToUTF16("recipient_name"),
 417                   ASCIIToUTF16("address_line_1"),
 418                   ASCIIToUTF16("address_line_2"),
 419                   ASCIIToUTF16("locality_name"),
 420                   ASCIIToUTF16("administrative_area_name"),
 421                   ASCIIToUTF16("postal_code_number"),
 422                   ASCIIToUTF16("phone_number"),
 423                   "id1");
 424
 425   AutofillType type = AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE);
 426   EXPECT_EQ(ASCIIToUTF16("FR"), address.GetInfo(type, "en-US"));
 427
 428   type = AutofillType(HTML_TYPE_COUNTRY_NAME, HTML_MODE_NONE);
 429   EXPECT_EQ(ASCIIToUTF16("France"), address.GetInfo(type, "en-US"));
 430
 431   type = AutofillType(ADDRESS_HOME_COUNTRY);
 432   EXPECT_EQ(ASCIIToUTF16("France"), address.GetInfo(type, "en-US"));
 433 }
 434
 435 // Verifies that WalletAddress::GetInfo() can correctly return a concatenated
 436 // full street address.
 437 TEST_F(WalletAddressTest, GetStreetAddress) {
 438   // Address has both lines 1 and 2.
 439   Address address1("FR",
 440                    ASCIIToUTF16("recipient_name"),
 441                    ASCIIToUTF16("address_line_1"),
 442                    ASCIIToUTF16("address_line_2"),
 443                    ASCIIToUTF16("locality_name"),
 444                    ASCIIToUTF16("administrative_area_name"),
 445                    ASCIIToUTF16("postal_code_number"),
 446                    ASCIIToUTF16("phone_number"),
 447                    "id1");
 448   AutofillType type = AutofillType(HTML_TYPE_STREET_ADDRESS, HTML_MODE_NONE);
 449   EXPECT_EQ(ASCIIToUTF16("address_line_1, address_line_2"),
 450             address1.GetInfo(type, "en-US"));
 451
 452   // Address has only line 1.
 453   Address address2("FR",
 454                    ASCIIToUTF16("recipient_name"),
 455                    ASCIIToUTF16("address_line_1"),
 456                    base::string16(),
 457                    ASCIIToUTF16("locality_name"),
 458                    ASCIIToUTF16("administrative_area_name"),
 459                    ASCIIToUTF16("postal_code_number"),
 460                    ASCIIToUTF16("phone_number"),
 461                    "id1");
 462   EXPECT_EQ(ASCIIToUTF16("address_line_1"), address2.GetInfo(type, "en-US"));
 463
 464   // Address has no address lines.
 465   Address address3("FR",
 466                    ASCIIToUTF16("recipient_name"),
 467                    base::string16(),
 468                    base::string16(),
 469                    ASCIIToUTF16("locality_name"),
 470                    ASCIIToUTF16("administrative_area_name"),
 471                    ASCIIToUTF16("postal_code_number"),
 472                    ASCIIToUTF16("phone_number"),
 473                    "id1");
 474   EXPECT_EQ(base::string16(), address3.GetInfo(type, "en-US"));
 475 }
 476
 477 }  // namespace wallet
 478 }  // namespace autofill