src/components/autofill/content/browser/wallet/wallet_test_util.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 "components/autofill/content/browser/wallet/wallet_test_util.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/strings/string16.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/values.h"
  14 #include "components/autofill/content/browser/wallet/full_wallet.h"
  15 #include "components/autofill/content/browser/wallet/gaia_account.h"
  16 #include "components/autofill/content/browser/wallet/instrument.h"
  17 #include "components/autofill/content/browser/wallet/required_action.h"
  18 #include "components/autofill/content/browser/wallet/wallet_address.h"
  19
  20 using base::ASCIIToUTF16;
  21
  22 namespace autofill {
  23 namespace wallet {
  24
  25 namespace {
  26
  27 int FutureYear() {
  28   // "In the Year 3000." - Richie "LaBamba" Rosenberg
  29   return 3000;
  30 }
  31
  32 }  // namespace
  33
  34 scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentWithDetails(
  35     const std::string& id,
  36     scoped_ptr<Address> address,
  37     WalletItems::MaskedInstrument::Type type,
  38     WalletItems::MaskedInstrument::Status status) {
  39   return make_scoped_ptr(
  40       new WalletItems::MaskedInstrument(ASCIIToUTF16("descriptive_name"),
  41                                         type,
  42                                         std::vector<base::string16>(),
  43                                         ASCIIToUTF16("1111"),
  44                                         12,
  45                                         FutureYear(),
  46                                         address.Pass(),
  47                                         status,
  48                                         id));
  49 }
  50
  51 scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentWithId(
  52     const std::string& id) {
  53   return GetTestMaskedInstrumentWithDetails(
  54       id,
  55       GetTestAddress(),
  56       WalletItems::MaskedInstrument::VISA,
  57       WalletItems::MaskedInstrument::VALID);
  58 }
  59
  60 scoped_ptr<WalletItems::MaskedInstrument>
  61 GetTestMaskedInstrumentWithIdAndAddress(
  62     const std::string& id, scoped_ptr<Address> address) {
  63   return GetTestMaskedInstrumentWithDetails(
  64       id,
  65       address.Pass(),
  66       WalletItems::MaskedInstrument::VISA,
  67       WalletItems::MaskedInstrument::VALID);
  68 }
  69
  70 scoped_ptr<GaiaAccount> GetTestGaiaAccount() {
  71   return GaiaAccount::CreateForTesting("user@chromium.org",
  72                                        "obfuscated_id",
  73                                        0,
  74                                        true);
  75 }
  76
  77 std::vector<base::string16> StreetAddress(const std::string& line1,
  78                                           const std::string& line2) {
  79   std::vector<base::string16> street_address;
  80   street_address.push_back(ASCIIToUTF16(line1));
  81   street_address.push_back(ASCIIToUTF16(line2));
  82   return street_address;
  83 }
  84
  85 scoped_ptr<Address> GetTestAddress() {
  86   return make_scoped_ptr(
  87       new Address("US",
  88                   ASCIIToUTF16("recipient_name"),
  89                   StreetAddress("address_line_1", "address_line_2"),
  90                   ASCIIToUTF16("locality_name"),
  91                   ASCIIToUTF16("dependent_locality_name"),
  92                   ASCIIToUTF16("admin_area_name"),
  93                   ASCIIToUTF16("postal_code_number"),
  94                   ASCIIToUTF16("sorting_code"),
  95                   ASCIIToUTF16("phone_number"),
  96                   std::string()));
  97 }
  98
  99 scoped_ptr<Address> GetTestMinimalAddress() {
 100   scoped_ptr<Address> address = GetTestAddress();
 101   address->set_is_complete_address(false);
 102   return address.Pass();
 103 }
 104
 105 scoped_ptr<FullWallet> GetTestFullWallet() {
 106   return GetTestFullWalletWithRequiredActions(std::vector<RequiredAction>());
 107 }
 108
 109 scoped_ptr<FullWallet> GetTestFullWalletWithRequiredActions(
 110     const std::vector<RequiredAction>& actions) {
 111   scoped_ptr<FullWallet> wallet(new FullWallet(FutureYear(),
 112                                                12,
 113                                                "528512",
 114                                                "5ec4feecf9d6",
 115                                                GetTestAddress(),
 116                                                GetTestShippingAddress(),
 117                                                actions));
 118   std::vector<uint8> one_time_pad;
 119   base::HexStringToBytes("5F04A8704183", &one_time_pad);
 120   wallet->set_one_time_pad(one_time_pad);
 121   return wallet.Pass();
 122 }
 123
 124 scoped_ptr<FullWallet> GetTestFullWalletInstrumentOnly() {
 125   scoped_ptr<FullWallet> wallet(new FullWallet(FutureYear(),
 126                                                12,
 127                                                "528512",
 128                                                "5ec4feecf9d6",
 129                                                GetTestAddress(),
 130                                                scoped_ptr<Address>(),
 131                                                std::vector<RequiredAction>()));
 132   std::vector<uint8> one_time_pad;
 133   base::HexStringToBytes("5F04A8704183", &one_time_pad);
 134   wallet->set_one_time_pad(one_time_pad);
 135   return wallet.Pass();
 136 }
 137
 138 scoped_ptr<Instrument> GetTestInstrument() {
 139   return make_scoped_ptr(new Instrument(ASCIIToUTF16("4444444444444448"),
 140                                         ASCIIToUTF16("123"),
 141                                         12,
 142                                         FutureYear(),
 143                                         Instrument::VISA,
 144                                         GetTestAddress()));
 145 }
 146
 147 scoped_ptr<Instrument> GetTestAddressUpgradeInstrument() {
 148   return make_scoped_ptr(new Instrument(base::string16(),
 149                                         base::string16(),
 150                                         12,
 151                                         FutureYear(),
 152                                         Instrument::UNKNOWN,
 153                                         GetTestAddress()));
 154 }
 155
 156 scoped_ptr<Instrument> GetTestExpirationDateChangeInstrument() {
 157   return make_scoped_ptr(new Instrument(base::string16(),
 158                                         ASCIIToUTF16("123"),
 159                                         12,
 160                                         FutureYear() + 1,
 161                                         Instrument::UNKNOWN,
 162                                         scoped_ptr<Address>()));
 163 }
 164
 165 scoped_ptr<Instrument> GetTestAddressNameChangeInstrument() {
 166   return make_scoped_ptr(new Instrument(base::string16(),
 167                                         ASCIIToUTF16("123"),
 168                                         12,
 169                                         FutureYear(),
 170                                         Instrument::UNKNOWN,
 171                                         GetTestAddress()));
 172 }
 173
 174 scoped_ptr<WalletItems::LegalDocument> GetTestLegalDocument() {
 175   base::DictionaryValue dict;
 176   dict.SetString("legal_document_id", "document_id");
 177   dict.SetString("display_name", "display_name");
 178   return wallet::WalletItems::LegalDocument::CreateLegalDocument(dict);
 179 }
 180
 181 scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrument() {
 182   return GetTestMaskedInstrumentWithId("default_instrument_id");
 183 }
 184
 185 scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentExpired() {
 186   return GetTestMaskedInstrumentWithDetails(
 187       "default_instrument_id",
 188       GetTestAddress(),
 189       WalletItems::MaskedInstrument::VISA,
 190       WalletItems::MaskedInstrument::EXPIRED);
 191 }
 192
 193 scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentInvalid() {
 194   return GetTestMaskedInstrumentWithDetails(
 195       "default_instrument_id",
 196       GetTestAddress(),
 197       WalletItems::MaskedInstrument::VISA,
 198       WalletItems::MaskedInstrument::DECLINED);
 199 }
 200
 201 scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentAmex(
 202     AmexPermission amex_permission) {
 203   return GetTestMaskedInstrumentWithDetails(
 204       "default_instrument_id",
 205       GetTestAddress(),
 206       WalletItems::MaskedInstrument::AMEX,
 207       amex_permission == AMEX_ALLOWED ?
 208           WalletItems::MaskedInstrument::VALID :
 209           WalletItems::MaskedInstrument::AMEX_NOT_SUPPORTED);
 210 }
 211
 212 scoped_ptr<WalletItems::MaskedInstrument> GetTestNonDefaultMaskedInstrument() {
 213   return GetTestMaskedInstrumentWithId("instrument_id");
 214 }
 215
 216 scoped_ptr<Address> GetTestSaveableAddress() {
 217   return make_scoped_ptr(
 218       new Address("US",
 219                   ASCIIToUTF16("save_recipient_name"),
 220                   StreetAddress("save_address_line_1", "save_address_line_2"),
 221                   ASCIIToUTF16("save_locality_name"),
 222                   ASCIIToUTF16("save_dependent_locality_name"),
 223                   ASCIIToUTF16("save_admin_area_name"),
 224                   ASCIIToUTF16("save_postal_code_number"),
 225                   ASCIIToUTF16("save_sorting_code"),
 226                   ASCIIToUTF16("save_phone_number"),
 227                   std::string()));
 228 }
 229
 230 scoped_ptr<Address> GetTestShippingAddress() {
 231   return make_scoped_ptr(
 232       new Address("US",
 233                   ASCIIToUTF16("ship_recipient_name"),
 234                   StreetAddress("ship_address_line_1", "ship_address_line_2"),
 235                   ASCIIToUTF16("ship_locality_name"),
 236                   ASCIIToUTF16("ship_dependent_locality_name"),
 237                   ASCIIToUTF16("ship_admin_area_name"),
 238                   ASCIIToUTF16("ship_postal_code_number"),
 239                   ASCIIToUTF16("ship_sorting_code"),
 240                   ASCIIToUTF16("ship_phone_number"),
 241                   "default_address_id"));
 242 }
 243
 244 scoped_ptr<Address> GetTestNonDefaultShippingAddress() {
 245   scoped_ptr<Address> address = GetTestShippingAddress();
 246   address->set_object_id("address_id");
 247   return address.Pass();
 248 }
 249
 250 scoped_ptr<WalletItems> GetTestWalletItemsWithDetails(
 251     const std::vector<RequiredAction>& required_actions,
 252     const std::string& default_instrument_id,
 253     const std::string& default_address_id,
 254     AmexPermission amex_permission) {
 255   return make_scoped_ptr(new wallet::WalletItems(required_actions,
 256                                                  "google_transaction_id",
 257                                                  default_instrument_id,
 258                                                  default_address_id,
 259                                                  amex_permission));
 260 }
 261
 262 scoped_ptr<WalletItems> GetTestWalletItemsWithRequiredAction(
 263     RequiredAction action) {
 264   std::vector<RequiredAction> required_actions(1, action);
 265   scoped_ptr<WalletItems> items =
 266       GetTestWalletItemsWithDetails(required_actions,
 267                                     "default_instrument_id",
 268                                     "default_address_id",
 269                                     AMEX_ALLOWED);
 270
 271   if (action != GAIA_AUTH)
 272     items->AddAccount(GetTestGaiaAccount());
 273
 274   return items.Pass();
 275 }
 276
 277 scoped_ptr<WalletItems> GetTestWalletItems(AmexPermission amex_permission) {
 278   return GetTestWalletItemsWithDefaultIds("default_instrument_id",
 279                                           "default_address_id",
 280                                           amex_permission);
 281 }
 282
 283 scoped_ptr<WalletItems> GetTestWalletItemsWithUsers(
 284     const std::vector<std::string>& users, size_t active_index) {
 285   scoped_ptr<WalletItems> items =
 286       GetTestWalletItemsWithDetails(std::vector<RequiredAction>(),
 287                                     "default_instrument_id",
 288                                     "default_address_id",
 289                                     AMEX_ALLOWED);
 290   for (size_t i = 0; i < users.size(); ++i) {
 291     scoped_ptr<GaiaAccount> account(GaiaAccount::CreateForTesting(
 292         users[i], "obfuscated_id", i, i == active_index));
 293     items->AddAccount(account.Pass());
 294   }
 295   return items.Pass();
 296 }
 297
 298 scoped_ptr<WalletItems> GetTestWalletItemsWithDefaultIds(
 299     const std::string& default_instrument_id,
 300     const std::string& default_address_id,
 301     AmexPermission amex_permission) {
 302   scoped_ptr<WalletItems> items =
 303       GetTestWalletItemsWithDetails(std::vector<RequiredAction>(),
 304                                     default_instrument_id,
 305                                     default_address_id,
 306                                     amex_permission);
 307   items->AddAccount(GetTestGaiaAccount());
 308   return items.Pass();
 309 }
 310
 311 }  // namespace wallet
 312 }  // namespace autofill