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 <string>
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/memory/scoped_vector.h"
   9 #include "chrome/browser/chromeos/file_system_provider/observer.h"
  10 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
  11 #include "chrome/browser/chromeos/file_system_provider/service.h"
  12 #include "chrome/browser/chromeos/login/fake_user_manager.h"
  13 #include "chrome/test/base/testing_profile.h"
  14 #include "content/public/test/test_browser_thread_bundle.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "webkit/browser/fileapi/external_mount_points.h"
  17
  18 namespace chromeos {
  19 namespace file_system_provider {
  20 namespace {
  21
  22 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
  23 const char kFileSystemName[] = "Camera Pictures";
  24
  25 // Utility observer, logging events from file_system_provider::Service.
  26 class LoggingObserver : public Observer {
  27  public:
  28   LoggingObserver() {}
  29   virtual ~LoggingObserver() {}
  30
  31   // file_system_provider::Observer overrides.
  32   virtual void OnProvidedFileSystemRegistered(
  33       const ProvidedFileSystem& file_system) OVERRIDE {
  34     registered.push_back(new const ProvidedFileSystem(file_system));
  35   }
  36
  37   virtual void OnProvidedFileSystemUnregistered(
  38       const ProvidedFileSystem& file_system) OVERRIDE {
  39     unregistered.push_back(new const ProvidedFileSystem(file_system));
  40   }
  41
  42   ScopedVector<const ProvidedFileSystem> registered;
  43   ScopedVector<const ProvidedFileSystem> unregistered;
  44 };
  45
  46 }  // namespace
  47
  48 class FileSystemProviderServiceTest : public testing::Test {
  49  protected:
  50   FileSystemProviderServiceTest() {}
  51   virtual ~FileSystemProviderServiceTest() {}
  52
  53   virtual void SetUp() OVERRIDE {
  54     user_manager_ = new FakeUserManager();
  55     user_manager_enabler_.reset(new ScopedUserManagerEnabler(user_manager_));
  56     profile_.reset(new TestingProfile);
  57     user_manager_->AddUser(profile_->GetProfileName());
  58     file_system_provider_service_.reset(new Service(profile_.get()));
  59   }
  60
  61   virtual void TearDown() {
  62     fileapi::ExternalMountPoints::GetSystemInstance()->RevokeAllFileSystems();
  63   }
  64
  65   content::TestBrowserThreadBundle thread_bundle_;
  66   scoped_ptr<TestingProfile> profile_;
  67   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
  68   FakeUserManager* user_manager_;
  69   scoped_ptr<Service> file_system_provider_service_;
  70 };
  71
  72 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem) {
  73   LoggingObserver observer;
  74   file_system_provider_service_->AddObserver(&observer);
  75
  76   int file_system_id = file_system_provider_service_->RegisterFileSystem(
  77       kExtensionId, kFileSystemName);
  78
  79   EXPECT_LT(0, file_system_id);
  80   ASSERT_EQ(1u, observer.registered.size());
  81   EXPECT_EQ(kExtensionId, observer.registered[0]->extension_id());
  82   EXPECT_EQ(1, observer.registered[0]->file_system_id());
  83   EXPECT_EQ("/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash",
  84             observer.registered[0]->mount_path().AsUTF8Unsafe());
  85   EXPECT_EQ(kFileSystemName, observer.registered[0]->file_system_name());
  86   ASSERT_EQ(0u, observer.unregistered.size());
  87
  88   std::vector<ProvidedFileSystem> provided_file_systems =
  89       file_system_provider_service_->GetRegisteredFileSystems();
  90   ASSERT_EQ(1u, provided_file_systems.size());
  91
  92   file_system_provider_service_->RemoveObserver(&observer);
  93 }
  94
  95 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem_UniqueIds) {
  96   LoggingObserver observer;
  97   file_system_provider_service_->AddObserver(&observer);
  98
  99   int file_system_first_id = file_system_provider_service_->RegisterFileSystem(
 100       kExtensionId, kFileSystemName);
 101   ASSERT_LT(0, file_system_first_id);
 102
 103   int file_system_second_id = file_system_provider_service_->RegisterFileSystem(
 104       kExtensionId, kFileSystemName);
 105   ASSERT_LT(0, file_system_second_id);
 106
 107   ASSERT_NE(file_system_first_id, file_system_second_id);
 108   ASSERT_EQ(2u, observer.registered.size());
 109
 110   std::vector<ProvidedFileSystem> provided_file_systems =
 111       file_system_provider_service_->GetRegisteredFileSystems();
 112   ASSERT_EQ(2u, provided_file_systems.size());
 113
 114   file_system_provider_service_->RemoveObserver(&observer);
 115 }
 116
 117 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem_StressTest) {
 118   LoggingObserver observer;
 119   file_system_provider_service_->AddObserver(&observer);
 120
 121   const size_t kMaxFileSystems = 16;
 122   for (size_t i = 0; i < kMaxFileSystems; ++i) {
 123     int file_system_id = file_system_provider_service_->RegisterFileSystem(
 124         kExtensionId, kFileSystemName);
 125     ASSERT_LT(0, file_system_id);
 126   }
 127   ASSERT_EQ(kMaxFileSystems, observer.registered.size());
 128
 129   // The next file system is out of limit, and registering it should fail.
 130   int file_system_id = file_system_provider_service_->RegisterFileSystem(
 131       kExtensionId, kFileSystemName);
 132   ASSERT_EQ(0, file_system_id);
 133   ASSERT_EQ(kMaxFileSystems, observer.registered.size());
 134
 135   std::vector<ProvidedFileSystem> provided_file_systems =
 136       file_system_provider_service_->GetRegisteredFileSystems();
 137   ASSERT_EQ(kMaxFileSystems, provided_file_systems.size());
 138
 139   file_system_provider_service_->RemoveObserver(&observer);
 140 }
 141
 142 TEST_F(FileSystemProviderServiceTest, UnregisterFileSystem) {
 143   LoggingObserver observer;
 144   file_system_provider_service_->AddObserver(&observer);
 145
 146   int file_system_id = file_system_provider_service_->RegisterFileSystem(
 147       kExtensionId, kFileSystemName);
 148   ASSERT_LT(0, file_system_id);
 149   ASSERT_EQ(1u, observer.registered.size());
 150
 151   const bool result = file_system_provider_service_->UnregisterFileSystem(
 152       kExtensionId, file_system_id);
 153   ASSERT_TRUE(result);
 154   ASSERT_EQ(1u, observer.unregistered.size());
 155
 156   EXPECT_EQ(kExtensionId, observer.unregistered[0]->extension_id());
 157   EXPECT_EQ(1, observer.unregistered[0]->file_system_id());
 158   EXPECT_EQ("/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash",
 159             observer.unregistered[0]->mount_path().AsUTF8Unsafe());
 160   EXPECT_EQ(kFileSystemName, observer.unregistered[0]->file_system_name());
 161
 162   std::vector<ProvidedFileSystem> provided_file_systems =
 163       file_system_provider_service_->GetRegisteredFileSystems();
 164   ASSERT_EQ(0u, provided_file_systems.size());
 165
 166   file_system_provider_service_->RemoveObserver(&observer);
 167 }
 168
 169 TEST_F(FileSystemProviderServiceTest, UnregisterFileSystem_WrongExtensionId) {
 170   LoggingObserver observer;
 171   file_system_provider_service_->AddObserver(&observer);
 172
 173   const std::string kWrongExtensionId = "helloworldhelloworldhelloworldhe";
 174
 175   int file_system_id = file_system_provider_service_->RegisterFileSystem(
 176       kExtensionId, kFileSystemName);
 177   ASSERT_LT(0, file_system_id);
 178   ASSERT_EQ(1u, observer.registered.size());
 179
 180   const bool result = file_system_provider_service_->UnregisterFileSystem(
 181       kWrongExtensionId, file_system_id);
 182   ASSERT_FALSE(result);
 183   ASSERT_EQ(0u, observer.unregistered.size());
 184
 185   std::vector<ProvidedFileSystem> provided_file_systems =
 186       file_system_provider_service_->GetRegisteredFileSystems();
 187   ASSERT_EQ(1u, provided_file_systems.size());
 188
 189   file_system_provider_service_->RemoveObserver(&observer);
 190 }
 191
 192 }  // namespace file_system_provider
 193 }  // namespace chromeos