Home | History | Annotate | Download | only in features 
      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/complex_feature.h"
      6 
      7 #include "chrome/common/extensions/features/feature_channel.h"
      8 #include "chrome/common/extensions/features/simple_feature.h"
      9 #include "chrome/common/extensions/value_builder.h"
     10 #include "testing/gtest/include/gtest/gtest.h"
     11 
     12 using chrome::VersionInfo;
     13 using extensions::ComplexFeature;
     14 using extensions::DictionaryBuilder;
     15 using extensions::Feature;
     16 using extensions::ListBuilder;
     17 using extensions::Manifest;
     18 using extensions::ScopedCurrentChannel;
     19 using extensions::SimpleFeature;
     20 
     21 namespace {
     22 
     23 class ExtensionComplexFeatureTest : public testing::Test {
     24  protected:
     25   ExtensionComplexFeatureTest()
     26       : current_channel_(VersionInfo::CHANNEL_UNKNOWN) {}
     27   virtual ~ExtensionComplexFeatureTest() {}
     28 
     29  private:
     30   ScopedCurrentChannel current_channel_;
     31 };
     32 
     33 TEST_F(ExtensionComplexFeatureTest, MultipleRulesWhitelist) {
     34   const std::string kIdFoo("fooabbbbccccddddeeeeffffgggghhhh");
     35   const std::string kIdBar("barabbbbccccddddeeeeffffgggghhhh");
     36   scoped_ptr<ComplexFeature::FeatureList> features(
     37       new ComplexFeature::FeatureList());
     38 
     39   // Rule: "extension", whitelist "foo".
     40   scoped_ptr<SimpleFeature> simple_feature(new SimpleFeature());
     41   scoped_ptr<base::DictionaryValue> rule(
     42       DictionaryBuilder()
     43       .Set("whitelist", ListBuilder().Append(kIdFoo))
     44       .Set("extension_types", ListBuilder().Append("extension")).Build());
     45   simple_feature->Parse(rule.get());
     46   features->push_back(simple_feature.release());
     47 
     48   // Rule: "packaged_app", whitelist "bar".
     49   simple_feature.reset(new SimpleFeature());
     50   rule = DictionaryBuilder()
     51       .Set("whitelist", ListBuilder().Append(kIdBar))
     52       .Set("extension_types", ListBuilder().Append("packaged_app")).Build();
     53   simple_feature->Parse(rule.get());
     54   features->push_back(simple_feature.release());
     55 
     56   scoped_ptr<ComplexFeature> feature(new ComplexFeature(features.Pass()));
     57 
     58   // Test match 1st rule.
     59   EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
     60       kIdFoo,
     61       Manifest::TYPE_EXTENSION,
     62       Feature::UNSPECIFIED_LOCATION,
     63       Feature::UNSPECIFIED_PLATFORM,
     64       Feature::GetCurrentPlatform()).result());
     65 
     66   // Test match 2nd rule.
     67   EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
     68       kIdBar,
     69       Manifest::TYPE_LEGACY_PACKAGED_APP,
     70       Feature::UNSPECIFIED_LOCATION,
     71       Feature::UNSPECIFIED_PLATFORM,
     72       Feature::GetCurrentPlatform()).result());
     73 
     74   // Test whitelist with wrong extension type.
     75   EXPECT_NE(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
     76       kIdBar,
     77       Manifest::TYPE_EXTENSION,
     78       Feature::UNSPECIFIED_LOCATION,
     79       Feature::UNSPECIFIED_PLATFORM,
     80       Feature::GetCurrentPlatform()).result());
     81   EXPECT_NE(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(kIdFoo,
     82       Manifest::TYPE_LEGACY_PACKAGED_APP,
     83       Feature::UNSPECIFIED_LOCATION,
     84       Feature::UNSPECIFIED_PLATFORM,
     85       Feature::GetCurrentPlatform()).result());
     86 }
     87 
     88 TEST_F(ExtensionComplexFeatureTest, MultipleRulesChannels) {
     89   scoped_ptr<ComplexFeature::FeatureList> features(
     90       new ComplexFeature::FeatureList());
     91 
     92   // Rule: "extension", channel trunk.
     93   scoped_ptr<SimpleFeature> simple_feature(new SimpleFeature());
     94   scoped_ptr<base::DictionaryValue> rule(
     95       DictionaryBuilder()
     96       .Set("channel", "trunk")
     97       .Set("extension_types", ListBuilder().Append("extension")).Build());
     98   simple_feature->Parse(rule.get());
     99   features->push_back(simple_feature.release());
    100 
    101   // Rule: "packaged_app", channel stable.
    102   simple_feature.reset(new SimpleFeature());
    103   rule = DictionaryBuilder()
    104       .Set("channel", "stable")
    105       .Set("extension_types", ListBuilder().Append("packaged_app")).Build();
    106   simple_feature->Parse(rule.get());
    107   features->push_back(simple_feature.release());
    108 
    109   scoped_ptr<ComplexFeature> feature(new ComplexFeature(features.Pass()));
    110 
    111   // Test match 1st rule.
    112   {
    113     ScopedCurrentChannel current_channel(VersionInfo::CHANNEL_UNKNOWN);
    114     EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
    115         "1",
    116         Manifest::TYPE_EXTENSION,
    117         Feature::UNSPECIFIED_LOCATION,
    118         Feature::UNSPECIFIED_PLATFORM,
    119         Feature::GetCurrentPlatform()).result());
    120   }
    121 
    122   // Test match 2nd rule.
    123   {
    124     ScopedCurrentChannel current_channel(VersionInfo::CHANNEL_BETA);
    125     EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
    126         "2",
    127         Manifest::TYPE_LEGACY_PACKAGED_APP,
    128         Feature::UNSPECIFIED_LOCATION,
    129         Feature::UNSPECIFIED_PLATFORM,
    130         Feature::GetCurrentPlatform()).result());
    131   }
    132 
    133   // Test feature not available to extensions above channel unknown.
    134   {
    135     ScopedCurrentChannel current_channel(VersionInfo::CHANNEL_BETA);
    136     EXPECT_NE(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
    137         "1",
    138         Manifest::TYPE_EXTENSION,
    139         Feature::UNSPECIFIED_LOCATION,
    140         Feature::UNSPECIFIED_PLATFORM,
    141         Feature::GetCurrentPlatform()).result());
    142   }
    143 }
    144 
    145 }  // namespace
    146