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// TODO(mtomasz): Move these test cases to operations/unmount_unittest.cc.
6
7#include <string>
8#include <vector>
9
10#include "base/files/file.h"
11#include "base/memory/scoped_ptr.h"
12#include "base/run_loop.h"
13#include "base/values.h"
14#include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
15#include "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
16#include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
17#include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
18#include "chrome/browser/chromeos/file_system_provider/request_manager.h"
19#include "chrome/common/extensions/api/file_system_provider.h"
20#include "chrome/test/base/testing_profile.h"
21#include "content/public/test/test_browser_thread_bundle.h"
22#include "extensions/browser/event_router.h"
23#include "testing/gtest/include/gtest/gtest.h"
24
25namespace chromeos {
26namespace file_system_provider {
27
28namespace {
29
30const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
31const int kExpectedRequestId = 1;
32const char kFileSystemId[] = "camera-pictures";
33const char kFileSystemName[] = "Camera Pictures";
34
35class FakeEventRouter : public extensions::EventRouter {
36 public:
37  explicit FakeEventRouter(Profile* profile) : EventRouter(profile, NULL) {}
38  virtual ~FakeEventRouter() {}
39
40  virtual void DispatchEventToExtension(const std::string& extension_id,
41                                        scoped_ptr<extensions::Event> event)
42      OVERRIDE {
43    extension_id_ = extension_id;
44    event_ = event.Pass();
45  }
46
47  const std::string& extension_id() const { return extension_id_; }
48
49  const extensions::Event* event() const { return event_.get(); }
50
51 private:
52  std::string extension_id_;
53  scoped_ptr<extensions::Event> event_;
54
55  DISALLOW_COPY_AND_ASSIGN(FakeEventRouter);
56};
57
58class EventLogger {
59 public:
60  EventLogger() : weak_ptr_factory_(this) {}
61  virtual ~EventLogger() {}
62
63  void OnStatusCallback(base::File::Error error) {
64    error_.reset(new base::File::Error(error));
65  }
66
67  base::File::Error* error() { return error_.get(); }
68
69  base::WeakPtr<EventLogger> GetWeakPtr() {
70    return weak_ptr_factory_.GetWeakPtr();
71  }
72
73 private:
74  scoped_ptr<base::File::Error> error_;
75
76  base::WeakPtrFactory<EventLogger> weak_ptr_factory_;
77  DISALLOW_COPY_AND_ASSIGN(EventLogger);
78};
79
80}  // namespace
81
82class FileSystemProviderProvidedFileSystemTest : public testing::Test {
83 protected:
84  FileSystemProviderProvidedFileSystemTest() {}
85  virtual ~FileSystemProviderProvidedFileSystemTest() {}
86
87  virtual void SetUp() OVERRIDE {
88    profile_.reset(new TestingProfile);
89    event_router_.reset(new FakeEventRouter(profile_.get()));
90    event_router_->AddEventListener(
91        extensions::api::file_system_provider::OnUnmountRequested::kEventName,
92        NULL,
93        kExtensionId);
94
95    const base::FilePath mount_path =
96        util::GetMountPath(profile_.get(), kExtensionId, kFileSystemId);
97    file_system_info_.reset(new ProvidedFileSystemInfo(
98        kExtensionId, kFileSystemId, kFileSystemName, mount_path));
99    provided_file_system_.reset(
100        new ProvidedFileSystem(event_router_.get(), *file_system_info_.get()));
101  }
102
103  content::TestBrowserThreadBundle thread_bundle_;
104  scoped_ptr<TestingProfile> profile_;
105  scoped_ptr<FakeEventRouter> event_router_;
106  scoped_ptr<ProvidedFileSystemInfo> file_system_info_;
107  scoped_ptr<ProvidedFileSystemInterface> provided_file_system_;
108};
109
110TEST_F(FileSystemProviderProvidedFileSystemTest, RequestUnmount_Success) {
111  EventLogger logger;
112
113  provided_file_system_->RequestUnmount(
114      base::Bind(&EventLogger::OnStatusCallback, logger.GetWeakPtr()));
115  base::RunLoop().RunUntilIdle();
116
117  // Verify that the event has been sent to the providing extension.
118  EXPECT_EQ(kExtensionId, event_router_->extension_id());
119  const extensions::Event* event = event_router_->event();
120  ASSERT_TRUE(event);
121  ASSERT_TRUE(event->event_args);
122  base::ListValue* event_args = event->event_args.get();
123  EXPECT_EQ(2u, event_args->GetSize());
124  std::string file_system_id;
125  EXPECT_TRUE(event_args->GetString(0, &file_system_id));
126  EXPECT_EQ(kFileSystemId, file_system_id);
127
128  // Remember the request id, and verify it is valid.
129  int request_id = 0;
130  EXPECT_TRUE(event_args->GetInteger(1, &request_id));
131  EXPECT_EQ(kExpectedRequestId, request_id);
132
133  // Callback should not be called, yet.
134  EXPECT_FALSE(logger.error());
135
136  // Simulate sending a success response from the providing extension.
137  RequestManager* request_manager = provided_file_system_->GetRequestManager();
138  ASSERT_TRUE(request_manager);
139  scoped_ptr<RequestValue> response;
140  bool reply_result = request_manager->FulfillRequest(
141      request_id, response.Pass(), false /* has_more */);
142  EXPECT_TRUE(reply_result);
143
144  // Callback should be called. Verify the error code.
145  ASSERT_TRUE(logger.error());
146  EXPECT_EQ(base::File::FILE_OK, *logger.error());
147}
148
149TEST_F(FileSystemProviderProvidedFileSystemTest, RequestUnmount_Error) {
150  EventLogger logger;
151
152  provided_file_system_->RequestUnmount(
153      base::Bind(&EventLogger::OnStatusCallback, logger.GetWeakPtr()));
154  base::RunLoop().RunUntilIdle();
155
156  // Verify that the event has been sent to the providing extension.
157  EXPECT_EQ(kExtensionId, event_router_->extension_id());
158  const extensions::Event* event = event_router_->event();
159  ASSERT_TRUE(event);
160  ASSERT_TRUE(event->event_args);
161  base::ListValue* event_args = event->event_args.get();
162  EXPECT_EQ(2u, event_args->GetSize());
163  std::string file_system_id;
164  EXPECT_TRUE(event_args->GetString(0, &file_system_id));
165  EXPECT_EQ(kFileSystemId, file_system_id);
166
167  // Remember the request id, and verify it is valid.
168  int request_id = 0;
169  EXPECT_TRUE(event_args->GetInteger(1, &request_id));
170  EXPECT_EQ(kExpectedRequestId, request_id);
171
172  // Simulate sending an error response from the providing extension.
173  RequestManager* request_manager = provided_file_system_->GetRequestManager();
174  ASSERT_TRUE(request_manager);
175  bool reply_result = request_manager->RejectRequest(
176      request_id, base::File::FILE_ERROR_NOT_FOUND);
177  EXPECT_TRUE(reply_result);
178
179  // Callback should be called. Verify the error code.
180  ASSERT_TRUE(logger.error());
181  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, *logger.error());
182}
183
184}  // namespace file_system_provider
185}  // namespace chromeos
186