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