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