components/storage_monitor/storage_monitor_mac_unittest.mm

   1 // Copyright 2014 The Chromium Authors
   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 "components/storage_monitor/storage_monitor_mac.h"
   6
   7 #include <stdint.h>
   8
   9 #include <memory>
  10
  11 #include "base/apple/foundation_util.h"
  12 #include "base/files/file_util.h"
  13 #include "base/files/scoped_temp_dir.h"
  14 #include "base/functional/bind.h"
  15 #include "base/functional/callback_helpers.h"
  16 #include "base/run_loop.h"
  17 #include "base/strings/sys_string_conversions.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "components/storage_monitor/mock_removable_storage_observer.h"
  20 #include "components/storage_monitor/removable_device_constants.h"
  21 #include "components/storage_monitor/storage_info.h"
  22 #include "components/storage_monitor/test_storage_monitor.h"
  23 #include "content/public/browser/browser_task_traits.h"
  24 #include "content/public/browser/browser_thread.h"
  25 #include "content/public/test/browser_task_environment.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27
  28 uint64_t kTestSize = 1000000ULL;
  29
  30 namespace storage_monitor {
  31
  32 namespace {
  33
  34 StorageInfo CreateStorageInfo(const std::string& device_id,
  35                               const std::string& model_name,
  36                               const base::FilePath& mount_point,
  37                               uint64_t size_bytes) {
  38   return StorageInfo(device_id, mount_point.value(), /*label=*/std::u16string(),
  39                      /*vendor=*/std::u16string(), base::UTF8ToUTF16(model_name),
  40                      size_bytes);
  41 }
  42
  43 }  // namespace
  44
  45 class StorageMonitorMacTest : public testing::Test {
  46  public:
  47   StorageMonitorMacTest() = default;
  48
  49   void SetUp() override {
  50     monitor_ = std::make_unique<StorageMonitorMac>();
  51
  52     mock_storage_observer_ = std::make_unique<MockRemovableStorageObserver>();
  53     monitor_->AddObserver(mock_storage_observer_.get());
  54
  55     unique_id_ = "test_id";
  56     mount_point_ = base::FilePath("/unused_test_directory");
  57     device_id_ = StorageInfo::MakeDeviceId(
  58         StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM, unique_id_);
  59     disk_info_ = CreateStorageInfo(device_id_, "",
  60                                    mount_point_, kTestSize);
  61   }
  62
  63   void UpdateDisk(StorageInfo info, StorageMonitorMac::UpdateType update_type) {
  64     content::GetUIThreadTaskRunner({})->PostTask(
  65         FROM_HERE,
  66         base::BindOnce(&StorageMonitorMac::UpdateDisk,
  67                        base::Unretained(monitor_.get()), update_type,
  68                        base::Owned(new std::string("dummy_bsd_name")), info));
  69     base::RunLoop().RunUntilIdle();
  70   }
  71
  72  protected:
  73   content::BrowserTaskEnvironment task_environment_;
  74
  75   std::unique_ptr<MockRemovableStorageObserver> mock_storage_observer_;
  76
  77   // Information about the disk.
  78   std::string unique_id_;
  79   base::FilePath mount_point_;
  80   std::string device_id_;
  81   StorageInfo disk_info_;
  82
  83   std::unique_ptr<StorageMonitorMac> monitor_;
  84 };
  85
  86 TEST_F(StorageMonitorMacTest, AddRemove) {
  87   UpdateDisk(disk_info_, StorageMonitorMac::UPDATE_DEVICE_ADDED);
  88
  89   EXPECT_EQ(1, mock_storage_observer_->attach_calls());
  90   EXPECT_EQ(0, mock_storage_observer_->detach_calls());
  91   EXPECT_EQ(device_id_, mock_storage_observer_->last_attached().device_id());
  92   EXPECT_EQ(mount_point_.value(),
  93             mock_storage_observer_->last_attached().location());
  94
  95   UpdateDisk(disk_info_, StorageMonitorMac::UPDATE_DEVICE_REMOVED);
  96
  97   EXPECT_EQ(1, mock_storage_observer_->attach_calls());
  98   EXPECT_EQ(1, mock_storage_observer_->detach_calls());
  99   EXPECT_EQ(device_id_, mock_storage_observer_->last_detached().device_id());
 100 }
 101
 102 TEST_F(StorageMonitorMacTest, UpdateVolumeName) {
 103   UpdateDisk(disk_info_, StorageMonitorMac::UPDATE_DEVICE_ADDED);
 104
 105   EXPECT_EQ(1, mock_storage_observer_->attach_calls());
 106   EXPECT_EQ(0, mock_storage_observer_->detach_calls());
 107   EXPECT_EQ(device_id_, mock_storage_observer_->last_attached().device_id());
 108   EXPECT_EQ(kTestSize,
 109             mock_storage_observer_->last_attached().total_size_in_bytes());
 110   EXPECT_EQ(mount_point_.value(),
 111             mock_storage_observer_->last_attached().location());
 112
 113   StorageInfo info2 = CreateStorageInfo(
 114       device_id_, "", mount_point_, kTestSize * 2);
 115   UpdateDisk(info2, StorageMonitorMac::UPDATE_DEVICE_CHANGED);
 116   base::RunLoop().RunUntilIdle();
 117
 118   EXPECT_EQ(1, mock_storage_observer_->detach_calls());
 119   EXPECT_EQ(device_id_, mock_storage_observer_->last_detached().device_id());
 120   EXPECT_EQ(2, mock_storage_observer_->attach_calls());
 121   EXPECT_EQ(device_id_, mock_storage_observer_->last_attached().device_id());
 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(
 132       base::CreateDirectory(temp_dir.GetPath().Append(kDCIMDirectoryName)));
 133
 134   base::FilePath mount_point = temp_dir.GetPath();
 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(mount_point.value(),
 145             mock_storage_observer_->last_attached().location());
 146 }
 147
 148 TEST_F(StorageMonitorMacTest, GetStorageInfo) {
 149   UpdateDisk(disk_info_, StorageMonitorMac::UPDATE_DEVICE_ADDED);
 150
 151   EXPECT_EQ(1, mock_storage_observer_->attach_calls());
 152   EXPECT_EQ(0, mock_storage_observer_->detach_calls());
 153   EXPECT_EQ(device_id_, mock_storage_observer_->last_attached().device_id());
 154   EXPECT_EQ(mount_point_.value(),
 155             mock_storage_observer_->last_attached().location());
 156
 157   StorageInfo info;
 158   EXPECT_TRUE(monitor_->GetStorageInfoForPath(mount_point_.AppendASCII("foo"),
 159                                               &info));
 160   EXPECT_EQ(device_id_, info.device_id());
 161   EXPECT_EQ(mount_point_.value(), info.location());
 162   EXPECT_EQ(kTestSize, info.total_size_in_bytes());
 163
 164   EXPECT_FALSE(monitor_->GetStorageInfoForPath(
 165       base::FilePath("/non/matching/path"), &info));
 166 }
 167
 168 // Test that mounting a DMG doesn't send a notification.
 169 TEST_F(StorageMonitorMacTest, DMG) {
 170   StorageInfo info = CreateStorageInfo(
 171       device_id_, "Disk Image", mount_point_, kTestSize);
 172   UpdateDisk(info, StorageMonitorMac::UPDATE_DEVICE_ADDED);
 173   EXPECT_EQ(0, mock_storage_observer_->attach_calls());
 174 }
 175
 176 }  // namespace storage_monitor