extensions/browser/extension_registry_unittest.cc

   1 // Copyright 2013 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/browser/extension_registry.h"
   6
   7 #include <string>
   8
   9 #include "base/memory/ref_counted.h"
  10 #include "extensions/browser/extension_registry_observer.h"
  11 #include "extensions/common/extension.h"
  12 #include "extensions/common/test_util.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace extensions {
  16 namespace {
  17
  18 typedef testing::Test ExtensionRegistryTest;
  19
  20 testing::AssertionResult HasSingleExtension(
  21     const ExtensionList& list,
  22     const scoped_refptr<const Extension>& extension) {
  23   if (list.empty())
  24     return testing::AssertionFailure() << "No extensions in list";
  25   if (list.size() > 1)
  26     return testing::AssertionFailure() << list.size()
  27                                        << " extensions, expected 1";
  28   const Extension* did_load = list[0].get();
  29   if (did_load != extension)
  30     return testing::AssertionFailure() << "Expected " << extension->id()
  31                                        << " found " << did_load->id();
  32   return testing::AssertionSuccess();
  33 }
  34
  35 class TestObserver : public ExtensionRegistryObserver {
  36  public:
  37   void Reset() {
  38     loaded_.clear();
  39     unloaded_.clear();
  40   }
  41
  42   const ExtensionList& loaded() { return loaded_; }
  43   const ExtensionList& unloaded() { return unloaded_; }
  44
  45  private:
  46   virtual void OnExtensionLoaded(content::BrowserContext* browser_context,
  47                                  const Extension* extension) OVERRIDE {
  48     loaded_.push_back(extension);
  49   }
  50
  51   virtual void OnExtensionUnloaded(content::BrowserContext* browser_context,
  52                                    const Extension* extension) OVERRIDE {
  53     unloaded_.push_back(extension);
  54   }
  55
  56   ExtensionList loaded_;
  57   ExtensionList unloaded_;
  58 };
  59
  60 TEST_F(ExtensionRegistryTest, FillAndClearRegistry) {
  61   ExtensionRegistry registry(NULL);
  62   scoped_refptr<Extension> extension1 = test_util::CreateExtensionWithID("id1");
  63   scoped_refptr<Extension> extension2 = test_util::CreateExtensionWithID("id2");
  64   scoped_refptr<Extension> extension3 = test_util::CreateExtensionWithID("id3");
  65   scoped_refptr<Extension> extension4 = test_util::CreateExtensionWithID("id4");
  66
  67   // All the sets start empty.
  68   EXPECT_EQ(0u, registry.enabled_extensions().size());
  69   EXPECT_EQ(0u, registry.disabled_extensions().size());
  70   EXPECT_EQ(0u, registry.terminated_extensions().size());
  71   EXPECT_EQ(0u, registry.blacklisted_extensions().size());
  72
  73   // Extensions can be added to each set.
  74   registry.AddEnabled(extension1);
  75   registry.AddDisabled(extension2);
  76   registry.AddTerminated(extension3);
  77   registry.AddBlacklisted(extension4);
  78
  79   EXPECT_EQ(1u, registry.enabled_extensions().size());
  80   EXPECT_EQ(1u, registry.disabled_extensions().size());
  81   EXPECT_EQ(1u, registry.terminated_extensions().size());
  82   EXPECT_EQ(1u, registry.blacklisted_extensions().size());
  83
  84   // Clearing the registry clears all sets.
  85   registry.ClearAll();
  86
  87   EXPECT_EQ(0u, registry.enabled_extensions().size());
  88   EXPECT_EQ(0u, registry.disabled_extensions().size());
  89   EXPECT_EQ(0u, registry.terminated_extensions().size());
  90   EXPECT_EQ(0u, registry.blacklisted_extensions().size());
  91 }
  92
  93 // A simple test of adding and removing things from sets.
  94 TEST_F(ExtensionRegistryTest, AddAndRemoveExtensionFromRegistry) {
  95   ExtensionRegistry registry(NULL);
  96
  97   // Adding an extension works.
  98   scoped_refptr<Extension> extension = test_util::CreateExtensionWithID("id");
  99   EXPECT_TRUE(registry.AddEnabled(extension));
 100   EXPECT_EQ(1u, registry.enabled_extensions().size());
 101
 102   // The extension was only added to one set.
 103   EXPECT_EQ(0u, registry.disabled_extensions().size());
 104   EXPECT_EQ(0u, registry.terminated_extensions().size());
 105   EXPECT_EQ(0u, registry.blacklisted_extensions().size());
 106
 107   // Removing an extension works.
 108   EXPECT_TRUE(registry.RemoveEnabled(extension->id()));
 109   EXPECT_EQ(0u, registry.enabled_extensions().size());
 110
 111   // Trying to remove an extension that isn't in the set fails cleanly.
 112   EXPECT_FALSE(registry.RemoveEnabled(extension->id()));
 113 }
 114
 115 TEST_F(ExtensionRegistryTest, AddExtensionToRegistryTwice) {
 116   ExtensionRegistry registry(NULL);
 117   scoped_refptr<Extension> extension = test_util::CreateExtensionWithID("id");
 118
 119   // An extension can exist in two sets at once. It would be nice to eliminate
 120   // this functionality, but some users of ExtensionRegistry need it.
 121   EXPECT_TRUE(registry.AddEnabled(extension));
 122   EXPECT_TRUE(registry.AddDisabled(extension));
 123
 124   EXPECT_EQ(1u, registry.enabled_extensions().size());
 125   EXPECT_EQ(1u, registry.disabled_extensions().size());
 126   EXPECT_EQ(0u, registry.terminated_extensions().size());
 127   EXPECT_EQ(0u, registry.blacklisted_extensions().size());
 128 }
 129
 130 TEST_F(ExtensionRegistryTest, GetExtensionById) {
 131   ExtensionRegistry registry(NULL);
 132
 133   // Trying to get an extension fails cleanly when the sets are empty.
 134   EXPECT_FALSE(
 135       registry.GetExtensionById("id", ExtensionRegistry::EVERYTHING));
 136
 137   scoped_refptr<Extension> enabled =
 138       test_util::CreateExtensionWithID("enabled");
 139   scoped_refptr<Extension> disabled =
 140       test_util::CreateExtensionWithID("disabled");
 141   scoped_refptr<Extension> terminated =
 142       test_util::CreateExtensionWithID("terminated");
 143   scoped_refptr<Extension> blacklisted =
 144       test_util::CreateExtensionWithID("blacklisted");
 145
 146   // Add an extension to each set.
 147   registry.AddEnabled(enabled);
 148   registry.AddDisabled(disabled);
 149   registry.AddTerminated(terminated);
 150   registry.AddBlacklisted(blacklisted);
 151
 152   // Enabled is part of everything and the enabled list.
 153   EXPECT_TRUE(
 154       registry.GetExtensionById("enabled", ExtensionRegistry::EVERYTHING));
 155   EXPECT_TRUE(
 156       registry.GetExtensionById("enabled", ExtensionRegistry::ENABLED));
 157   EXPECT_FALSE(
 158       registry.GetExtensionById("enabled", ExtensionRegistry::DISABLED));
 159   EXPECT_FALSE(
 160       registry.GetExtensionById("enabled", ExtensionRegistry::TERMINATED));
 161   EXPECT_FALSE(
 162       registry.GetExtensionById("enabled", ExtensionRegistry::BLACKLISTED));
 163
 164   // Disabled is part of everything and the disabled list.
 165   EXPECT_TRUE(
 166       registry.GetExtensionById("disabled", ExtensionRegistry::EVERYTHING));
 167   EXPECT_FALSE(
 168       registry.GetExtensionById("disabled", ExtensionRegistry::ENABLED));
 169   EXPECT_TRUE(
 170       registry.GetExtensionById("disabled", ExtensionRegistry::DISABLED));
 171   EXPECT_FALSE(
 172       registry.GetExtensionById("disabled", ExtensionRegistry::TERMINATED));
 173   EXPECT_FALSE(
 174       registry.GetExtensionById("disabled", ExtensionRegistry::BLACKLISTED));
 175
 176   // Terminated is part of everything and the terminated list.
 177   EXPECT_TRUE(
 178       registry.GetExtensionById("terminated", ExtensionRegistry::EVERYTHING));
 179   EXPECT_FALSE(
 180       registry.GetExtensionById("terminated", ExtensionRegistry::ENABLED));
 181   EXPECT_FALSE(
 182       registry.GetExtensionById("terminated", ExtensionRegistry::DISABLED));
 183   EXPECT_TRUE(
 184       registry.GetExtensionById("terminated", ExtensionRegistry::TERMINATED));
 185   EXPECT_FALSE(
 186       registry.GetExtensionById("terminated", ExtensionRegistry::BLACKLISTED));
 187
 188   // Blacklisted is part of everything and the blacklisted list.
 189   EXPECT_TRUE(
 190       registry.GetExtensionById("blacklisted", ExtensionRegistry::EVERYTHING));
 191   EXPECT_FALSE(
 192       registry.GetExtensionById("blacklisted", ExtensionRegistry::ENABLED));
 193   EXPECT_FALSE(
 194       registry.GetExtensionById("blacklisted", ExtensionRegistry::DISABLED));
 195   EXPECT_FALSE(
 196       registry.GetExtensionById("blacklisted", ExtensionRegistry::TERMINATED));
 197   EXPECT_TRUE(
 198       registry.GetExtensionById("blacklisted", ExtensionRegistry::BLACKLISTED));
 199
 200   // Enabled can be found with multiple flags set.
 201   EXPECT_TRUE(registry.GetExtensionById(
 202       "enabled", ExtensionRegistry::ENABLED | ExtensionRegistry::TERMINATED));
 203
 204   // Enabled isn't found if the wrong flags are set.
 205   EXPECT_FALSE(registry.GetExtensionById(
 206       "enabled", ExtensionRegistry::DISABLED | ExtensionRegistry::BLACKLISTED));
 207 }
 208
 209 TEST_F(ExtensionRegistryTest, Observer) {
 210   ExtensionRegistry registry(NULL);
 211   TestObserver observer;
 212   registry.AddObserver(&observer);
 213
 214   EXPECT_TRUE(observer.loaded().empty());
 215   EXPECT_TRUE(observer.unloaded().empty());
 216
 217   scoped_refptr<const Extension> extension =
 218       test_util::CreateExtensionWithID("id");
 219
 220   registry.AddEnabled(extension);
 221   registry.TriggerOnLoaded(extension);
 222
 223   EXPECT_TRUE(HasSingleExtension(observer.loaded(), extension.get()));
 224   EXPECT_TRUE(observer.unloaded().empty());
 225   observer.Reset();
 226
 227   registry.RemoveEnabled(extension->id());
 228   registry.TriggerOnUnloaded(extension);
 229
 230   EXPECT_TRUE(observer.loaded().empty());
 231   EXPECT_TRUE(HasSingleExtension(observer.unloaded(), extension.get()));
 232   observer.Reset();
 233
 234   registry.RemoveObserver(&observer);
 235 }
 236
 237 }  // namespace
 238 }  // namespace extensions