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