src/chrome/browser/chromeos/drive/resource_entry_conversion_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 #include "chrome/browser/chromeos/drive/resource_entry_conversion.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/time/time.h"
   9 #include "base/values.h"
  10 #include "chrome/browser/chromeos/drive/drive.pb.h"
  11 #include "chrome/browser/chromeos/drive/file_system_util.h"
  12 #include "chrome/browser/chromeos/drive/test_util.h"
  13 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace drive {
  17
  18 TEST(ResourceEntryConversionTest, ConvertToResourceEntry_File) {
  19   scoped_ptr<base::Value> value =
  20       google_apis::test_util::LoadJSONFile("gdata/file_entry.json");
  21   ASSERT_TRUE(value.get());
  22
  23   scoped_ptr<google_apis::ResourceEntry> gdata_resource_entry(
  24       google_apis::ResourceEntry::ExtractAndParse(*value));
  25   ASSERT_TRUE(gdata_resource_entry.get());
  26
  27   ResourceEntry entry;
  28   std::string parent_resource_id;
  29   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry,
  30                                      &parent_resource_id));
  31
  32   EXPECT_EQ("File 1.mp3", entry.title());
  33   EXPECT_EQ("File 1.mp3", entry.base_name());
  34   EXPECT_EQ("file:2_file_resource_id", entry.resource_id());
  35   EXPECT_EQ(util::kDriveOtherDirSpecialResourceId, parent_resource_id);
  36
  37   EXPECT_FALSE(entry.deleted());
  38   EXPECT_FALSE(entry.shared_with_me());
  39
  40   base::Time expected_creation_time;
  41   base::Time expected_modified_time;
  42
  43   {
  44     // 2011-12-14T00:40:47.330Z
  45     base::Time::Exploded exploded;
  46     exploded.year = 2011;
  47     exploded.month = 12;
  48     exploded.day_of_month = 13;
  49     exploded.day_of_week = 2;  // Tuesday
  50     exploded.hour = 0;
  51     exploded.minute = 40;
  52     exploded.second = 47;
  53     exploded.millisecond = 330;
  54     expected_creation_time = base::Time::FromUTCExploded(exploded);
  55   }
  56
  57   {
  58     // 2011-12-13T00:40:47.330Z
  59     base::Time::Exploded exploded;
  60     exploded.year = 2011;
  61     exploded.month = 12;
  62     exploded.day_of_month = 14;
  63     exploded.day_of_week = 3;  // Wednesday
  64     exploded.hour = 0;
  65     exploded.minute = 40;
  66     exploded.second = 47;
  67     exploded.millisecond = 330;
  68     expected_modified_time = base::Time::FromUTCExploded(exploded);
  69   }
  70
  71   EXPECT_EQ(expected_modified_time.ToInternalValue(),
  72             entry.file_info().last_modified());
  73   // Last accessed value equal to 0 means that the file has never been viewed.
  74   EXPECT_EQ(0, entry.file_info().last_accessed());
  75   EXPECT_EQ(expected_creation_time.ToInternalValue(),
  76             entry.file_info().creation_time());
  77
  78   EXPECT_EQ("audio/mpeg",
  79             entry.file_specific_info().content_mime_type());
  80   EXPECT_FALSE(entry.file_specific_info().is_hosted_document());
  81   EXPECT_EQ("https://file_link_alternate/",
  82             entry.file_specific_info().alternate_url());
  83
  84   // Regular file specific fields.
  85   EXPECT_EQ(892721, entry.file_info().size());
  86   EXPECT_EQ("3b4382ebefec6e743578c76bbd0575ce",
  87             entry.file_specific_info().md5());
  88   EXPECT_FALSE(entry.file_info().is_directory());
  89 }
  90
  91 TEST(ResourceEntryConversionTest,
  92      ConvertToResourceEntry_HostedDocument) {
  93   scoped_ptr<base::Value> value =
  94       google_apis::test_util::LoadJSONFile(
  95           "gdata/hosted_document_entry.json");
  96   ASSERT_TRUE(value.get());
  97
  98   scoped_ptr<google_apis::ResourceEntry> gdata_resource_entry(
  99       google_apis::ResourceEntry::ExtractAndParse(*value));
 100   ASSERT_TRUE(gdata_resource_entry.get());
 101
 102   ResourceEntry entry;
 103   std::string parent_resource_id;
 104   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry,
 105                                      &parent_resource_id));
 106
 107   EXPECT_EQ("Document 1", entry.title());
 108   EXPECT_EQ("Document 1.gdoc", entry.base_name());  // The suffix added.
 109   EXPECT_EQ(".gdoc", entry.file_specific_info().document_extension());
 110   EXPECT_EQ("document:5_document_resource_id", entry.resource_id());
 111   EXPECT_EQ(util::kDriveOtherDirSpecialResourceId, parent_resource_id);
 112
 113   EXPECT_FALSE(entry.deleted());
 114   EXPECT_FALSE(entry.shared_with_me());
 115
 116   // 2011-12-12T23:28:52.783Z
 117   base::Time::Exploded exploded;
 118   exploded.year = 2011;
 119   exploded.month = 12;
 120   exploded.day_of_month = 12;
 121   exploded.day_of_week = 1;  // Monday
 122   exploded.hour = 23;
 123   exploded.minute = 28;
 124   exploded.second = 52;
 125   exploded.millisecond = 783;
 126   const base::Time expected_last_modified_time =
 127       base::Time::FromUTCExploded(exploded);
 128
 129   // 2011-12-12T23:28:46.686Z
 130   exploded.year = 2011;
 131   exploded.month = 12;
 132   exploded.day_of_month = 12;
 133   exploded.day_of_week = 1;  // Monday
 134   exploded.hour = 23;
 135   exploded.minute = 28;
 136   exploded.second = 46;
 137   exploded.millisecond = 686;
 138   const base::Time expected_creation_time =
 139       base::Time::FromUTCExploded(exploded);
 140
 141   // 2011-12-13T02:12:18.527Z
 142   exploded.year = 2011;
 143   exploded.month = 12;
 144   exploded.day_of_month = 13;
 145   exploded.day_of_week = 2;  // Tuesday
 146   exploded.hour = 2;
 147   exploded.minute = 12;
 148   exploded.second = 18;
 149   exploded.millisecond = 527;
 150   const base::Time expected_last_accessed_time =
 151       base::Time::FromUTCExploded(exploded);
 152
 153   EXPECT_EQ(expected_last_modified_time.ToInternalValue(),
 154             entry.file_info().last_modified());
 155   EXPECT_EQ(expected_last_accessed_time.ToInternalValue(),
 156             entry.file_info().last_accessed());
 157   EXPECT_EQ(expected_creation_time.ToInternalValue(),
 158             entry.file_info().creation_time());
 159
 160   EXPECT_EQ("text/html",
 161             entry.file_specific_info().content_mime_type());
 162   EXPECT_TRUE(entry.file_specific_info().is_hosted_document());
 163   EXPECT_EQ("https://3_document_alternate_link/",
 164             entry.file_specific_info().alternate_url());
 165
 166   // The size should be 0 for a hosted document.
 167   EXPECT_EQ(0, entry.file_info().size());
 168   EXPECT_FALSE(entry.file_info().is_directory());
 169 }
 170
 171 TEST(ResourceEntryConversionTest,
 172      ConvertToResourceEntry_Directory) {
 173   scoped_ptr<base::Value> value =
 174       google_apis::test_util::LoadJSONFile(
 175           "gdata/directory_entry.json");
 176   ASSERT_TRUE(value.get());
 177
 178   scoped_ptr<google_apis::ResourceEntry> gdata_resource_entry(
 179       google_apis::ResourceEntry::ExtractAndParse(*value));
 180   ASSERT_TRUE(gdata_resource_entry.get());
 181
 182   ResourceEntry entry;
 183   std::string parent_resource_id;
 184   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry,
 185                                      &parent_resource_id));
 186
 187   EXPECT_EQ("Sub Directory Folder", entry.title());
 188   EXPECT_EQ("Sub Directory Folder", entry.base_name());
 189   EXPECT_EQ("folder:sub_dir_folder_resource_id", entry.resource_id());
 190   // The parent resource ID should be obtained as this is a sub directory
 191   // under a non-root directory.
 192   EXPECT_EQ("folder:1_folder_resource_id", parent_resource_id);
 193
 194   EXPECT_FALSE(entry.deleted());
 195   EXPECT_FALSE(entry.shared_with_me());
 196
 197   // 2011-04-01T18:34:08.234Z
 198   base::Time::Exploded exploded;
 199   exploded.year = 2011;
 200   exploded.month = 04;
 201   exploded.day_of_month = 01;
 202   exploded.day_of_week = 5;  // Friday
 203   exploded.hour = 18;
 204   exploded.minute = 34;
 205   exploded.second = 8;
 206   exploded.millisecond = 234;
 207   const base::Time expected_last_modified_time =
 208       base::Time::FromUTCExploded(exploded);
 209
 210   // 2010-11-07T05:03:54.719Z
 211   exploded.year = 2010;
 212   exploded.month = 11;
 213   exploded.day_of_month = 7;
 214   exploded.day_of_week = 0;  // Sunday
 215   exploded.hour = 5;
 216   exploded.minute = 3;
 217   exploded.second = 54;
 218   exploded.millisecond = 719;
 219   const base::Time expected_creation_time =
 220       base::Time::FromUTCExploded(exploded);
 221
 222   // 2011-11-02T04:37:38.469Z
 223   exploded.year = 2011;
 224   exploded.month = 11;
 225   exploded.day_of_month = 2;
 226   exploded.day_of_week = 2;  // Tuesday
 227   exploded.hour = 4;
 228   exploded.minute = 37;
 229   exploded.second = 38;
 230   exploded.millisecond = 469;
 231   const base::Time expected_last_accessed_time =
 232       base::Time::FromUTCExploded(exploded);
 233
 234   EXPECT_EQ(expected_last_modified_time.ToInternalValue(),
 235             entry.file_info().last_modified());
 236   EXPECT_EQ(expected_last_accessed_time.ToInternalValue(),
 237             entry.file_info().last_accessed());
 238   EXPECT_EQ(expected_creation_time.ToInternalValue(),
 239             entry.file_info().creation_time());
 240
 241   EXPECT_TRUE(entry.file_info().is_directory());
 242 }
 243
 244 TEST(ResourceEntryConversionTest,
 245      ConvertToResourceEntry_DeletedHostedDocument) {
 246   scoped_ptr<base::Value> value =
 247       google_apis::test_util::LoadJSONFile(
 248           "gdata/deleted_hosted_document_entry.json");
 249   ASSERT_TRUE(value.get());
 250
 251   scoped_ptr<google_apis::ResourceEntry> gdata_resource_entry(
 252       google_apis::ResourceEntry::ExtractAndParse(*value));
 253   ASSERT_TRUE(gdata_resource_entry.get());
 254
 255   ResourceEntry entry;
 256   std::string parent_resource_id;
 257   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry,
 258                                      &parent_resource_id));
 259
 260   EXPECT_EQ("Deleted document", entry.title());
 261   EXPECT_EQ("Deleted document.gdoc", entry.base_name());
 262   EXPECT_EQ("document:deleted_in_root_id", entry.resource_id());
 263   EXPECT_EQ(util::kDriveOtherDirSpecialResourceId, parent_resource_id);
 264
 265   EXPECT_TRUE(entry.deleted());  // The document was deleted.
 266   EXPECT_FALSE(entry.shared_with_me());
 267
 268   // 2012-04-10T22:50:55.797Z
 269   base::Time::Exploded exploded;
 270   exploded.year = 2012;
 271   exploded.month = 04;
 272   exploded.day_of_month = 10;
 273   exploded.day_of_week = 2;  // Tuesday
 274   exploded.hour = 22;
 275   exploded.minute = 50;
 276   exploded.second = 55;
 277   exploded.millisecond = 797;
 278   const base::Time expected_last_modified_time =
 279       base::Time::FromUTCExploded(exploded);
 280
 281   // 2012-04-10T22:50:53.237Z
 282   exploded.year = 2012;
 283   exploded.month = 04;
 284   exploded.day_of_month = 10;
 285   exploded.day_of_week = 2;  // Tuesday
 286   exploded.hour = 22;
 287   exploded.minute = 50;
 288   exploded.second = 53;
 289   exploded.millisecond = 237;
 290   const base::Time expected_creation_time =
 291       base::Time::FromUTCExploded(exploded);
 292
 293   // 2012-04-10T22:50:55.797Z
 294   exploded.year = 2012;
 295   exploded.month = 04;
 296   exploded.day_of_month = 10;
 297   exploded.day_of_week = 2;  // Tuesday
 298   exploded.hour = 22;
 299   exploded.minute = 50;
 300   exploded.second = 55;
 301   exploded.millisecond = 797;
 302   const base::Time expected_last_accessed_time =
 303       base::Time::FromUTCExploded(exploded);
 304
 305   EXPECT_EQ(expected_last_modified_time.ToInternalValue(),
 306             entry.file_info().last_modified());
 307   EXPECT_EQ(expected_last_accessed_time.ToInternalValue(),
 308             entry.file_info().last_accessed());
 309   EXPECT_EQ(expected_creation_time.ToInternalValue(),
 310             entry.file_info().creation_time());
 311
 312   EXPECT_EQ("text/html",
 313             entry.file_specific_info().content_mime_type());
 314   EXPECT_TRUE(entry.file_specific_info().is_hosted_document());
 315   EXPECT_EQ("https://alternate/document%3Adeleted_in_root_id/edit",
 316             entry.file_specific_info().alternate_url());
 317
 318   // The size should be 0 for a hosted document.
 319   EXPECT_EQ(0, entry.file_info().size());
 320 }
 321
 322 TEST(ResourceEntryConversionTest,
 323      ConvertToResourceEntry_SharedWithMeEntry) {
 324   scoped_ptr<base::Value> value = google_apis::test_util::LoadJSONFile(
 325       "gdata/shared_with_me_entry.json");
 326   ASSERT_TRUE(value.get());
 327
 328   scoped_ptr<google_apis::ResourceEntry> gdata_resource_entry(
 329       google_apis::ResourceEntry::ExtractAndParse(*value));
 330   ASSERT_TRUE(gdata_resource_entry.get());
 331
 332   ResourceEntry entry;
 333   std::string parent_resource_id;
 334   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry,
 335                                      &parent_resource_id));
 336   EXPECT_TRUE(entry.shared_with_me());
 337 }
 338
 339 TEST(ResourceEntryConversionTest, ToPlatformFileInfo) {
 340   ResourceEntry entry;
 341   entry.mutable_file_info()->set_size(12345);
 342   entry.mutable_file_info()->set_is_directory(true);
 343   entry.mutable_file_info()->set_is_symbolic_link(true);
 344   entry.mutable_file_info()->set_creation_time(999);
 345   entry.mutable_file_info()->set_last_modified(123456789);
 346   entry.mutable_file_info()->set_last_accessed(987654321);
 347
 348   base::PlatformFileInfo file_info;
 349   ConvertResourceEntryToPlatformFileInfo(entry, &file_info);
 350   EXPECT_EQ(entry.file_info().size(), file_info.size);
 351   EXPECT_EQ(entry.file_info().is_directory(), file_info.is_directory);
 352   EXPECT_EQ(entry.file_info().is_symbolic_link(), file_info.is_symbolic_link);
 353   EXPECT_EQ(base::Time::FromInternalValue(entry.file_info().creation_time()),
 354             file_info.creation_time);
 355   EXPECT_EQ(base::Time::FromInternalValue(entry.file_info().last_modified()),
 356             file_info.last_modified);
 357   EXPECT_EQ(base::Time::FromInternalValue(entry.file_info().last_accessed()),
 358             file_info.last_accessed);
 359 }
 360
 361 TEST(ResourceEntryConversionTest, FromPlatformFileInfo) {
 362   base::PlatformFileInfo file_info;
 363   file_info.size = 12345;
 364   file_info.is_directory = true;
 365   file_info.is_symbolic_link = true;
 366   file_info.last_modified =
 367       base::Time::UnixEpoch() + base::TimeDelta::FromDays(999);
 368   file_info.last_accessed =
 369       base::Time::UnixEpoch() + base::TimeDelta::FromDays(12345);
 370   file_info.creation_time =
 371       base::Time::UnixEpoch() + base::TimeDelta::FromDays(54321);
 372
 373   ResourceEntry entry;
 374   SetPlatformFileInfoToResourceEntry(file_info, &entry);
 375
 376   EXPECT_EQ(file_info.size, entry.file_info().size());
 377   EXPECT_EQ(file_info.is_directory, entry.file_info().is_directory());
 378   EXPECT_EQ(file_info.is_symbolic_link, entry.file_info().is_symbolic_link());
 379   EXPECT_EQ(file_info.creation_time,
 380             base::Time::FromInternalValue(entry.file_info().creation_time()));
 381   EXPECT_EQ(file_info.last_modified,
 382             base::Time::FromInternalValue(entry.file_info().last_modified()));
 383   EXPECT_EQ(file_info.last_accessed,
 384             base::Time::FromInternalValue(entry.file_info().last_accessed()));
 385 }
 386
 387 TEST(ResourceEntryConversionTest, ConvertToResourceEntry_ImageMediaMetadata) {
 388   google_apis::ResourceEntry entry_all_fields;
 389   google_apis::ResourceEntry entry_zero_fields;
 390   google_apis::ResourceEntry entry_no_fields;
 391
 392   entry_all_fields.set_image_width(640);
 393   entry_all_fields.set_image_height(480);
 394   entry_all_fields.set_image_rotation(90);
 395   entry_all_fields.set_kind(google_apis::ENTRY_KIND_FILE);
 396
 397   entry_zero_fields.set_image_width(0);
 398   entry_zero_fields.set_image_height(0);
 399   entry_zero_fields.set_image_rotation(0);
 400   entry_zero_fields.set_kind(google_apis::ENTRY_KIND_FILE);
 401
 402   entry_no_fields.set_kind(google_apis::ENTRY_KIND_FILE);
 403
 404   {
 405     ResourceEntry entry;
 406     std::string parent_resource_id;
 407     EXPECT_TRUE(ConvertToResourceEntry(entry_all_fields, &entry,
 408                                        &parent_resource_id));
 409     EXPECT_EQ(640, entry.file_specific_info().image_width());
 410     EXPECT_EQ(480, entry.file_specific_info().image_height());
 411     EXPECT_EQ(90, entry.file_specific_info().image_rotation());
 412   }
 413   {
 414     ResourceEntry entry;
 415     std::string parent_resource_id;
 416     EXPECT_TRUE(ConvertToResourceEntry(entry_zero_fields, &entry,
 417                                        &parent_resource_id));
 418     EXPECT_TRUE(entry.file_specific_info().has_image_width());
 419     EXPECT_TRUE(entry.file_specific_info().has_image_height());
 420     EXPECT_TRUE(entry.file_specific_info().has_image_rotation());
 421     EXPECT_EQ(0, entry.file_specific_info().image_width());
 422     EXPECT_EQ(0, entry.file_specific_info().image_height());
 423     EXPECT_EQ(0, entry.file_specific_info().image_rotation());
 424   }
 425   {
 426     ResourceEntry entry;
 427     std::string parent_resource_id;
 428     EXPECT_TRUE(ConvertToResourceEntry(entry_no_fields, &entry,
 429                                        &parent_resource_id));
 430     EXPECT_FALSE(entry.file_specific_info().has_image_width());
 431     EXPECT_FALSE(entry.file_specific_info().has_image_height());
 432     EXPECT_FALSE(entry.file_specific_info().has_image_rotation());
 433   }
 434 }
 435
 436 }  // namespace drive