1// Copyright (c) 2011 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 <vector>
6
7#include "app/sql/statement.h"
8#include "base/file_util.h"
9#include "base/path_service.h"
10#include "base/string_number_conversions.h"
11#include "base/time.h"
12#include "base/utf_string_conversions.h"
13#include "chrome/common/chrome_paths.h"
14#include "chrome/browser/autofill/autofill_profile.h"
15#include "chrome/browser/autofill/autofill_type.h"
16#include "chrome/browser/autofill/credit_card.h"
17#include "chrome/browser/password_manager/encryptor.h"
18#include "chrome/browser/webdata/autofill_change.h"
19#include "chrome/browser/webdata/autofill_entry.h"
20#include "chrome/browser/webdata/web_database.h"
21#include "chrome/common/guid.h"
22#include "testing/gtest/include/gtest/gtest.h"
23#include "webkit/glue/form_field.h"
24
25using base::Time;
26using base::TimeDelta;
27using webkit_glue::FormField;
28
29// So we can compare AutofillKeys with EXPECT_EQ().
30std::ostream& operator<<(std::ostream& os, const AutofillKey& key) {
31  return os << UTF16ToASCII(key.name()) << ", " << UTF16ToASCII(key.value());
32}
33
34// So we can compare AutofillChanges with EXPECT_EQ().
35std::ostream& operator<<(std::ostream& os, const AutofillChange& change) {
36  switch (change.type()) {
37    case AutofillChange::ADD: {
38      os << "ADD";
39      break;
40    }
41    case AutofillChange::UPDATE: {
42      os << "UPDATE";
43      break;
44    }
45    case AutofillChange::REMOVE: {
46      os << "REMOVE";
47      break;
48    }
49  }
50  return os << " " << change.key();
51}
52
53namespace {
54
55bool CompareAutofillEntries(const AutofillEntry& a, const AutofillEntry& b) {
56  std::set<Time> timestamps1(a.timestamps().begin(), a.timestamps().end());
57  std::set<Time> timestamps2(b.timestamps().begin(), b.timestamps().end());
58
59  int compVal = a.key().name().compare(b.key().name());
60  if (compVal != 0) {
61    return compVal < 0;
62  }
63
64  compVal = a.key().value().compare(b.key().value());
65  if (compVal != 0) {
66    return compVal < 0;
67  }
68
69  if (timestamps1.size() != timestamps2.size()) {
70    return timestamps1.size() < timestamps2.size();
71  }
72
73  std::set<Time>::iterator it;
74  for (it = timestamps1.begin(); it != timestamps1.end(); it++) {
75    timestamps2.erase(*it);
76  }
77
78  return !timestamps2.empty();
79}
80
81}  // anonymous namespace
82
83class AutofillTableTest : public testing::Test {
84 public:
85  AutofillTableTest() {}
86  virtual ~AutofillTableTest() {}
87
88 protected:
89  typedef std::vector<AutofillChange> AutofillChangeList;
90  typedef std::set<AutofillEntry,
91    bool (*)(const AutofillEntry&, const AutofillEntry&)> AutofillEntrySet;
92  typedef std::set<AutofillEntry, bool (*)(const AutofillEntry&,
93    const AutofillEntry&)>::iterator AutofillEntrySetIterator;
94
95  virtual void SetUp() {
96#if defined(OS_MACOSX)
97    Encryptor::UseMockKeychain(true);
98#endif
99    PathService::Get(chrome::DIR_TEST_DATA, &file_);
100    const std::string test_db = "TestWebDatabase" +
101        base::Int64ToString(Time::Now().ToTimeT()) +
102        ".db";
103    file_ = file_.AppendASCII(test_db);
104    file_util::Delete(file_, false);
105  }
106
107  virtual void TearDown() {
108    file_util::Delete(file_, false);
109  }
110
111  static AutofillEntry MakeAutofillEntry(const char* name,
112                                         const char* value,
113                                         time_t timestamp0,
114                                         time_t timestamp1) {
115    std::vector<Time> timestamps;
116    if (timestamp0 >= 0)
117      timestamps.push_back(Time::FromTimeT(timestamp0));
118    if (timestamp1 >= 0)
119      timestamps.push_back(Time::FromTimeT(timestamp1));
120    return AutofillEntry(
121        AutofillKey(ASCIIToUTF16(name), ASCIIToUTF16(value)), timestamps);
122  }
123
124  FilePath file_;
125
126 private:
127  DISALLOW_COPY_AND_ASSIGN(AutofillTableTest);
128};
129
130TEST_F(AutofillTableTest, Autofill) {
131  WebDatabase db;
132
133  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
134
135  Time t1 = Time::Now();
136
137  // Simulate the submission of a handful of entries in a field called "Name",
138  // some more often than others.
139  AutofillChangeList changes;
140  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
141      FormField(string16(),
142                ASCIIToUTF16("Name"),
143                ASCIIToUTF16("Superman"),
144                string16(),
145                0,
146                false),
147      &changes));
148  std::vector<string16> v;
149  for (int i = 0; i < 5; i++) {
150    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
151        FormField(string16(),
152                  ASCIIToUTF16("Name"),
153                  ASCIIToUTF16("Clark Kent"),
154                  string16(),
155                  0,
156                  false),
157        &changes));
158  }
159  for (int i = 0; i < 3; i++) {
160    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
161        FormField(string16(),
162                  ASCIIToUTF16("Name"),
163                  ASCIIToUTF16("Clark Sutter"),
164                  string16(),
165                  0,
166                  false),
167        &changes));
168  }
169  for (int i = 0; i < 2; i++) {
170    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
171        FormField(string16(),
172                  ASCIIToUTF16("Favorite Color"),
173                  ASCIIToUTF16("Green"),
174                  string16(),
175                  0,
176                  false),
177        &changes));
178  }
179
180  int count = 0;
181  int64 pair_id = 0;
182
183  // We have added the name Clark Kent 5 times, so count should be 5 and pair_id
184  // should be somthing non-zero.
185  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
186      FormField(string16(),
187                ASCIIToUTF16("Name"),
188                ASCIIToUTF16("Clark Kent"),
189                string16(),
190                0,
191                false),
192      &pair_id, &count));
193  EXPECT_EQ(5, count);
194  EXPECT_NE(0, pair_id);
195
196  // Storing in the data base should be case sensitive, so there should be no
197  // database entry for clark kent lowercase.
198  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
199      FormField(string16(),
200                ASCIIToUTF16("Name"),
201                ASCIIToUTF16("clark kent"),
202                string16(),
203                0,
204                false),
205      &pair_id, &count));
206  EXPECT_EQ(0, count);
207
208  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
209      FormField(string16(),
210                ASCIIToUTF16("Favorite Color"),
211                ASCIIToUTF16("Green"),
212                string16(),
213                0,
214                false),
215      &pair_id, &count));
216  EXPECT_EQ(2, count);
217
218  // This is meant to get a list of suggestions for Name.  The empty prefix
219  // in the second argument means it should return all suggestions for a name
220  // no matter what they start with.  The order that the names occur in the list
221  // should be decreasing order by count.
222  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
223      ASCIIToUTF16("Name"), string16(), &v, 6));
224  EXPECT_EQ(3U, v.size());
225  if (v.size() == 3) {
226    EXPECT_EQ(ASCIIToUTF16("Clark Kent"), v[0]);
227    EXPECT_EQ(ASCIIToUTF16("Clark Sutter"), v[1]);
228    EXPECT_EQ(ASCIIToUTF16("Superman"), v[2]);
229  }
230
231  // If we query again limiting the list size to 1, we should only get the most
232  // frequent entry.
233  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
234      ASCIIToUTF16("Name"), string16(), &v, 1));
235  EXPECT_EQ(1U, v.size());
236  if (v.size() == 1) {
237    EXPECT_EQ(ASCIIToUTF16("Clark Kent"), v[0]);
238  }
239
240  // Querying for suggestions given a prefix is case-insensitive, so the prefix
241  // "cLa" shoud get suggestions for both Clarks.
242  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
243      ASCIIToUTF16("Name"), ASCIIToUTF16("cLa"), &v, 6));
244  EXPECT_EQ(2U, v.size());
245  if (v.size() == 2) {
246    EXPECT_EQ(ASCIIToUTF16("Clark Kent"), v[0]);
247    EXPECT_EQ(ASCIIToUTF16("Clark Sutter"), v[1]);
248  }
249
250  // Removing all elements since the beginning of this function should remove
251  // everything from the database.
252  changes.clear();
253  EXPECT_TRUE(db.GetAutofillTable()->RemoveFormElementsAddedBetween(
254      t1, Time(), &changes));
255
256  const AutofillChange expected_changes[] = {
257    AutofillChange(AutofillChange::REMOVE,
258                   AutofillKey(ASCIIToUTF16("Name"),
259                               ASCIIToUTF16("Superman"))),
260    AutofillChange(AutofillChange::REMOVE,
261                   AutofillKey(ASCIIToUTF16("Name"),
262                               ASCIIToUTF16("Clark Kent"))),
263    AutofillChange(AutofillChange::REMOVE,
264                   AutofillKey(ASCIIToUTF16("Name"),
265                               ASCIIToUTF16("Clark Sutter"))),
266    AutofillChange(AutofillChange::REMOVE,
267                   AutofillKey(ASCIIToUTF16("Favorite Color"),
268                               ASCIIToUTF16("Green"))),
269  };
270  EXPECT_EQ(arraysize(expected_changes), changes.size());
271  for (size_t i = 0; i < arraysize(expected_changes); i++) {
272    EXPECT_EQ(expected_changes[i], changes[i]);
273  }
274
275  EXPECT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
276      FormField(string16(),
277                ASCIIToUTF16("Name"),
278                ASCIIToUTF16("Clark Kent"),
279                string16(),
280                0,
281                false),
282      &pair_id, &count));
283  EXPECT_EQ(0, count);
284
285  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
286      ASCIIToUTF16("Name"), string16(), &v, 6));
287  EXPECT_EQ(0U, v.size());
288
289  // Now add some values with empty strings.
290  const string16 kValue = ASCIIToUTF16("  toto   ");
291  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
292      FormField(string16(),
293          ASCIIToUTF16("blank"),
294          string16(),
295          string16(),
296          0,
297          false),
298      &changes));
299  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
300      FormField(string16(),
301          ASCIIToUTF16("blank"),
302          ASCIIToUTF16(" "),
303          string16(),
304          0,
305          false),
306      &changes));
307  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
308      FormField(string16(),
309          ASCIIToUTF16("blank"),
310          ASCIIToUTF16("      "),
311          string16(),
312          0,
313          false),
314      &changes));
315  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
316      FormField(string16(),
317          ASCIIToUTF16("blank"),
318          kValue,
319          string16(),
320          0,
321          false),
322      &changes));
323
324  // They should be stored normally as the DB layer does not check for empty
325  // values.
326  v.clear();
327  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
328      ASCIIToUTF16("blank"), string16(), &v, 10));
329  EXPECT_EQ(4U, v.size());
330
331  // Now we'll check that ClearAutofillEmptyValueElements() works as expected.
332  db.GetAutofillTable()->ClearAutofillEmptyValueElements();
333
334  v.clear();
335  EXPECT_TRUE(db.GetAutofillTable()->GetFormValuesForElementName(
336      ASCIIToUTF16("blank"), string16(), &v, 10));
337  ASSERT_EQ(1U, v.size());
338
339  EXPECT_EQ(kValue, v[0]);
340}
341
342TEST_F(AutofillTableTest, Autofill_RemoveBetweenChanges) {
343  WebDatabase db;
344  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
345
346  TimeDelta one_day(TimeDelta::FromDays(1));
347  Time t1 = Time::Now();
348  Time t2 = t1 + one_day;
349
350  AutofillChangeList changes;
351  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
352      FormField(string16(),
353                ASCIIToUTF16("Name"),
354                ASCIIToUTF16("Superman"),
355                string16(),
356                0,
357                false),
358      &changes,
359      t1));
360  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
361      FormField(string16(),
362                ASCIIToUTF16("Name"),
363                ASCIIToUTF16("Superman"),
364                string16(),
365                0,
366                false),
367      &changes,
368      t2));
369
370  changes.clear();
371  EXPECT_TRUE(db.GetAutofillTable()->RemoveFormElementsAddedBetween(
372      t1, t2, &changes));
373  ASSERT_EQ(1U, changes.size());
374  EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
375                           AutofillKey(ASCIIToUTF16("Name"),
376                                       ASCIIToUTF16("Superman"))),
377            changes[0]);
378  changes.clear();
379
380  EXPECT_TRUE(db.GetAutofillTable()->RemoveFormElementsAddedBetween(
381      t2, t2 + one_day, &changes));
382  ASSERT_EQ(1U, changes.size());
383  EXPECT_EQ(AutofillChange(AutofillChange::REMOVE,
384                           AutofillKey(ASCIIToUTF16("Name"),
385                                       ASCIIToUTF16("Superman"))),
386            changes[0]);
387}
388
389TEST_F(AutofillTableTest, Autofill_AddChanges) {
390  WebDatabase db;
391  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
392
393  TimeDelta one_day(TimeDelta::FromDays(1));
394  Time t1 = Time::Now();
395  Time t2 = t1 + one_day;
396
397  AutofillChangeList changes;
398  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
399      FormField(string16(),
400                ASCIIToUTF16("Name"),
401                ASCIIToUTF16("Superman"),
402                string16(),
403                0,
404                false),
405      &changes,
406      t1));
407  ASSERT_EQ(1U, changes.size());
408  EXPECT_EQ(AutofillChange(AutofillChange::ADD,
409                           AutofillKey(ASCIIToUTF16("Name"),
410                                       ASCIIToUTF16("Superman"))),
411            changes[0]);
412
413  changes.clear();
414  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
415      FormField(string16(),
416                ASCIIToUTF16("Name"),
417                ASCIIToUTF16("Superman"),
418                string16(),
419                0,
420                false),
421      &changes,
422      t2));
423  ASSERT_EQ(1U, changes.size());
424  EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
425                           AutofillKey(ASCIIToUTF16("Name"),
426                                       ASCIIToUTF16("Superman"))),
427            changes[0]);
428}
429
430TEST_F(AutofillTableTest, Autofill_UpdateOneWithOneTimestamp) {
431  WebDatabase db;
432  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
433
434  AutofillEntry entry(MakeAutofillEntry("foo", "bar", 1, -1));
435  std::vector<AutofillEntry> entries;
436  entries.push_back(entry);
437  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
438
439  FormField field(string16(),
440                  ASCIIToUTF16("foo"),
441                  ASCIIToUTF16("bar"),
442                  string16(),
443                  0,
444                  false);
445  int64 pair_id;
446  int count;
447  ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
448      field, &pair_id, &count));
449  EXPECT_LE(0, pair_id);
450  EXPECT_EQ(1, count);
451
452  std::vector<AutofillEntry> all_entries;
453  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
454  ASSERT_EQ(1U, all_entries.size());
455  EXPECT_TRUE(entry == all_entries[0]);
456}
457
458TEST_F(AutofillTableTest, Autofill_UpdateOneWithTwoTimestamps) {
459  WebDatabase db;
460  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
461
462  AutofillEntry entry(MakeAutofillEntry("foo", "bar", 1, 2));
463  std::vector<AutofillEntry> entries;
464  entries.push_back(entry);
465  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
466
467  FormField field(string16(),
468                  ASCIIToUTF16("foo"),
469                  ASCIIToUTF16("bar"),
470                  string16(),
471                  0,
472                  false);
473  int64 pair_id;
474  int count;
475  ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
476      field, &pair_id, &count));
477  EXPECT_LE(0, pair_id);
478  EXPECT_EQ(2, count);
479
480  std::vector<AutofillEntry> all_entries;
481  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
482  ASSERT_EQ(1U, all_entries.size());
483  EXPECT_TRUE(entry == all_entries[0]);
484}
485
486TEST_F(AutofillTableTest, Autofill_GetAutofillTimestamps) {
487  WebDatabase db;
488  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
489
490  AutofillEntry entry(MakeAutofillEntry("foo", "bar", 1, 2));
491  std::vector<AutofillEntry> entries;
492  entries.push_back(entry);
493  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
494
495  std::vector<Time> timestamps;
496  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillTimestamps(ASCIIToUTF16("foo"),
497                                                           ASCIIToUTF16("bar"),
498                                                           &timestamps));
499  ASSERT_EQ(2U, timestamps.size());
500  EXPECT_TRUE(Time::FromTimeT(1) == timestamps[0]);
501  EXPECT_TRUE(Time::FromTimeT(2) == timestamps[1]);
502}
503
504TEST_F(AutofillTableTest, Autofill_UpdateTwo) {
505  WebDatabase db;
506  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
507
508  AutofillEntry entry0(MakeAutofillEntry("foo", "bar0", 1, -1));
509  AutofillEntry entry1(MakeAutofillEntry("foo", "bar1", 2, 3));
510  std::vector<AutofillEntry> entries;
511  entries.push_back(entry0);
512  entries.push_back(entry1);
513  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
514
515  FormField field0(string16(),
516                   ASCIIToUTF16("foo"),
517                   ASCIIToUTF16("bar0"),
518                   string16(),
519                   0,
520                   false);
521  int64 pair_id;
522  int count;
523  ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
524      field0, &pair_id, &count));
525  EXPECT_LE(0, pair_id);
526  EXPECT_EQ(1, count);
527
528  FormField field1(string16(),
529                   ASCIIToUTF16("foo"),
530                   ASCIIToUTF16("bar1"),
531                   string16(),
532                   0,
533                   false);
534  ASSERT_TRUE(db.GetAutofillTable()->GetIDAndCountOfFormElement(
535      field1, &pair_id, &count));
536  EXPECT_LE(0, pair_id);
537  EXPECT_EQ(2, count);
538}
539
540TEST_F(AutofillTableTest, Autofill_UpdateReplace) {
541  WebDatabase db;
542  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
543
544  AutofillChangeList changes;
545  // Add a form field.  This will be replaced.
546  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValue(
547      FormField(string16(),
548                ASCIIToUTF16("Name"),
549                ASCIIToUTF16("Superman"),
550                string16(),
551                0,
552                false),
553      &changes));
554
555  AutofillEntry entry(MakeAutofillEntry("Name", "Superman", 1, 2));
556  std::vector<AutofillEntry> entries;
557  entries.push_back(entry);
558  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
559
560  std::vector<AutofillEntry> all_entries;
561  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
562  ASSERT_EQ(1U, all_entries.size());
563  EXPECT_TRUE(entry == all_entries[0]);
564}
565
566TEST_F(AutofillTableTest, Autofill_UpdateDontReplace) {
567  WebDatabase db;
568  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
569
570  Time t = Time::Now();
571  AutofillEntry existing(
572      MakeAutofillEntry("Name", "Superman", t.ToTimeT(), -1));
573
574  AutofillChangeList changes;
575  // Add a form field.  This will NOT be replaced.
576  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
577      FormField(string16(),
578                existing.key().name(),
579                existing.key().value(),
580                string16(),
581                0,
582                false),
583      &changes,
584      t));
585  AutofillEntry entry(MakeAutofillEntry("Name", "Clark Kent", 1, 2));
586  std::vector<AutofillEntry> entries;
587  entries.push_back(entry);
588  ASSERT_TRUE(db.GetAutofillTable()->UpdateAutofillEntries(entries));
589
590  std::vector<AutofillEntry> all_entries;
591  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
592  ASSERT_EQ(2U, all_entries.size());
593  AutofillEntrySet expected_entries(all_entries.begin(),
594                                    all_entries.end(),
595                                    CompareAutofillEntries);
596  EXPECT_EQ(1U, expected_entries.count(existing));
597  EXPECT_EQ(1U, expected_entries.count(entry));
598}
599
600TEST_F(AutofillTableTest, Autofill_AddFormFieldValues) {
601  WebDatabase db;
602  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
603
604  Time t = Time::Now();
605
606  // Add multiple values for "firstname" and "lastname" names.  Test that only
607  // first value of each gets added. Related to security issue:
608  // http://crbug.com/51727.
609  std::vector<FormField> elements;
610  elements.push_back(FormField(string16(),
611                               ASCIIToUTF16("firstname"),
612                               ASCIIToUTF16("Joe"),
613                               string16(),
614                               0,
615                               false));
616  elements.push_back(FormField(string16(),
617                               ASCIIToUTF16("firstname"),
618                               ASCIIToUTF16("Jane"),
619                               string16(),
620                               0,
621                               false));
622  elements.push_back(FormField(string16(),
623                               ASCIIToUTF16("lastname"),
624                               ASCIIToUTF16("Smith"),
625                               string16(),
626                               0,
627                               false));
628  elements.push_back(FormField(string16(),
629                               ASCIIToUTF16("lastname"),
630                               ASCIIToUTF16("Jones"),
631                               string16(),
632                               0,
633                               false));
634
635  std::vector<AutofillChange> changes;
636  db.GetAutofillTable()->AddFormFieldValuesTime(elements, &changes, t);
637
638  ASSERT_EQ(2U, changes.size());
639  EXPECT_EQ(changes[0], AutofillChange(AutofillChange::ADD,
640                                       AutofillKey(ASCIIToUTF16("firstname"),
641                                       ASCIIToUTF16("Joe"))));
642  EXPECT_EQ(changes[1], AutofillChange(AutofillChange::ADD,
643                                       AutofillKey(ASCIIToUTF16("lastname"),
644                                       ASCIIToUTF16("Smith"))));
645
646  std::vector<AutofillEntry> all_entries;
647  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&all_entries));
648  ASSERT_EQ(2U, all_entries.size());
649}
650
651TEST_F(AutofillTableTest, AutofillProfile) {
652  WebDatabase db;
653
654  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
655
656  // Add a 'Home' profile.
657  AutofillProfile home_profile;
658  home_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("John"));
659  home_profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16("Q."));
660  home_profile.SetInfo(NAME_LAST, ASCIIToUTF16("Smith"));
661  home_profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16("js@smith.xyz"));
662  home_profile.SetInfo(COMPANY_NAME, ASCIIToUTF16("Google"));
663  home_profile.SetInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1234 Apple Way"));
664  home_profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("unit 5"));
665  home_profile.SetInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("Los Angeles"));
666  home_profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
667  home_profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
668  home_profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
669  home_profile.SetInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("18181234567"));
670  home_profile.SetInfo(PHONE_FAX_WHOLE_NUMBER, ASCIIToUTF16("1915243678"));
671
672  Time pre_creation_time = Time::Now();
673  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(home_profile));
674  Time post_creation_time = Time::Now();
675
676  // Get the 'Home' profile.
677  AutofillProfile* db_profile;
678  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
679      home_profile.guid(), &db_profile));
680  EXPECT_EQ(home_profile, *db_profile);
681  sql::Statement s_home(db.GetSQLConnection()->GetUniqueStatement(
682      "SELECT date_modified "
683      "FROM autofill_profiles WHERE guid=?"));
684  s_home.BindString(0, home_profile.guid());
685  ASSERT_TRUE(s_home);
686  ASSERT_TRUE(s_home.Step());
687  EXPECT_GE(s_home.ColumnInt64(0), pre_creation_time.ToTimeT());
688  EXPECT_LE(s_home.ColumnInt64(0), post_creation_time.ToTimeT());
689  EXPECT_FALSE(s_home.Step());
690  delete db_profile;
691
692  // Add a 'Billing' profile.
693  AutofillProfile billing_profile = home_profile;
694  billing_profile.set_guid(guid::GenerateGUID());
695  billing_profile.SetInfo(ADDRESS_HOME_LINE1,
696                          ASCIIToUTF16("5678 Bottom Street"));
697  billing_profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("suite 3"));
698
699  pre_creation_time = Time::Now();
700  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(billing_profile));
701  post_creation_time = Time::Now();
702
703  // Get the 'Billing' profile.
704  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
705      billing_profile.guid(), &db_profile));
706  EXPECT_EQ(billing_profile, *db_profile);
707  sql::Statement s_billing(db.GetSQLConnection()->GetUniqueStatement(
708      "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
709  s_billing.BindString(0, billing_profile.guid());
710  ASSERT_TRUE(s_billing);
711  ASSERT_TRUE(s_billing.Step());
712  EXPECT_GE(s_billing.ColumnInt64(0), pre_creation_time.ToTimeT());
713  EXPECT_LE(s_billing.ColumnInt64(0), post_creation_time.ToTimeT());
714  EXPECT_FALSE(s_billing.Step());
715  delete db_profile;
716
717  // Update the 'Billing' profile, name only.
718  billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
719  Time pre_modification_time = Time::Now();
720  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(
721      billing_profile));
722  Time post_modification_time = Time::Now();
723  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
724      billing_profile.guid(), &db_profile));
725  EXPECT_EQ(billing_profile, *db_profile);
726  sql::Statement s_billing_updated(db.GetSQLConnection()->GetUniqueStatement(
727      "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
728  s_billing_updated.BindString(0, billing_profile.guid());
729  ASSERT_TRUE(s_billing_updated);
730  ASSERT_TRUE(s_billing_updated.Step());
731  EXPECT_GE(s_billing_updated.ColumnInt64(0),
732            pre_modification_time.ToTimeT());
733  EXPECT_LE(s_billing_updated.ColumnInt64(0),
734            post_modification_time.ToTimeT());
735  EXPECT_FALSE(s_billing_updated.Step());
736  delete db_profile;
737
738  // Update the 'Billing' profile.
739  billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("Janice"));
740  billing_profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16("C."));
741  billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("Joplin"));
742  billing_profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16("jane@singer.com"));
743  billing_profile.SetInfo(COMPANY_NAME, ASCIIToUTF16("Indy"));
744  billing_profile.SetInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("Open Road"));
745  billing_profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Route 66"));
746  billing_profile.SetInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("NFA"));
747  billing_profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("NY"));
748  billing_profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("10011"));
749  billing_profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("United States"));
750  billing_profile.SetInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("18181230000"));
751  billing_profile.SetInfo(PHONE_FAX_WHOLE_NUMBER, ASCIIToUTF16("1915240000"));
752  Time pre_modification_time_2 = Time::Now();
753  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(
754      billing_profile));
755  Time post_modification_time_2 = Time::Now();
756  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
757      billing_profile.guid(), &db_profile));
758  EXPECT_EQ(billing_profile, *db_profile);
759  sql::Statement s_billing_updated_2(db.GetSQLConnection()->GetUniqueStatement(
760      "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
761  s_billing_updated_2.BindString(0, billing_profile.guid());
762  ASSERT_TRUE(s_billing_updated_2);
763  ASSERT_TRUE(s_billing_updated_2.Step());
764  EXPECT_GE(s_billing_updated_2.ColumnInt64(0),
765            pre_modification_time_2.ToTimeT());
766  EXPECT_LE(s_billing_updated_2.ColumnInt64(0),
767            post_modification_time_2.ToTimeT());
768  EXPECT_FALSE(s_billing_updated_2.Step());
769  delete db_profile;
770
771  // Remove the 'Billing' profile.
772  EXPECT_TRUE(db.GetAutofillTable()->RemoveAutofillProfile(
773      billing_profile.guid()));
774  EXPECT_FALSE(db.GetAutofillTable()->GetAutofillProfile(
775      billing_profile.guid(), &db_profile));
776}
777
778TEST_F(AutofillTableTest, AutofillProfileMultiValueNames) {
779  WebDatabase db;
780  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
781
782  AutofillProfile p;
783  const string16 kJohnDoe(ASCIIToUTF16("John Doe"));
784  const string16 kJohnPDoe(ASCIIToUTF16("John P. Doe"));
785  std::vector<string16> set_values;
786  set_values.push_back(kJohnDoe);
787  set_values.push_back(kJohnPDoe);
788  p.SetMultiInfo(NAME_FULL, set_values);
789
790  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(p));
791
792  AutofillProfile* db_profile;
793  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
794  EXPECT_EQ(p, *db_profile);
795  EXPECT_EQ(0, p.CompareMulti(*db_profile));
796  delete db_profile;
797
798  // Update the values.
799  const string16 kNoOne(ASCIIToUTF16("No One"));
800  set_values[1] = kNoOne;
801  p.SetMultiInfo(NAME_FULL, set_values);
802  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
803  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
804  EXPECT_EQ(p, *db_profile);
805  EXPECT_EQ(0, p.CompareMulti(*db_profile));
806  delete db_profile;
807
808  // Delete values.
809  set_values.clear();
810  p.SetMultiInfo(NAME_FULL, set_values);
811  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
812  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
813  EXPECT_EQ(p, *db_profile);
814  EXPECT_EQ(0, p.CompareMulti(*db_profile));
815  EXPECT_EQ(string16(), db_profile->GetInfo(NAME_FULL));
816  delete db_profile;
817}
818
819TEST_F(AutofillTableTest, AutofillProfileSingleValue) {
820  WebDatabase db;
821  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
822
823  AutofillProfile p;
824  const string16 kJohnDoe(ASCIIToUTF16("John Doe"));
825  const string16 kJohnPDoe(ASCIIToUTF16("John P. Doe"));
826  std::vector<string16> set_values;
827  set_values.push_back(kJohnDoe);
828  set_values.push_back(kJohnPDoe);
829  p.SetMultiInfo(NAME_FULL, set_values);
830
831  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(p));
832
833  AutofillProfile* db_profile;
834  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
835  EXPECT_EQ(p, *db_profile);
836  EXPECT_EQ(0, p.CompareMulti(*db_profile));
837  delete db_profile;
838
839  // Update the values.  This update is the "single value" update, it should
840  // not perturb the multi-values following the zeroth entry.  This simulates
841  // the Sync use-case until Sync can be changed to be multi-value aware.
842  const string16 kNoOne(ASCIIToUTF16("No One"));
843  set_values.resize(1);
844  set_values[0] = kNoOne;
845  p.SetMultiInfo(NAME_FULL, set_values);
846  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfile(p));
847  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
848  EXPECT_EQ(p, *db_profile);
849  EXPECT_NE(0, p.CompareMulti(*db_profile));
850  db_profile->GetMultiInfo(NAME_FULL, &set_values);
851  ASSERT_EQ(2UL, set_values.size());
852  EXPECT_EQ(kNoOne, set_values[0]);
853  EXPECT_EQ(kJohnPDoe, set_values[1]);
854  delete db_profile;
855}
856
857TEST_F(AutofillTableTest, AutofillProfileMultiValueEmails) {
858  WebDatabase db;
859  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
860
861  AutofillProfile p;
862  const string16 kJohnDoe(ASCIIToUTF16("john@doe.com"));
863  const string16 kJohnPDoe(ASCIIToUTF16("john_p@doe.com"));
864  std::vector<string16> set_values;
865  set_values.push_back(kJohnDoe);
866  set_values.push_back(kJohnPDoe);
867  p.SetMultiInfo(EMAIL_ADDRESS, set_values);
868
869  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(p));
870
871  AutofillProfile* db_profile;
872  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
873  EXPECT_EQ(p, *db_profile);
874  EXPECT_EQ(0, p.CompareMulti(*db_profile));
875  delete db_profile;
876
877  // Update the values.
878  const string16 kNoOne(ASCIIToUTF16("no@one.com"));
879  set_values[1] = kNoOne;
880  p.SetMultiInfo(EMAIL_ADDRESS, set_values);
881  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
882  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
883  EXPECT_EQ(p, *db_profile);
884  EXPECT_EQ(0, p.CompareMulti(*db_profile));
885  delete db_profile;
886
887  // Delete values.
888  set_values.clear();
889  p.SetMultiInfo(EMAIL_ADDRESS, set_values);
890  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
891  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
892  EXPECT_EQ(p, *db_profile);
893  EXPECT_EQ(0, p.CompareMulti(*db_profile));
894  EXPECT_EQ(string16(), db_profile->GetInfo(EMAIL_ADDRESS));
895  delete db_profile;
896}
897
898TEST_F(AutofillTableTest, AutofillProfileMultiValuePhone) {
899  WebDatabase db;
900  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
901
902  AutofillProfile p;
903  const string16 kJohnDoe(ASCIIToUTF16("4151112222"));
904  const string16 kJohnPDoe(ASCIIToUTF16("4151113333"));
905  std::vector<string16> set_values;
906  set_values.push_back(kJohnDoe);
907  set_values.push_back(kJohnPDoe);
908  p.SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, set_values);
909
910  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(p));
911
912  AutofillProfile* db_profile;
913  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
914  EXPECT_EQ(p, *db_profile);
915  EXPECT_EQ(0, p.CompareMulti(*db_profile));
916  delete db_profile;
917
918  // Update the values.
919  const string16 kNoOne(ASCIIToUTF16("4151110000"));
920  set_values[1] = kNoOne;
921  p.SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, set_values);
922  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
923  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
924  EXPECT_EQ(p, *db_profile);
925  EXPECT_EQ(0, p.CompareMulti(*db_profile));
926  delete db_profile;
927
928  // Delete values.
929  set_values.clear();
930  p.SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, set_values);
931  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
932  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
933  EXPECT_EQ(p, *db_profile);
934  EXPECT_EQ(0, p.CompareMulti(*db_profile));
935  EXPECT_EQ(string16(), db_profile->GetInfo(EMAIL_ADDRESS));
936  delete db_profile;
937}
938
939TEST_F(AutofillTableTest, AutofillProfileMultiValueFax) {
940  WebDatabase db;
941  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
942
943  AutofillProfile p;
944  const string16 kJohnDoe(ASCIIToUTF16("4151112222"));
945  const string16 kJohnPDoe(ASCIIToUTF16("4151113333"));
946  std::vector<string16> set_values;
947  set_values.push_back(kJohnDoe);
948  set_values.push_back(kJohnPDoe);
949  p.SetMultiInfo(PHONE_FAX_WHOLE_NUMBER, set_values);
950
951  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(p));
952
953  AutofillProfile* db_profile;
954  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
955  EXPECT_EQ(p, *db_profile);
956  EXPECT_EQ(0, p.CompareMulti(*db_profile));
957  delete db_profile;
958
959  // Update the values.
960  const string16 kNoOne(ASCIIToUTF16("4151110000"));
961  set_values[1] = kNoOne;
962  p.SetMultiInfo(PHONE_FAX_WHOLE_NUMBER, set_values);
963  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
964  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
965  EXPECT_EQ(p, *db_profile);
966  EXPECT_EQ(0, p.CompareMulti(*db_profile));
967  delete db_profile;
968
969  // Delete values.
970  set_values.clear();
971  p.SetMultiInfo(PHONE_FAX_WHOLE_NUMBER, set_values);
972  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(p));
973  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(p.guid(), &db_profile));
974  EXPECT_EQ(p, *db_profile);
975  EXPECT_EQ(0, p.CompareMulti(*db_profile));
976  EXPECT_EQ(string16(), db_profile->GetInfo(EMAIL_ADDRESS));
977  delete db_profile;
978}
979
980TEST_F(AutofillTableTest, AutofillProfileTrash) {
981  WebDatabase db;
982
983  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
984
985  std::vector<std::string> guids;
986  db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids);
987  EXPECT_TRUE(guids.empty());
988
989  ASSERT_TRUE(db.GetAutofillTable()->AddAutofillGUIDToTrash(
990      "00000000-0000-0000-0000-000000000000"));
991  ASSERT_TRUE(db.GetAutofillTable()->AddAutofillGUIDToTrash(
992      "00000000-0000-0000-0000-000000000001"));
993  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids));
994  EXPECT_EQ(2UL, guids.size());
995  EXPECT_EQ("00000000-0000-0000-0000-000000000000", guids[0]);
996  EXPECT_EQ("00000000-0000-0000-0000-000000000001", guids[1]);
997
998  ASSERT_TRUE(db.GetAutofillTable()->EmptyAutofillProfilesTrash());
999  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids));
1000  EXPECT_TRUE(guids.empty());
1001}
1002
1003TEST_F(AutofillTableTest, AutofillProfileTrashInteraction) {
1004  WebDatabase db;
1005
1006  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
1007
1008  std::vector<std::string> guids;
1009  db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids);
1010  EXPECT_TRUE(guids.empty());
1011
1012  AutofillProfile profile;
1013  profile.SetInfo(NAME_FIRST, ASCIIToUTF16("John"));
1014  profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16("Q."));
1015  profile.SetInfo(NAME_LAST, ASCIIToUTF16("Smith"));
1016  profile.SetInfo(EMAIL_ADDRESS,ASCIIToUTF16("js@smith.xyz"));
1017  profile.SetInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1 Main St"));
1018  profile.SetInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("Los Angeles"));
1019  profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
1020  profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
1021  profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
1022
1023  // Mark this profile as in the trash.  This stops |AddAutofillProfile| from
1024  // adding it.
1025  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillGUIDToTrash(profile.guid()));
1026  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(profile));
1027  AutofillProfile* added_profile = NULL;
1028  EXPECT_FALSE(db.GetAutofillTable()->GetAutofillProfile(
1029      profile.guid(), &added_profile));
1030  EXPECT_EQ(static_cast<AutofillProfile*>(NULL), added_profile);
1031
1032  // Add the profile for real this time.
1033  EXPECT_TRUE(db.GetAutofillTable()->EmptyAutofillProfilesTrash());
1034  EXPECT_TRUE(db.GetAutofillTable()->GetAutofillProfilesInTrash(&guids));
1035  EXPECT_TRUE(guids.empty());
1036  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(profile));
1037  EXPECT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
1038                                                        &added_profile));
1039  ASSERT_NE(static_cast<AutofillProfile*>(NULL), added_profile);
1040  delete added_profile;
1041
1042  // Mark this profile as in the trash.  This stops |UpdateAutofillProfileMulti|
1043  // from updating it.  In normal operation a profile should not be both in the
1044  // trash and in the profiles table simultaneously.
1045  EXPECT_TRUE(db.GetAutofillTable()->AddAutofillGUIDToTrash(profile.guid()));
1046  profile.SetInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
1047  EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(profile));
1048  AutofillProfile* updated_profile = NULL;
1049  EXPECT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
1050      profile.guid(), &updated_profile));
1051  ASSERT_NE(static_cast<AutofillProfile*>(NULL), added_profile);
1052  EXPECT_EQ(ASCIIToUTF16("John"), updated_profile->GetInfo(NAME_FIRST));
1053  delete updated_profile;
1054
1055  // Try to delete the trashed profile.  This stops |RemoveAutofillProfile| from
1056  // deleting it.  In normal operation deletion is done by migration step, and
1057  // removal from trash is done by |WebDataService|.  |RemoveAutofillProfile|
1058  // does remove the item from the trash if it is found however, so that if
1059  // other clients remove it (via Sync say) then it is gone and doesn't need to
1060  // be processed further by |WebDataService|.
1061  EXPECT_TRUE(db.GetAutofillTable()->RemoveAutofillProfile(profile.guid()));
1062  AutofillProfile* removed_profile = NULL;
1063  EXPECT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
1064                                                        &removed_profile));
1065  EXPECT_FALSE(db.GetAutofillTable()->IsAutofillGUIDInTrash(profile.guid()));
1066  ASSERT_NE(static_cast<AutofillProfile*>(NULL), removed_profile);
1067  delete removed_profile;
1068
1069  // Check that emptying the trash now allows removal to occur.
1070  EXPECT_TRUE(db.GetAutofillTable()->EmptyAutofillProfilesTrash());
1071  EXPECT_TRUE(db.GetAutofillTable()->RemoveAutofillProfile(profile.guid()));
1072  removed_profile = NULL;
1073  EXPECT_FALSE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
1074                                                         &removed_profile));
1075  EXPECT_EQ(static_cast<AutofillProfile*>(NULL), removed_profile);
1076}
1077
1078TEST_F(AutofillTableTest, CreditCard) {
1079  WebDatabase db;
1080
1081  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
1082
1083  // Add a 'Work' credit card.
1084  CreditCard work_creditcard;
1085  work_creditcard.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Jack Torrance"));
1086  work_creditcard.SetInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("1234567890123456"));
1087  work_creditcard.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("04"));
1088  work_creditcard.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2013"));
1089
1090  Time pre_creation_time = Time::Now();
1091  EXPECT_TRUE(db.GetAutofillTable()->AddCreditCard(work_creditcard));
1092  Time post_creation_time = Time::Now();
1093
1094  // Get the 'Work' credit card.
1095  CreditCard* db_creditcard;
1096  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(work_creditcard.guid(),
1097                                                   &db_creditcard));
1098  EXPECT_EQ(work_creditcard, *db_creditcard);
1099  sql::Statement s_work(db.GetSQLConnection()->GetUniqueStatement(
1100      "SELECT guid, name_on_card, expiration_month, expiration_year, "
1101      "card_number_encrypted, date_modified "
1102      "FROM credit_cards WHERE guid=?"));
1103  s_work.BindString(0, work_creditcard.guid());
1104  ASSERT_TRUE(s_work);
1105  ASSERT_TRUE(s_work.Step());
1106  EXPECT_GE(s_work.ColumnInt64(5), pre_creation_time.ToTimeT());
1107  EXPECT_LE(s_work.ColumnInt64(5), post_creation_time.ToTimeT());
1108  EXPECT_FALSE(s_work.Step());
1109  delete db_creditcard;
1110
1111  // Add a 'Target' credit card.
1112  CreditCard target_creditcard;
1113  target_creditcard.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Jack Torrance"));
1114  target_creditcard.SetInfo(CREDIT_CARD_NUMBER,
1115                            ASCIIToUTF16("1111222233334444"));
1116  target_creditcard.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("06"));
1117  target_creditcard.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2012"));
1118
1119  pre_creation_time = Time::Now();
1120  EXPECT_TRUE(db.GetAutofillTable()->AddCreditCard(target_creditcard));
1121  post_creation_time = Time::Now();
1122  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(target_creditcard.guid(),
1123                                                   &db_creditcard));
1124  EXPECT_EQ(target_creditcard, *db_creditcard);
1125  sql::Statement s_target(db.GetSQLConnection()->GetUniqueStatement(
1126      "SELECT guid, name_on_card, expiration_month, expiration_year, "
1127      "card_number_encrypted, date_modified "
1128      "FROM credit_cards WHERE guid=?"));
1129  s_target.BindString(0, target_creditcard.guid());
1130  ASSERT_TRUE(s_target);
1131  ASSERT_TRUE(s_target.Step());
1132  EXPECT_GE(s_target.ColumnInt64(5), pre_creation_time.ToTimeT());
1133  EXPECT_LE(s_target.ColumnInt64(5), post_creation_time.ToTimeT());
1134  EXPECT_FALSE(s_target.Step());
1135  delete db_creditcard;
1136
1137  // Update the 'Target' credit card.
1138  target_creditcard.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Charles Grady"));
1139  Time pre_modification_time = Time::Now();
1140  EXPECT_TRUE(db.GetAutofillTable()->UpdateCreditCard(target_creditcard));
1141  Time post_modification_time = Time::Now();
1142  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(target_creditcard.guid(),
1143                                                   &db_creditcard));
1144  EXPECT_EQ(target_creditcard, *db_creditcard);
1145  sql::Statement s_target_updated(db.GetSQLConnection()->GetUniqueStatement(
1146      "SELECT guid, name_on_card, expiration_month, expiration_year, "
1147      "card_number_encrypted, date_modified "
1148      "FROM credit_cards WHERE guid=?"));
1149  s_target_updated.BindString(0, target_creditcard.guid());
1150  ASSERT_TRUE(s_target_updated);
1151  ASSERT_TRUE(s_target_updated.Step());
1152  EXPECT_GE(s_target_updated.ColumnInt64(5), pre_modification_time.ToTimeT());
1153  EXPECT_LE(s_target_updated.ColumnInt64(5), post_modification_time.ToTimeT());
1154  EXPECT_FALSE(s_target_updated.Step());
1155  delete db_creditcard;
1156
1157  // Remove the 'Target' credit card.
1158  EXPECT_TRUE(db.GetAutofillTable()->RemoveCreditCard(
1159      target_creditcard.guid()));
1160  EXPECT_FALSE(db.GetAutofillTable()->GetCreditCard(target_creditcard.guid(),
1161                                                    &db_creditcard));
1162}
1163
1164TEST_F(AutofillTableTest, UpdateAutofillProfile) {
1165  WebDatabase db;
1166  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
1167
1168  // Add a profile to the db.
1169  AutofillProfile profile;
1170  profile.SetInfo(NAME_FIRST, ASCIIToUTF16("John"));
1171  profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16("Q."));
1172  profile.SetInfo(NAME_LAST, ASCIIToUTF16("Smith"));
1173  profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16("js@example.com"));
1174  profile.SetInfo(COMPANY_NAME, ASCIIToUTF16("Google"));
1175  profile.SetInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1234 Apple Way"));
1176  profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("unit 5"));
1177  profile.SetInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("Los Angeles"));
1178  profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
1179  profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
1180  profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
1181  profile.SetInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("18181234567"));
1182  profile.SetInfo(PHONE_FAX_WHOLE_NUMBER, ASCIIToUTF16("1915243678"));
1183  db.GetAutofillTable()->AddAutofillProfile(profile);
1184
1185  // Set a mocked value for the profile's creation time.
1186  const time_t mock_creation_date = Time::Now().ToTimeT() - 13;
1187  sql::Statement s_mock_creation_date(db.GetSQLConnection()->GetUniqueStatement(
1188      "UPDATE autofill_profiles SET date_modified = ?"));
1189  ASSERT_TRUE(s_mock_creation_date);
1190  s_mock_creation_date.BindInt64(0, mock_creation_date);
1191  ASSERT_TRUE(s_mock_creation_date.Run());
1192
1193  // Get the profile.
1194  AutofillProfile* tmp_profile;
1195  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
1196                                                        &tmp_profile));
1197  scoped_ptr<AutofillProfile> db_profile(tmp_profile);
1198  EXPECT_EQ(profile, *db_profile);
1199  sql::Statement s_original(db.GetSQLConnection()->GetUniqueStatement(
1200      "SELECT date_modified FROM autofill_profiles"));
1201  ASSERT_TRUE(s_original);
1202  ASSERT_TRUE(s_original.Step());
1203  EXPECT_EQ(mock_creation_date, s_original.ColumnInt64(0));
1204  EXPECT_FALSE(s_original.Step());
1205
1206  // Now, update the profile and save the update to the database.
1207  // The modification date should change to reflect the update.
1208  profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16("js@smith.xyz"));
1209  db.GetAutofillTable()->UpdateAutofillProfileMulti(profile);
1210
1211  // Get the profile.
1212  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
1213                                                        &tmp_profile));
1214  db_profile.reset(tmp_profile);
1215  EXPECT_EQ(profile, *db_profile);
1216  sql::Statement s_updated(db.GetSQLConnection()->GetUniqueStatement(
1217      "SELECT date_modified FROM autofill_profiles"));
1218  ASSERT_TRUE(s_updated);
1219  ASSERT_TRUE(s_updated.Step());
1220  EXPECT_LT(mock_creation_date, s_updated.ColumnInt64(0));
1221  EXPECT_FALSE(s_updated.Step());
1222
1223  // Set a mocked value for the profile's modification time.
1224  const time_t mock_modification_date = Time::Now().ToTimeT() - 7;
1225  sql::Statement s_mock_modification_date(
1226      db.GetSQLConnection()->GetUniqueStatement(
1227          "UPDATE autofill_profiles SET date_modified = ?"));
1228  ASSERT_TRUE(s_mock_modification_date);
1229  s_mock_modification_date.BindInt64(0, mock_modification_date);
1230  ASSERT_TRUE(s_mock_modification_date.Run());
1231
1232  // Finally, call into |UpdateAutofillProfileMulti()| without changing the
1233  // profile.  The modification date should not change.
1234  db.GetAutofillTable()->UpdateAutofillProfileMulti(profile);
1235
1236  // Get the profile.
1237  ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
1238                                                        &tmp_profile));
1239  db_profile.reset(tmp_profile);
1240  EXPECT_EQ(profile, *db_profile);
1241  sql::Statement s_unchanged(db.GetSQLConnection()->GetUniqueStatement(
1242      "SELECT date_modified FROM autofill_profiles"));
1243  ASSERT_TRUE(s_unchanged);
1244  ASSERT_TRUE(s_unchanged.Step());
1245  EXPECT_EQ(mock_modification_date, s_unchanged.ColumnInt64(0));
1246  EXPECT_FALSE(s_unchanged.Step());
1247}
1248
1249TEST_F(AutofillTableTest, UpdateCreditCard) {
1250  WebDatabase db;
1251  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
1252
1253  // Add a credit card to the db.
1254  CreditCard credit_card;
1255  credit_card.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Jack Torrance"));
1256  credit_card.SetInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("1234567890123456"));
1257  credit_card.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("04"));
1258  credit_card.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2013"));
1259  db.GetAutofillTable()->AddCreditCard(credit_card);
1260
1261  // Set a mocked value for the credit card's creation time.
1262  const time_t mock_creation_date = Time::Now().ToTimeT() - 13;
1263  sql::Statement s_mock_creation_date(db.GetSQLConnection()->GetUniqueStatement(
1264      "UPDATE credit_cards SET date_modified = ?"));
1265  ASSERT_TRUE(s_mock_creation_date);
1266  s_mock_creation_date.BindInt64(0, mock_creation_date);
1267  ASSERT_TRUE(s_mock_creation_date.Run());
1268
1269  // Get the credit card.
1270  CreditCard* tmp_credit_card;
1271  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(credit_card.guid(),
1272                                                   &tmp_credit_card));
1273  scoped_ptr<CreditCard> db_credit_card(tmp_credit_card);
1274  EXPECT_EQ(credit_card, *db_credit_card);
1275  sql::Statement s_original(db.GetSQLConnection()->GetUniqueStatement(
1276      "SELECT date_modified FROM credit_cards"));
1277  ASSERT_TRUE(s_original);
1278  ASSERT_TRUE(s_original.Step());
1279  EXPECT_EQ(mock_creation_date, s_original.ColumnInt64(0));
1280  EXPECT_FALSE(s_original.Step());
1281
1282  // Now, update the credit card and save the update to the database.
1283  // The modification date should change to reflect the update.
1284  credit_card.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01"));
1285  db.GetAutofillTable()->UpdateCreditCard(credit_card);
1286
1287  // Get the credit card.
1288  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(credit_card.guid(),
1289                                                   &tmp_credit_card));
1290  db_credit_card.reset(tmp_credit_card);
1291  EXPECT_EQ(credit_card, *db_credit_card);
1292  sql::Statement s_updated(db.GetSQLConnection()->GetUniqueStatement(
1293      "SELECT date_modified FROM credit_cards"));
1294  ASSERT_TRUE(s_updated);
1295  ASSERT_TRUE(s_updated.Step());
1296  EXPECT_LT(mock_creation_date, s_updated.ColumnInt64(0));
1297  EXPECT_FALSE(s_updated.Step());
1298
1299  // Set a mocked value for the credit card's modification time.
1300  const time_t mock_modification_date = Time::Now().ToTimeT() - 7;
1301  sql::Statement s_mock_modification_date(
1302      db.GetSQLConnection()->GetUniqueStatement(
1303          "UPDATE credit_cards SET date_modified = ?"));
1304  ASSERT_TRUE(s_mock_modification_date);
1305  s_mock_modification_date.BindInt64(0, mock_modification_date);
1306  ASSERT_TRUE(s_mock_modification_date.Run());
1307
1308  // Finally, call into |UpdateCreditCard()| without changing the credit card.
1309  // The modification date should not change.
1310  db.GetAutofillTable()->UpdateCreditCard(credit_card);
1311
1312  // Get the profile.
1313  ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(credit_card.guid(),
1314                                                   &tmp_credit_card));
1315  db_credit_card.reset(tmp_credit_card);
1316  EXPECT_EQ(credit_card, *db_credit_card);
1317  sql::Statement s_unchanged(db.GetSQLConnection()->GetUniqueStatement(
1318      "SELECT date_modified FROM credit_cards"));
1319  ASSERT_TRUE(s_unchanged);
1320  ASSERT_TRUE(s_unchanged.Step());
1321  EXPECT_EQ(mock_modification_date, s_unchanged.ColumnInt64(0));
1322  EXPECT_FALSE(s_unchanged.Step());
1323}
1324
1325TEST_F(AutofillTableTest, RemoveAutofillProfilesAndCreditCardsModifiedBetween) {
1326  WebDatabase db;
1327  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
1328
1329  // Populate the autofill_profiles and credit_cards tables.
1330  ASSERT_TRUE(db.GetSQLConnection()->Execute(
1331      "INSERT INTO autofill_profiles (guid, date_modified) "
1332      "VALUES('00000000-0000-0000-0000-000000000000', 11);"
1333      "INSERT INTO autofill_profiles (guid, date_modified) "
1334      "VALUES('00000000-0000-0000-0000-000000000001', 21);"
1335      "INSERT INTO autofill_profiles (guid, date_modified) "
1336      "VALUES('00000000-0000-0000-0000-000000000002', 31);"
1337      "INSERT INTO autofill_profiles (guid, date_modified) "
1338      "VALUES('00000000-0000-0000-0000-000000000003', 41);"
1339      "INSERT INTO autofill_profiles (guid, date_modified) "
1340      "VALUES('00000000-0000-0000-0000-000000000004', 51);"
1341      "INSERT INTO autofill_profiles (guid, date_modified) "
1342      "VALUES('00000000-0000-0000-0000-000000000005', 61);"
1343      "INSERT INTO credit_cards (guid, date_modified) "
1344      "VALUES('00000000-0000-0000-0000-000000000006', 17);"
1345      "INSERT INTO credit_cards (guid, date_modified) "
1346      "VALUES('00000000-0000-0000-0000-000000000007', 27);"
1347      "INSERT INTO credit_cards (guid, date_modified) "
1348      "VALUES('00000000-0000-0000-0000-000000000008', 37);"
1349      "INSERT INTO credit_cards (guid, date_modified) "
1350      "VALUES('00000000-0000-0000-0000-000000000009', 47);"
1351      "INSERT INTO credit_cards (guid, date_modified) "
1352      "VALUES('00000000-0000-0000-0000-000000000010', 57);"
1353      "INSERT INTO credit_cards (guid, date_modified) "
1354      "VALUES('00000000-0000-0000-0000-000000000011', 67);"));
1355
1356  // Remove all entries modified in the bounded time range [17,41).
1357  std::vector<std::string> profile_guids;
1358  std::vector<std::string> credit_card_guids;
1359  db.GetAutofillTable()->RemoveAutofillProfilesAndCreditCardsModifiedBetween(
1360      Time::FromTimeT(17), Time::FromTimeT(41),
1361      &profile_guids, &credit_card_guids);
1362  ASSERT_EQ(2UL, profile_guids.size());
1363  EXPECT_EQ("00000000-0000-0000-0000-000000000001", profile_guids[0]);
1364  EXPECT_EQ("00000000-0000-0000-0000-000000000002", profile_guids[1]);
1365  sql::Statement s_autofill_profiles_bounded(
1366      db.GetSQLConnection()->GetUniqueStatement(
1367          "SELECT date_modified FROM autofill_profiles"));
1368  ASSERT_TRUE(s_autofill_profiles_bounded);
1369  ASSERT_TRUE(s_autofill_profiles_bounded.Step());
1370  EXPECT_EQ(11, s_autofill_profiles_bounded.ColumnInt64(0));
1371  ASSERT_TRUE(s_autofill_profiles_bounded.Step());
1372  EXPECT_EQ(41, s_autofill_profiles_bounded.ColumnInt64(0));
1373  ASSERT_TRUE(s_autofill_profiles_bounded.Step());
1374  EXPECT_EQ(51, s_autofill_profiles_bounded.ColumnInt64(0));
1375  ASSERT_TRUE(s_autofill_profiles_bounded.Step());
1376  EXPECT_EQ(61, s_autofill_profiles_bounded.ColumnInt64(0));
1377  EXPECT_FALSE(s_autofill_profiles_bounded.Step());
1378  ASSERT_EQ(3UL, credit_card_guids.size());
1379  EXPECT_EQ("00000000-0000-0000-0000-000000000006", credit_card_guids[0]);
1380  EXPECT_EQ("00000000-0000-0000-0000-000000000007", credit_card_guids[1]);
1381  EXPECT_EQ("00000000-0000-0000-0000-000000000008", credit_card_guids[2]);
1382  sql::Statement s_credit_cards_bounded(
1383      db.GetSQLConnection()->GetUniqueStatement(
1384          "SELECT date_modified FROM credit_cards"));
1385  ASSERT_TRUE(s_credit_cards_bounded);
1386  ASSERT_TRUE(s_credit_cards_bounded.Step());
1387  EXPECT_EQ(47, s_credit_cards_bounded.ColumnInt64(0));
1388  ASSERT_TRUE(s_credit_cards_bounded.Step());
1389  EXPECT_EQ(57, s_credit_cards_bounded.ColumnInt64(0));
1390  ASSERT_TRUE(s_credit_cards_bounded.Step());
1391  EXPECT_EQ(67, s_credit_cards_bounded.ColumnInt64(0));
1392  EXPECT_FALSE(s_credit_cards_bounded.Step());
1393
1394  // Remove all entries modified on or after time 51 (unbounded range).
1395  db.GetAutofillTable()->RemoveAutofillProfilesAndCreditCardsModifiedBetween(
1396      Time::FromTimeT(51), Time(),
1397      &profile_guids, &credit_card_guids);
1398  ASSERT_EQ(2UL, profile_guids.size());
1399  EXPECT_EQ("00000000-0000-0000-0000-000000000004", profile_guids[0]);
1400  EXPECT_EQ("00000000-0000-0000-0000-000000000005", profile_guids[1]);
1401  sql::Statement s_autofill_profiles_unbounded(
1402      db.GetSQLConnection()->GetUniqueStatement(
1403          "SELECT date_modified FROM autofill_profiles"));
1404  ASSERT_TRUE(s_autofill_profiles_unbounded);
1405  ASSERT_TRUE(s_autofill_profiles_unbounded.Step());
1406  EXPECT_EQ(11, s_autofill_profiles_unbounded.ColumnInt64(0));
1407  ASSERT_TRUE(s_autofill_profiles_unbounded.Step());
1408  EXPECT_EQ(41, s_autofill_profiles_unbounded.ColumnInt64(0));
1409  EXPECT_FALSE(s_autofill_profiles_unbounded.Step());
1410  ASSERT_EQ(2UL, credit_card_guids.size());
1411  EXPECT_EQ("00000000-0000-0000-0000-000000000010", credit_card_guids[0]);
1412  EXPECT_EQ("00000000-0000-0000-0000-000000000011", credit_card_guids[1]);
1413  sql::Statement s_credit_cards_unbounded(
1414      db.GetSQLConnection()->GetUniqueStatement(
1415          "SELECT date_modified FROM credit_cards"));
1416  ASSERT_TRUE(s_credit_cards_unbounded);
1417  ASSERT_TRUE(s_credit_cards_unbounded.Step());
1418  EXPECT_EQ(47, s_credit_cards_unbounded.ColumnInt64(0));
1419  EXPECT_FALSE(s_credit_cards_unbounded.Step());
1420
1421  // Remove all remaining entries.
1422  db.GetAutofillTable()->RemoveAutofillProfilesAndCreditCardsModifiedBetween(
1423      Time(), Time(),
1424      &profile_guids, &credit_card_guids);
1425  ASSERT_EQ(2UL, profile_guids.size());
1426  EXPECT_EQ("00000000-0000-0000-0000-000000000000", profile_guids[0]);
1427  EXPECT_EQ("00000000-0000-0000-0000-000000000003", profile_guids[1]);
1428  sql::Statement s_autofill_profiles_empty(
1429      db.GetSQLConnection()->GetUniqueStatement(
1430          "SELECT date_modified FROM autofill_profiles"));
1431  ASSERT_TRUE(s_autofill_profiles_empty);
1432  EXPECT_FALSE(s_autofill_profiles_empty.Step());
1433  ASSERT_EQ(1UL, credit_card_guids.size());
1434  EXPECT_EQ("00000000-0000-0000-0000-000000000009", credit_card_guids[0]);
1435  sql::Statement s_credit_cards_empty(
1436      db.GetSQLConnection()->GetUniqueStatement(
1437          "SELECT date_modified FROM credit_cards"));
1438  ASSERT_TRUE(s_credit_cards_empty);
1439  EXPECT_FALSE(s_credit_cards_empty.Step());
1440}
1441
1442TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_NoResults) {
1443  WebDatabase db;
1444
1445  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
1446
1447  std::vector<AutofillEntry> entries;
1448  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));
1449
1450  EXPECT_EQ(0U, entries.size());
1451}
1452
1453TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_OneResult) {
1454  WebDatabase db;
1455
1456  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
1457
1458  AutofillChangeList changes;
1459  std::map<std::string, std::vector<Time> > name_value_times_map;
1460
1461  time_t start = 0;
1462  std::vector<Time> timestamps1;
1463  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
1464      FormField(string16(),
1465                ASCIIToUTF16("Name"),
1466                ASCIIToUTF16("Superman"),
1467                string16(),
1468                0,
1469                false),
1470      &changes,
1471      Time::FromTimeT(start)));
1472  timestamps1.push_back(Time::FromTimeT(start));
1473  std::string key1("NameSuperman");
1474  name_value_times_map.insert(std::pair<std::string,
1475    std::vector<Time> > (key1, timestamps1));
1476
1477  AutofillEntrySet expected_entries(CompareAutofillEntries);
1478  AutofillKey ak1(ASCIIToUTF16("Name"), ASCIIToUTF16("Superman"));
1479  AutofillEntry ae1(ak1, timestamps1);
1480
1481  expected_entries.insert(ae1);
1482
1483  std::vector<AutofillEntry> entries;
1484  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));
1485  AutofillEntrySet entry_set(entries.begin(), entries.end(),
1486    CompareAutofillEntries);
1487
1488  // make sure the lists of entries match
1489  ASSERT_EQ(expected_entries.size(), entry_set.size());
1490  AutofillEntrySetIterator it;
1491  for (it = entry_set.begin(); it != entry_set.end(); it++) {
1492    expected_entries.erase(*it);
1493  }
1494
1495  EXPECT_EQ(0U, expected_entries.size());
1496}
1497
1498TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_TwoDistinct) {
1499  WebDatabase db;
1500
1501  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
1502
1503  AutofillChangeList changes;
1504  std::map<std::string, std::vector<Time> > name_value_times_map;
1505  time_t start = 0;
1506
1507  std::vector<Time> timestamps1;
1508  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
1509      FormField(string16(),
1510                ASCIIToUTF16("Name"),
1511                ASCIIToUTF16("Superman"),
1512                string16(),
1513                0,
1514                false),
1515      &changes,
1516      Time::FromTimeT(start)));
1517  timestamps1.push_back(Time::FromTimeT(start));
1518  std::string key1("NameSuperman");
1519  name_value_times_map.insert(std::pair<std::string,
1520    std::vector<Time> > (key1, timestamps1));
1521
1522  start++;
1523  std::vector<Time> timestamps2;
1524  EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
1525      FormField(string16(),
1526                ASCIIToUTF16("Name"),
1527                ASCIIToUTF16("Clark Kent"),
1528                string16(),
1529                0,
1530                false),
1531      &changes,
1532      Time::FromTimeT(start)));
1533  timestamps2.push_back(Time::FromTimeT(start));
1534  std::string key2("NameClark Kent");
1535  name_value_times_map.insert(std::pair<std::string,
1536    std::vector<Time> > (key2, timestamps2));
1537
1538  AutofillEntrySet expected_entries(CompareAutofillEntries);
1539  AutofillKey ak1(ASCIIToUTF16("Name"), ASCIIToUTF16("Superman"));
1540  AutofillKey ak2(ASCIIToUTF16("Name"), ASCIIToUTF16("Clark Kent"));
1541  AutofillEntry ae1(ak1, timestamps1);
1542  AutofillEntry ae2(ak2, timestamps2);
1543
1544  expected_entries.insert(ae1);
1545  expected_entries.insert(ae2);
1546
1547  std::vector<AutofillEntry> entries;
1548  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));
1549  AutofillEntrySet entry_set(entries.begin(), entries.end(),
1550    CompareAutofillEntries);
1551
1552  // make sure the lists of entries match
1553  ASSERT_EQ(expected_entries.size(), entry_set.size());
1554  AutofillEntrySetIterator it;
1555  for (it = entry_set.begin(); it != entry_set.end(); it++) {
1556    expected_entries.erase(*it);
1557  }
1558
1559  EXPECT_EQ(0U, expected_entries.size());
1560}
1561
1562TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_TwoSame) {
1563  WebDatabase db;
1564
1565  ASSERT_EQ(sql::INIT_OK, db.Init(file_));
1566
1567  AutofillChangeList changes;
1568  std::map<std::string, std::vector<Time> > name_value_times_map;
1569
1570  time_t start = 0;
1571  std::vector<Time> timestamps;
1572  for (int i = 0; i < 2; i++) {
1573    EXPECT_TRUE(db.GetAutofillTable()->AddFormFieldValueTime(
1574        FormField(string16(),
1575                  ASCIIToUTF16("Name"),
1576                  ASCIIToUTF16("Superman"),
1577                  string16(),
1578                  0,
1579                  false),
1580        &changes,
1581        Time::FromTimeT(start)));
1582    timestamps.push_back(Time::FromTimeT(start));
1583    start++;
1584  }
1585
1586  std::string key("NameSuperman");
1587  name_value_times_map.insert(std::pair<std::string,
1588      std::vector<Time> > (key, timestamps));
1589
1590  AutofillEntrySet expected_entries(CompareAutofillEntries);
1591  AutofillKey ak1(ASCIIToUTF16("Name"), ASCIIToUTF16("Superman"));
1592  AutofillEntry ae1(ak1, timestamps);
1593
1594  expected_entries.insert(ae1);
1595
1596  std::vector<AutofillEntry> entries;
1597  ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));
1598  AutofillEntrySet entry_set(entries.begin(), entries.end(),
1599    CompareAutofillEntries);
1600
1601  // make sure the lists of entries match
1602  ASSERT_EQ(expected_entries.size(), entry_set.size());
1603  AutofillEntrySetIterator it;
1604  for (it = entry_set.begin(); it != entry_set.end(); it++) {
1605    expected_entries.erase(*it);
1606  }
1607
1608  EXPECT_EQ(0U, expected_entries.size());
1609}
1610