components/autofill/core/common/form_data_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/autofill/core/common/form_data.h"
   6
   7 #include "base/pickle.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "components/autofill/core/common/form_field_data.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace autofill {
  13
  14 namespace {
  15
  16 // This function serializes the form data into the pickle in version one format.
  17 // It should always be possible to deserialize it using DeserializeFormData(),
  18 // even when version changes. See kPickleVersion in form_data.cc.
  19 void SerializeInVersion1Format(const FormData& form_data,
  20                                base::Pickle* pickle) {
  21   DCHECK_EQ(true, form_data.is_form_tag);
  22   pickle->WriteInt(1);
  23   pickle->WriteString16(form_data.name);
  24   base::string16 method(base::ASCIIToUTF16("POST"));
  25   pickle->WriteString16(method);
  26   pickle->WriteString(form_data.origin.spec());
  27   pickle->WriteString(form_data.action.spec());
  28   pickle->WriteBool(form_data.user_submitted);
  29   pickle->WriteInt(static_cast<int>(form_data.fields.size()));
  30   for (size_t i = 0; i < form_data.fields.size(); ++i) {
  31     SerializeFormFieldData(form_data.fields[i], pickle);
  32   }
  33 }
  34
  35 void SerializeInVersion2Format(const FormData& form_data,
  36                                base::Pickle* pickle) {
  37   DCHECK_EQ(true, form_data.is_form_tag);
  38   pickle->WriteInt(2);
  39   pickle->WriteString16(form_data.name);
  40   pickle->WriteString(form_data.origin.spec());
  41   pickle->WriteString(form_data.action.spec());
  42   pickle->WriteBool(form_data.user_submitted);
  43   pickle->WriteInt(static_cast<int>(form_data.fields.size()));
  44   for (size_t i = 0; i < form_data.fields.size(); ++i) {
  45     SerializeFormFieldData(form_data.fields[i], pickle);
  46   }
  47 }
  48
  49 // This function serializes the form data into the pickle in incorrect format
  50 // (no version number).
  51 void SerializeIncorrectFormat(const FormData& form_data, base::Pickle* pickle) {
  52   pickle->WriteString16(form_data.name);
  53   pickle->WriteString(form_data.origin.spec());
  54   pickle->WriteString(form_data.action.spec());
  55   pickle->WriteBool(form_data.user_submitted);
  56   pickle->WriteInt(static_cast<int>(form_data.fields.size()));
  57   for (size_t i = 0; i < form_data.fields.size(); ++i) {
  58     SerializeFormFieldData(form_data.fields[i], pickle);
  59   }
  60 }
  61
  62 void FillInDummyFormData(FormData* data) {
  63   data->name = base::ASCIIToUTF16("name");
  64   data->origin = GURL("origin");
  65   data->action = GURL("action");
  66   data->user_submitted = true;
  67
  68   FormFieldData field_data;
  69   field_data.label = base::ASCIIToUTF16("label");
  70   field_data.name = base::ASCIIToUTF16("name");
  71   field_data.value = base::ASCIIToUTF16("value");
  72   field_data.form_control_type = "password";
  73   field_data.autocomplete_attribute = "off";
  74   field_data.max_length = 200;
  75   field_data.is_autofilled = true;
  76   field_data.is_checked = true;
  77   field_data.is_checkable = true;
  78   field_data.is_focusable = true;
  79   field_data.should_autocomplete = false;
  80   field_data.text_direction = base::i18n::RIGHT_TO_LEFT;
  81   field_data.option_values.push_back(base::ASCIIToUTF16("First"));
  82   field_data.option_values.push_back(base::ASCIIToUTF16("Second"));
  83   field_data.option_contents.push_back(base::ASCIIToUTF16("First"));
  84   field_data.option_contents.push_back(base::ASCIIToUTF16("Second"));
  85
  86   data->fields.push_back(field_data);
  87
  88   // Change a few fields.
  89   field_data.max_length = 150;
  90   field_data.option_values.push_back(base::ASCIIToUTF16("Third"));
  91   field_data.option_contents.push_back(base::ASCIIToUTF16("Third"));
  92   data->fields.push_back(field_data);
  93 }
  94
  95 }  // namespace
  96
  97 TEST(FormDataTest, SerializeAndDeserialize) {
  98   FormData data;
  99   FillInDummyFormData(&data);
 100   data.is_form_tag = false;
 101
 102   base::Pickle pickle;
 103   SerializeFormData(data, &pickle);
 104
 105   base::PickleIterator iter(pickle);
 106   FormData actual;
 107   EXPECT_TRUE(DeserializeFormData(&iter, &actual));
 108
 109   EXPECT_TRUE(actual.SameFormAs(data));
 110 }
 111
 112 TEST(FormDataTest, Serialize_v1_Deserialize_vCurrent) {
 113   FormData data;
 114   FillInDummyFormData(&data);
 115
 116   base::Pickle pickle;
 117   SerializeInVersion1Format(data, &pickle);
 118
 119   base::PickleIterator iter(pickle);
 120   FormData actual;
 121   EXPECT_TRUE(DeserializeFormData(&iter, &actual));
 122
 123   EXPECT_TRUE(actual.SameFormAs(data));
 124 }
 125
 126 TEST(FormDataTest, Serialize_v2_Deserialize_vCurrent) {
 127   FormData data;
 128   FillInDummyFormData(&data);
 129
 130   base::Pickle pickle;
 131   SerializeInVersion2Format(data, &pickle);
 132
 133   base::PickleIterator iter(pickle);
 134   FormData actual;
 135   EXPECT_TRUE(DeserializeFormData(&iter, &actual));
 136
 137   EXPECT_TRUE(actual.SameFormAs(data));
 138 }
 139
 140 TEST(FormDataTest, SerializeIncorrectFormatAndDeserialize) {
 141   FormData data;
 142   FillInDummyFormData(&data);
 143
 144   base::Pickle pickle;
 145   SerializeIncorrectFormat(data, &pickle);
 146
 147   base::PickleIterator iter(pickle);
 148   FormData actual;
 149   EXPECT_FALSE(DeserializeFormData(&iter, &actual));
 150
 151   FormData empty;
 152   EXPECT_TRUE(actual.SameFormAs(empty));
 153 }
 154
 155 TEST(FormDataTest, SerializeAndDeserializeInStrings) {
 156   FormData data;
 157   FillInDummyFormData(&data);
 158   data.is_form_tag = false;
 159
 160   std::string serialized_data;
 161   SerializeFormDataToBase64String(data, &serialized_data);
 162
 163   FormData actual;
 164   EXPECT_TRUE(DeserializeFormDataFromBase64String(serialized_data, &actual));
 165
 166   EXPECT_TRUE(actual.SameFormAs(data));
 167 }
 168
 169 }  // namespace autofill