src/chrome/common/extensions/api/file_browser_handlers/file_browser_handler_manifest_unittest.cc

   1 // Copyright 2013 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 "base/strings/string_number_conversions.h"
   6 #include "chrome/common/extensions/api/file_browser_handlers/file_browser_handler.h"
   7 #include "chrome/common/extensions/extension_builder.h"
   8 #include "chrome/common/extensions/extension_constants.h"
   9 #include "chrome/common/extensions/manifest_tests/extension_manifest_test.h"
  10 #include "chrome/common/extensions/value_builder.h"
  11 #include "extensions/common/error_utils.h"
  12 #include "extensions/common/manifest_constants.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace errors = extensions::manifest_errors;
  16
  17 using extensions::DictionaryBuilder;
  18 using extensions::Extension;
  19 using extensions::ExtensionBuilder;
  20 using extensions::ListBuilder;
  21
  22 namespace {
  23
  24 class FileBrowserHandlerManifestTest : public ExtensionManifestTest {
  25 };
  26
  27 TEST_F(FileBrowserHandlerManifestTest, InvalidFileBrowserHandlers) {
  28   Testcase testcases[] = {
  29     Testcase("filebrowser_invalid_access_permission.json",
  30              extensions::ErrorUtils::FormatErrorMessage(
  31                  errors::kInvalidFileAccessValue, base::IntToString(1))),
  32     Testcase("filebrowser_invalid_access_permission_list.json",
  33              errors::kInvalidFileAccessList),
  34     Testcase("filebrowser_invalid_empty_access_permission_list.json",
  35              errors::kInvalidFileAccessList),
  36     Testcase("filebrowser_invalid_actions_1.json",
  37              errors::kInvalidFileBrowserHandler),
  38     Testcase("filebrowser_invalid_actions_2.json",
  39              errors::kInvalidFileBrowserHandler),
  40     Testcase("filebrowser_invalid_action_id.json",
  41              errors::kInvalidPageActionId),
  42     Testcase("filebrowser_invalid_action_title.json",
  43              errors::kInvalidPageActionDefaultTitle),
  44     Testcase("filebrowser_invalid_file_filters_1.json",
  45              errors::kInvalidFileFiltersList),
  46     Testcase("filebrowser_invalid_file_filters_2.json",
  47              extensions::ErrorUtils::FormatErrorMessage(
  48                 errors::kInvalidFileFilterValue, base::IntToString(0))),
  49     Testcase("filebrowser_invalid_file_filters_url.json",
  50              extensions::ErrorUtils::FormatErrorMessage(
  51                 errors::kInvalidURLPatternError, "http:*.html"))
  52   };
  53   RunTestcases(testcases, arraysize(testcases), EXPECT_TYPE_ERROR);
  54 }
  55
  56 TEST_F(FileBrowserHandlerManifestTest, ValidFileBrowserHandler) {
  57   scoped_refptr<const Extension> extension =
  58       ExtensionBuilder()
  59       .SetManifest(DictionaryBuilder()
  60                    .Set("name", "file browser handler test")
  61                    .Set("version", "1.0.0")
  62                    .Set("manifest_version", 2)
  63                    .Set("file_browser_handlers", ListBuilder()
  64                        .Append(DictionaryBuilder()
  65                            .Set("id", "ExtremelyCoolAction")
  66                            .Set("default_title", "Be Amazed")
  67                            .Set("default_icon", "icon.png")
  68                            .Set("file_filters", ListBuilder()
  69                                .Append("filesystem:*.txt")))))
  70       .Build();
  71
  72   ASSERT_TRUE(extension.get());
  73   FileBrowserHandler::List* handlers =
  74       FileBrowserHandler::GetHandlers(extension.get());
  75   ASSERT_TRUE(handlers != NULL);
  76   ASSERT_EQ(1U, handlers->size());
  77   const FileBrowserHandler* action = handlers->at(0).get();
  78
  79   EXPECT_EQ("ExtremelyCoolAction", action->id());
  80   EXPECT_EQ("Be Amazed", action->title());
  81   EXPECT_EQ("icon.png", action->icon_path());
  82   const extensions::URLPatternSet& patterns = action->file_url_patterns();
  83   ASSERT_EQ(1U, patterns.patterns().size());
  84   EXPECT_TRUE(action->MatchesURL(
  85       GURL("filesystem:chrome-extension://foo/local/test.txt")));
  86   EXPECT_FALSE(action->HasCreateAccessPermission());
  87   EXPECT_TRUE(action->CanRead());
  88   EXPECT_TRUE(action->CanWrite());
  89 }
  90
  91 TEST_F(FileBrowserHandlerManifestTest, ValidFileBrowserHandlerMIMETypes) {
  92   scoped_refptr<const Extension> extension =
  93       ExtensionBuilder()
  94       .SetID(extension_misc::kQuickOfficeExtensionId)
  95       .SetManifest(DictionaryBuilder()
  96                    .Set("name", "file browser handler test")
  97                    .Set("version", "1.0.0")
  98                    .Set("manifest_version", 2)
  99                    .Set("file_browser_handlers", ListBuilder()
 100                        .Append(DictionaryBuilder()
 101                            .Set("id", "ID")
 102                            .Set("default_title", "Default title")
 103                            .Set("default_icon", "icon.png")
 104                            .Set("file_filters", ListBuilder()
 105                                .Append("filesystem:*.txt")))))
 106       .Build();
 107
 108   ASSERT_TRUE(extension.get());
 109   FileBrowserHandler::List* handlers =
 110       FileBrowserHandler::GetHandlers(extension.get());
 111   ASSERT_TRUE(handlers != NULL);
 112   ASSERT_EQ(1U, handlers->size());
 113   const FileBrowserHandler* action = handlers->at(0).get();
 114
 115   const extensions::URLPatternSet& patterns = action->file_url_patterns();
 116   ASSERT_EQ(1U, patterns.patterns().size());
 117   EXPECT_TRUE(action->MatchesURL(
 118       GURL("filesystem:chrome-extension://foo/local/test.txt")));
 119 }
 120
 121 TEST_F(FileBrowserHandlerManifestTest, ValidFileBrowserHandlerWithCreate) {
 122   scoped_refptr<const Extension> extension =
 123       ExtensionBuilder()
 124       .SetManifest(DictionaryBuilder()
 125                    .Set("name", "file browser handler test create")
 126                    .Set("version", "1.0.0")
 127                    .Set("manifest_version", 2)
 128                    .Set("file_browser_handlers", ListBuilder()
 129                        .Append(DictionaryBuilder()
 130                            .Set("id", "ID")
 131                            .Set("default_title", "Default title")
 132                            .Set("default_icon", "icon.png")
 133                            .Set("file_filters", ListBuilder()
 134                                .Append("filesystem:*.txt"))
 135                            .Set("file_access", ListBuilder()
 136                                .Append("create")))))
 137       .Build();
 138
 139   ASSERT_TRUE(extension.get());
 140   FileBrowserHandler::List* handlers =
 141       FileBrowserHandler::GetHandlers(extension.get());
 142   ASSERT_TRUE(handlers != NULL);
 143   ASSERT_EQ(1U, handlers->size());
 144   const FileBrowserHandler* action = handlers->at(0).get();
 145   const extensions::URLPatternSet& patterns = action->file_url_patterns();
 146
 147   EXPECT_EQ(0U, patterns.patterns().size());
 148   EXPECT_TRUE(action->HasCreateAccessPermission());
 149   EXPECT_FALSE(action->CanRead());
 150   EXPECT_FALSE(action->CanWrite());
 151 }
 152
 153 }  // namespace