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 259
