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