chrome/common/extensions/features/simple_feature_unittest.cc

   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/features/simple_feature.h"
   6
   7 #include "chrome/common/extensions/features/feature_channel.h"
   8 #include "extensions/common/value_builder.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 using chrome::VersionInfo;
  12 using extensions::DictionaryBuilder;
  13 using extensions::Extension;
  14 using extensions::Feature;
  15 using extensions::ListBuilder;
  16 using extensions::Manifest;
  17 using extensions::ScopedCurrentChannel;
  18 using extensions::SimpleFeature;
  19
  20 namespace {
  21
  22 struct IsAvailableTestData {
  23   std::string extension_id;
  24   Manifest::Type extension_type;
  25   Feature::Location location;
  26   Feature::Platform platform;
  27   int manifest_version;
  28   Feature::AvailabilityResult expected_result;
  29 };
  30
  31 class ExtensionSimpleFeatureTest : public testing::Test {
  32  protected:
  33   ExtensionSimpleFeatureTest()
  34       : current_channel_(VersionInfo::CHANNEL_UNKNOWN) {}
  35   virtual ~ExtensionSimpleFeatureTest() {}
  36
  37  private:
  38   ScopedCurrentChannel current_channel_;
  39 };
  40
  41 TEST_F(ExtensionSimpleFeatureTest, IsAvailableNullCase) {
  42   const IsAvailableTestData tests[] = {
  43     { "", Manifest::TYPE_UNKNOWN,
  44       Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1,
  45       Feature::IS_AVAILABLE },
  46     { "random-extension", Manifest::TYPE_UNKNOWN,
  47       Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1,
  48       Feature::IS_AVAILABLE },
  49     { "", Manifest::TYPE_LEGACY_PACKAGED_APP,
  50       Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1,
  51       Feature::IS_AVAILABLE },
  52     { "", Manifest::TYPE_UNKNOWN,
  53       Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1,
  54       Feature::IS_AVAILABLE },
  55     { "", Manifest::TYPE_UNKNOWN,
  56       Feature::COMPONENT_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1,
  57       Feature::IS_AVAILABLE },
  58     { "", Manifest::TYPE_UNKNOWN,
  59       Feature::UNSPECIFIED_LOCATION, Feature::CHROMEOS_PLATFORM, -1,
  60       Feature::IS_AVAILABLE },
  61     { "", Manifest::TYPE_UNKNOWN,
  62       Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, 25,
  63       Feature::IS_AVAILABLE }
  64   };
  65
  66   SimpleFeature feature;
  67   for (size_t i = 0; i < arraysize(tests); ++i) {
  68     const IsAvailableTestData& test = tests[i];
  69     EXPECT_EQ(test.expected_result,
  70               feature.IsAvailableToManifest(test.extension_id,
  71                                             test.extension_type,
  72                                             test.location,
  73                                             test.manifest_version,
  74                                             test.platform).result());
  75   }
  76 }
  77
  78 TEST_F(ExtensionSimpleFeatureTest, Whitelist) {
  79   const std::string kIdFoo("fooabbbbccccddddeeeeffffgggghhhh");
  80   const std::string kIdBar("barabbbbccccddddeeeeffffgggghhhh");
  81   const std::string kIdBaz("bazabbbbccccddddeeeeffffgggghhhh");
  82   SimpleFeature feature;
  83   feature.whitelist()->insert(kIdFoo);
  84   feature.whitelist()->insert(kIdBar);
  85
  86   EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
  87       kIdFoo, Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
  88       Feature::UNSPECIFIED_PLATFORM).result());
  89   EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
  90       kIdBar, Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
  91       Feature::UNSPECIFIED_PLATFORM).result());
  92
  93   EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest(
  94       kIdBaz, Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
  95       Feature::UNSPECIFIED_PLATFORM).result());
  96   EXPECT_EQ(
  97       Feature::NOT_FOUND_IN_WHITELIST,
  98       feature.IsAvailableToManifest(std::string(),
  99                                     Manifest::TYPE_UNKNOWN,
 100                                     Feature::UNSPECIFIED_LOCATION,
 101                                     -1,
 102                                     Feature::UNSPECIFIED_PLATFORM).result());
 103
 104   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
 105   EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest(
 106       kIdBaz, Manifest::TYPE_LEGACY_PACKAGED_APP,
 107       Feature::UNSPECIFIED_LOCATION, -1,
 108       Feature::UNSPECIFIED_PLATFORM).result());
 109 }
 110
 111 TEST_F(ExtensionSimpleFeatureTest, HashedIdWhitelist) {
 112   // echo -n "fooabbbbccccddddeeeeffffgggghhhh" |
 113   //   sha1sum | tr '[:lower:]' '[:upper:]'
 114   const std::string kIdFoo("fooabbbbccccddddeeeeffffgggghhhh");
 115   const std::string kIdFooHashed("55BC7228A0D502A2A48C9BB16B07062A01E62897");
 116   SimpleFeature feature;
 117
 118   feature.whitelist()->insert(kIdFooHashed);
 119
 120   EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
 121       kIdFoo, Manifest::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1,
 122       Feature::UNSPECIFIED_PLATFORM).result());
 123   EXPECT_NE(Feature::IS_AVAILABLE, feature.IsAvailableToManifest(
 124       kIdFooHashed, Manifest::TYPE_UNKNOWN,
 125       Feature::UNSPECIFIED_LOCATION, -1,
 126       Feature::UNSPECIFIED_PLATFORM).result());
 127   EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest(
 128       "slightlytoooolongforanextensionid", Manifest::TYPE_UNKNOWN,
 129       Feature::UNSPECIFIED_LOCATION, -1,
 130       Feature::UNSPECIFIED_PLATFORM).result());
 131   EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest(
 132       "tooshortforanextensionid", Manifest::TYPE_UNKNOWN,
 133       Feature::UNSPECIFIED_LOCATION, -1,
 134       Feature::UNSPECIFIED_PLATFORM).result());
 135 }
 136
 137 TEST_F(ExtensionSimpleFeatureTest, PackageType) {
 138   SimpleFeature feature;
 139   feature.extension_types()->insert(Manifest::TYPE_EXTENSION);
 140   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
 141
 142   EXPECT_EQ(
 143       Feature::IS_AVAILABLE,
 144       feature.IsAvailableToManifest(std::string(),
 145                                     Manifest::TYPE_EXTENSION,
 146                                     Feature::UNSPECIFIED_LOCATION,
 147                                     -1,
 148                                     Feature::UNSPECIFIED_PLATFORM).result());
 149   EXPECT_EQ(
 150       Feature::IS_AVAILABLE,
 151       feature.IsAvailableToManifest(std::string(),
 152                                     Manifest::TYPE_LEGACY_PACKAGED_APP,
 153                                     Feature::UNSPECIFIED_LOCATION,
 154                                     -1,
 155                                     Feature::UNSPECIFIED_PLATFORM).result());
 156
 157   EXPECT_EQ(
 158       Feature::INVALID_TYPE,
 159       feature.IsAvailableToManifest(std::string(),
 160                                     Manifest::TYPE_UNKNOWN,
 161                                     Feature::UNSPECIFIED_LOCATION,
 162                                     -1,
 163                                     Feature::UNSPECIFIED_PLATFORM).result());
 164   EXPECT_EQ(
 165       Feature::INVALID_TYPE,
 166       feature.IsAvailableToManifest(std::string(),
 167                                     Manifest::TYPE_THEME,
 168                                     Feature::UNSPECIFIED_LOCATION,
 169                                     -1,
 170                                     Feature::UNSPECIFIED_PLATFORM).result());
 171 }
 172
 173 TEST_F(ExtensionSimpleFeatureTest, Context) {
 174   SimpleFeature feature;
 175   feature.set_name("somefeature");
 176   feature.GetContexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
 177   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
 178   feature.platforms()->insert(Feature::CHROMEOS_PLATFORM);
 179   feature.set_min_manifest_version(21);
 180   feature.set_max_manifest_version(25);
 181
 182   base::DictionaryValue manifest;
 183   manifest.SetString("name", "test");
 184   manifest.SetString("version", "1");
 185   manifest.SetInteger("manifest_version", 21);
 186   manifest.SetString("app.launch.local_path", "foo.html");
 187
 188   std::string error;
 189   scoped_refptr<const Extension> extension(Extension::Create(
 190       base::FilePath(), Manifest::INTERNAL, manifest, Extension::NO_FLAGS,
 191       &error));
 192   EXPECT_EQ("", error);
 193   ASSERT_TRUE(extension.get());
 194
 195   feature.whitelist()->insert("monkey");
 196   EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToContext(
 197       extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
 198       Feature::CHROMEOS_PLATFORM).result());
 199   feature.whitelist()->clear();
 200
 201   feature.extension_types()->clear();
 202   feature.extension_types()->insert(Manifest::TYPE_THEME);
 203   {
 204     Feature::Availability availability = feature.IsAvailableToContext(
 205         extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
 206         Feature::CHROMEOS_PLATFORM);
 207     EXPECT_EQ(Feature::INVALID_TYPE, availability.result());
 208     EXPECT_EQ("'somefeature' is only allowed for themes, "
 209               "but this is a legacy packaged app.",
 210               availability.message());
 211   }
 212
 213   feature.extension_types()->clear();
 214   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
 215   feature.GetContexts()->clear();
 216   feature.GetContexts()->insert(Feature::UNBLESSED_EXTENSION_CONTEXT);
 217   feature.GetContexts()->insert(Feature::CONTENT_SCRIPT_CONTEXT);
 218   {
 219     Feature::Availability availability = feature.IsAvailableToContext(
 220         extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
 221         Feature::CHROMEOS_PLATFORM);
 222     EXPECT_EQ(Feature::INVALID_CONTEXT, availability.result());
 223     EXPECT_EQ("'somefeature' is only allowed to run in extension iframes and "
 224               "content scripts, but this is a privileged page",
 225               availability.message());
 226   }
 227
 228   feature.GetContexts()->insert(Feature::WEB_PAGE_CONTEXT);
 229   {
 230     Feature::Availability availability = feature.IsAvailableToContext(
 231         extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
 232         Feature::CHROMEOS_PLATFORM);
 233     EXPECT_EQ(Feature::INVALID_CONTEXT, availability.result());
 234     EXPECT_EQ("'somefeature' is only allowed to run in extension iframes, "
 235               "content scripts, and web pages, but this is a privileged page",
 236               availability.message());
 237   }
 238
 239   feature.GetContexts()->clear();
 240   feature.GetContexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
 241   feature.set_location(Feature::COMPONENT_LOCATION);
 242   EXPECT_EQ(Feature::INVALID_LOCATION, feature.IsAvailableToContext(
 243       extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
 244       Feature::CHROMEOS_PLATFORM).result());
 245   feature.set_location(Feature::UNSPECIFIED_LOCATION);
 246
 247   EXPECT_EQ(Feature::INVALID_PLATFORM, feature.IsAvailableToContext(
 248       extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
 249       Feature::UNSPECIFIED_PLATFORM).result());
 250
 251   feature.set_min_manifest_version(22);
 252   EXPECT_EQ(Feature::INVALID_MIN_MANIFEST_VERSION, feature.IsAvailableToContext(
 253       extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
 254       Feature::CHROMEOS_PLATFORM).result());
 255   feature.set_min_manifest_version(21);
 256
 257   feature.set_max_manifest_version(18);
 258   EXPECT_EQ(Feature::INVALID_MAX_MANIFEST_VERSION, feature.IsAvailableToContext(
 259       extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
 260       Feature::CHROMEOS_PLATFORM).result());
 261   feature.set_max_manifest_version(25);
 262 }
 263
 264 TEST_F(ExtensionSimpleFeatureTest, Location) {
 265   SimpleFeature feature;
 266
 267   // If the feature specifies "component" as its location, then only component
 268   // extensions can access it.
 269   feature.set_location(Feature::COMPONENT_LOCATION);
 270   EXPECT_EQ(
 271       Feature::IS_AVAILABLE,
 272       feature.IsAvailableToManifest(std::string(),
 273                                     Manifest::TYPE_UNKNOWN,
 274                                     Feature::COMPONENT_LOCATION,
 275                                     -1,
 276                                     Feature::UNSPECIFIED_PLATFORM).result());
 277   EXPECT_EQ(
 278       Feature::INVALID_LOCATION,
 279       feature.IsAvailableToManifest(std::string(),
 280                                     Manifest::TYPE_UNKNOWN,
 281                                     Feature::UNSPECIFIED_LOCATION,
 282                                     -1,
 283                                     Feature::UNSPECIFIED_PLATFORM).result());
 284
 285   // But component extensions can access anything else, whatever their location.
 286   feature.set_location(Feature::UNSPECIFIED_LOCATION);
 287   EXPECT_EQ(
 288       Feature::IS_AVAILABLE,
 289       feature.IsAvailableToManifest(std::string(),
 290                                     Manifest::TYPE_UNKNOWN,
 291                                     Feature::COMPONENT_LOCATION,
 292                                     -1,
 293                                     Feature::UNSPECIFIED_PLATFORM).result());
 294 }
 295
 296 TEST_F(ExtensionSimpleFeatureTest, Platform) {
 297   SimpleFeature feature;
 298   feature.platforms()->insert(Feature::CHROMEOS_PLATFORM);
 299   EXPECT_EQ(Feature::IS_AVAILABLE,
 300             feature.IsAvailableToManifest(std::string(),
 301                                           Manifest::TYPE_UNKNOWN,
 302                                           Feature::UNSPECIFIED_LOCATION,
 303                                           -1,
 304                                           Feature::CHROMEOS_PLATFORM).result());
 305   EXPECT_EQ(
 306       Feature::INVALID_PLATFORM,
 307       feature.IsAvailableToManifest(std::string(),
 308                                     Manifest::TYPE_UNKNOWN,
 309                                     Feature::UNSPECIFIED_LOCATION,
 310                                     -1,
 311                                     Feature::UNSPECIFIED_PLATFORM).result());
 312 }
 313
 314 TEST_F(ExtensionSimpleFeatureTest, Version) {
 315   SimpleFeature feature;
 316   feature.set_min_manifest_version(5);
 317
 318   EXPECT_EQ(
 319       Feature::INVALID_MIN_MANIFEST_VERSION,
 320       feature.IsAvailableToManifest(std::string(),
 321                                     Manifest::TYPE_UNKNOWN,
 322                                     Feature::UNSPECIFIED_LOCATION,
 323                                     0,
 324                                     Feature::UNSPECIFIED_PLATFORM).result());
 325   EXPECT_EQ(
 326       Feature::INVALID_MIN_MANIFEST_VERSION,
 327       feature.IsAvailableToManifest(std::string(),
 328                                     Manifest::TYPE_UNKNOWN,
 329                                     Feature::UNSPECIFIED_LOCATION,
 330                                     4,
 331                                     Feature::UNSPECIFIED_PLATFORM).result());
 332
 333   EXPECT_EQ(
 334       Feature::IS_AVAILABLE,
 335       feature.IsAvailableToManifest(std::string(),
 336                                     Manifest::TYPE_UNKNOWN,
 337                                     Feature::UNSPECIFIED_LOCATION,
 338                                     5,
 339                                     Feature::UNSPECIFIED_PLATFORM).result());
 340   EXPECT_EQ(
 341       Feature::IS_AVAILABLE,
 342       feature.IsAvailableToManifest(std::string(),
 343                                     Manifest::TYPE_UNKNOWN,
 344                                     Feature::UNSPECIFIED_LOCATION,
 345                                     10,
 346                                     Feature::UNSPECIFIED_PLATFORM).result());
 347
 348   feature.set_max_manifest_version(8);
 349
 350   EXPECT_EQ(
 351       Feature::INVALID_MAX_MANIFEST_VERSION,
 352       feature.IsAvailableToManifest(std::string(),
 353                                     Manifest::TYPE_UNKNOWN,
 354                                     Feature::UNSPECIFIED_LOCATION,
 355                                     10,
 356                                     Feature::UNSPECIFIED_PLATFORM).result());
 357   EXPECT_EQ(
 358       Feature::IS_AVAILABLE,
 359       feature.IsAvailableToManifest(std::string(),
 360                                     Manifest::TYPE_UNKNOWN,
 361                                     Feature::UNSPECIFIED_LOCATION,
 362                                     8,
 363                                     Feature::UNSPECIFIED_PLATFORM).result());
 364   EXPECT_EQ(
 365       Feature::IS_AVAILABLE,
 366       feature.IsAvailableToManifest(std::string(),
 367                                     Manifest::TYPE_UNKNOWN,
 368                                     Feature::UNSPECIFIED_LOCATION,
 369                                     7,
 370                                     Feature::UNSPECIFIED_PLATFORM).result());
 371 }
 372
 373 TEST_F(ExtensionSimpleFeatureTest, ParseNull) {
 374   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 375   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
 376   feature->Parse(value.get());
 377   EXPECT_TRUE(feature->whitelist()->empty());
 378   EXPECT_TRUE(feature->extension_types()->empty());
 379   EXPECT_TRUE(feature->GetContexts()->empty());
 380   EXPECT_EQ(Feature::UNSPECIFIED_LOCATION, feature->location());
 381   EXPECT_TRUE(feature->platforms()->empty());
 382   EXPECT_EQ(0, feature->min_manifest_version());
 383   EXPECT_EQ(0, feature->max_manifest_version());
 384 }
 385
 386 TEST_F(ExtensionSimpleFeatureTest, ParseWhitelist) {
 387   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 388   base::ListValue* whitelist = new base::ListValue();
 389   whitelist->Append(new base::StringValue("foo"));
 390   whitelist->Append(new base::StringValue("bar"));
 391   value->Set("whitelist", whitelist);
 392   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
 393   feature->Parse(value.get());
 394   EXPECT_EQ(2u, feature->whitelist()->size());
 395   EXPECT_TRUE(feature->whitelist()->count("foo"));
 396   EXPECT_TRUE(feature->whitelist()->count("bar"));
 397 }
 398
 399 TEST_F(ExtensionSimpleFeatureTest, ParsePackageTypes) {
 400   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 401   base::ListValue* extension_types = new base::ListValue();
 402   extension_types->Append(new base::StringValue("extension"));
 403   extension_types->Append(new base::StringValue("theme"));
 404   extension_types->Append(new base::StringValue("legacy_packaged_app"));
 405   extension_types->Append(new base::StringValue("hosted_app"));
 406   extension_types->Append(new base::StringValue("platform_app"));
 407   extension_types->Append(new base::StringValue("shared_module"));
 408   value->Set("extension_types", extension_types);
 409   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
 410   feature->Parse(value.get());
 411   EXPECT_EQ(6u, feature->extension_types()->size());
 412   EXPECT_TRUE(feature->extension_types()->count(Manifest::TYPE_EXTENSION));
 413   EXPECT_TRUE(feature->extension_types()->count(Manifest::TYPE_THEME));
 414   EXPECT_TRUE(feature->extension_types()->count(
 415       Manifest::TYPE_LEGACY_PACKAGED_APP));
 416   EXPECT_TRUE(feature->extension_types()->count(Manifest::TYPE_HOSTED_APP));
 417   EXPECT_TRUE(feature->extension_types()->count(Manifest::TYPE_PLATFORM_APP));
 418   EXPECT_TRUE(feature->extension_types()->count(Manifest::TYPE_SHARED_MODULE));
 419
 420   value->SetString("extension_types", "all");
 421   scoped_ptr<SimpleFeature> feature2(new SimpleFeature());
 422   feature2->Parse(value.get());
 423   EXPECT_EQ(*(feature->extension_types()), *(feature2->extension_types()));
 424 }
 425
 426 TEST_F(ExtensionSimpleFeatureTest, ParseContexts) {
 427   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 428   base::ListValue* contexts = new base::ListValue();
 429   contexts->Append(new base::StringValue("blessed_extension"));
 430   contexts->Append(new base::StringValue("unblessed_extension"));
 431   contexts->Append(new base::StringValue("content_script"));
 432   contexts->Append(new base::StringValue("web_page"));
 433   contexts->Append(new base::StringValue("blessed_web_page"));
 434   value->Set("contexts", contexts);
 435   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
 436   feature->Parse(value.get());
 437   EXPECT_EQ(5u, feature->GetContexts()->size());
 438   EXPECT_TRUE(
 439       feature->GetContexts()->count(Feature::BLESSED_EXTENSION_CONTEXT));
 440   EXPECT_TRUE(
 441       feature->GetContexts()->count(Feature::UNBLESSED_EXTENSION_CONTEXT));
 442   EXPECT_TRUE(
 443       feature->GetContexts()->count(Feature::CONTENT_SCRIPT_CONTEXT));
 444   EXPECT_TRUE(
 445       feature->GetContexts()->count(Feature::WEB_PAGE_CONTEXT));
 446   EXPECT_TRUE(
 447       feature->GetContexts()->count(Feature::BLESSED_WEB_PAGE_CONTEXT));
 448
 449   value->SetString("contexts", "all");
 450   scoped_ptr<SimpleFeature> feature2(new SimpleFeature());
 451   feature2->Parse(value.get());
 452   EXPECT_EQ(*(feature->GetContexts()), *(feature2->GetContexts()));
 453 }
 454
 455 TEST_F(ExtensionSimpleFeatureTest, ParseLocation) {
 456   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 457   value->SetString("location", "component");
 458   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
 459   feature->Parse(value.get());
 460   EXPECT_EQ(Feature::COMPONENT_LOCATION, feature->location());
 461 }
 462
 463 TEST_F(ExtensionSimpleFeatureTest, ParsePlatforms) {
 464   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 465   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
 466   base::ListValue* platforms = new base::ListValue();
 467   value->Set("platforms", platforms);
 468   feature->Parse(value.get());
 469   EXPECT_TRUE(feature->platforms()->empty());
 470
 471   platforms->AppendString("chromeos");
 472   feature->Parse(value.get());
 473   EXPECT_FALSE(feature->platforms()->empty());
 474   EXPECT_EQ(Feature::CHROMEOS_PLATFORM, *feature->platforms()->begin());
 475
 476   platforms->Clear();
 477   platforms->AppendString("win");
 478   feature->Parse(value.get());
 479   EXPECT_FALSE(feature->platforms()->empty());
 480   EXPECT_EQ(Feature::WIN_PLATFORM, *feature->platforms()->begin());
 481
 482   platforms->Clear();
 483   platforms->AppendString("win");
 484   platforms->AppendString("chromeos");
 485   feature->Parse(value.get());
 486   std::set<Feature::Platform> expected_platforms;
 487   expected_platforms.insert(Feature::CHROMEOS_PLATFORM);
 488   expected_platforms.insert(Feature::WIN_PLATFORM);
 489
 490   EXPECT_FALSE(feature->platforms()->empty());
 491   EXPECT_EQ(expected_platforms, *feature->platforms());
 492 }
 493
 494 TEST_F(ExtensionSimpleFeatureTest, ManifestVersion) {
 495   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 496   value->SetInteger("min_manifest_version", 1);
 497   value->SetInteger("max_manifest_version", 5);
 498   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
 499   feature->Parse(value.get());
 500   EXPECT_EQ(1, feature->min_manifest_version());
 501   EXPECT_EQ(5, feature->max_manifest_version());
 502 }
 503
 504 TEST_F(ExtensionSimpleFeatureTest, Inheritance) {
 505   SimpleFeature feature;
 506   feature.whitelist()->insert("foo");
 507   feature.extension_types()->insert(Manifest::TYPE_THEME);
 508   feature.GetContexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
 509   feature.set_location(Feature::COMPONENT_LOCATION);
 510   feature.platforms()->insert(Feature::CHROMEOS_PLATFORM);
 511   feature.set_min_manifest_version(1);
 512   feature.set_max_manifest_version(2);
 513
 514   SimpleFeature feature2 = feature;
 515   EXPECT_TRUE(feature2.Equals(feature));
 516
 517   base::DictionaryValue definition;
 518   feature2.Parse(&definition);
 519   EXPECT_TRUE(feature2.Equals(feature));
 520
 521   base::ListValue* whitelist = new base::ListValue();
 522   base::ListValue* extension_types = new base::ListValue();
 523   base::ListValue* contexts = new base::ListValue();
 524   whitelist->Append(new base::StringValue("bar"));
 525   extension_types->Append(new base::StringValue("extension"));
 526   contexts->Append(new base::StringValue("unblessed_extension"));
 527   definition.Set("whitelist", whitelist);
 528   definition.Set("extension_types", extension_types);
 529   definition.Set("contexts", contexts);
 530   // Can't test location or platform because we only have one value so far.
 531   definition.Set("min_manifest_version", new base::FundamentalValue(2));
 532   definition.Set("max_manifest_version", new base::FundamentalValue(3));
 533
 534   feature2.Parse(&definition);
 535   EXPECT_FALSE(feature2.Equals(feature));
 536   EXPECT_EQ(1u, feature2.whitelist()->size());
 537   EXPECT_EQ(1u, feature2.extension_types()->size());
 538   EXPECT_EQ(1u, feature2.GetContexts()->size());
 539   EXPECT_EQ(1u, feature2.whitelist()->count("bar"));
 540   EXPECT_EQ(1u, feature2.extension_types()->count(Manifest::TYPE_EXTENSION));
 541   EXPECT_EQ(1u, feature2.GetContexts()->count(
 542       Feature::UNBLESSED_EXTENSION_CONTEXT));
 543   EXPECT_EQ(2, feature2.min_manifest_version());
 544   EXPECT_EQ(3, feature2.max_manifest_version());
 545 }
 546
 547 TEST_F(ExtensionSimpleFeatureTest, Equals) {
 548   SimpleFeature feature;
 549   feature.whitelist()->insert("foo");
 550   feature.extension_types()->insert(Manifest::TYPE_THEME);
 551   feature.GetContexts()->insert(Feature::UNBLESSED_EXTENSION_CONTEXT);
 552   feature.set_location(Feature::COMPONENT_LOCATION);
 553   feature.platforms()->insert(Feature::CHROMEOS_PLATFORM);
 554   feature.set_min_manifest_version(18);
 555   feature.set_max_manifest_version(25);
 556
 557   SimpleFeature feature2(feature);
 558   EXPECT_TRUE(feature2.Equals(feature));
 559
 560   feature2.whitelist()->clear();
 561   EXPECT_FALSE(feature2.Equals(feature));
 562
 563   feature2 = feature;
 564   feature2.extension_types()->clear();
 565   EXPECT_FALSE(feature2.Equals(feature));
 566
 567   feature2 = feature;
 568   feature2.GetContexts()->clear();
 569   EXPECT_FALSE(feature2.Equals(feature));
 570
 571   feature2 = feature;
 572   feature2.set_location(Feature::UNSPECIFIED_LOCATION);
 573   EXPECT_FALSE(feature2.Equals(feature));
 574
 575   feature2 = feature;
 576   feature.platforms()->insert(Feature::UNSPECIFIED_PLATFORM);
 577   EXPECT_FALSE(feature2.Equals(feature));
 578
 579   feature2 = feature;
 580   feature2.set_min_manifest_version(0);
 581   EXPECT_FALSE(feature2.Equals(feature));
 582
 583   feature2 = feature;
 584   feature2.set_max_manifest_version(0);
 585   EXPECT_FALSE(feature2.Equals(feature));
 586 }
 587
 588 Feature::AvailabilityResult IsAvailableInChannel(
 589     const std::string& channel, VersionInfo::Channel channel_for_testing) {
 590   ScopedCurrentChannel current_channel(channel_for_testing);
 591
 592   SimpleFeature feature;
 593   if (!channel.empty()) {
 594     base::DictionaryValue feature_value;
 595     feature_value.SetString("channel", channel);
 596     feature.Parse(&feature_value);
 597   }
 598
 599   return feature.IsAvailableToManifest(
 600       "random-extension",
 601       Manifest::TYPE_UNKNOWN,
 602       Feature::UNSPECIFIED_LOCATION,
 603       -1,
 604       Feature::GetCurrentPlatform()).result();
 605 }
 606
 607 TEST_F(ExtensionSimpleFeatureTest, SupportedChannel) {
 608   // stable supported.
 609   EXPECT_EQ(Feature::IS_AVAILABLE,
 610       IsAvailableInChannel("stable", VersionInfo::CHANNEL_UNKNOWN));
 611   EXPECT_EQ(Feature::IS_AVAILABLE,
 612       IsAvailableInChannel("stable", VersionInfo::CHANNEL_CANARY));
 613   EXPECT_EQ(Feature::IS_AVAILABLE,
 614       IsAvailableInChannel("stable", VersionInfo::CHANNEL_DEV));
 615   EXPECT_EQ(Feature::IS_AVAILABLE,
 616       IsAvailableInChannel("stable", VersionInfo::CHANNEL_BETA));
 617   EXPECT_EQ(Feature::IS_AVAILABLE,
 618       IsAvailableInChannel("stable", VersionInfo::CHANNEL_STABLE));
 619
 620   // beta supported.
 621   EXPECT_EQ(Feature::IS_AVAILABLE,
 622       IsAvailableInChannel("beta", VersionInfo::CHANNEL_UNKNOWN));
 623   EXPECT_EQ(Feature::IS_AVAILABLE,
 624       IsAvailableInChannel("beta", VersionInfo::CHANNEL_CANARY));
 625   EXPECT_EQ(Feature::IS_AVAILABLE,
 626       IsAvailableInChannel("beta", VersionInfo::CHANNEL_DEV));
 627   EXPECT_EQ(Feature::IS_AVAILABLE,
 628       IsAvailableInChannel("beta", VersionInfo::CHANNEL_BETA));
 629   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 630       IsAvailableInChannel("beta", VersionInfo::CHANNEL_STABLE));
 631
 632   // dev supported.
 633   EXPECT_EQ(Feature::IS_AVAILABLE,
 634       IsAvailableInChannel("dev", VersionInfo::CHANNEL_UNKNOWN));
 635   EXPECT_EQ(Feature::IS_AVAILABLE,
 636       IsAvailableInChannel("dev", VersionInfo::CHANNEL_CANARY));
 637   EXPECT_EQ(Feature::IS_AVAILABLE,
 638       IsAvailableInChannel("dev", VersionInfo::CHANNEL_DEV));
 639   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 640       IsAvailableInChannel("dev", VersionInfo::CHANNEL_BETA));
 641   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 642       IsAvailableInChannel("dev", VersionInfo::CHANNEL_STABLE));
 643
 644   // canary supported.
 645   EXPECT_EQ(Feature::IS_AVAILABLE,
 646       IsAvailableInChannel("canary", VersionInfo::CHANNEL_UNKNOWN));
 647   EXPECT_EQ(Feature::IS_AVAILABLE,
 648       IsAvailableInChannel("canary", VersionInfo::CHANNEL_CANARY));
 649   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 650       IsAvailableInChannel("canary", VersionInfo::CHANNEL_DEV));
 651   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 652       IsAvailableInChannel("canary", VersionInfo::CHANNEL_BETA));
 653   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 654       IsAvailableInChannel("canary", VersionInfo::CHANNEL_STABLE));
 655
 656   // trunk supported.
 657   EXPECT_EQ(Feature::IS_AVAILABLE,
 658       IsAvailableInChannel("trunk", VersionInfo::CHANNEL_UNKNOWN));
 659   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 660       IsAvailableInChannel("trunk", VersionInfo::CHANNEL_CANARY));
 661   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 662       IsAvailableInChannel("trunk", VersionInfo::CHANNEL_DEV));
 663   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 664       IsAvailableInChannel("trunk", VersionInfo::CHANNEL_BETA));
 665   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
 666       IsAvailableInChannel("trunk", VersionInfo::CHANNEL_STABLE));
 667 }
 668
 669 }  // namespace