src/sync/protocol/proto_value_conversions_unittest.cc

   1 // Copyright (c) 2012 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 // Keep this file in sync with the .proto files in this directory.
   6
   7 #include "sync/protocol/proto_value_conversions.h"
   8
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/time/time.h"
  12 #include "base/values.h"
  13 #include "sync/internal_api/public/base/model_type.h"
  14 #include "sync/protocol/app_notification_specifics.pb.h"
  15 #include "sync/protocol/app_setting_specifics.pb.h"
  16 #include "sync/protocol/app_specifics.pb.h"
  17 #include "sync/protocol/autofill_specifics.pb.h"
  18 #include "sync/protocol/bookmark_specifics.pb.h"
  19 #include "sync/protocol/device_info_specifics.pb.h"
  20 #include "sync/protocol/encryption.pb.h"
  21 #include "sync/protocol/experiments_specifics.pb.h"
  22 #include "sync/protocol/extension_setting_specifics.pb.h"
  23 #include "sync/protocol/extension_specifics.pb.h"
  24 #include "sync/protocol/favicon_image_specifics.pb.h"
  25 #include "sync/protocol/favicon_tracking_specifics.pb.h"
  26 #include "sync/protocol/managed_user_setting_specifics.pb.h"
  27 #include "sync/protocol/managed_user_shared_setting_specifics.pb.h"
  28 #include "sync/protocol/managed_user_specifics.pb.h"
  29 #include "sync/protocol/nigori_specifics.pb.h"
  30 #include "sync/protocol/password_specifics.pb.h"
  31 #include "sync/protocol/preference_specifics.pb.h"
  32 #include "sync/protocol/priority_preference_specifics.pb.h"
  33 #include "sync/protocol/search_engine_specifics.pb.h"
  34 #include "sync/protocol/session_specifics.pb.h"
  35 #include "sync/protocol/sync.pb.h"
  36 #include "sync/protocol/theme_specifics.pb.h"
  37 #include "sync/protocol/typed_url_specifics.pb.h"
  38 #include "testing/gtest/include/gtest/gtest.h"
  39
  40 namespace syncer {
  41 namespace {
  42
  43 class ProtoValueConversionsTest : public testing::Test {
  44  protected:
  45   template <class T>
  46   void TestSpecificsToValue(
  47       base::DictionaryValue* (*specifics_to_value)(const T&)) {
  48     const T& specifics(T::default_instance());
  49     scoped_ptr<base::DictionaryValue> value(specifics_to_value(specifics));
  50     // We can't do much but make sure that this doesn't crash.
  51   }
  52 };
  53
  54 TEST_F(ProtoValueConversionsTest, ProtoChangeCheck) {
  55   // If this number changes, that means we added or removed a data
  56   // type.  Don't forget to add a unit test for {New
  57   // type}SpecificsToValue below.
  58   EXPECT_EQ(31, MODEL_TYPE_COUNT);
  59
  60   // We'd also like to check if we changed any field in our messages.
  61   // However, that's hard to do: sizeof could work, but it's
  62   // platform-dependent.  default_instance().ByteSize() won't change
  63   // for most changes, since most of our fields are optional.  So we
  64   // just settle for comments in the proto files.
  65 }
  66
  67 TEST_F(ProtoValueConversionsTest, EncryptedDataToValue) {
  68   TestSpecificsToValue(EncryptedDataToValue);
  69 }
  70
  71 TEST_F(ProtoValueConversionsTest, SessionHeaderToValue) {
  72   TestSpecificsToValue(SessionHeaderToValue);
  73 }
  74
  75 TEST_F(ProtoValueConversionsTest, SessionTabToValue) {
  76   TestSpecificsToValue(SessionTabToValue);
  77 }
  78
  79 TEST_F(ProtoValueConversionsTest, SessionWindowToValue) {
  80   TestSpecificsToValue(SessionWindowToValue);
  81 }
  82
  83 TEST_F(ProtoValueConversionsTest, TabNavigationToValue) {
  84   TestSpecificsToValue(TabNavigationToValue);
  85 }
  86
  87 TEST_F(ProtoValueConversionsTest, PasswordSpecificsData) {
  88   sync_pb::PasswordSpecificsData specifics;
  89   specifics.set_password_value("secret");
  90   scoped_ptr<base::DictionaryValue> value(
  91       PasswordSpecificsDataToValue(specifics));
  92   EXPECT_FALSE(value->empty());
  93   std::string password_value;
  94   EXPECT_TRUE(value->GetString("password_value", &password_value));
  95   EXPECT_EQ("<redacted>", password_value);
  96 }
  97
  98 TEST_F(ProtoValueConversionsTest, AppListSpecificsToValue) {
  99   TestSpecificsToValue(AppListSpecificsToValue);
 100 }
 101
 102 TEST_F(ProtoValueConversionsTest, AppNotificationToValue) {
 103   TestSpecificsToValue(AppNotificationToValue);
 104 }
 105
 106 TEST_F(ProtoValueConversionsTest, AppSettingSpecificsToValue) {
 107   sync_pb::AppNotificationSettings specifics;
 108   specifics.set_disabled(true);
 109   specifics.set_oauth_client_id("some_id_value");
 110   scoped_ptr<base::DictionaryValue> value(AppSettingsToValue(specifics));
 111   EXPECT_FALSE(value->empty());
 112   bool disabled_value = false;
 113   std::string oauth_client_id_value;
 114   EXPECT_TRUE(value->GetBoolean("disabled", &disabled_value));
 115   EXPECT_EQ(true, disabled_value);
 116   EXPECT_TRUE(value->GetString("oauth_client_id", &oauth_client_id_value));
 117   EXPECT_EQ("some_id_value", oauth_client_id_value);
 118 }
 119
 120 TEST_F(ProtoValueConversionsTest, AppSpecificsToValue) {
 121   TestSpecificsToValue(AppSpecificsToValue);
 122 }
 123
 124 TEST_F(ProtoValueConversionsTest, AutofillSpecificsToValue) {
 125   TestSpecificsToValue(AutofillSpecificsToValue);
 126 }
 127
 128 TEST_F(ProtoValueConversionsTest, AutofillProfileSpecificsToValue) {
 129   TestSpecificsToValue(AutofillProfileSpecificsToValue);
 130 }
 131
 132 TEST_F(ProtoValueConversionsTest, BookmarkSpecificsToValue) {
 133   TestSpecificsToValue(BookmarkSpecificsToValue);
 134 }
 135
 136 TEST_F(ProtoValueConversionsTest, BookmarkSpecificsData) {
 137   const base::Time creation_time(base::Time::Now());
 138   const std::string icon_url = "http://www.google.com/favicon.ico";
 139   sync_pb::BookmarkSpecifics specifics;
 140   specifics.set_creation_time_us(creation_time.ToInternalValue());
 141   specifics.set_icon_url(icon_url);
 142   sync_pb::MetaInfo* meta_1 = specifics.add_meta_info();
 143   meta_1->set_key("key1");
 144   meta_1->set_value("value1");
 145   sync_pb::MetaInfo* meta_2 = specifics.add_meta_info();
 146   meta_2->set_key("key2");
 147   meta_2->set_value("value2");
 148
 149   scoped_ptr<base::DictionaryValue> value(BookmarkSpecificsToValue(specifics));
 150   EXPECT_FALSE(value->empty());
 151   std::string encoded_time;
 152   EXPECT_TRUE(value->GetString("creation_time_us", &encoded_time));
 153   EXPECT_EQ(base::Int64ToString(creation_time.ToInternalValue()), encoded_time);
 154   std::string encoded_icon_url;
 155   EXPECT_TRUE(value->GetString("icon_url", &encoded_icon_url));
 156   EXPECT_EQ(icon_url, encoded_icon_url);
 157   base::ListValue* meta_info_list;
 158   ASSERT_TRUE(value->GetList("meta_info", &meta_info_list));
 159   EXPECT_EQ(2u, meta_info_list->GetSize());
 160   base::DictionaryValue* meta_info;
 161   std::string meta_key;
 162   std::string meta_value;
 163   ASSERT_TRUE(meta_info_list->GetDictionary(0, &meta_info));
 164   EXPECT_TRUE(meta_info->GetString("key", &meta_key));
 165   EXPECT_TRUE(meta_info->GetString("value", &meta_value));
 166   EXPECT_EQ("key1", meta_key);
 167   EXPECT_EQ("value1", meta_value);
 168   ASSERT_TRUE(meta_info_list->GetDictionary(1, &meta_info));
 169   EXPECT_TRUE(meta_info->GetString("key", &meta_key));
 170   EXPECT_TRUE(meta_info->GetString("value", &meta_value));
 171   EXPECT_EQ("key2", meta_key);
 172   EXPECT_EQ("value2", meta_value);
 173 }
 174
 175 TEST_F(ProtoValueConversionsTest, PriorityPreferenceSpecificsToValue) {
 176   TestSpecificsToValue(PriorityPreferenceSpecificsToValue);
 177 }
 178
 179 TEST_F(ProtoValueConversionsTest, DeviceInfoSpecificsToValue) {
 180   TestSpecificsToValue(DeviceInfoSpecificsToValue);
 181 }
 182
 183 TEST_F(ProtoValueConversionsTest, ExperimentsSpecificsToValue) {
 184   TestSpecificsToValue(ExperimentsSpecificsToValue);
 185 }
 186
 187 TEST_F(ProtoValueConversionsTest, ExtensionSettingSpecificsToValue) {
 188   TestSpecificsToValue(ExtensionSettingSpecificsToValue);
 189 }
 190
 191 TEST_F(ProtoValueConversionsTest, ExtensionSpecificsToValue) {
 192   TestSpecificsToValue(ExtensionSpecificsToValue);
 193 }
 194
 195 TEST_F(ProtoValueConversionsTest, FaviconImageSpecificsToValue) {
 196   TestSpecificsToValue(FaviconImageSpecificsToValue);
 197 }
 198
 199 TEST_F(ProtoValueConversionsTest, FaviconTrackingSpecificsToValue) {
 200   TestSpecificsToValue(FaviconTrackingSpecificsToValue);
 201 }
 202
 203 TEST_F(ProtoValueConversionsTest, HistoryDeleteDirectiveSpecificsToValue) {
 204   TestSpecificsToValue(HistoryDeleteDirectiveSpecificsToValue);
 205 }
 206
 207 TEST_F(ProtoValueConversionsTest, ManagedUserSettingSpecificsToValue) {
 208   TestSpecificsToValue(ManagedUserSettingSpecificsToValue);
 209 }
 210
 211 TEST_F(ProtoValueConversionsTest, ManagedUserSpecificsToValue) {
 212   TestSpecificsToValue(ManagedUserSpecificsToValue);
 213 }
 214
 215 TEST_F(ProtoValueConversionsTest, ManagedUserSharedSettingSpecificsToValue) {
 216   TestSpecificsToValue(ManagedUserSharedSettingSpecificsToValue);
 217 }
 218
 219 TEST_F(ProtoValueConversionsTest, NigoriSpecificsToValue) {
 220   TestSpecificsToValue(NigoriSpecificsToValue);
 221 }
 222
 223 TEST_F(ProtoValueConversionsTest, PasswordSpecificsToValue) {
 224   TestSpecificsToValue(PasswordSpecificsToValue);
 225 }
 226
 227 TEST_F(ProtoValueConversionsTest, PreferenceSpecificsToValue) {
 228   TestSpecificsToValue(PreferenceSpecificsToValue);
 229 }
 230
 231 TEST_F(ProtoValueConversionsTest, SearchEngineSpecificsToValue) {
 232   TestSpecificsToValue(SearchEngineSpecificsToValue);
 233 }
 234
 235 TEST_F(ProtoValueConversionsTest, SessionSpecificsToValue) {
 236   TestSpecificsToValue(SessionSpecificsToValue);
 237 }
 238
 239 TEST_F(ProtoValueConversionsTest, SyncedNotificationSpecificsToValue) {
 240   TestSpecificsToValue(SyncedNotificationSpecificsToValue);
 241 }
 242
 243 TEST_F(ProtoValueConversionsTest, ThemeSpecificsToValue) {
 244   TestSpecificsToValue(ThemeSpecificsToValue);
 245 }
 246
 247 TEST_F(ProtoValueConversionsTest, TypedUrlSpecificsToValue) {
 248   TestSpecificsToValue(TypedUrlSpecificsToValue);
 249 }
 250
 251 TEST_F(ProtoValueConversionsTest, DictionarySpecificsToValue) {
 252   TestSpecificsToValue(DictionarySpecificsToValue);
 253 }
 254
 255 TEST_F(ProtoValueConversionsTest, ArticleSpecificsToValue) {
 256   TestSpecificsToValue(ArticleSpecificsToValue);
 257 }
 258
 259 // TODO(akalin): Figure out how to better test EntitySpecificsToValue.
 260
 261 TEST_F(ProtoValueConversionsTest, EntitySpecificsToValue) {
 262   sync_pb::EntitySpecifics specifics;
 263   // Touch the extensions to make sure it shows up in the generated
 264   // value.
 265 #define SET_FIELD(key) (void)specifics.mutable_##key()
 266
 267   SET_FIELD(app);
 268   SET_FIELD(app_list);
 269   SET_FIELD(app_notification);
 270   SET_FIELD(app_setting);
 271   SET_FIELD(article);
 272   SET_FIELD(autofill);
 273   SET_FIELD(autofill_profile);
 274   SET_FIELD(bookmark);
 275   SET_FIELD(device_info);
 276   SET_FIELD(dictionary);
 277   SET_FIELD(experiments);
 278   SET_FIELD(extension);
 279   SET_FIELD(extension_setting);
 280   SET_FIELD(favicon_image);
 281   SET_FIELD(favicon_tracking);
 282   SET_FIELD(history_delete_directive);
 283   SET_FIELD(managed_user_setting);
 284   SET_FIELD(managed_user_shared_setting);
 285   SET_FIELD(managed_user);
 286   SET_FIELD(nigori);
 287   SET_FIELD(password);
 288   SET_FIELD(preference);
 289   SET_FIELD(priority_preference);
 290   SET_FIELD(search_engine);
 291   SET_FIELD(session);
 292   SET_FIELD(synced_notification);
 293   SET_FIELD(theme);
 294   SET_FIELD(typed_url);
 295
 296 #undef SET_FIELD
 297
 298   scoped_ptr<base::DictionaryValue> value(EntitySpecificsToValue(specifics));
 299   EXPECT_EQ(MODEL_TYPE_COUNT - FIRST_REAL_MODEL_TYPE -
 300             (LAST_PROXY_TYPE - FIRST_PROXY_TYPE + 1),
 301             static_cast<int>(value->size()));
 302 }
 303
 304 namespace {
 305 // Returns whether the given value has specifics under the entries in the given
 306 // path.
 307 bool ValueHasSpecifics(const base::DictionaryValue& value,
 308                        const std::string& path) {
 309   const base::ListValue* entities_list = NULL;
 310   const base::DictionaryValue* entry_dictionary = NULL;
 311   const base::DictionaryValue* specifics_dictionary = NULL;
 312
 313   if (!value.GetList(path, &entities_list))
 314     return false;
 315
 316   if (!entities_list->GetDictionary(0, &entry_dictionary))
 317     return false;
 318
 319   return entry_dictionary->GetDictionary("specifics",
 320                                          &specifics_dictionary);
 321 }
 322 }  // namespace
 323
 324 // Create a ClientToServerMessage with an EntitySpecifics.  Converting it to
 325 // a value should respect the |include_specifics| flag.
 326 TEST_F(ProtoValueConversionsTest, ClientToServerMessageToValue) {
 327   sync_pb::ClientToServerMessage message;
 328   sync_pb::CommitMessage* commit_message = message.mutable_commit();
 329   sync_pb::SyncEntity* entity = commit_message->add_entries();
 330   entity->mutable_specifics();
 331
 332   scoped_ptr<base::DictionaryValue> value_with_specifics(
 333       ClientToServerMessageToValue(message, true /* include_specifics */));
 334   EXPECT_FALSE(value_with_specifics->empty());
 335   EXPECT_TRUE(ValueHasSpecifics(*(value_with_specifics.get()),
 336                                 "commit.entries"));
 337
 338   scoped_ptr<base::DictionaryValue> value_without_specifics(
 339       ClientToServerMessageToValue(message, false /* include_specifics */));
 340   EXPECT_FALSE(value_without_specifics->empty());
 341   EXPECT_FALSE(ValueHasSpecifics(*(value_without_specifics.get()),
 342                                  "commit.entries"));
 343 }
 344
 345 // Create a ClientToServerResponse with an EntitySpecifics.  Converting it to
 346 // a value should respect the |include_specifics| flag.
 347 TEST_F(ProtoValueConversionsTest, ClientToServerResponseToValue) {
 348   sync_pb::ClientToServerResponse message;
 349   sync_pb::GetUpdatesResponse* response = message.mutable_get_updates();
 350   sync_pb::SyncEntity* entity = response->add_entries();
 351   entity->mutable_specifics();
 352
 353   scoped_ptr<base::DictionaryValue> value_with_specifics(
 354       ClientToServerResponseToValue(message, true /* include_specifics */));
 355   EXPECT_FALSE(value_with_specifics->empty());
 356   EXPECT_TRUE(ValueHasSpecifics(*(value_with_specifics.get()),
 357                                 "get_updates.entries"));
 358
 359   scoped_ptr<base::DictionaryValue> value_without_specifics(
 360       ClientToServerResponseToValue(message, false /* include_specifics */));
 361   EXPECT_FALSE(value_without_specifics->empty());
 362   EXPECT_FALSE(ValueHasSpecifics(*(value_without_specifics.get()),
 363                                  "get_updates.entries"));
 364 }
 365
 366 TEST_F(ProtoValueConversionsTest, SyncAttachmentIdToValue) {
 367   TestSpecificsToValue(SyncAttachmentIdToValue);
 368 }
 369
 370 }  // namespace
 371 }  // namespace syncer