Home | History | Annotate | Download | only in file_manager
      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 "base/stl_util.h"
      6 #include "chrome/browser/extensions/extension_apitest.h"
      7 #include "chromeos/dbus/cros_disks_client.h"
      8 #include "chromeos/disks/mock_disk_mount_manager.h"
      9 
     10 using ::testing::_;
     11 using ::testing::ReturnRef;
     12 
     13 using chromeos::disks::DiskMountManager;
     14 
     15 namespace {
     16 
     17 struct TestDiskInfo {
     18   const char* system_path;
     19   const char* file_path;
     20   const char* device_label;
     21   const char* drive_label;
     22   const char* vendor_id;
     23   const char* vendor_name;
     24   const char* product_id;
     25   const char* product_name;
     26   const char* fs_uuid;
     27   const char* system_path_prefix;
     28   chromeos::DeviceType device_type;
     29   uint64 size_in_bytes;
     30   bool is_parent;
     31   bool is_read_only;
     32   bool has_media;
     33   bool on_boot_device;
     34   bool is_hidden;
     35 };
     36 
     37 struct TestMountPoint {
     38   std::string source_path;
     39   std::string mount_path;
     40   chromeos::MountType mount_type;
     41   chromeos::disks::MountCondition mount_condition;
     42 
     43   // -1 if there is no disk info.
     44   int disk_info_index;
     45 };
     46 
     47 TestDiskInfo kTestDisks[] = {
     48   {
     49     "system_path1",
     50     "file_path1",
     51     "device_label1",
     52     "drive_label1",
     53     "0123",
     54     "vendor1",
     55     "abcd",
     56     "product1",
     57     "FFFF-FFFF",
     58     "system_path_prefix1",
     59     chromeos::DEVICE_TYPE_USB,
     60     1073741824,
     61     false,
     62     false,
     63     false,
     64     false,
     65     false
     66   },
     67   {
     68     "system_path2",
     69     "file_path2",
     70     "device_label2",
     71     "drive_label2",
     72     "4567",
     73     "vendor2",
     74     "cdef",
     75     "product2",
     76     "0FFF-FFFF",
     77     "system_path_prefix2",
     78     chromeos::DEVICE_TYPE_MOBILE,
     79     47723,
     80     true,
     81     true,
     82     true,
     83     true,
     84     false
     85   },
     86   {
     87     "system_path3",
     88     "file_path3",
     89     "device_label3",
     90     "drive_label3",
     91     "89ab",
     92     "vendor3",
     93     "ef01",
     94     "product3",
     95     "00FF-FFFF",
     96     "system_path_prefix3",
     97     chromeos::DEVICE_TYPE_OPTICAL_DISC,
     98     0,
     99     true,
    100     false,
    101     false,
    102     true,
    103     false
    104   }
    105 };
    106 
    107 }  // namespace
    108 
    109 class ExtensionFileBrowserPrivateApiTest : public ExtensionApiTest {
    110  public:
    111   ExtensionFileBrowserPrivateApiTest()
    112       : disk_mount_manager_mock_(NULL) {
    113     InitMountPoints();
    114   }
    115 
    116   virtual ~ExtensionFileBrowserPrivateApiTest() {
    117     DCHECK(!disk_mount_manager_mock_);
    118     STLDeleteValues(&volumes_);
    119   }
    120 
    121   // ExtensionApiTest override
    122   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
    123     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
    124 
    125     disk_mount_manager_mock_ = new chromeos::disks::MockDiskMountManager;
    126     chromeos::disks::DiskMountManager::InitializeForTesting(
    127         disk_mount_manager_mock_);
    128     disk_mount_manager_mock_->SetupDefaultReplies();
    129 
    130     // OVERRIDE FindDiskBySourcePath mock function.
    131     ON_CALL(*disk_mount_manager_mock_, FindDiskBySourcePath(_)).
    132         WillByDefault(Invoke(
    133             this, &ExtensionFileBrowserPrivateApiTest::FindVolumeBySourcePath));
    134   }
    135 
    136   // ExtensionApiTest override
    137   virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
    138     chromeos::disks::DiskMountManager::Shutdown();
    139     disk_mount_manager_mock_ = NULL;
    140 
    141     ExtensionApiTest::TearDownInProcessBrowserTestFixture();
    142   }
    143 
    144  private:
    145   void InitMountPoints() {
    146     const TestMountPoint kTestMountPoints[] = {
    147       {
    148         "device_path1",
    149         chromeos::CrosDisksClient::GetRemovableDiskMountPoint().AppendASCII(
    150             "mount_path1").AsUTF8Unsafe(),
    151         chromeos::MOUNT_TYPE_DEVICE,
    152         chromeos::disks::MOUNT_CONDITION_NONE,
    153         0
    154       },
    155       {
    156         "device_path2",
    157         chromeos::CrosDisksClient::GetRemovableDiskMountPoint().AppendASCII(
    158             "mount_path2").AsUTF8Unsafe(),
    159         chromeos::MOUNT_TYPE_DEVICE,
    160         chromeos::disks::MOUNT_CONDITION_NONE,
    161         1
    162       },
    163       {
    164         "device_path3",
    165         chromeos::CrosDisksClient::GetRemovableDiskMountPoint().AppendASCII(
    166             "mount_path3").AsUTF8Unsafe(),
    167         chromeos::MOUNT_TYPE_DEVICE,
    168         chromeos::disks::MOUNT_CONDITION_NONE,
    169         2
    170       },
    171       {
    172         "archive_path",
    173         chromeos::CrosDisksClient::GetArchiveMountPoint().AppendASCII(
    174             "archive_mount_path").AsUTF8Unsafe(),
    175         chromeos::MOUNT_TYPE_ARCHIVE,
    176         chromeos::disks::MOUNT_CONDITION_NONE,
    177         -1
    178       }
    179     };
    180 
    181     for (size_t i = 0; i < arraysize(kTestMountPoints); i++) {
    182       mount_points_.insert(DiskMountManager::MountPointMap::value_type(
    183           kTestMountPoints[i].mount_path,
    184           DiskMountManager::MountPointInfo(kTestMountPoints[i].source_path,
    185                                            kTestMountPoints[i].mount_path,
    186                                            kTestMountPoints[i].mount_type,
    187                                            kTestMountPoints[i].mount_condition)
    188       ));
    189       int disk_info_index = kTestMountPoints[i].disk_info_index;
    190       if (kTestMountPoints[i].disk_info_index >= 0) {
    191         EXPECT_GT(arraysize(kTestDisks), static_cast<size_t>(disk_info_index));
    192         if (static_cast<size_t>(disk_info_index) >= arraysize(kTestDisks))
    193           return;
    194 
    195         volumes_.insert(DiskMountManager::DiskMap::value_type(
    196             kTestMountPoints[i].source_path,
    197             new DiskMountManager::Disk(
    198                 kTestMountPoints[i].source_path,
    199                 kTestMountPoints[i].mount_path,
    200                 kTestDisks[disk_info_index].system_path,
    201                 kTestDisks[disk_info_index].file_path,
    202                 kTestDisks[disk_info_index].device_label,
    203                 kTestDisks[disk_info_index].drive_label,
    204                 kTestDisks[disk_info_index].vendor_id,
    205                 kTestDisks[disk_info_index].vendor_name,
    206                 kTestDisks[disk_info_index].product_id,
    207                 kTestDisks[disk_info_index].product_name,
    208                 kTestDisks[disk_info_index].fs_uuid,
    209                 kTestDisks[disk_info_index].system_path_prefix,
    210                 kTestDisks[disk_info_index].device_type,
    211                 kTestDisks[disk_info_index].size_in_bytes,
    212                 kTestDisks[disk_info_index].is_parent,
    213                 kTestDisks[disk_info_index].is_read_only,
    214                 kTestDisks[disk_info_index].has_media,
    215                 kTestDisks[disk_info_index].on_boot_device,
    216                 kTestDisks[disk_info_index].is_hidden
    217             )
    218         ));
    219       }
    220     }
    221   }
    222 
    223   const DiskMountManager::Disk* FindVolumeBySourcePath(
    224       const std::string& source_path) {
    225     DiskMountManager::DiskMap::const_iterator volume_it =
    226         volumes_.find(source_path);
    227     return (volume_it == volumes_.end()) ? NULL : volume_it->second;
    228   }
    229 
    230  protected:
    231   chromeos::disks::MockDiskMountManager* disk_mount_manager_mock_;
    232   DiskMountManager::DiskMap volumes_;
    233   DiskMountManager::MountPointMap mount_points_;
    234 };
    235 
    236 IN_PROC_BROWSER_TEST_F(ExtensionFileBrowserPrivateApiTest, FileBrowserMount) {
    237   // We will call fileBrowserPrivate.unmountVolume once. To test that method, we
    238   // check that UnmountPath is really called with the same value.
    239   EXPECT_CALL(*disk_mount_manager_mock_, UnmountPath(_, _,  _))
    240       .Times(0);
    241   EXPECT_CALL(*disk_mount_manager_mock_,
    242               UnmountPath(
    243                   chromeos::CrosDisksClient::GetArchiveMountPoint().AppendASCII(
    244                       "archive_mount_path").AsUTF8Unsafe(),
    245                   chromeos::UNMOUNT_OPTIONS_NONE, _)).Times(1);
    246 
    247   EXPECT_CALL(*disk_mount_manager_mock_, disks())
    248       .WillRepeatedly(ReturnRef(volumes_));
    249 
    250   EXPECT_CALL(*disk_mount_manager_mock_, mount_points())
    251       .WillRepeatedly(ReturnRef(mount_points_));
    252 
    253   ASSERT_TRUE(RunComponentExtensionTest("filebrowser_mount"))  << message_;
    254 }
    255