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
20using base::ASCIIToUTF16;
21
22namespace autofill {
23namespace wallet {
24
25namespace {
26
27int FutureYear() {
28  // "In the Year 3000." - Richie "LaBamba" Rosenberg
29  return 3000;
30}
31
32}  // namespace
33
34scoped_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                                        ASCIIToUTF16("1111"),
43                                        12,
44                                        FutureYear(),
45                                        address.Pass(),
46                                        status,
47                                        id));
48}
49
50scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentWithId(
51    const std::string& id) {
52  return GetTestMaskedInstrumentWithDetails(
53      id,
54      GetTestAddress(),
55      WalletItems::MaskedInstrument::VISA,
56      WalletItems::MaskedInstrument::VALID);
57}
58
59scoped_ptr<WalletItems::MaskedInstrument>
60GetTestMaskedInstrumentWithIdAndAddress(
61    const std::string& id, scoped_ptr<Address> address) {
62  return GetTestMaskedInstrumentWithDetails(
63      id,
64      address.Pass(),
65      WalletItems::MaskedInstrument::VISA,
66      WalletItems::MaskedInstrument::VALID);
67}
68
69scoped_ptr<GaiaAccount> GetTestGaiaAccount() {
70  return GaiaAccount::CreateForTesting("user@chromium.org",
71                                       "obfuscated_id",
72                                       0,
73                                       true);
74}
75
76std::vector<base::string16> StreetAddress(const std::string& line1,
77                                          const std::string& line2) {
78  std::vector<base::string16> street_address;
79  street_address.push_back(ASCIIToUTF16(line1));
80  street_address.push_back(ASCIIToUTF16(line2));
81  return street_address;
82}
83
84scoped_ptr<Address> GetTestAddress() {
85  return make_scoped_ptr(
86      new Address("US",
87                  ASCIIToUTF16("recipient_name"),
88                  StreetAddress("address_line_1", "address_line_2"),
89                  ASCIIToUTF16("locality_name"),
90                  ASCIIToUTF16("dependent_locality_name"),
91                  ASCIIToUTF16("admin_area_name"),
92                  ASCIIToUTF16("postal_code_number"),
93                  ASCIIToUTF16("sorting_code"),
94                  ASCIIToUTF16("phone_number"),
95                  std::string(),
96                  "language_code"));
97}
98
99scoped_ptr<Address> GetTestMinimalAddress() {
100  scoped_ptr<Address> address = GetTestAddress();
101  address->set_is_complete_address(false);
102  return address.Pass();
103}
104
105scoped_ptr<FullWallet> GetTestFullWallet() {
106  return GetTestFullWalletWithRequiredActions(std::vector<RequiredAction>());
107}
108
109scoped_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
124scoped_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
138scoped_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
147scoped_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
156scoped_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
165scoped_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
174scoped_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
181scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrument() {
182  return GetTestMaskedInstrumentWithId("default_instrument_id");
183}
184
185scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentExpired() {
186  return GetTestMaskedInstrumentWithDetails(
187      "default_instrument_id",
188      GetTestAddress(),
189      WalletItems::MaskedInstrument::VISA,
190      WalletItems::MaskedInstrument::EXPIRED);
191}
192
193scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentInvalid() {
194  return GetTestMaskedInstrumentWithDetails(
195      "default_instrument_id",
196      GetTestAddress(),
197      WalletItems::MaskedInstrument::VISA,
198      WalletItems::MaskedInstrument::DECLINED);
199}
200
201scoped_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
212scoped_ptr<WalletItems::MaskedInstrument> GetTestNonDefaultMaskedInstrument() {
213  return GetTestMaskedInstrumentWithId("instrument_id");
214}
215
216scoped_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                  "save_language_code"));
229}
230
231scoped_ptr<Address> GetTestShippingAddress() {
232  return make_scoped_ptr(
233      new Address("US",
234                  ASCIIToUTF16("ship_recipient_name"),
235                  StreetAddress("ship_address_line_1", "ship_address_line_2"),
236                  ASCIIToUTF16("ship_locality_name"),
237                  ASCIIToUTF16("ship_dependent_locality_name"),
238                  ASCIIToUTF16("ship_admin_area_name"),
239                  ASCIIToUTF16("ship_postal_code_number"),
240                  ASCIIToUTF16("ship_sorting_code"),
241                  ASCIIToUTF16("ship_phone_number"),
242                  "default_address_id",
243                  "ship_language_code"));
244}
245
246scoped_ptr<Address> GetTestNonDefaultShippingAddress() {
247  scoped_ptr<Address> address = GetTestShippingAddress();
248  address->set_object_id("address_id");
249  return address.Pass();
250}
251
252scoped_ptr<WalletItems> GetTestWalletItemsWithDetails(
253    const std::vector<RequiredAction>& required_actions,
254    const std::string& default_instrument_id,
255    const std::string& default_address_id,
256    AmexPermission amex_permission) {
257  return make_scoped_ptr(new wallet::WalletItems(required_actions,
258                                                 "google_transaction_id",
259                                                 default_instrument_id,
260                                                 default_address_id,
261                                                 amex_permission));
262}
263
264scoped_ptr<WalletItems> GetTestWalletItemsWithRequiredAction(
265    RequiredAction action) {
266  std::vector<RequiredAction> required_actions(1, action);
267  scoped_ptr<WalletItems> items =
268      GetTestWalletItemsWithDetails(required_actions,
269                                    "default_instrument_id",
270                                    "default_address_id",
271                                    AMEX_ALLOWED);
272
273  if (action != GAIA_AUTH)
274    items->AddAccount(GetTestGaiaAccount());
275
276  return items.Pass();
277}
278
279scoped_ptr<WalletItems> GetTestWalletItems(AmexPermission amex_permission) {
280  return GetTestWalletItemsWithDefaultIds("default_instrument_id",
281                                          "default_address_id",
282                                          amex_permission);
283}
284
285scoped_ptr<WalletItems> GetTestWalletItemsWithUsers(
286    const std::vector<std::string>& users, size_t active_index) {
287  scoped_ptr<WalletItems> items =
288      GetTestWalletItemsWithDetails(std::vector<RequiredAction>(),
289                                    "default_instrument_id",
290                                    "default_address_id",
291                                    AMEX_ALLOWED);
292  for (size_t i = 0; i < users.size(); ++i) {
293    scoped_ptr<GaiaAccount> account(GaiaAccount::CreateForTesting(
294        users[i], "obfuscated_id", i, i == active_index));
295    items->AddAccount(account.Pass());
296  }
297  return items.Pass();
298}
299
300scoped_ptr<WalletItems> GetTestWalletItemsWithDefaultIds(
301    const std::string& default_instrument_id,
302    const std::string& default_address_id,
303    AmexPermission amex_permission) {
304  scoped_ptr<WalletItems> items =
305      GetTestWalletItemsWithDetails(std::vector<RequiredAction>(),
306                                    default_instrument_id,
307                                    default_address_id,
308                                    amex_permission);
309  items->AddAccount(GetTestGaiaAccount());
310  return items.Pass();
311}
312
313}  // namespace wallet
314}  // namespace autofill
315