volume_manager_unittest.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9 
1// Copyright 2013 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/chromeos/file_manager/volume_manager.h"
6
7#include <string>
8#include <vector>
9
10#include "base/basictypes.h"
11#include "base/prefs/pref_service.h"
12#include "chrome/browser/chromeos/file_manager/fake_disk_mount_manager.h"
13#include "chrome/browser/chromeos/file_manager/volume_manager_observer.h"
14#include "chrome/common/pref_names.h"
15#include "chrome/test/base/testing_profile.h"
16#include "chromeos/dbus/fake_power_manager_client.h"
17#include "chromeos/disks/disk_mount_manager.h"
18#include "content/public/test/test_browser_thread_bundle.h"
19#include "testing/gtest/include/gtest/gtest.h"
20
21namespace file_manager {
22namespace {
23
24class LoggingObserver : public VolumeManagerObserver {
25 public:
26  struct Event {
27    enum EventType {
28      DISK_ADDED,
29      DISK_REMOVED,
30      DEVICE_ADDED,
31      DEVICE_REMOVED,
32      VOLUME_MOUNTED,
33      VOLUME_UNMOUNTED,
34      FORMAT_STARTED,
35      FORMAT_COMPLETED,
36    } type;
37
38    // Available on DEVICE_ADDED, DEVICE_REMOVED, VOLUME_MOUNTED,
39    // VOLUME_UNMOUNTED, FORMAT_STARTED and FORMAT_COMPLETED.
40    std::string device_path;
41
42    // Available on DISK_ADDED.
43    bool mounting;
44
45    // Available on VOLUME_MOUNTED and VOLUME_UNMOUNTED.
46    chromeos::MountError mount_error;
47
48    // Available on VOLUME_MOUNTED.
49    bool is_remounting;
50
51    // Available on FORMAT_STARTED and FORMAT_COMPLETED.
52    bool success;
53  };
54
55  LoggingObserver() {}
56  virtual ~LoggingObserver() {}
57
58  const std::vector<Event>& events() const { return events_; }
59
60  // VolumeManagerObserver overrides.
61  virtual void OnDiskAdded(const chromeos::disks::DiskMountManager::Disk& disk,
62                           bool mounting) OVERRIDE {
63    Event event;
64    event.type = Event::DISK_ADDED;
65    event.device_path = disk.device_path();  // Keep only device_path.
66    event.mounting = mounting;
67    events_.push_back(event);
68  }
69
70  virtual void OnDiskRemoved(
71      const chromeos::disks::DiskMountManager::Disk& disk) OVERRIDE {
72    Event event;
73    event.type = Event::DISK_REMOVED;
74    event.device_path = disk.device_path();  // Keep only device_path.
75    events_.push_back(event);
76  }
77
78  virtual void OnDeviceAdded(const std::string& device_path) OVERRIDE {
79    Event event;
80    event.type = Event::DEVICE_ADDED;
81    event.device_path = device_path;
82    events_.push_back(event);
83  }
84
85  virtual void OnDeviceRemoved(const std::string& device_path) OVERRIDE {
86    Event event;
87    event.type = Event::DEVICE_REMOVED;
88    event.device_path = device_path;
89    events_.push_back(event);
90  }
91
92  virtual void OnVolumeMounted(chromeos::MountError error_code,
93                               const VolumeInfo& volume_info,
94                               bool is_remounting) OVERRIDE {
95    Event event;
96    event.type = Event::VOLUME_MOUNTED;
97    event.device_path = volume_info.source_path.AsUTF8Unsafe();
98    event.mount_error = error_code;
99    event.is_remounting = is_remounting;
100    events_.push_back(event);
101  }
102
103  virtual void OnVolumeUnmounted(chromeos::MountError error_code,
104                                 const VolumeInfo& volume_info) OVERRIDE {
105    Event event;
106    event.type = Event::VOLUME_UNMOUNTED;
107    event.device_path = volume_info.source_path.AsUTF8Unsafe();
108    event.mount_error = error_code;
109    events_.push_back(event);
110  }
111
112  virtual void OnFormatStarted(
113      const std::string& device_path, bool success) OVERRIDE {
114    Event event;
115    event.type = Event::FORMAT_STARTED;
116    event.device_path = device_path;
117    event.success = success;
118    events_.push_back(event);
119  }
120
121  virtual void OnFormatCompleted(
122      const std::string& device_path, bool success) OVERRIDE {
123    Event event;
124    event.type = Event::FORMAT_COMPLETED;
125    event.device_path = device_path;
126    event.success = success;
127    events_.push_back(event);
128  }
129
130 private:
131  std::vector<Event> events_;
132
133  DISALLOW_COPY_AND_ASSIGN(LoggingObserver);
134};
135
136}  // namespace
137
138class VolumeManagerTest : public testing::Test {
139 protected:
140  VolumeManagerTest() {
141  }
142  virtual ~VolumeManagerTest() {
143  }
144
145  virtual void SetUp() OVERRIDE {
146    power_manager_client_.reset(new chromeos::FakePowerManagerClient);
147    disk_mount_manager_.reset(new FakeDiskMountManager);
148    profile_.reset(new TestingProfile);
149    volume_manager_.reset(new VolumeManager(profile_.get(),
150                                            NULL,  // DriveIntegrationService
151                                            power_manager_client_.get(),
152                                            disk_mount_manager_.get()));
153  }
154
155  content::TestBrowserThreadBundle thread_bundle_;
156  scoped_ptr<chromeos::FakePowerManagerClient> power_manager_client_;
157  scoped_ptr<FakeDiskMountManager> disk_mount_manager_;
158  scoped_ptr<TestingProfile> profile_;
159  scoped_ptr<VolumeManager> volume_manager_;
160};
161
162TEST_F(VolumeManagerTest, OnDriveFileSystemMountAndUnmount) {
163  LoggingObserver observer;
164  volume_manager_->AddObserver(&observer);
165
166  volume_manager_->OnFileSystemMounted();
167
168  ASSERT_EQ(1U, observer.events().size());
169  LoggingObserver::Event event = observer.events()[0];
170  EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
171  EXPECT_EQ(drive::util::GetDriveMountPointPath(profile_.get()).AsUTF8Unsafe(),
172            event.device_path);
173  EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
174  EXPECT_FALSE(event.is_remounting);
175
176  volume_manager_->OnFileSystemBeingUnmounted();
177
178  ASSERT_EQ(2U, observer.events().size());
179  event = observer.events()[1];
180  EXPECT_EQ(LoggingObserver::Event::VOLUME_UNMOUNTED, event.type);
181  EXPECT_EQ(drive::util::GetDriveMountPointPath(profile_.get()).AsUTF8Unsafe(),
182            event.device_path);
183  EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
184
185  volume_manager_->RemoveObserver(&observer);
186}
187
188TEST_F(VolumeManagerTest, OnDriveFileSystemUnmountWithoutMount) {
189  LoggingObserver observer;
190  volume_manager_->AddObserver(&observer);
191  volume_manager_->OnFileSystemBeingUnmounted();
192
193  // Unmount event for non-mounted volume is not reported.
194  ASSERT_EQ(0U, observer.events().size());
195  volume_manager_->RemoveObserver(&observer);
196}
197
198TEST_F(VolumeManagerTest, OnDiskEvent_Hidden) {
199  LoggingObserver observer;
200  volume_manager_->AddObserver(&observer);
201
202  const bool kIsHidden = true;
203  const chromeos::disks::DiskMountManager::Disk kDisk(
204      "device1", "", "", "", "", "", "", "", "", "", "", "",
205      chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, kIsHidden);
206
207  volume_manager_->OnDiskEvent(
208      chromeos::disks::DiskMountManager::DISK_ADDED, &kDisk);
209  EXPECT_EQ(0U, observer.events().size());
210
211  volume_manager_->OnDiskEvent(
212      chromeos::disks::DiskMountManager::DISK_REMOVED, &kDisk);
213  EXPECT_EQ(0U, observer.events().size());
214
215  volume_manager_->OnDiskEvent(
216      chromeos::disks::DiskMountManager::DISK_CHANGED, &kDisk);
217  EXPECT_EQ(0U, observer.events().size());
218
219  volume_manager_->RemoveObserver(&observer);
220}
221
222TEST_F(VolumeManagerTest, OnDiskEvent_Added) {
223  // Enable external storage.
224  profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
225
226  LoggingObserver observer;
227  volume_manager_->AddObserver(&observer);
228
229  const chromeos::disks::DiskMountManager::Disk kEmptyDevicePathDisk(
230      "",  // empty device path.
231      "", "", "", "", "", "", "", "", "", "", "",
232      chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
233  volume_manager_->OnDiskEvent(
234      chromeos::disks::DiskMountManager::DISK_ADDED, &kEmptyDevicePathDisk);
235  EXPECT_EQ(0U, observer.events().size());
236
237  const bool kHasMedia = true;
238  const chromeos::disks::DiskMountManager::Disk kMediaDisk(
239      "device1", "", "", "", "", "", "", "", "", "", "", "",
240      chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, kHasMedia, false, false);
241  volume_manager_->OnDiskEvent(
242      chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
243  ASSERT_EQ(1U, observer.events().size());
244  const LoggingObserver::Event& event = observer.events()[0];
245  EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
246  EXPECT_EQ("device1", event.device_path);
247  EXPECT_TRUE(event.mounting);
248
249  ASSERT_EQ(1U, disk_mount_manager_->mount_requests().size());
250  const FakeDiskMountManager::MountRequest& mount_request =
251      disk_mount_manager_->mount_requests()[0];
252  EXPECT_EQ("device1", mount_request.source_path);
253  EXPECT_EQ("", mount_request.source_format);
254  EXPECT_EQ("", mount_request.mount_label);
255  EXPECT_EQ(chromeos::MOUNT_TYPE_DEVICE, mount_request.type);
256
257  volume_manager_->RemoveObserver(&observer);
258}
259
260TEST_F(VolumeManagerTest, OnDiskEvent_AddedNonMounting) {
261  // Enable external storage.
262  profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
263
264  // Device which is already mounted.
265  {
266    LoggingObserver observer;
267    volume_manager_->AddObserver(&observer);
268
269    const bool kHasMedia = true;
270    const chromeos::disks::DiskMountManager::Disk kMountedMediaDisk(
271        "device1", "mounted", "", "", "", "", "", "", "", "", "", "",
272        chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
273        kHasMedia, false, false);
274    volume_manager_->OnDiskEvent(
275        chromeos::disks::DiskMountManager::DISK_ADDED, &kMountedMediaDisk);
276    ASSERT_EQ(1U, observer.events().size());
277    const LoggingObserver::Event& event = observer.events()[0];
278    EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
279    EXPECT_EQ("device1", event.device_path);
280    EXPECT_FALSE(event.mounting);
281
282    ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
283
284    volume_manager_->RemoveObserver(&observer);
285  }
286
287  // Device without media.
288  {
289    LoggingObserver observer;
290    volume_manager_->AddObserver(&observer);
291
292    const bool kWithoutMedia = false;
293    const chromeos::disks::DiskMountManager::Disk kNoMediaDisk(
294        "device1", "", "", "", "", "", "", "", "", "", "", "",
295        chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
296        kWithoutMedia, false, false);
297    volume_manager_->OnDiskEvent(
298        chromeos::disks::DiskMountManager::DISK_ADDED, &kNoMediaDisk);
299    ASSERT_EQ(1U, observer.events().size());
300    const LoggingObserver::Event& event = observer.events()[0];
301    EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
302    EXPECT_EQ("device1", event.device_path);
303    EXPECT_FALSE(event.mounting);
304
305    ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
306
307    volume_manager_->RemoveObserver(&observer);
308  }
309
310  // External storage is disabled.
311  {
312    profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, true);
313
314    LoggingObserver observer;
315    volume_manager_->AddObserver(&observer);
316
317    const bool kHasMedia = true;
318    const chromeos::disks::DiskMountManager::Disk kMediaDisk(
319        "device1", "", "", "", "", "", "", "", "", "", "", "",
320        chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
321        kHasMedia, false, false);
322    volume_manager_->OnDiskEvent(
323        chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
324    ASSERT_EQ(1U, observer.events().size());
325    const LoggingObserver::Event& event = observer.events()[0];
326    EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
327    EXPECT_EQ("device1", event.device_path);
328    EXPECT_FALSE(event.mounting);
329
330    ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
331
332    volume_manager_->RemoveObserver(&observer);
333  }
334}
335
336TEST_F(VolumeManagerTest, OnDiskEvent_Removed) {
337  LoggingObserver observer;
338  volume_manager_->AddObserver(&observer);
339
340  const chromeos::disks::DiskMountManager::Disk kMountedDisk(
341      "device1", "mount_path", "", "", "", "", "", "", "", "", "", "",
342      chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
343  volume_manager_->OnDiskEvent(
344      chromeos::disks::DiskMountManager::DISK_REMOVED, &kMountedDisk);
345
346  ASSERT_EQ(1U, observer.events().size());
347  const LoggingObserver::Event& event = observer.events()[0];
348  EXPECT_EQ(LoggingObserver::Event::DISK_REMOVED, event.type);
349  EXPECT_EQ("device1", event.device_path);
350
351  ASSERT_EQ(1U, disk_mount_manager_->unmount_requests().size());
352  const FakeDiskMountManager::UnmountRequest& unmount_request =
353      disk_mount_manager_->unmount_requests()[0];
354  EXPECT_EQ("mount_path", unmount_request.mount_path);
355  EXPECT_EQ(chromeos::UNMOUNT_OPTIONS_LAZY, unmount_request.options);
356
357  volume_manager_->RemoveObserver(&observer);
358}
359
360TEST_F(VolumeManagerTest, OnDiskEvent_RemovedNotMounted) {
361  LoggingObserver observer;
362  volume_manager_->AddObserver(&observer);
363
364  const chromeos::disks::DiskMountManager::Disk kNotMountedDisk(
365      "device1", "", "", "", "", "", "", "", "", "", "", "",
366      chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
367  volume_manager_->OnDiskEvent(
368      chromeos::disks::DiskMountManager::DISK_REMOVED, &kNotMountedDisk);
369
370  ASSERT_EQ(1U, observer.events().size());
371  const LoggingObserver::Event& event = observer.events()[0];
372  EXPECT_EQ(LoggingObserver::Event::DISK_REMOVED, event.type);
373  EXPECT_EQ("device1", event.device_path);
374
375  ASSERT_EQ(0U, disk_mount_manager_->unmount_requests().size());
376
377  volume_manager_->RemoveObserver(&observer);
378}
379
380TEST_F(VolumeManagerTest, OnDiskEvent_Changed) {
381  // Changed event should cause mounting (if possible).
382  LoggingObserver observer;
383  volume_manager_->AddObserver(&observer);
384
385  const chromeos::disks::DiskMountManager::Disk kDisk(
386      "device1", "", "", "", "", "", "", "", "", "", "", "",
387      chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, true, false, false);
388  volume_manager_->OnDiskEvent(
389      chromeos::disks::DiskMountManager::DISK_CHANGED, &kDisk);
390
391  EXPECT_EQ(1U, observer.events().size());
392  EXPECT_EQ(1U, disk_mount_manager_->mount_requests().size());
393  EXPECT_EQ(0U, disk_mount_manager_->unmount_requests().size());
394
395  volume_manager_->RemoveObserver(&observer);
396}
397
398TEST_F(VolumeManagerTest, OnDeviceEvent_Added) {
399  LoggingObserver observer;
400  volume_manager_->AddObserver(&observer);
401
402  volume_manager_->OnDeviceEvent(
403      chromeos::disks::DiskMountManager::DEVICE_ADDED, "device1");
404
405  ASSERT_EQ(1U, observer.events().size());
406  const LoggingObserver::Event& event = observer.events()[0];
407  EXPECT_EQ(LoggingObserver::Event::DEVICE_ADDED, event.type);
408  EXPECT_EQ("device1", event.device_path);
409
410  volume_manager_->RemoveObserver(&observer);
411}
412
413TEST_F(VolumeManagerTest, OnDeviceEvent_Removed) {
414  LoggingObserver observer;
415  volume_manager_->AddObserver(&observer);
416
417  volume_manager_->OnDeviceEvent(
418      chromeos::disks::DiskMountManager::DEVICE_REMOVED, "device1");
419
420  ASSERT_EQ(1U, observer.events().size());
421  const LoggingObserver::Event& event = observer.events()[0];
422  EXPECT_EQ(LoggingObserver::Event::DEVICE_REMOVED, event.type);
423  EXPECT_EQ("device1", event.device_path);
424
425  volume_manager_->RemoveObserver(&observer);
426}
427
428TEST_F(VolumeManagerTest, OnDeviceEvent_Scanned) {
429  LoggingObserver observer;
430  volume_manager_->AddObserver(&observer);
431
432  volume_manager_->OnDeviceEvent(
433      chromeos::disks::DiskMountManager::DEVICE_SCANNED, "device1");
434
435  // SCANNED event is just ignored.
436  EXPECT_EQ(0U, observer.events().size());
437
438  volume_manager_->RemoveObserver(&observer);
439}
440
441TEST_F(VolumeManagerTest, OnMountEvent_MountingAndUnmounting) {
442  LoggingObserver observer;
443  volume_manager_->AddObserver(&observer);
444
445  const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
446      "device1",
447      "mount1",
448      chromeos::MOUNT_TYPE_DEVICE,
449      chromeos::disks::MOUNT_CONDITION_NONE);
450
451  volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::MOUNTING,
452                                chromeos::MOUNT_ERROR_NONE,
453                                kMountPoint);
454
455  ASSERT_EQ(1U, observer.events().size());
456  LoggingObserver::Event event = observer.events()[0];
457  EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
458  EXPECT_EQ("device1", event.device_path);
459  EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
460  EXPECT_FALSE(event.is_remounting);
461
462  volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::UNMOUNTING,
463                                chromeos::MOUNT_ERROR_NONE,
464                                kMountPoint);
465
466  ASSERT_EQ(2U, observer.events().size());
467  event = observer.events()[1];
468  EXPECT_EQ(LoggingObserver::Event::VOLUME_UNMOUNTED, event.type);
469  EXPECT_EQ("device1", event.device_path);
470  EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
471
472  volume_manager_->RemoveObserver(&observer);
473}
474
475TEST_F(VolumeManagerTest, OnMountEvent_Remounting) {
476  scoped_ptr<chromeos::disks::DiskMountManager::Disk> disk(
477      new chromeos::disks::DiskMountManager::Disk(
478          "device1", "", "", "", "", "", "", "", "", "", "uuid1", "",
479          chromeos::DEVICE_TYPE_UNKNOWN, 0,
480          false, false, false, false, false));
481  disk_mount_manager_->AddDiskForTest(disk.release());
482  disk_mount_manager_->MountPath(
483      "device1", "", "", chromeos::MOUNT_TYPE_DEVICE);
484
485  // Emulate system suspend and then resume.
486  {
487    power_manager_client_->SendSuspendImminent();
488    power_manager::SuspendState state;
489    state.set_type(power_manager::SuspendState_Type_SUSPEND_TO_MEMORY);
490    state.set_wall_time(0);
491    power_manager_client_->SendSuspendStateChanged(state);
492    state.set_type(power_manager::SuspendState_Type_RESUME);
493    power_manager_client_->SendSuspendStateChanged(state);
494
495    // After resume, the device is unmounted and then mounted.
496    disk_mount_manager_->UnmountPath(
497        "device1", chromeos::UNMOUNT_OPTIONS_NONE,
498        chromeos::disks::DiskMountManager::UnmountPathCallback());
499    disk_mount_manager_->MountPath(
500        "device1", "", "", chromeos::MOUNT_TYPE_DEVICE);
501  }
502
503  LoggingObserver observer;
504  volume_manager_->AddObserver(&observer);
505
506  const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
507      "device1",
508      "mount1",
509      chromeos::MOUNT_TYPE_DEVICE,
510      chromeos::disks::MOUNT_CONDITION_NONE);
511
512  volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::MOUNTING,
513                                chromeos::MOUNT_ERROR_NONE,
514                                kMountPoint);
515
516  ASSERT_EQ(1U, observer.events().size());
517  const LoggingObserver::Event& event = observer.events()[0];
518  EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
519  EXPECT_EQ("device1", event.device_path);
520  EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
521  EXPECT_TRUE(event.is_remounting);
522
523  volume_manager_->RemoveObserver(&observer);
524}
525
526TEST_F(VolumeManagerTest, OnMountEvent_UnmountingWithoutMounting) {
527  LoggingObserver observer;
528  volume_manager_->AddObserver(&observer);
529
530  const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
531      "device1",
532      "mount1",
533      chromeos::MOUNT_TYPE_DEVICE,
534      chromeos::disks::MOUNT_CONDITION_NONE);
535
536  volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::UNMOUNTING,
537                                chromeos::MOUNT_ERROR_NONE,
538                                kMountPoint);
539
540  // Unmount event for a disk not mounted in this manager is not reported.
541  ASSERT_EQ(0U, observer.events().size());
542
543  volume_manager_->RemoveObserver(&observer);
544}
545
546TEST_F(VolumeManagerTest, OnFormatEvent_Started) {
547  LoggingObserver observer;
548  volume_manager_->AddObserver(&observer);
549
550  volume_manager_->OnFormatEvent(
551      chromeos::disks::DiskMountManager::FORMAT_STARTED,
552      chromeos::FORMAT_ERROR_NONE,
553      "device1");
554
555  ASSERT_EQ(1U, observer.events().size());
556  const LoggingObserver::Event& event = observer.events()[0];
557  EXPECT_EQ(LoggingObserver::Event::FORMAT_STARTED, event.type);
558  EXPECT_EQ("device1", event.device_path);
559  EXPECT_TRUE(event.success);
560
561  volume_manager_->RemoveObserver(&observer);
562}
563
564TEST_F(VolumeManagerTest, OnFormatEvent_StartFailed) {
565  LoggingObserver observer;
566  volume_manager_->AddObserver(&observer);
567
568  volume_manager_->OnFormatEvent(
569      chromeos::disks::DiskMountManager::FORMAT_STARTED,
570      chromeos::FORMAT_ERROR_UNKNOWN,
571      "device1");
572
573  ASSERT_EQ(1U, observer.events().size());
574  const LoggingObserver::Event& event = observer.events()[0];
575  EXPECT_EQ(LoggingObserver::Event::FORMAT_STARTED, event.type);
576  EXPECT_EQ("device1", event.device_path);
577  EXPECT_FALSE(event.success);
578
579  volume_manager_->RemoveObserver(&observer);
580}
581
582TEST_F(VolumeManagerTest, OnFormatEvent_Completed) {
583  LoggingObserver observer;
584  volume_manager_->AddObserver(&observer);
585
586  volume_manager_->OnFormatEvent(
587      chromeos::disks::DiskMountManager::FORMAT_COMPLETED,
588      chromeos::FORMAT_ERROR_NONE,
589      "device1");
590
591  ASSERT_EQ(1U, observer.events().size());
592  const LoggingObserver::Event& event = observer.events()[0];
593  EXPECT_EQ(LoggingObserver::Event::FORMAT_COMPLETED, event.type);
594  EXPECT_EQ("device1", event.device_path);
595  EXPECT_TRUE(event.success);
596
597  // When "format" is successfully done, VolumeManager requests to mount it.
598  ASSERT_EQ(1U, disk_mount_manager_->mount_requests().size());
599  const FakeDiskMountManager::MountRequest& mount_request =
600      disk_mount_manager_->mount_requests()[0];
601  EXPECT_EQ("device1", mount_request.source_path);
602  EXPECT_EQ("", mount_request.source_format);
603  EXPECT_EQ("", mount_request.mount_label);
604  EXPECT_EQ(chromeos::MOUNT_TYPE_DEVICE, mount_request.type);
605
606  volume_manager_->RemoveObserver(&observer);
607}
608
609TEST_F(VolumeManagerTest, OnFormatEvent_CompletedFailed) {
610  LoggingObserver observer;
611  volume_manager_->AddObserver(&observer);
612
613  volume_manager_->OnFormatEvent(
614      chromeos::disks::DiskMountManager::FORMAT_COMPLETED,
615      chromeos::FORMAT_ERROR_UNKNOWN,
616      "device1");
617
618  ASSERT_EQ(1U, observer.events().size());
619  const LoggingObserver::Event& event = observer.events()[0];
620  EXPECT_EQ(LoggingObserver::Event::FORMAT_COMPLETED, event.type);
621  EXPECT_EQ("device1", event.device_path);
622  EXPECT_FALSE(event.success);
623
624  EXPECT_EQ(0U, disk_mount_manager_->mount_requests().size());
625
626  volume_manager_->RemoveObserver(&observer);
627}
628
629TEST_F(VolumeManagerTest, OnExternalStorageDisabledChanged) {
630  // Here create two mount points.
631  disk_mount_manager_->MountPath(
632      "mount1", "", "", chromeos::MOUNT_TYPE_DEVICE);
633  disk_mount_manager_->MountPath(
634      "mount2", "", "", chromeos::MOUNT_TYPE_DEVICE);
635
636  // Initially, there are two mount points.
637  ASSERT_EQ(2U, disk_mount_manager_->mount_points().size());
638  ASSERT_EQ(0U, disk_mount_manager_->unmount_requests().size());
639
640  // Emulate to set kExternalStorageDisabled to false.
641  profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
642  volume_manager_->OnExternalStorageDisabledChanged();
643
644  // Expect no effects.
645  EXPECT_EQ(2U, disk_mount_manager_->mount_points().size());
646  EXPECT_EQ(0U, disk_mount_manager_->unmount_requests().size());
647
648  // Emulate to set kExternalStorageDisabled to true.
649  profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, true);
650  volume_manager_->OnExternalStorageDisabledChanged();
651
652  // The all mount points should be unmounted.
653  EXPECT_EQ(0U, disk_mount_manager_->mount_points().size());
654
655  EXPECT_EQ(2U, disk_mount_manager_->unmount_requests().size());
656  const FakeDiskMountManager::UnmountRequest& unmount_request1 =
657      disk_mount_manager_->unmount_requests()[0];
658  EXPECT_EQ("mount1", unmount_request1.mount_path);
659
660  const FakeDiskMountManager::UnmountRequest& unmount_request2 =
661      disk_mount_manager_->unmount_requests()[1];
662  EXPECT_EQ("mount2", unmount_request2.mount_path);
663}
664
665TEST_F(VolumeManagerTest, GetVolumeInfoList) {
666  volume_manager_->Initialize();  // Adds "Downloads"
667  std::vector<VolumeInfo> info_list = volume_manager_->GetVolumeInfoList();
668  ASSERT_EQ(1u, info_list.size());
669  EXPECT_EQ("downloads:Downloads", info_list[0].volume_id);
670  EXPECT_EQ(VOLUME_TYPE_DOWNLOADS_DIRECTORY, info_list[0].type);
671}
672
673TEST_F(VolumeManagerTest, FindVolumeInfoById) {
674  volume_manager_->Initialize();  // Adds "Downloads"
675  VolumeInfo volume_info;
676  ASSERT_FALSE(volume_manager_->FindVolumeInfoById(
677      "nonexistent", &volume_info));
678  ASSERT_TRUE(volume_manager_->FindVolumeInfoById(
679      "downloads:Downloads", &volume_info));
680  EXPECT_EQ("downloads:Downloads", volume_info.volume_id);
681  EXPECT_EQ(VOLUME_TYPE_DOWNLOADS_DIRECTORY, volume_info.type);
682}
683
684TEST_F(VolumeManagerTest, ArchiveSourceFiltering) {
685  LoggingObserver observer;
686  volume_manager_->AddObserver(&observer);
687
688  // Mount a USB stick.
689  volume_manager_->OnMountEvent(
690      chromeos::disks::DiskMountManager::MOUNTING,
691      chromeos::MOUNT_ERROR_NONE,
692      chromeos::disks::DiskMountManager::MountPointInfo(
693          "/removable/usb",
694          "/removable/usb",
695          chromeos::MOUNT_TYPE_DEVICE,
696          chromeos::disks::MOUNT_CONDITION_NONE));
697
698  // Mount a zip archive in the stick.
699  volume_manager_->OnMountEvent(
700      chromeos::disks::DiskMountManager::MOUNTING,
701      chromeos::MOUNT_ERROR_NONE,
702      chromeos::disks::DiskMountManager::MountPointInfo(
703          "/removable/usb/1.zip",
704          "/archive/1",
705          chromeos::MOUNT_TYPE_ARCHIVE,
706          chromeos::disks::MOUNT_CONDITION_NONE));
707  VolumeInfo volume_info;
708  ASSERT_TRUE(volume_manager_->FindVolumeInfoById("archive:1", &volume_info));
709  EXPECT_EQ("/archive/1", volume_info.mount_path.AsUTF8Unsafe());
710  EXPECT_EQ(2u, observer.events().size());
711
712  // Mount a zip archive in the previous zip archive.
713  volume_manager_->OnMountEvent(
714      chromeos::disks::DiskMountManager::MOUNTING,
715      chromeos::MOUNT_ERROR_NONE,
716      chromeos::disks::DiskMountManager::MountPointInfo(
717          "/archive/1/2.zip",
718          "/archive/2",
719          chromeos::MOUNT_TYPE_ARCHIVE,
720          chromeos::disks::MOUNT_CONDITION_NONE));
721  ASSERT_TRUE(volume_manager_->FindVolumeInfoById("archive:2", &volume_info));
722  EXPECT_EQ("/archive/2", volume_info.mount_path.AsUTF8Unsafe());
723  EXPECT_EQ(3u, observer.events().size());
724
725  // A zip file is mounted from other profile. It must be ignored in the current
726  // VolumeManager.
727  volume_manager_->OnMountEvent(
728      chromeos::disks::DiskMountManager::MOUNTING,
729      chromeos::MOUNT_ERROR_NONE,
730      chromeos::disks::DiskMountManager::MountPointInfo(
731          "/other/profile/drive/folder/3.zip",
732          "/archive/3",
733          chromeos::MOUNT_TYPE_ARCHIVE,
734          chromeos::disks::MOUNT_CONDITION_NONE));
735  EXPECT_FALSE(volume_manager_->FindVolumeInfoById("archive:3", &volume_info));
736  EXPECT_EQ(3u, observer.events().size());
737}
738
739}  // namespace file_manager
740