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