Home | History | Annotate | Download | only in drive
      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   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry));
     29 
     30   EXPECT_EQ("File 1.mp3",  entry.title());
     31   EXPECT_EQ("File 1.mp3",  entry.base_name());
     32   EXPECT_EQ("file:2_file_resource_id",  entry.resource_id());
     33   EXPECT_EQ(util::kDriveOtherDirSpecialResourceId,
     34             entry.parent_resource_id());
     35 
     36   EXPECT_FALSE(entry.deleted());
     37   EXPECT_FALSE(entry.shared_with_me());
     38 
     39   base::Time expected_creation_time;
     40   base::Time expected_modified_time;
     41 
     42   {
     43     // 2011-12-14T00:40:47.330Z
     44     base::Time::Exploded exploded;
     45     exploded.year = 2011;
     46     exploded.month = 12;
     47     exploded.day_of_month = 13;
     48     exploded.day_of_week = 2;  // Tuesday
     49     exploded.hour = 0;
     50     exploded.minute = 40;
     51     exploded.second = 47;
     52     exploded.millisecond = 330;
     53     expected_creation_time = base::Time::FromUTCExploded(exploded);
     54   }
     55 
     56   {
     57     // 2011-12-13T00:40:47.330Z
     58     base::Time::Exploded exploded;
     59     exploded.year = 2011;
     60     exploded.month = 12;
     61     exploded.day_of_month = 14;
     62     exploded.day_of_week = 3;  // Wednesday
     63     exploded.hour = 0;
     64     exploded.minute = 40;
     65     exploded.second = 47;
     66     exploded.millisecond = 330;
     67     expected_modified_time = base::Time::FromUTCExploded(exploded);
     68   }
     69 
     70   EXPECT_EQ(expected_modified_time.ToInternalValue(),
     71             entry.file_info().last_modified());
     72   // Last accessed value equal to 0 means that the file has never been viewed.
     73   EXPECT_EQ(0, entry.file_info().last_accessed());
     74   EXPECT_EQ(expected_creation_time.ToInternalValue(),
     75             entry.file_info().creation_time());
     76 
     77   EXPECT_EQ("audio/mpeg",
     78             entry.file_specific_info().content_mime_type());
     79   EXPECT_FALSE(entry.file_specific_info().is_hosted_document());
     80   EXPECT_EQ("",
     81             entry.file_specific_info().thumbnail_url());
     82   EXPECT_EQ("https://file_link_alternate/",
     83             entry.file_specific_info().alternate_url());
     84 
     85   // Regular file specific fields.
     86   EXPECT_EQ(892721,  entry.file_info().size());
     87   EXPECT_EQ("3b4382ebefec6e743578c76bbd0575ce",
     88             entry.file_specific_info().md5());
     89   EXPECT_FALSE(entry.file_info().is_directory());
     90 }
     91 
     92 TEST(ResourceEntryConversionTest,
     93      ConvertToResourceEntry_HostedDocument) {
     94   scoped_ptr<base::Value> value =
     95       google_apis::test_util::LoadJSONFile(
     96           "gdata/hosted_document_entry.json");
     97   ASSERT_TRUE(value.get());
     98 
     99   scoped_ptr<google_apis::ResourceEntry> gdata_resource_entry(
    100       google_apis::ResourceEntry::ExtractAndParse(*value));
    101   ASSERT_TRUE(gdata_resource_entry.get());
    102 
    103   ResourceEntry entry;
    104   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry));
    105 
    106   EXPECT_EQ("Document 1",  entry.title());
    107   EXPECT_EQ("Document 1.gdoc",  entry.base_name());  // The suffix added.
    108   EXPECT_EQ(".gdoc", entry.file_specific_info().document_extension());
    109   EXPECT_EQ("document:5_document_resource_id",  entry.resource_id());
    110   EXPECT_EQ(util::kDriveOtherDirSpecialResourceId,
    111             entry.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_thumbnail_link/",
    164             entry.file_specific_info().thumbnail_url());
    165   EXPECT_EQ("https://3_document_alternate_link/",
    166             entry.file_specific_info().alternate_url());
    167 
    168   // The size should be 0 for a hosted document.
    169   EXPECT_EQ(0,  entry.file_info().size());
    170   EXPECT_FALSE(entry.file_info().is_directory());
    171 }
    172 
    173 TEST(ResourceEntryConversionTest,
    174      ConvertToResourceEntry_Directory) {
    175   scoped_ptr<base::Value> value =
    176       google_apis::test_util::LoadJSONFile(
    177           "gdata/directory_entry.json");
    178   ASSERT_TRUE(value.get());
    179 
    180   scoped_ptr<google_apis::ResourceEntry> gdata_resource_entry(
    181       google_apis::ResourceEntry::ExtractAndParse(*value));
    182   ASSERT_TRUE(gdata_resource_entry.get());
    183 
    184   ResourceEntry entry;
    185   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry));
    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",  entry.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   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry));
    257 
    258   EXPECT_EQ("Deleted document",  entry.title());
    259   EXPECT_EQ("Deleted document.gdoc",  entry.base_name());
    260   EXPECT_EQ("document:deleted_in_root_id",  entry.resource_id());
    261   EXPECT_EQ(util::kDriveOtherDirSpecialResourceId,
    262             entry.parent_resource_id());
    263 
    264   EXPECT_TRUE(entry.deleted());  // The document was deleted.
    265   EXPECT_FALSE(entry.shared_with_me());
    266 
    267   // 2012-04-10T22:50:55.797Z
    268   base::Time::Exploded exploded;
    269   exploded.year = 2012;
    270   exploded.month = 04;
    271   exploded.day_of_month = 10;
    272   exploded.day_of_week = 2;  // Tuesday
    273   exploded.hour = 22;
    274   exploded.minute = 50;
    275   exploded.second = 55;
    276   exploded.millisecond = 797;
    277   const base::Time expected_last_modified_time =
    278       base::Time::FromUTCExploded(exploded);
    279 
    280   // 2012-04-10T22:50:53.237Z
    281   exploded.year = 2012;
    282   exploded.month = 04;
    283   exploded.day_of_month = 10;
    284   exploded.day_of_week = 2;  // Tuesday
    285   exploded.hour = 22;
    286   exploded.minute = 50;
    287   exploded.second = 53;
    288   exploded.millisecond = 237;
    289   const base::Time expected_creation_time =
    290       base::Time::FromUTCExploded(exploded);
    291 
    292   // 2012-04-10T22:50:55.797Z
    293   exploded.year = 2012;
    294   exploded.month = 04;
    295   exploded.day_of_month = 10;
    296   exploded.day_of_week = 2;  // Tuesday
    297   exploded.hour = 22;
    298   exploded.minute = 50;
    299   exploded.second = 55;
    300   exploded.millisecond = 797;
    301   const base::Time expected_last_accessed_time =
    302       base::Time::FromUTCExploded(exploded);
    303 
    304   EXPECT_EQ(expected_last_modified_time.ToInternalValue(),
    305             entry.file_info().last_modified());
    306   EXPECT_EQ(expected_last_accessed_time.ToInternalValue(),
    307             entry.file_info().last_accessed());
    308   EXPECT_EQ(expected_creation_time.ToInternalValue(),
    309             entry.file_info().creation_time());
    310 
    311   EXPECT_EQ("text/html",
    312             entry.file_specific_info().content_mime_type());
    313   EXPECT_TRUE(entry.file_specific_info().is_hosted_document());
    314   EXPECT_EQ("",
    315             entry.file_specific_info().thumbnail_url());
    316   EXPECT_EQ("https://alternate/document%3Adeleted_in_root_id/edit",
    317             entry.file_specific_info().alternate_url());
    318 
    319   // The size should be 0 for a hosted document.
    320   EXPECT_EQ(0,  entry.file_info().size());
    321 }
    322 
    323 TEST(ResourceEntryConversionTest,
    324      ConvertToResourceEntry_SharedWithMeEntry) {
    325   scoped_ptr<base::Value> value = google_apis::test_util::LoadJSONFile(
    326       "gdata/shared_with_me_entry.json");
    327   ASSERT_TRUE(value.get());
    328 
    329   scoped_ptr<google_apis::ResourceEntry> gdata_resource_entry(
    330       google_apis::ResourceEntry::ExtractAndParse(*value));
    331   ASSERT_TRUE(gdata_resource_entry.get());
    332 
    333   ResourceEntry entry;
    334   EXPECT_TRUE(ConvertToResourceEntry(*gdata_resource_entry, &entry));
    335 
    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 }  // namespace drive
    388