| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 "extensions/common/manifest_test.h" | |
| 6 | |
| 7 #include "base/files/file_path.h" | |
| 8 #include "base/files/file_util.h" | |
| 9 #include "base/json/json_file_value_serializer.h" | |
| 10 #include "base/path_service.h" | |
| 11 #include "base/strings/string_util.h" | |
| 12 #include "base/values.h" | |
| 13 #include "extensions/common/extension_l10n_util.h" | |
| 14 #include "extensions/common/extension_paths.h" | |
| 15 #include "extensions/common/test_util.h" | |
| 16 #include "ui/base/l10n/l10n_util.h" | |
| 17 | |
| 18 namespace extensions { | |
| 19 namespace { | |
| 20 | |
| 21 // |manifest_path| is an absolute path to a manifest file. | |
| 22 base::DictionaryValue* LoadManifestFile(const base::FilePath& manifest_path, | |
| 23 std::string* error) { | |
| 24 base::FilePath extension_path = manifest_path.DirName(); | |
| 25 | |
| 26 EXPECT_TRUE(base::PathExists(manifest_path)) << | |
| 27 "Couldn't find " << manifest_path.value(); | |
| 28 | |
| 29 JSONFileValueSerializer serializer(manifest_path); | |
| 30 base::DictionaryValue* manifest = | |
| 31 static_cast<base::DictionaryValue*>(serializer.Deserialize(NULL, error)); | |
| 32 | |
| 33 // Most unit tests don't need localization, and they'll fail if we try to | |
| 34 // localize them, since their manifests don't have a default_locale key. | |
| 35 // Only localize manifests that indicate they want to be localized. | |
| 36 // Calling LocalizeExtension at this point mirrors file_util::LoadExtension. | |
| 37 if (manifest && | |
| 38 manifest_path.value().find(FILE_PATH_LITERAL("localized")) != | |
| 39 std::string::npos) | |
| 40 extension_l10n_util::LocalizeExtension(extension_path, manifest, error); | |
| 41 | |
| 42 return manifest; | |
| 43 } | |
| 44 | |
| 45 } // namespace | |
| 46 | |
| 47 ManifestTest::ManifestTest() | |
| 48 : enable_apps_(true) { | |
| 49 } | |
| 50 | |
| 51 ManifestTest::~ManifestTest() { | |
| 52 } | |
| 53 | |
| 54 // Helper class that simplifies creating methods that take either a filename | |
| 55 // to a manifest or the manifest itself. | |
| 56 ManifestTest::ManifestData::ManifestData(const char* name) | |
| 57 : name_(name), manifest_(NULL) { | |
| 58 } | |
| 59 | |
| 60 ManifestTest::ManifestData::ManifestData(base::DictionaryValue* manifest, | |
| 61 const char* name) | |
| 62 : name_(name), manifest_(manifest) { | |
| 63 CHECK(manifest_) << "Manifest NULL"; | |
| 64 } | |
| 65 | |
| 66 ManifestTest::ManifestData::ManifestData( | |
| 67 scoped_ptr<base::DictionaryValue> manifest) | |
| 68 : manifest_(manifest.get()), manifest_holder_(manifest.Pass()) { | |
| 69 CHECK(manifest_) << "Manifest NULL"; | |
| 70 } | |
| 71 | |
| 72 ManifestTest::ManifestData::ManifestData(const ManifestData& m) { | |
| 73 NOTREACHED(); | |
| 74 } | |
| 75 | |
| 76 ManifestTest::ManifestData::~ManifestData() { | |
| 77 } | |
| 78 | |
| 79 base::DictionaryValue* ManifestTest::ManifestData::GetManifest( | |
| 80 base::FilePath test_data_dir, std::string* error) const { | |
| 81 if (manifest_) | |
| 82 return manifest_; | |
| 83 | |
| 84 base::FilePath manifest_path = test_data_dir.AppendASCII(name_); | |
| 85 manifest_ = LoadManifestFile(manifest_path, error); | |
| 86 manifest_holder_.reset(manifest_); | |
| 87 return manifest_; | |
| 88 } | |
| 89 | |
| 90 base::FilePath ManifestTest::GetTestDataDir() { | |
| 91 base::FilePath path; | |
| 92 PathService::Get(DIR_TEST_DATA, &path); | |
| 93 return path.AppendASCII("manifest_tests"); | |
| 94 } | |
| 95 | |
| 96 scoped_ptr<base::DictionaryValue> ManifestTest::LoadManifest( | |
| 97 char const* manifest_name, std::string* error) { | |
| 98 base::FilePath manifest_path = GetTestDataDir().AppendASCII(manifest_name); | |
| 99 return make_scoped_ptr(LoadManifestFile(manifest_path, error)); | |
| 100 } | |
| 101 | |
| 102 scoped_refptr<Extension> ManifestTest::LoadExtension( | |
| 103 const ManifestData& manifest, | |
| 104 std::string* error, | |
| 105 extensions::Manifest::Location location, | |
| 106 int flags) { | |
| 107 base::FilePath test_data_dir = GetTestDataDir(); | |
| 108 base::DictionaryValue* value = manifest.GetManifest(test_data_dir, error); | |
| 109 if (!value) | |
| 110 return NULL; | |
| 111 return Extension::Create( | |
| 112 test_data_dir.DirName(), location, *value, flags, error); | |
| 113 } | |
| 114 | |
| 115 scoped_refptr<Extension> ManifestTest::LoadAndExpectSuccess( | |
| 116 const ManifestData& manifest, | |
| 117 extensions::Manifest::Location location, | |
| 118 int flags) { | |
| 119 std::string error; | |
| 120 scoped_refptr<Extension> extension = | |
| 121 LoadExtension(manifest, &error, location, flags); | |
| 122 EXPECT_TRUE(extension.get()) << manifest.name(); | |
| 123 EXPECT_EQ("", error) << manifest.name(); | |
| 124 return extension; | |
| 125 } | |
| 126 | |
| 127 scoped_refptr<Extension> ManifestTest::LoadAndExpectSuccess( | |
| 128 char const* manifest_name, | |
| 129 extensions::Manifest::Location location, | |
| 130 int flags) { | |
| 131 return LoadAndExpectSuccess(ManifestData(manifest_name), location, flags); | |
| 132 } | |
| 133 | |
| 134 scoped_refptr<Extension> ManifestTest::LoadAndExpectWarning( | |
| 135 const ManifestData& manifest, | |
| 136 const std::string& expected_warning, | |
| 137 extensions::Manifest::Location location, | |
| 138 int flags) { | |
| 139 std::string error; | |
| 140 scoped_refptr<Extension> extension = | |
| 141 LoadExtension(manifest, &error, location, flags); | |
| 142 EXPECT_TRUE(extension.get()) << manifest.name(); | |
| 143 EXPECT_EQ("", error) << manifest.name(); | |
| 144 EXPECT_EQ(1u, extension->install_warnings().size()); | |
| 145 EXPECT_EQ(expected_warning, extension->install_warnings()[0].message); | |
| 146 return extension; | |
| 147 } | |
| 148 | |
| 149 scoped_refptr<Extension> ManifestTest::LoadAndExpectWarning( | |
| 150 char const* manifest_name, | |
| 151 const std::string& expected_warning, | |
| 152 extensions::Manifest::Location location, | |
| 153 int flags) { | |
| 154 return LoadAndExpectWarning( | |
| 155 ManifestData(manifest_name), expected_warning, location, flags); | |
| 156 } | |
| 157 | |
| 158 void ManifestTest::VerifyExpectedError( | |
| 159 Extension* extension, | |
| 160 const std::string& name, | |
| 161 const std::string& error, | |
| 162 const std::string& expected_error) { | |
| 163 EXPECT_FALSE(extension) << | |
| 164 "Expected failure loading extension '" << name << | |
| 165 "', but didn't get one."; | |
| 166 EXPECT_TRUE(MatchPattern(error, expected_error)) << name << | |
| 167 " expected '" << expected_error << "' but got '" << error << "'"; | |
| 168 } | |
| 169 | |
| 170 void ManifestTest::LoadAndExpectError( | |
| 171 const ManifestData& manifest, | |
| 172 const std::string& expected_error, | |
| 173 extensions::Manifest::Location location, | |
| 174 int flags) { | |
| 175 std::string error; | |
| 176 scoped_refptr<Extension> extension( | |
| 177 LoadExtension(manifest, &error, location, flags)); | |
| 178 VerifyExpectedError(extension.get(), manifest.name(), error, | |
| 179 expected_error); | |
| 180 } | |
| 181 | |
| 182 void ManifestTest::LoadAndExpectError( | |
| 183 char const* manifest_name, | |
| 184 const std::string& expected_error, | |
| 185 extensions::Manifest::Location location, | |
| 186 int flags) { | |
| 187 return LoadAndExpectError( | |
| 188 ManifestData(manifest_name), expected_error, location, flags); | |
| 189 } | |
| 190 | |
| 191 void ManifestTest::AddPattern(extensions::URLPatternSet* extent, | |
| 192 const std::string& pattern) { | |
| 193 int schemes = URLPattern::SCHEME_ALL; | |
| 194 extent->AddPattern(URLPattern(schemes, pattern)); | |
| 195 } | |
| 196 | |
| 197 ManifestTest::Testcase::Testcase( | |
| 198 std::string manifest_filename, | |
| 199 std::string expected_error, | |
| 200 extensions::Manifest::Location location, | |
| 201 int flags) | |
| 202 : manifest_filename_(manifest_filename), | |
| 203 expected_error_(expected_error), | |
| 204 location_(location), flags_(flags) { | |
| 205 } | |
| 206 | |
| 207 ManifestTest::Testcase::Testcase(std::string manifest_filename, | |
| 208 std::string expected_error) | |
| 209 : manifest_filename_(manifest_filename), | |
| 210 expected_error_(expected_error), | |
| 211 location_(extensions::Manifest::INTERNAL), | |
| 212 flags_(Extension::NO_FLAGS) { | |
| 213 } | |
| 214 | |
| 215 ManifestTest::Testcase::Testcase(std::string manifest_filename) | |
| 216 : manifest_filename_(manifest_filename), | |
| 217 location_(extensions::Manifest::INTERNAL), | |
| 218 flags_(Extension::NO_FLAGS) {} | |
| 219 | |
| 220 ManifestTest::Testcase::Testcase( | |
| 221 std::string manifest_filename, | |
| 222 extensions::Manifest::Location location, | |
| 223 int flags) | |
| 224 : manifest_filename_(manifest_filename), | |
| 225 location_(location), | |
| 226 flags_(flags) {} | |
| 227 | |
| 228 void ManifestTest::RunTestcases(const Testcase* testcases, | |
| 229 size_t num_testcases, | |
| 230 ExpectType type) { | |
| 231 for (size_t i = 0; i < num_testcases; ++i) | |
| 232 RunTestcase(testcases[i], type); | |
| 233 } | |
| 234 | |
| 235 void ManifestTest::RunTestcase(const Testcase& testcase, | |
| 236 ExpectType type) { | |
| 237 switch (type) { | |
| 238 case EXPECT_TYPE_ERROR: | |
| 239 LoadAndExpectError(testcase.manifest_filename_.c_str(), | |
| 240 testcase.expected_error_, | |
| 241 testcase.location_, | |
| 242 testcase.flags_); | |
| 243 break; | |
| 244 case EXPECT_TYPE_WARNING: | |
| 245 LoadAndExpectWarning(testcase.manifest_filename_.c_str(), | |
| 246 testcase.expected_error_, | |
| 247 testcase.location_, | |
| 248 testcase.flags_); | |
| 249 break; | |
| 250 case EXPECT_TYPE_SUCCESS: | |
| 251 LoadAndExpectSuccess(testcase.manifest_filename_.c_str(), | |
| 252 testcase.location_, | |
| 253 testcase.flags_); | |
| 254 break; | |
| 255 } | |
| 256 } | |
| 257 | |
| 258 } // namespace extensions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 578653005:
Revert "Refactor ExtensionManifestTest to allow usage in src/extensions" (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master