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