chrome/browser/chromeos/file_system_provider/operations/get_metadata_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/files/file.h"
   8 #include "base/files/file_path.h"
   9 #include "base/json/json_reader.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/memory/scoped_vector.h"
  12 #include "base/values.h"
  13 #include "chrome/browser/chromeos/file_system_provider/operations/get_metadata.h"
  14 #include "chrome/common/extensions/api/file_system_provider.h"
  15 #include "chrome/common/extensions/api/file_system_provider_internal.h"
  16 #include "extensions/browser/event_router.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "webkit/browser/fileapi/async_file_util.h"
  19
  20 namespace chromeos {
  21 namespace file_system_provider {
  22 namespace operations {
  23 namespace {
  24
  25 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
  26 const char kFileSystemId[] = "testing-file-system";
  27 const char kMimeType[] = "text/plain";
  28 const int kRequestId = 2;
  29 const base::FilePath::CharType kDirectoryPath[] = "/directory";
  30
  31 // Fake event dispatcher implementation with extra logging capability. Acts as
  32 // a providing extension end-point.
  33 class LoggingDispatchEventImpl {
  34  public:
  35   explicit LoggingDispatchEventImpl(bool dispatch_reply)
  36       : dispatch_reply_(dispatch_reply) {}
  37   virtual ~LoggingDispatchEventImpl() {}
  38
  39   bool OnDispatchEventImpl(scoped_ptr<extensions::Event> event) {
  40     events_.push_back(event->DeepCopy());
  41     return dispatch_reply_;
  42   }
  43
  44   ScopedVector<extensions::Event>& events() { return events_; }
  45
  46  private:
  47   ScopedVector<extensions::Event> events_;
  48   bool dispatch_reply_;
  49
  50   DISALLOW_COPY_AND_ASSIGN(LoggingDispatchEventImpl);
  51 };
  52
  53 // Callback invocation logger. Acts as a fileapi end-point.
  54 class CallbackLogger {
  55  public:
  56   class Event {
  57    public:
  58     Event(const EntryMetadata& metadata, base::File::Error result)
  59         : metadata_(metadata), result_(result) {}
  60     virtual ~Event() {}
  61
  62     const EntryMetadata& metadata() { return metadata_; }
  63     base::File::Error result() { return result_; }
  64
  65    private:
  66     EntryMetadata metadata_;
  67     base::File::Error result_;
  68
  69     DISALLOW_COPY_AND_ASSIGN(Event);
  70   };
  71
  72   CallbackLogger() {}
  73   virtual ~CallbackLogger() {}
  74
  75   void OnGetMetadata(const EntryMetadata& metadata, base::File::Error result) {
  76     events_.push_back(new Event(metadata, result));
  77   }
  78
  79   ScopedVector<Event>& events() { return events_; }
  80
  81  private:
  82   ScopedVector<Event> events_;
  83   bool dispatch_reply_;
  84
  85   DISALLOW_COPY_AND_ASSIGN(CallbackLogger);
  86 };
  87
  88 }  // namespace
  89
  90 class FileSystemProviderOperationsGetMetadataTest : public testing::Test {
  91  protected:
  92   FileSystemProviderOperationsGetMetadataTest() {}
  93   virtual ~FileSystemProviderOperationsGetMetadataTest() {}
  94
  95   virtual void SetUp() OVERRIDE {
  96     file_system_info_ =
  97         ProvidedFileSystemInfo(kExtensionId,
  98                                kFileSystemId,
  99                                "" /* file_system_name */,
 100                                base::FilePath() /* mount_path */);
 101   }
 102
 103   ProvidedFileSystemInfo file_system_info_;
 104 };
 105
 106 TEST_F(FileSystemProviderOperationsGetMetadataTest, Execute) {
 107   LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
 108   CallbackLogger callback_logger;
 109
 110   GetMetadata get_metadata(NULL,
 111                            file_system_info_,
 112                            base::FilePath::FromUTF8Unsafe(kDirectoryPath),
 113                            base::Bind(&CallbackLogger::OnGetMetadata,
 114                                       base::Unretained(&callback_logger)));
 115   get_metadata.SetDispatchEventImplForTesting(
 116       base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
 117                  base::Unretained(&dispatcher)));
 118
 119   EXPECT_TRUE(get_metadata.Execute(kRequestId));
 120
 121   ASSERT_EQ(1u, dispatcher.events().size());
 122   extensions::Event* event = dispatcher.events()[0];
 123   EXPECT_EQ(
 124       extensions::api::file_system_provider::OnGetMetadataRequested::kEventName,
 125       event->event_name);
 126   base::ListValue* event_args = event->event_args.get();
 127   ASSERT_EQ(1u, event_args->GetSize());
 128
 129   base::DictionaryValue* options = NULL;
 130   ASSERT_TRUE(event_args->GetDictionary(0, &options));
 131
 132   std::string event_file_system_id;
 133   EXPECT_TRUE(options->GetString("fileSystemId", &event_file_system_id));
 134   EXPECT_EQ(kFileSystemId, event_file_system_id);
 135
 136   int event_request_id = -1;
 137   EXPECT_TRUE(options->GetInteger("requestId", &event_request_id));
 138   EXPECT_EQ(kRequestId, event_request_id);
 139
 140   std::string event_entry_path;
 141   EXPECT_TRUE(options->GetString("entryPath", &event_entry_path));
 142   EXPECT_EQ(kDirectoryPath, event_entry_path);
 143 }
 144
 145 TEST_F(FileSystemProviderOperationsGetMetadataTest, Execute_NoListener) {
 146   LoggingDispatchEventImpl dispatcher(false /* dispatch_reply */);
 147   CallbackLogger callback_logger;
 148
 149   GetMetadata get_metadata(NULL,
 150                            file_system_info_,
 151                            base::FilePath::FromUTF8Unsafe(kDirectoryPath),
 152                            base::Bind(&CallbackLogger::OnGetMetadata,
 153                                       base::Unretained(&callback_logger)));
 154   get_metadata.SetDispatchEventImplForTesting(
 155       base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
 156                  base::Unretained(&dispatcher)));
 157
 158   EXPECT_FALSE(get_metadata.Execute(kRequestId));
 159 }
 160
 161 TEST_F(FileSystemProviderOperationsGetMetadataTest, OnSuccess) {
 162   using extensions::api::file_system_provider_internal::
 163       GetMetadataRequestedSuccess::Params;
 164
 165   LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
 166   CallbackLogger callback_logger;
 167
 168   GetMetadata get_metadata(NULL,
 169                            file_system_info_,
 170                            base::FilePath::FromUTF8Unsafe(kDirectoryPath),
 171                            base::Bind(&CallbackLogger::OnGetMetadata,
 172                                       base::Unretained(&callback_logger)));
 173   get_metadata.SetDispatchEventImplForTesting(
 174       base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
 175                  base::Unretained(&dispatcher)));
 176
 177   EXPECT_TRUE(get_metadata.Execute(kRequestId));
 178
 179   // Sample input as JSON. Keep in sync with file_system_provider_api.idl.
 180   // As for now, it is impossible to create *::Params class directly, not from
 181   // base::Value.
 182   const std::string input =
 183       "[\n"
 184       "  \"testing-file-system\",\n"  // kFileSystemId
 185       "  2,\n"                        // kRequestId
 186       "  {\n"
 187       "    \"isDirectory\": false,\n"
 188       "    \"name\": \"blueberries.txt\",\n"
 189       "    \"size\": 4096,\n"
 190       "    \"modificationTime\": {\n"
 191       "      \"value\": \"Thu Apr 24 00:46:52 UTC 2014\"\n"
 192       "    },\n"
 193       "    \"mimeType\": \"text/plain\"\n"  // kMimeType
 194       "  },\n"
 195       "  0\n"  // execution_time
 196       "]\n";
 197
 198   int json_error_code;
 199   std::string json_error_msg;
 200   scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError(
 201       input, base::JSON_PARSE_RFC, &json_error_code, &json_error_msg));
 202   ASSERT_TRUE(value.get()) << json_error_msg;
 203
 204   base::ListValue* value_as_list;
 205   ASSERT_TRUE(value->GetAsList(&value_as_list));
 206   scoped_ptr<Params> params(Params::Create(*value_as_list));
 207   ASSERT_TRUE(params.get());
 208   scoped_ptr<RequestValue> request_value(
 209       RequestValue::CreateForGetMetadataSuccess(params.Pass()));
 210   ASSERT_TRUE(request_value.get());
 211
 212   const bool has_more = false;
 213   get_metadata.OnSuccess(kRequestId, request_value.Pass(), has_more);
 214
 215   ASSERT_EQ(1u, callback_logger.events().size());
 216   CallbackLogger::Event* event = callback_logger.events()[0];
 217   EXPECT_EQ(base::File::FILE_OK, event->result());
 218
 219   const EntryMetadata& metadata = event->metadata();
 220   EXPECT_FALSE(metadata.is_directory);
 221   EXPECT_EQ(4096, metadata.size);
 222   base::Time expected_time;
 223   EXPECT_TRUE(
 224       base::Time::FromString("Thu Apr 24 00:46:52 UTC 2014", &expected_time));
 225   EXPECT_EQ(expected_time, metadata.modification_time);
 226   EXPECT_EQ(kMimeType, metadata.mime_type);
 227 }
 228
 229 TEST_F(FileSystemProviderOperationsGetMetadataTest, OnError) {
 230   LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
 231   CallbackLogger callback_logger;
 232
 233   GetMetadata get_metadata(NULL,
 234                            file_system_info_,
 235                            base::FilePath::FromUTF8Unsafe(kDirectoryPath),
 236                            base::Bind(&CallbackLogger::OnGetMetadata,
 237                                       base::Unretained(&callback_logger)));
 238   get_metadata.SetDispatchEventImplForTesting(
 239       base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
 240                  base::Unretained(&dispatcher)));
 241
 242   EXPECT_TRUE(get_metadata.Execute(kRequestId));
 243
 244   get_metadata.OnError(kRequestId,
 245                        scoped_ptr<RequestValue>(new RequestValue()),
 246                        base::File::FILE_ERROR_TOO_MANY_OPENED);
 247
 248   ASSERT_EQ(1u, callback_logger.events().size());
 249   CallbackLogger::Event* event = callback_logger.events()[0];
 250   EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, event->result());
 251 }
 252
 253 }  // namespace operations
 254 }  // namespace file_system_provider
 255 }  // namespace chromeos