chrome/common/extensions/features/base_feature_provider_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/base_feature_provider.h"
   6
   7 #include "chrome/common/extensions/features/feature_channel.h"
   8 #include "chrome/common/extensions/features/permission_feature.h"
   9 #include "extensions/common/value_builder.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 using chrome::VersionInfo;
  13
  14 namespace extensions {
  15
  16 TEST(BaseFeatureProviderTest, ManifestFeatures) {
  17   FeatureProvider* provider = BaseFeatureProvider::GetByName("manifest");
  18   SimpleFeature* feature =
  19       static_cast<SimpleFeature*>(provider->GetFeature("description"));
  20   ASSERT_TRUE(feature);
  21   EXPECT_EQ(6u, feature->extension_types()->size());
  22   EXPECT_EQ(1u, feature->extension_types()->count(Manifest::TYPE_EXTENSION));
  23   EXPECT_EQ(1u,
  24       feature->extension_types()->count(Manifest::TYPE_LEGACY_PACKAGED_APP));
  25   EXPECT_EQ(1u,
  26             feature->extension_types()->count(Manifest::TYPE_PLATFORM_APP));
  27   EXPECT_EQ(1u, feature->extension_types()->count(Manifest::TYPE_HOSTED_APP));
  28   EXPECT_EQ(1u, feature->extension_types()->count(Manifest::TYPE_THEME));
  29   EXPECT_EQ(1u,
  30             feature->extension_types()->count(Manifest::TYPE_SHARED_MODULE));
  31
  32   base::DictionaryValue manifest;
  33   manifest.SetString("name", "test extension");
  34   manifest.SetString("version", "1");
  35   manifest.SetString("description", "hello there");
  36
  37   std::string error;
  38   scoped_refptr<const Extension> extension(Extension::Create(
  39       base::FilePath(), Manifest::INTERNAL, manifest, Extension::NO_FLAGS,
  40       &error));
  41
  42   ASSERT_TRUE(extension.get());
  43   EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToContext(
  44       extension.get(), Feature::UNSPECIFIED_CONTEXT).result());
  45
  46   feature =
  47     static_cast<SimpleFeature*>(provider->GetFeature("theme"));
  48   ASSERT_TRUE(feature);
  49   EXPECT_EQ(Feature::INVALID_TYPE, feature->IsAvailableToContext(
  50       extension.get(), Feature::UNSPECIFIED_CONTEXT).result());
  51
  52   feature =
  53     static_cast<SimpleFeature*>(provider->GetFeature("devtools_page"));
  54   ASSERT_TRUE(feature);
  55   EXPECT_EQ(Feature::NOT_PRESENT, feature->IsAvailableToContext(
  56       extension.get(), Feature::UNSPECIFIED_CONTEXT).result());
  57 }
  58
  59 TEST(BaseFeatureProviderTest, PermissionFeatures) {
  60   FeatureProvider* provider = BaseFeatureProvider::GetByName("permission");
  61   SimpleFeature* feature =
  62       static_cast<SimpleFeature*>(provider->GetFeature("contextMenus"));
  63   ASSERT_TRUE(feature);
  64   EXPECT_EQ(3u, feature->extension_types()->size());
  65   EXPECT_EQ(1u, feature->extension_types()->count(Manifest::TYPE_EXTENSION));
  66   EXPECT_EQ(1u,
  67       feature->extension_types()->count(Manifest::TYPE_LEGACY_PACKAGED_APP));
  68   EXPECT_EQ(1u,
  69             feature->extension_types()->count(Manifest::TYPE_PLATFORM_APP));
  70
  71   base::DictionaryValue manifest;
  72   manifest.SetString("name", "test extension");
  73   manifest.SetString("version", "1");
  74   base::ListValue* permissions = new base::ListValue();
  75   manifest.Set("permissions", permissions);
  76   permissions->Append(new base::StringValue("contextMenus"));
  77
  78   std::string error;
  79   scoped_refptr<const Extension> extension(Extension::Create(
  80       base::FilePath(), Manifest::INTERNAL, manifest, Extension::NO_FLAGS,
  81       &error));
  82
  83   ASSERT_TRUE(extension.get());
  84   EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToContext(
  85       extension.get(), Feature::UNSPECIFIED_CONTEXT).result());
  86
  87   feature =
  88     static_cast<SimpleFeature*>(provider->GetFeature("chromePrivate"));
  89   ASSERT_TRUE(feature);
  90   EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature->IsAvailableToContext(
  91       extension.get(), Feature::UNSPECIFIED_CONTEXT).result());
  92
  93   feature =
  94     static_cast<SimpleFeature*>(provider->GetFeature("clipboardWrite"));
  95   ASSERT_TRUE(feature);
  96   EXPECT_EQ(Feature::NOT_PRESENT, feature->IsAvailableToContext(
  97       extension.get(), Feature::UNSPECIFIED_CONTEXT).result());
  98 }
  99
 100 SimpleFeature* CreatePermissionFeature() {
 101   return new PermissionFeature();
 102 }
 103
 104 TEST(BaseFeatureProviderTest, Validation) {
 105   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 106
 107   base::DictionaryValue* feature1 = new base::DictionaryValue();
 108   feature1->SetString("channel", "trunk");
 109   value->Set("feature1", feature1);
 110
 111   base::DictionaryValue* feature2 = new base::DictionaryValue();
 112   feature2->SetString("channel", "trunk");
 113   base::ListValue* extension_types = new base::ListValue();
 114   extension_types->Append(new base::StringValue("extension"));
 115   feature2->Set("extension_types", extension_types);
 116   base::ListValue* contexts = new base::ListValue();
 117   contexts->Append(new base::StringValue("blessed_extension"));
 118   feature2->Set("contexts", contexts);
 119   value->Set("feature2", feature2);
 120
 121   scoped_ptr<BaseFeatureProvider> provider(
 122       new BaseFeatureProvider(*value, CreatePermissionFeature));
 123
 124   // feature1 won't validate because it lacks an extension type.
 125   EXPECT_FALSE(provider->GetFeature("feature1"));
 126
 127   // If we add one, it works.
 128   feature1->Set("extension_types", extension_types->DeepCopy());
 129   provider.reset(new BaseFeatureProvider(*value, CreatePermissionFeature));
 130   EXPECT_TRUE(provider->GetFeature("feature1"));
 131
 132   // Remove the channel, and feature1 won't validate.
 133   feature1->Remove("channel", NULL);
 134   provider.reset(new BaseFeatureProvider(*value, CreatePermissionFeature));
 135   EXPECT_FALSE(provider->GetFeature("feature1"));
 136
 137   // feature2 won't validate because of the presence of "contexts".
 138   EXPECT_FALSE(provider->GetFeature("feature2"));
 139
 140   // If we remove it, it works.
 141   feature2->Remove("contexts", NULL);
 142   provider.reset(new BaseFeatureProvider(*value, CreatePermissionFeature));
 143   EXPECT_TRUE(provider->GetFeature("feature2"));
 144 }
 145
 146 TEST(BaseFeatureProviderTest, ComplexFeatures) {
 147   scoped_ptr<base::DictionaryValue> rule(
 148       DictionaryBuilder()
 149       .Set("feature1", ListBuilder()
 150           .Append(DictionaryBuilder()
 151               .Set("channel", "beta")
 152               .Set("extension_types", ListBuilder()
 153                   .Append("extension")))
 154                   .Append(DictionaryBuilder()
 155                       .Set("channel", "beta")
 156                       .Set("extension_types", ListBuilder()
 157                           .Append("legacy_packaged_app"))))
 158       .Build());
 159
 160   scoped_ptr<BaseFeatureProvider> provider(
 161       new BaseFeatureProvider(*rule, NULL));
 162
 163   Feature* feature = provider->GetFeature("feature1");
 164   EXPECT_TRUE(feature);
 165
 166   // Make sure both rules are applied correctly.
 167   {
 168     ScopedCurrentChannel current_channel(VersionInfo::CHANNEL_BETA);
 169     EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
 170         "1",
 171         Manifest::TYPE_EXTENSION,
 172         Feature::UNSPECIFIED_LOCATION,
 173         Feature::UNSPECIFIED_PLATFORM).result());
 174     EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
 175         "2",
 176         Manifest::TYPE_LEGACY_PACKAGED_APP,
 177         Feature::UNSPECIFIED_LOCATION,
 178         Feature::UNSPECIFIED_PLATFORM).result());
 179   }
 180   {
 181     ScopedCurrentChannel current_channel(VersionInfo::CHANNEL_STABLE);
 182     EXPECT_NE(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
 183         "1",
 184         Manifest::TYPE_EXTENSION,
 185         Feature::UNSPECIFIED_LOCATION,
 186         Feature::UNSPECIFIED_PLATFORM).result());
 187     EXPECT_NE(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
 188         "2",
 189         Manifest::TYPE_LEGACY_PACKAGED_APP,
 190         Feature::UNSPECIFIED_LOCATION,
 191         Feature::UNSPECIFIED_PLATFORM).result());
 192   }
 193 }
 194
 195 }  // namespace extensions