[fsp] Move unmount unit tests to the operations directory.

Operations are tested outside of the ProvidedFileSystem class. This CL moves
the last operation which was tested in the deprecated way.

TEST=unit_tests: *FileSystemProviderOperations*Unmount
BUG=373165

Review URL: https://codereview.chromium.org/301633003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@273091 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/chromeos/file_system_provider/operations/unmount_unittest.cc

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <string>
+#include <vector>
+
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
+#include "chrome/browser/chromeos/file_system_provider/operations/unmount.h"
+#include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
+#include "chrome/common/extensions/api/file_system_provider.h"
+#include "chrome/common/extensions/api/file_system_provider_internal.h"
+#include "extensions/browser/event_router.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace file_system_provider {
+namespace operations {
+namespace {
+
+const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
+const char kFileSystemId[] = "testing-file-system";
+const int kRequestId = 2;
+
+// Fake event dispatcher implementation with extra logging capability. Acts as
+// a providing extension end-point.
+class LoggingDispatchEventImpl {
+ public:
+  explicit LoggingDispatchEventImpl(bool dispatch_reply)
+      : dispatch_reply_(dispatch_reply) {}
+  virtual ~LoggingDispatchEventImpl() {}
+
+  bool OnDispatchEventImpl(scoped_ptr<extensions::Event> event) {
+    events_.push_back(event->DeepCopy());
+    return dispatch_reply_;
+  }
+
+  ScopedVector<extensions::Event>& events() { return events_; }
+
+ private:
+  ScopedVector<extensions::Event> events_;
+  bool dispatch_reply_;
+
+  DISALLOW_COPY_AND_ASSIGN(LoggingDispatchEventImpl);
+};
+
+// Callback invocation logger. Acts as a fileapi end-point.
+class CallbackLogger {
+ public:
+  CallbackLogger() : weak_ptr_factory_(this) {}
+  virtual ~CallbackLogger() {}
+
+  void OnUnmount(base::File::Error result) { events_.push_back(result); }
+
+  std::vector<base::File::Error>& events() { return events_; }
+
+  base::WeakPtr<CallbackLogger> GetWeakPtr() {
+    return weak_ptr_factory_.GetWeakPtr();
+  }
+
+ private:
+  std::vector<base::File::Error> events_;
+  bool dispatch_reply_;
+  base::WeakPtrFactory<CallbackLogger> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallbackLogger);
+};
+
+}  // namespace
+
+class FileSystemProviderOperationsUnmountTest : public testing::Test {
+ protected:
+  FileSystemProviderOperationsUnmountTest() {}
+  virtual ~FileSystemProviderOperationsUnmountTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    file_system_info_ =
+        ProvidedFileSystemInfo(kExtensionId,
+                               kFileSystemId,
+                               "" /* file_system_name */,
+                               base::FilePath() /* mount_path */);
+  }
+
+  ProvidedFileSystemInfo file_system_info_;
+};
+
+TEST_F(FileSystemProviderOperationsUnmountTest, Execute) {
+  LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
+  CallbackLogger callback_logger;
+
+  Unmount unmount(
+      NULL,
+      file_system_info_,
+      base::Bind(&CallbackLogger::OnUnmount, callback_logger.GetWeakPtr()));
+  unmount.SetDispatchEventImplForTesting(
+      base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
+                 base::Unretained(&dispatcher)));
+
+  EXPECT_TRUE(unmount.Execute(kRequestId));
+
+  ASSERT_EQ(1u, dispatcher.events().size());
+  extensions::Event* event = dispatcher.events()[0];
+  EXPECT_EQ(
+      extensions::api::file_system_provider::OnUnmountRequested::kEventName,
+      event->event_name);
+  base::ListValue* event_args = event->event_args.get();
+  ASSERT_EQ(2u, event_args->GetSize());
+
+  std::string event_file_system_id;
+  EXPECT_TRUE(event_args->GetString(0, &event_file_system_id));
+  EXPECT_EQ(kFileSystemId, event_file_system_id);
+
+  int event_request_id = -1;
+  EXPECT_TRUE(event_args->GetInteger(1, &event_request_id));
+  EXPECT_EQ(kRequestId, event_request_id);
+}
+
+TEST_F(FileSystemProviderOperationsUnmountTest, Execute_NoListener) {
+  LoggingDispatchEventImpl dispatcher(false /* dispatch_reply */);
+  CallbackLogger callback_logger;
+
+  Unmount unmount(
+      NULL,
+      file_system_info_,
+      base::Bind(&CallbackLogger::OnUnmount, callback_logger.GetWeakPtr()));
+  unmount.SetDispatchEventImplForTesting(
+      base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
+                 base::Unretained(&dispatcher)));
+
+  EXPECT_FALSE(unmount.Execute(kRequestId));
+}
+
+TEST_F(FileSystemProviderOperationsUnmountTest, OnSuccess) {
+  using extensions::api::file_system_provider_internal::
+      UnmountRequestedSuccess::Params;
+
+  LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
+  CallbackLogger callback_logger;
+
+  Unmount unmount(
+      NULL,
+      file_system_info_,
+      base::Bind(&CallbackLogger::OnUnmount, callback_logger.GetWeakPtr()));
+  unmount.SetDispatchEventImplForTesting(
+      base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
+                 base::Unretained(&dispatcher)));
+
+  EXPECT_TRUE(unmount.Execute(kRequestId));
+
+  unmount.OnSuccess(kRequestId,
+                    scoped_ptr<RequestValue>(new RequestValue()),
+                    false /* has_more */);
+  ASSERT_EQ(1u, callback_logger.events().size());
+  base::File::Error event_result = callback_logger.events()[0];
+  EXPECT_EQ(base::File::FILE_OK, event_result);
+}
+
+TEST_F(FileSystemProviderOperationsUnmountTest, OnError) {
+  using extensions::api::file_system_provider_internal::UnmountRequestedError::
+      Params;
+
+  LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
+  CallbackLogger callback_logger;
+
+  Unmount unmount(
+      NULL,
+      file_system_info_,
+      base::Bind(&CallbackLogger::OnUnmount, callback_logger.GetWeakPtr()));
+  unmount.SetDispatchEventImplForTesting(
+      base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
+                 base::Unretained(&dispatcher)));
+
+  EXPECT_TRUE(unmount.Execute(kRequestId));
+
+  unmount.OnError(kRequestId, base::File::FILE_ERROR_NOT_FOUND);
+  ASSERT_EQ(1u, callback_logger.events().size());
+  base::File::Error event_result = callback_logger.events()[0];
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, event_result);
+}
+
+}  // namespace operations
+}  // namespace file_system_provider
+}  // namespace chromeos

chrome/browser/chromeos/file_system_provider/provided_file_system_unittest.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// TODO(mtomasz): Move these test cases to operations/unmount_unittest.cc.
-
-#include <string>
-#include <vector>
-
-#include "base/files/file.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/run_loop.h"
-#include "base/values.h"
-#include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
-#include "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
-#include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
-#include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
-#include "chrome/browser/chromeos/file_system_provider/request_manager.h"
-#include "chrome/common/extensions/api/file_system_provider.h"
-#include "chrome/test/base/testing_profile.h"
-#include "content/public/test/test_browser_thread_bundle.h"
-#include "extensions/browser/event_router.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace chromeos {
-namespace file_system_provider {
-
-namespace {
-
-const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
-const int kExpectedRequestId = 1;
-const char kFileSystemId[] = "camera-pictures";
-const char kFileSystemName[] = "Camera Pictures";
-
-class FakeEventRouter : public extensions::EventRouter {
- public:
-  explicit FakeEventRouter(Profile* profile) : EventRouter(profile, NULL) {}
-  virtual ~FakeEventRouter() {}
-
-  virtual void DispatchEventToExtension(const std::string& extension_id,
-                                        scoped_ptr<extensions::Event> event)
-      OVERRIDE {
-    extension_id_ = extension_id;
-    event_ = event.Pass();
-  }
-
-  const std::string& extension_id() const { return extension_id_; }
-
-  const extensions::Event* event() const { return event_.get(); }
-
- private:
-  std::string extension_id_;
-  scoped_ptr<extensions::Event> event_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeEventRouter);
-};
-
-class EventLogger {
- public:
-  EventLogger() : weak_ptr_factory_(this) {}
-  virtual ~EventLogger() {}
-
-  void OnStatusCallback(base::File::Error error) {
-    error_.reset(new base::File::Error(error));
-  }
-
-  base::File::Error* error() { return error_.get(); }
-
-  base::WeakPtr<EventLogger> GetWeakPtr() {
-    return weak_ptr_factory_.GetWeakPtr();
-  }
-
- private:
-  scoped_ptr<base::File::Error> error_;
-
-  base::WeakPtrFactory<EventLogger> weak_ptr_factory_;
-  DISALLOW_COPY_AND_ASSIGN(EventLogger);
-};
-
-}  // namespace
-
-class FileSystemProviderProvidedFileSystemTest : public testing::Test {
- protected:
-  FileSystemProviderProvidedFileSystemTest() {}
-  virtual ~FileSystemProviderProvidedFileSystemTest() {}
-
-  virtual void SetUp() OVERRIDE {
-    profile_.reset(new TestingProfile);
-    event_router_.reset(new FakeEventRouter(profile_.get()));
-    event_router_->AddEventListener(
-        extensions::api::file_system_provider::OnUnmountRequested::kEventName,
-        NULL,
-        kExtensionId);
-
-    const base::FilePath mount_path =
-        util::GetMountPath(profile_.get(), kExtensionId, kFileSystemId);
-    file_system_info_.reset(new ProvidedFileSystemInfo(
-        kExtensionId, kFileSystemId, kFileSystemName, mount_path));
-    provided_file_system_.reset(
-        new ProvidedFileSystem(event_router_.get(), *file_system_info_.get()));
-  }
-
-  content::TestBrowserThreadBundle thread_bundle_;
-  scoped_ptr<TestingProfile> profile_;
-  scoped_ptr<FakeEventRouter> event_router_;
-  scoped_ptr<ProvidedFileSystemInfo> file_system_info_;
-  scoped_ptr<ProvidedFileSystemInterface> provided_file_system_;
-};
-
-TEST_F(FileSystemProviderProvidedFileSystemTest, RequestUnmount_Success) {
-  EventLogger logger;
-
-  provided_file_system_->RequestUnmount(
-      base::Bind(&EventLogger::OnStatusCallback, logger.GetWeakPtr()));
-  base::RunLoop().RunUntilIdle();
-
-  // Verify that the event has been sent to the providing extension.
-  EXPECT_EQ(kExtensionId, event_router_->extension_id());
-  const extensions::Event* event = event_router_->event();
-  ASSERT_TRUE(event);
-  ASSERT_TRUE(event->event_args);
-  base::ListValue* event_args = event->event_args.get();
-  EXPECT_EQ(2u, event_args->GetSize());
-  std::string file_system_id;
-  EXPECT_TRUE(event_args->GetString(0, &file_system_id));
-  EXPECT_EQ(kFileSystemId, file_system_id);
-
-  // Remember the request id, and verify it is valid.
-  int request_id = 0;
-  EXPECT_TRUE(event_args->GetInteger(1, &request_id));
-  EXPECT_EQ(kExpectedRequestId, request_id);
-
-  // Callback should not be called, yet.
-  EXPECT_FALSE(logger.error());
-
-  // Simulate sending a success response from the providing extension.
-  RequestManager* request_manager = provided_file_system_->GetRequestManager();
-  ASSERT_TRUE(request_manager);
-  scoped_ptr<RequestValue> response;
-  bool reply_result = request_manager->FulfillRequest(
-      request_id, response.Pass(), false /* has_next */);
-  EXPECT_TRUE(reply_result);
-
-  // Callback should be called. Verify the error code.
-  ASSERT_TRUE(logger.error());
-  EXPECT_EQ(base::File::FILE_OK, *logger.error());
-}
-
-TEST_F(FileSystemProviderProvidedFileSystemTest, RequestUnmount_Error) {
-  EventLogger logger;
-
-  provided_file_system_->RequestUnmount(
-      base::Bind(&EventLogger::OnStatusCallback, logger.GetWeakPtr()));
-  base::RunLoop().RunUntilIdle();
-
-  // Verify that the event has been sent to the providing extension.
-  EXPECT_EQ(kExtensionId, event_router_->extension_id());
-  const extensions::Event* event = event_router_->event();
-  ASSERT_TRUE(event);
-  ASSERT_TRUE(event->event_args);
-  base::ListValue* event_args = event->event_args.get();
-  EXPECT_EQ(2u, event_args->GetSize());
-  std::string file_system_id;
-  EXPECT_TRUE(event_args->GetString(0, &file_system_id));
-  EXPECT_EQ(kFileSystemId, file_system_id);
-
-  // Remember the request id, and verify it is valid.
-  int request_id = 0;
-  EXPECT_TRUE(event_args->GetInteger(1, &request_id));
-  EXPECT_EQ(kExpectedRequestId, request_id);
-
-  // Simulate sending an error response from the providing extension.
-  RequestManager* request_manager = provided_file_system_->GetRequestManager();
-  ASSERT_TRUE(request_manager);
-  bool reply_result = request_manager->RejectRequest(
-      request_id, base::File::FILE_ERROR_NOT_FOUND);
-  EXPECT_TRUE(reply_result);
-
-  // Callback should be called. Verify the error code.
-  ASSERT_TRUE(logger.error());
-  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, *logger.error());
-}
-
-}  // namespace file_system_provider
-}  // namespace chromeos

chrome/chrome_tests_unit.gypi

@@ -716,7 +716,7 @@
         'browser/chromeos/file_system_provider/operations/open_file_unittest.cc',
         'browser/chromeos/file_system_provider/operations/read_directory_unittest.cc',
         'browser/chromeos/file_system_provider/operations/read_file_unittest.cc',
-        'browser/chromeos/file_system_provider/provided_file_system_unittest.cc',
+        'browser/chromeos/file_system_provider/operations/unmount_unittest.cc',
         'browser/chromeos/file_system_provider/request_manager_unittest.cc',
         'browser/chromeos/file_system_provider/service_unittest.cc',
         'browser/chromeos/fileapi/file_access_permissions_unittest.cc',