src/chrome/browser/storage_monitor/storage_monitor_mac_unittest.mm

   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/storage_monitor/storage_monitor_mac.h"
   6
   7 #include "base/file_util.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/mac/foundation_util.h"
  10 #include "base/run_loop.h"
  11 #include "base/strings/sys_string_conversions.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "chrome/browser/storage_monitor/mock_removable_storage_observer.h"
  14 #include "chrome/browser/storage_monitor/removable_device_constants.h"
  15 #include "chrome/browser/storage_monitor/storage_info.h"
  16 #include "chrome/browser/storage_monitor/test_storage_monitor.h"
  17 #include "chrome/test/base/testing_browser_process.h"
  18 #include "content/public/test/test_browser_thread_bundle.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 uint64 kTestSize = 1000000ULL;
  22
  23 namespace {
  24
  25 StorageInfo CreateStorageInfo(
  26     const std::string& device_id,
  27     const std::string& model_name,
  28     const base::FilePath& mount_point,
  29     uint64 size_bytes) {
  30   return StorageInfo(
  31       device_id, base::string16(), mount_point.value(),
  32       base::string16(), base::string16(), base::UTF8ToUTF16(model_name),
  33       size_bytes);
  34 }
  35
  36 }  // namespace
  37
  38 class StorageMonitorMacTest : public testing::Test {
  39  public:
  40   StorageMonitorMacTest() {}
  41
  42   virtual void SetUp() OVERRIDE {
  43     TestStorageMonitor::RemoveSingleton();
  44     monitor_ = new StorageMonitorMac;
  45     scoped_ptr<StorageMonitor> pass_monitor(monitor_);
  46     TestingBrowserProcess* browser_process = TestingBrowserProcess::GetGlobal();
  47     DCHECK(browser_process);
  48     browser_process->SetStorageMonitor(pass_monitor.Pass());
  49
  50     mock_storage_observer_.reset(new MockRemovableStorageObserver);
  51     monitor_->AddObserver(mock_storage_observer_.get());
  52
  53     unique_id_ = "test_id";
  54     mount_point_ = base::FilePath("/unused_test_directory");
  55     device_id_ = StorageInfo::MakeDeviceId(
  56         StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM, unique_id_);
  57     disk_info_ = CreateStorageInfo(device_id_, "",
  58                                    mount_point_, kTestSize);
  59   }
  60
  61   void UpdateDisk(StorageInfo info, StorageMonitorMac::UpdateType update_type) {
  62     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
  63         base::Bind(&StorageMonitorMac::UpdateDisk,
  64                    base::Unretained(monitor_),
  65                    "dummy_bsd_name", info, update_type));
  66     base::RunLoop().RunUntilIdle();
  67   }
  68
  69  protected:
  70   content::TestBrowserThreadBundle thread_bundle_;
  71
  72   scoped_ptr<MockRemovableStorageObserver> mock_storage_observer_;
  73
  74   // Information about the disk.
  75   std::string unique_id_;
  76   base::FilePath mount_point_;
  77   std::string device_id_;
  78   StorageInfo disk_info_;
  79
  80   StorageMonitorMac* monitor_;
  81 };
  82
  83 TEST_F(StorageMonitorMacTest, AddRemove) {
  84   UpdateDisk(disk_info_, StorageMonitorMac::UPDATE_DEVICE_ADDED);
  85
  86   EXPECT_EQ(1, mock_storage_observer_->attach_calls());
  87   EXPECT_EQ(0, mock_storage_observer_->detach_calls());
  88   EXPECT_EQ(device_id_, mock_storage_observer_->last_attached().device_id());
  89   EXPECT_EQ(base::string16(), mock_storage_observer_->last_attached().name());
  90   EXPECT_EQ(mount_point_.value(),
  91             mock_storage_observer_->last_attached().location());
  92
  93   UpdateDisk(disk_info_, StorageMonitorMac::UPDATE_DEVICE_REMOVED);
  94
  95   EXPECT_EQ(1, mock_storage_observer_->attach_calls());
  96   EXPECT_EQ(1, mock_storage_observer_->detach_calls());
  97   EXPECT_EQ(device_id_, mock_storage_observer_->last_detached().device_id());
  98 }
  99
 100 TEST_F(StorageMonitorMacTest, UpdateVolumeName) {
 101   UpdateDisk(disk_info_, StorageMonitorMac::UPDATE_DEVICE_ADDED);
 102
 103   EXPECT_EQ(1, mock_storage_observer_->attach_calls());
 104   EXPECT_EQ(0, mock_storage_observer_->detach_calls());
 105   EXPECT_EQ(device_id_, mock_storage_observer_->last_attached().device_id());
 106   EXPECT_EQ(base::string16(), mock_storage_observer_->last_attached().name());
 107   EXPECT_EQ(kTestSize,
 108             mock_storage_observer_->last_attached().total_size_in_bytes());
 109   EXPECT_EQ(mount_point_.value(),
 110             mock_storage_observer_->last_attached().location());
 111
 112   StorageInfo info2 = CreateStorageInfo(
 113       device_id_, "", mount_point_, kTestSize * 2);
 114   UpdateDisk(info2, StorageMonitorMac::UPDATE_DEVICE_CHANGED);
 115   base::RunLoop().RunUntilIdle();
 116
 117   EXPECT_EQ(1, mock_storage_observer_->detach_calls());
 118   EXPECT_EQ(device_id_, mock_storage_observer_->last_detached().device_id());
 119   EXPECT_EQ(2, mock_storage_observer_->attach_calls());
 120   EXPECT_EQ(device_id_, mock_storage_observer_->last_attached().device_id());
 121   EXPECT_EQ(base::string16(), mock_storage_observer_->last_attached().name());
 122   EXPECT_EQ(kTestSize * 2,
 123             mock_storage_observer_->last_attached().total_size_in_bytes());
 124   EXPECT_EQ(mount_point_.value(),
 125             mock_storage_observer_->last_attached().location());
 126 }
 127
 128 TEST_F(StorageMonitorMacTest, DCIM) {
 129   base::ScopedTempDir temp_dir;
 130   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 131   ASSERT_TRUE(base::CreateDirectory(
 132       temp_dir.path().Append(kDCIMDirectoryName)));
 133
 134   base::FilePath mount_point = temp_dir.path();
 135   std::string device_id = StorageInfo::MakeDeviceId(
 136       StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM, unique_id_);
 137   StorageInfo info = CreateStorageInfo(device_id, "", mount_point, kTestSize);
 138
 139   UpdateDisk(info, StorageMonitorMac::UPDATE_DEVICE_ADDED);
 140
 141   EXPECT_EQ(1, mock_storage_observer_->attach_calls());
 142   EXPECT_EQ(0, mock_storage_observer_->detach_calls());
 143   EXPECT_EQ(device_id, mock_storage_observer_->last_attached().device_id());
 144   EXPECT_EQ(base::string16(), mock_storage_observer_->last_attached().name());
 145   EXPECT_EQ(mount_point.value(),
 146             mock_storage_observer_->last_attached().location());
 147 }
 148
 149 TEST_F(StorageMonitorMacTest, GetStorageInfo) {
 150   UpdateDisk(disk_info_, StorageMonitorMac::UPDATE_DEVICE_ADDED);
 151
 152   EXPECT_EQ(1, mock_storage_observer_->attach_calls());
 153   EXPECT_EQ(0, mock_storage_observer_->detach_calls());
 154   EXPECT_EQ(device_id_, mock_storage_observer_->last_attached().device_id());
 155   EXPECT_EQ(base::string16(), mock_storage_observer_->last_attached().name());
 156   EXPECT_EQ(mount_point_.value(),
 157             mock_storage_observer_->last_attached().location());
 158
 159   StorageInfo info;
 160   EXPECT_TRUE(monitor_->GetStorageInfoForPath(mount_point_.AppendASCII("foo"),
 161                                               &info));
 162   EXPECT_EQ(device_id_, info.device_id());
 163   EXPECT_EQ(base::string16(), info.name());
 164   EXPECT_EQ(mount_point_.value(), info.location());
 165   EXPECT_EQ(kTestSize, info.total_size_in_bytes());
 166
 167   EXPECT_FALSE(monitor_->GetStorageInfoForPath(
 168       base::FilePath("/non/matching/path"), &info));
 169 }
 170
 171 // Test that mounting a DMG doesn't send a notification.
 172 TEST_F(StorageMonitorMacTest, DMG) {
 173   StorageInfo info = CreateStorageInfo(
 174       device_id_, "Disk Image", mount_point_, kTestSize);
 175   UpdateDisk(info, StorageMonitorMac::UPDATE_DEVICE_ADDED);
 176   EXPECT_EQ(0, mock_storage_observer_->attach_calls());
 177 }