src/chrome/browser/chromeos/file_system_provider/service_unittest.cc

   1 // Copyright 2014 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_system_provider/service.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/files/file.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "chrome/browser/chromeos/file_system_provider/fake_provided_file_system.h"
  15 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
  16 #include "chrome/browser/chromeos/file_system_provider/observer.h"
  17 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
  18 #include "chrome/browser/chromeos/file_system_provider/registry_interface.h"
  19 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
  20 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
  21 #include "chrome/test/base/testing_browser_process.h"
  22 #include "chrome/test/base/testing_pref_service_syncable.h"
  23 #include "chrome/test/base/testing_profile.h"
  24 #include "chrome/test/base/testing_profile_manager.h"
  25 #include "components/user_prefs/user_prefs.h"
  26 #include "content/public/test/test_browser_thread_bundle.h"
  27 #include "extensions/browser/extension_registry.h"
  28 #include "extensions/common/extension.h"
  29 #include "extensions/common/manifest_constants.h"
  30 #include "storage/browser/fileapi/external_mount_points.h"
  31 #include "testing/gtest/include/gtest/gtest.h"
  32
  33 namespace chromeos {
  34 namespace file_system_provider {
  35 namespace {
  36
  37 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
  38 const char kDisplayName[] = "Camera Pictures";
  39
  40 // The dot in the file system ID is there in order to check that saving to
  41 // preferences works correctly. File System ID is used as a key in
  42 // a base::DictionaryValue, so it has to be stored without path expansion.
  43 const char kFileSystemId[] = "camera/pictures/id .!@#$%^&*()_+";
  44
  45 // Utility observer, logging events from file_system_provider::Service.
  46 class LoggingObserver : public Observer {
  47  public:
  48   class Event {
  49    public:
  50     Event(const ProvidedFileSystemInfo& file_system_info,
  51           base::File::Error error)
  52         : file_system_info_(file_system_info), error_(error) {}
  53     ~Event() {}
  54
  55     const ProvidedFileSystemInfo& file_system_info() {
  56       return file_system_info_;
  57     }
  58     base::File::Error error() { return error_; }
  59
  60    private:
  61     ProvidedFileSystemInfo file_system_info_;
  62     base::File::Error error_;
  63   };
  64
  65   LoggingObserver() {}
  66   virtual ~LoggingObserver() {}
  67
  68   // file_system_provider::Observer overrides.
  69   virtual void OnProvidedFileSystemMount(
  70       const ProvidedFileSystemInfo& file_system_info,
  71       base::File::Error error) override {
  72     mounts.push_back(Event(file_system_info, error));
  73   }
  74
  75   virtual void OnProvidedFileSystemUnmount(
  76       const ProvidedFileSystemInfo& file_system_info,
  77       base::File::Error error) override {
  78     unmounts.push_back(Event(file_system_info, error));
  79   }
  80
  81   std::vector<Event> mounts;
  82   std::vector<Event> unmounts;
  83 };
  84
  85 // Fake implementation of the registry, since it's already tested separately.
  86 // For simplicity it can remember at most only one file system.
  87 class FakeRegistry : public RegistryInterface {
  88  public:
  89   FakeRegistry() {}
  90   virtual ~FakeRegistry() {}
  91
  92   // RegistryInterface overrides.
  93   virtual void RememberFileSystem(
  94       const ProvidedFileSystemInfo& file_system_info,
  95       const Watchers& watchers) override {
  96     file_system_info_.reset(new ProvidedFileSystemInfo(file_system_info));
  97     watchers_.reset(new Watchers(watchers));
  98   }
  99
 100   virtual void ForgetFileSystem(const std::string& extension_id,
 101                                 const std::string& file_system_id) override {
 102     if (!file_system_info_.get() || !watchers_.get())
 103       return;
 104     if (file_system_info_->extension_id() == extension_id &&
 105         file_system_info_->file_system_id() == file_system_id) {
 106       file_system_info_.reset();
 107       watchers_.reset();
 108     }
 109   }
 110
 111   virtual scoped_ptr<RestoredFileSystems> RestoreFileSystems(
 112       const std::string& extension_id) override {
 113     scoped_ptr<RestoredFileSystems> result(new RestoredFileSystems);
 114
 115     if (file_system_info_.get() && watchers_.get()) {
 116       RestoredFileSystem restored_file_system;
 117       restored_file_system.extension_id = file_system_info_->extension_id();
 118
 119       MountOptions options;
 120       options.file_system_id = file_system_info_->file_system_id();
 121       options.display_name = file_system_info_->display_name();
 122       options.writable = file_system_info_->writable();
 123       options.supports_notify_tag = file_system_info_->supports_notify_tag();
 124       restored_file_system.options = options;
 125       restored_file_system.watchers = *watchers_.get();
 126
 127       result->push_back(restored_file_system);
 128     }
 129
 130     return result;
 131   }
 132
 133   virtual void UpdateWatcherTag(const ProvidedFileSystemInfo& file_system_info,
 134                                 const Watcher& watcher) override {
 135     ASSERT_TRUE(watchers_.get());
 136     const Watchers::iterator it =
 137         watchers_->find(WatcherKey(watcher.entry_path, watcher.recursive));
 138     ASSERT_NE(watchers_->end(), it);
 139     it->second.last_tag = watcher.last_tag;
 140   }
 141
 142   ProvidedFileSystemInfo* const file_system_info() const {
 143     return file_system_info_.get();
 144   }
 145   Watchers* const watchers() const { return watchers_.get(); }
 146
 147  private:
 148   scoped_ptr<ProvidedFileSystemInfo> file_system_info_;
 149   scoped_ptr<Watchers> watchers_;
 150
 151   DISALLOW_COPY_AND_ASSIGN(FakeRegistry);
 152 };
 153
 154 // Creates a fake extension with the specified |extension_id|.
 155 scoped_refptr<extensions::Extension> CreateFakeExtension(
 156     const std::string& extension_id) {
 157   base::DictionaryValue manifest;
 158   std::string error;
 159   manifest.SetStringWithoutPathExpansion(extensions::manifest_keys::kVersion,
 160                                          "1.0.0.0");
 161   manifest.SetStringWithoutPathExpansion(extensions::manifest_keys::kName,
 162                                          "unused");
 163   return extensions::Extension::Create(base::FilePath(),
 164                                        extensions::Manifest::UNPACKED,
 165                                        manifest,
 166                                        extensions::Extension::NO_FLAGS,
 167                                        extension_id,
 168                                        &error);
 169 }
 170
 171 }  // namespace
 172
 173 class FileSystemProviderServiceTest : public testing::Test {
 174  protected:
 175   FileSystemProviderServiceTest() : profile_(NULL) {}
 176
 177   virtual ~FileSystemProviderServiceTest() {}
 178
 179   virtual void SetUp() override {
 180     profile_manager_.reset(
 181         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
 182     ASSERT_TRUE(profile_manager_->SetUp());
 183     profile_ = profile_manager_->CreateTestingProfile("test-user@example.com");
 184     user_manager_ = new FakeUserManager();
 185     user_manager_->AddUser(profile_->GetProfileName());
 186     user_manager_enabler_.reset(new ScopedUserManagerEnabler(user_manager_));
 187     extension_registry_.reset(new extensions::ExtensionRegistry(profile_));
 188
 189     service_.reset(new Service(profile_, extension_registry_.get()));
 190     service_->SetFileSystemFactoryForTesting(
 191         base::Bind(&FakeProvidedFileSystem::Create));
 192     extension_ = CreateFakeExtension(kExtensionId);
 193
 194     registry_ = new FakeRegistry;
 195     // Passes ownership to the service instance.
 196     service_->SetRegistryForTesting(make_scoped_ptr(registry_));
 197
 198     fake_watcher_.entry_path = base::FilePath(FILE_PATH_LITERAL("/a/b/c"));
 199     fake_watcher_.recursive = true;
 200     fake_watcher_.last_tag = "hello-world";
 201   }
 202
 203   content::TestBrowserThreadBundle thread_bundle_;
 204   scoped_ptr<TestingProfileManager> profile_manager_;
 205   TestingProfile* profile_;
 206   FakeUserManager* user_manager_;
 207   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
 208   scoped_ptr<extensions::ExtensionRegistry> extension_registry_;
 209   scoped_ptr<Service> service_;
 210   scoped_refptr<extensions::Extension> extension_;
 211   FakeRegistry* registry_;  // Owned by Service.
 212   Watcher fake_watcher_;
 213 };
 214
 215 TEST_F(FileSystemProviderServiceTest, MountFileSystem) {
 216   LoggingObserver observer;
 217   service_->AddObserver(&observer);
 218
 219   EXPECT_TRUE(service_->MountFileSystem(
 220       kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 221
 222   ASSERT_EQ(1u, observer.mounts.size());
 223   EXPECT_EQ(kExtensionId, observer.mounts[0].file_system_info().extension_id());
 224   EXPECT_EQ(kFileSystemId,
 225             observer.mounts[0].file_system_info().file_system_id());
 226   base::FilePath expected_mount_path =
 227       util::GetMountPath(profile_, kExtensionId, kFileSystemId);
 228   EXPECT_EQ(expected_mount_path.AsUTF8Unsafe(),
 229             observer.mounts[0].file_system_info().mount_path().AsUTF8Unsafe());
 230   EXPECT_EQ(kDisplayName, observer.mounts[0].file_system_info().display_name());
 231   EXPECT_FALSE(observer.mounts[0].file_system_info().writable());
 232   EXPECT_FALSE(observer.mounts[0].file_system_info().supports_notify_tag());
 233   EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
 234   ASSERT_EQ(0u, observer.unmounts.size());
 235
 236   std::vector<ProvidedFileSystemInfo> file_system_info_list =
 237       service_->GetProvidedFileSystemInfoList();
 238   ASSERT_EQ(1u, file_system_info_list.size());
 239
 240   service_->RemoveObserver(&observer);
 241 }
 242
 243 TEST_F(FileSystemProviderServiceTest,
 244        MountFileSystem_WritableAndSupportsNotifyTag) {
 245   LoggingObserver observer;
 246   service_->AddObserver(&observer);
 247
 248   MountOptions options(kFileSystemId, kDisplayName);
 249   options.writable = true;
 250   options.supports_notify_tag = true;
 251   EXPECT_TRUE(service_->MountFileSystem(kExtensionId, options));
 252
 253   ASSERT_EQ(1u, observer.mounts.size());
 254   EXPECT_TRUE(observer.mounts[0].file_system_info().writable());
 255   EXPECT_TRUE(observer.mounts[0].file_system_info().supports_notify_tag());
 256   ASSERT_EQ(0u, observer.unmounts.size());
 257   std::vector<ProvidedFileSystemInfo> file_system_info_list =
 258       service_->GetProvidedFileSystemInfoList();
 259   ASSERT_EQ(1u, file_system_info_list.size());
 260
 261   service_->RemoveObserver(&observer);
 262 }
 263
 264 TEST_F(FileSystemProviderServiceTest, MountFileSystem_UniqueIds) {
 265   LoggingObserver observer;
 266   service_->AddObserver(&observer);
 267
 268   EXPECT_TRUE(service_->MountFileSystem(
 269       kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 270   EXPECT_FALSE(service_->MountFileSystem(
 271       kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 272
 273   ASSERT_EQ(2u, observer.mounts.size());
 274   EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
 275   EXPECT_EQ(base::File::FILE_ERROR_EXISTS, observer.mounts[1].error());
 276
 277   std::vector<ProvidedFileSystemInfo> file_system_info_list =
 278       service_->GetProvidedFileSystemInfoList();
 279   ASSERT_EQ(1u, file_system_info_list.size());
 280
 281   service_->RemoveObserver(&observer);
 282 }
 283
 284 TEST_F(FileSystemProviderServiceTest, MountFileSystem_StressTest) {
 285   LoggingObserver observer;
 286   service_->AddObserver(&observer);
 287
 288   const size_t kMaxFileSystems = 16;
 289   for (size_t i = 0; i < kMaxFileSystems; ++i) {
 290     const std::string file_system_id =
 291         std::string("test-") + base::IntToString(i);
 292     EXPECT_TRUE(service_->MountFileSystem(
 293         kExtensionId, MountOptions(file_system_id, kDisplayName)));
 294   }
 295   ASSERT_EQ(kMaxFileSystems, observer.mounts.size());
 296
 297   // The next file system is out of limit, and registering it should fail.
 298   EXPECT_FALSE(service_->MountFileSystem(
 299       kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 300
 301   ASSERT_EQ(kMaxFileSystems + 1, observer.mounts.size());
 302   EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED,
 303             observer.mounts[kMaxFileSystems].error());
 304
 305   std::vector<ProvidedFileSystemInfo> file_system_info_list =
 306       service_->GetProvidedFileSystemInfoList();
 307   ASSERT_EQ(kMaxFileSystems, file_system_info_list.size());
 308
 309   service_->RemoveObserver(&observer);
 310 }
 311
 312 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem) {
 313   LoggingObserver observer;
 314   service_->AddObserver(&observer);
 315
 316   EXPECT_TRUE(service_->MountFileSystem(
 317       kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 318   ASSERT_EQ(1u, observer.mounts.size());
 319
 320   EXPECT_TRUE(service_->UnmountFileSystem(
 321       kExtensionId, kFileSystemId, Service::UNMOUNT_REASON_USER));
 322   ASSERT_EQ(1u, observer.unmounts.size());
 323   EXPECT_EQ(base::File::FILE_OK, observer.unmounts[0].error());
 324
 325   EXPECT_EQ(kExtensionId,
 326             observer.unmounts[0].file_system_info().extension_id());
 327   EXPECT_EQ(kFileSystemId,
 328             observer.unmounts[0].file_system_info().file_system_id());
 329
 330   std::vector<ProvidedFileSystemInfo> file_system_info_list =
 331       service_->GetProvidedFileSystemInfoList();
 332   ASSERT_EQ(0u, file_system_info_list.size());
 333
 334   service_->RemoveObserver(&observer);
 335 }
 336
 337 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_OnExtensionUnload) {
 338   LoggingObserver observer;
 339   service_->AddObserver(&observer);
 340
 341   EXPECT_TRUE(service_->MountFileSystem(
 342       kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 343   ASSERT_EQ(1u, observer.mounts.size());
 344
 345   // Directly call the observer's method.
 346   service_->OnExtensionUnloaded(
 347       profile_,
 348       extension_.get(),
 349       extensions::UnloadedExtensionInfo::REASON_DISABLE);
 350
 351   ASSERT_EQ(1u, observer.unmounts.size());
 352   EXPECT_EQ(base::File::FILE_OK, observer.unmounts[0].error());
 353
 354   EXPECT_EQ(kExtensionId,
 355             observer.unmounts[0].file_system_info().extension_id());
 356   EXPECT_EQ(kFileSystemId,
 357             observer.unmounts[0].file_system_info().file_system_id());
 358
 359   std::vector<ProvidedFileSystemInfo> file_system_info_list =
 360       service_->GetProvidedFileSystemInfoList();
 361   ASSERT_EQ(0u, file_system_info_list.size());
 362
 363   service_->RemoveObserver(&observer);
 364 }
 365
 366 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_WrongExtensionId) {
 367   LoggingObserver observer;
 368   service_->AddObserver(&observer);
 369
 370   const std::string kWrongExtensionId = "helloworldhelloworldhelloworldhe";
 371
 372   EXPECT_TRUE(service_->MountFileSystem(
 373       kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 374   ASSERT_EQ(1u, observer.mounts.size());
 375   ASSERT_EQ(1u, service_->GetProvidedFileSystemInfoList().size());
 376
 377   EXPECT_FALSE(service_->UnmountFileSystem(
 378       kWrongExtensionId, kFileSystemId, Service::UNMOUNT_REASON_USER));
 379   ASSERT_EQ(1u, observer.unmounts.size());
 380   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, observer.unmounts[0].error());
 381   ASSERT_EQ(1u, service_->GetProvidedFileSystemInfoList().size());
 382
 383   std::vector<ProvidedFileSystemInfo> file_system_info_list =
 384       service_->GetProvidedFileSystemInfoList();
 385   ASSERT_EQ(1u, file_system_info_list.size());
 386
 387   service_->RemoveObserver(&observer);
 388 }
 389
 390 TEST_F(FileSystemProviderServiceTest, RestoreFileSystem_OnExtensionLoad) {
 391   LoggingObserver observer;
 392   service_->AddObserver(&observer);
 393
 394   // Remember a fake file system first in order to be able to restore it.
 395   MountOptions options(kFileSystemId, kDisplayName);
 396   options.supports_notify_tag = true;
 397   ProvidedFileSystemInfo file_system_info(
 398       kExtensionId, options, base::FilePath(FILE_PATH_LITERAL("/a/b/c")));
 399   Watchers fake_watchers;
 400   fake_watchers[WatcherKey(fake_watcher_.entry_path, fake_watcher_.recursive)] =
 401       fake_watcher_;
 402   registry_->RememberFileSystem(file_system_info, fake_watchers);
 403
 404   EXPECT_EQ(0u, observer.mounts.size());
 405
 406   // Directly call the observer's method.
 407   service_->OnExtensionLoaded(profile_, extension_.get());
 408
 409   ASSERT_EQ(1u, observer.mounts.size());
 410   EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
 411
 412   EXPECT_EQ(file_system_info.extension_id(),
 413             observer.mounts[0].file_system_info().extension_id());
 414   EXPECT_EQ(file_system_info.file_system_id(),
 415             observer.mounts[0].file_system_info().file_system_id());
 416   EXPECT_EQ(file_system_info.writable(),
 417             observer.mounts[0].file_system_info().writable());
 418   EXPECT_EQ(file_system_info.supports_notify_tag(),
 419             observer.mounts[0].file_system_info().supports_notify_tag());
 420
 421   std::vector<ProvidedFileSystemInfo> file_system_info_list =
 422       service_->GetProvidedFileSystemInfoList();
 423   ASSERT_EQ(1u, file_system_info_list.size());
 424
 425   ProvidedFileSystemInterface* const file_system =
 426       service_->GetProvidedFileSystem(kExtensionId, kFileSystemId);
 427   ASSERT_TRUE(file_system);
 428
 429   const Watchers* const watchers = file_system->GetWatchers();
 430   ASSERT_TRUE(watchers);
 431   ASSERT_EQ(1u, watchers->size());
 432
 433   const Watchers::const_iterator restored_watcher_it = watchers->find(
 434       WatcherKey(fake_watcher_.entry_path, fake_watcher_.recursive));
 435   ASSERT_NE(watchers->end(), restored_watcher_it);
 436
 437   EXPECT_EQ(fake_watcher_.entry_path, restored_watcher_it->second.entry_path);
 438   EXPECT_EQ(fake_watcher_.recursive, restored_watcher_it->second.recursive);
 439   EXPECT_EQ(fake_watcher_.last_tag, restored_watcher_it->second.last_tag);
 440
 441   service_->RemoveObserver(&observer);
 442 }
 443
 444 TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnMount) {
 445   LoggingObserver observer;
 446   service_->AddObserver(&observer);
 447
 448   EXPECT_FALSE(registry_->file_system_info());
 449   EXPECT_FALSE(registry_->watchers());
 450
 451   EXPECT_TRUE(service_->MountFileSystem(
 452       kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 453   ASSERT_EQ(1u, observer.mounts.size());
 454
 455   ASSERT_TRUE(registry_->file_system_info());
 456   EXPECT_EQ(kExtensionId, registry_->file_system_info()->extension_id());
 457   EXPECT_EQ(kFileSystemId, registry_->file_system_info()->file_system_id());
 458   EXPECT_EQ(kDisplayName, registry_->file_system_info()->display_name());
 459   EXPECT_FALSE(registry_->file_system_info()->writable());
 460   EXPECT_FALSE(registry_->file_system_info()->supports_notify_tag());
 461   ASSERT_TRUE(registry_->watchers());
 462
 463   service_->RemoveObserver(&observer);
 464 }
 465
 466 TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnUnmountOnShutdown) {
 467   LoggingObserver observer;
 468   service_->AddObserver(&observer);
 469
 470   {
 471     EXPECT_FALSE(registry_->file_system_info());
 472     EXPECT_FALSE(registry_->watchers());
 473     EXPECT_TRUE(service_->MountFileSystem(
 474         kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 475
 476     EXPECT_EQ(1u, observer.mounts.size());
 477     EXPECT_TRUE(registry_->file_system_info());
 478     EXPECT_TRUE(registry_->watchers());
 479   }
 480
 481   {
 482     EXPECT_TRUE(service_->UnmountFileSystem(
 483         kExtensionId, kFileSystemId, Service::UNMOUNT_REASON_SHUTDOWN));
 484
 485     EXPECT_EQ(1u, observer.unmounts.size());
 486     EXPECT_TRUE(registry_->file_system_info());
 487     EXPECT_TRUE(registry_->watchers());
 488   }
 489
 490   service_->RemoveObserver(&observer);
 491 }
 492
 493 TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnUnmountByUser) {
 494   LoggingObserver observer;
 495   service_->AddObserver(&observer);
 496
 497   {
 498     EXPECT_FALSE(registry_->file_system_info());
 499     EXPECT_FALSE(registry_->watchers());
 500     EXPECT_TRUE(service_->MountFileSystem(
 501         kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 502
 503     EXPECT_EQ(1u, observer.mounts.size());
 504     EXPECT_TRUE(registry_->file_system_info());
 505     EXPECT_TRUE(registry_->watchers());
 506   }
 507
 508   {
 509     EXPECT_TRUE(service_->UnmountFileSystem(
 510         kExtensionId, kFileSystemId, Service::UNMOUNT_REASON_USER));
 511
 512     EXPECT_EQ(1u, observer.unmounts.size());
 513     EXPECT_FALSE(registry_->file_system_info());
 514     EXPECT_FALSE(registry_->watchers());
 515   }
 516
 517   service_->RemoveObserver(&observer);
 518 }
 519
 520 }  // namespace file_system_provider
 521 }  // namespace chromeos