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