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