chrome/browser/extensions/blacklist_unittest.cc

   1 // Copyright 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 "base/bind.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/run_loop.h"
   8 #include "chrome/browser/extensions/blacklist.h"
   9 #include "chrome/browser/extensions/extension_prefs.h"
  10 #include "chrome/browser/extensions/fake_safe_browsing_database_manager.h"
  11 #include "chrome/browser/extensions/test_blacklist.h"
  12 #include "chrome/browser/extensions/test_extension_prefs.h"
  13 #include "content/public/test/test_browser_thread.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace extensions {
  17 namespace {
  18
  19 class BlacklistTest : public testing::Test {
  20  public:
  21   BlacklistTest()
  22       : prefs_(message_loop_.message_loop_proxy().get()),
  23         ui_thread_(content::BrowserThread::UI, &message_loop_),
  24         io_thread_(content::BrowserThread::IO, &message_loop_),
  25         safe_browsing_database_manager_(new FakeSafeBrowsingDatabaseManager()),
  26         scoped_blacklist_database_manager_(safe_browsing_database_manager_),
  27         blacklist_(prefs_.prefs()) {}
  28
  29   bool IsBlacklisted(const Extension* extension) {
  30     return TestBlacklist(&blacklist_).IsBlacklisted(extension->id());
  31   }
  32
  33  protected:
  34   base::MessageLoop message_loop_;
  35
  36   TestExtensionPrefs prefs_;
  37
  38   content::TestBrowserThread ui_thread_;
  39   content::TestBrowserThread io_thread_;
  40
  41   scoped_refptr<FakeSafeBrowsingDatabaseManager>
  42       safe_browsing_database_manager_;
  43   Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_database_manager_;
  44
  45   Blacklist blacklist_;
  46 };
  47
  48 TEST_F(BlacklistTest, SetFromUpdater) {
  49   scoped_refptr<const Extension> extension_a = prefs_.AddExtension("a");
  50   scoped_refptr<const Extension> extension_b = prefs_.AddExtension("b");
  51   scoped_refptr<const Extension> extension_c = prefs_.AddExtension("c");
  52   scoped_refptr<const Extension> extension_d = prefs_.AddExtension("d");
  53
  54   // c, d, start blacklisted.
  55   prefs_.prefs()->SetExtensionBlacklisted(extension_c->id(), true);
  56   prefs_.prefs()->SetExtensionBlacklisted(extension_d->id(), true);
  57
  58   EXPECT_FALSE(IsBlacklisted(extension_a.get()));
  59   EXPECT_FALSE(IsBlacklisted(extension_b.get()));
  60   EXPECT_TRUE(IsBlacklisted(extension_c.get()));
  61   EXPECT_TRUE(IsBlacklisted(extension_d.get()));
  62
  63   // Mix up the blacklist.
  64   {
  65     std::vector<std::string> blacklist;
  66     blacklist.push_back(extension_b->id());
  67     blacklist.push_back(extension_c->id());
  68     blacklist_.SetFromUpdater(blacklist, "1");
  69   }
  70   EXPECT_FALSE(IsBlacklisted(extension_a.get()));
  71   EXPECT_TRUE(IsBlacklisted(extension_b.get()));
  72   EXPECT_TRUE(IsBlacklisted(extension_c.get()));
  73   EXPECT_FALSE(IsBlacklisted(extension_d.get()));
  74
  75   // No-op, just in case.
  76   {
  77     std::vector<std::string> blacklist;
  78     blacklist.push_back(extension_b->id());
  79     blacklist.push_back(extension_c->id());
  80     blacklist_.SetFromUpdater(blacklist, "2");
  81   }
  82   EXPECT_FALSE(IsBlacklisted(extension_a.get()));
  83   EXPECT_TRUE(IsBlacklisted(extension_b.get()));
  84   EXPECT_TRUE(IsBlacklisted(extension_c.get()));
  85   EXPECT_FALSE(IsBlacklisted(extension_d.get()));
  86
  87   // Strictly increase the blacklist.
  88   {
  89     std::vector<std::string> blacklist;
  90     blacklist.push_back(extension_a->id());
  91     blacklist.push_back(extension_b->id());
  92     blacklist.push_back(extension_c->id());
  93     blacklist.push_back(extension_d->id());
  94     blacklist_.SetFromUpdater(blacklist, "3");
  95   }
  96   EXPECT_TRUE(IsBlacklisted(extension_a.get()));
  97   EXPECT_TRUE(IsBlacklisted(extension_b.get()));
  98   EXPECT_TRUE(IsBlacklisted(extension_c.get()));
  99   EXPECT_TRUE(IsBlacklisted(extension_d.get()));
 100
 101   // Strictly decrease the blacklist.
 102   {
 103     std::vector<std::string> blacklist;
 104     blacklist.push_back(extension_a->id());
 105     blacklist.push_back(extension_b->id());
 106     blacklist_.SetFromUpdater(blacklist, "4");
 107   }
 108   EXPECT_TRUE(IsBlacklisted(extension_a.get()));
 109   EXPECT_TRUE(IsBlacklisted(extension_b.get()));
 110   EXPECT_FALSE(IsBlacklisted(extension_c.get()));
 111   EXPECT_FALSE(IsBlacklisted(extension_d.get()));
 112
 113   // Clear the blacklist.
 114   {
 115     std::vector<std::string> blacklist;
 116     blacklist_.SetFromUpdater(blacklist, "5");
 117   }
 118   EXPECT_FALSE(IsBlacklisted(extension_a.get()));
 119   EXPECT_FALSE(IsBlacklisted(extension_b.get()));
 120   EXPECT_FALSE(IsBlacklisted(extension_c.get()));
 121   EXPECT_FALSE(IsBlacklisted(extension_d.get()));
 122 }
 123
 124 void Assign(std::set<std::string> *to, const std::set<std::string>& from) {
 125   *to = from;
 126 }
 127
 128 TEST_F(BlacklistTest, OnlyIncludesRequestedIDs) {
 129   scoped_refptr<const Extension> extension_a = prefs_.AddExtension("a");
 130   scoped_refptr<const Extension> extension_b = prefs_.AddExtension("b");
 131   scoped_refptr<const Extension> extension_c = prefs_.AddExtension("c");
 132
 133   {
 134     std::vector<std::string> blacklist;
 135     blacklist.push_back(extension_a->id());
 136     blacklist.push_back(extension_b->id());
 137     blacklist_.SetFromUpdater(blacklist, "1");
 138     base::RunLoop().RunUntilIdle();
 139   }
 140
 141   std::set<std::string> blacklist_actual;
 142   {
 143     std::set<std::string> blacklist_query;
 144     blacklist_query.insert(extension_a->id());
 145     blacklist_query.insert(extension_c->id());
 146     blacklist_.GetBlacklistedIDs(blacklist_query,
 147                                  base::Bind(&Assign, &blacklist_actual));
 148     base::RunLoop().RunUntilIdle();
 149   }
 150
 151   std::set<std::string> blacklist_expected;
 152   blacklist_expected.insert(extension_a->id());
 153   EXPECT_EQ(blacklist_expected, blacklist_actual);
 154 }
 155
 156 TEST_F(BlacklistTest, PrefsVsSafeBrowsing) {
 157   scoped_refptr<const Extension> extension_a = prefs_.AddExtension("a");
 158   scoped_refptr<const Extension> extension_b = prefs_.AddExtension("b");
 159   scoped_refptr<const Extension> extension_c = prefs_.AddExtension("c");
 160
 161   // Prefs have a and b blacklisted, safebrowsing has b and c.
 162   prefs_.prefs()->SetExtensionBlacklisted(extension_a->id(), true);
 163   prefs_.prefs()->SetExtensionBlacklisted(extension_b->id(), true);
 164   {
 165     std::set<std::string> bc;
 166     bc.insert(extension_b->id());
 167     bc.insert(extension_c->id());
 168     safe_browsing_database_manager_->set_unsafe_ids(bc);
 169   }
 170
 171   // The manager is still disabled at this point, so c won't be blacklisted.
 172   EXPECT_TRUE(IsBlacklisted(extension_a.get()));
 173   EXPECT_TRUE(IsBlacklisted(extension_b.get()));
 174   EXPECT_FALSE(IsBlacklisted(extension_c.get()));
 175
 176   // Now it should be.
 177   safe_browsing_database_manager_->set_enabled(true);
 178   EXPECT_TRUE(IsBlacklisted(extension_a.get()));
 179   EXPECT_TRUE(IsBlacklisted(extension_b.get()));
 180   EXPECT_TRUE(IsBlacklisted(extension_c.get()));
 181
 182   // Corner case: nothing in safebrowsing (but still enabled).
 183   safe_browsing_database_manager_->set_unsafe_ids(std::set<std::string>());
 184   EXPECT_TRUE(IsBlacklisted(extension_a.get()));
 185   EXPECT_TRUE(IsBlacklisted(extension_b.get()));
 186   EXPECT_FALSE(IsBlacklisted(extension_c.get()));
 187
 188   // Corner case: nothing in prefs.
 189   prefs_.prefs()->SetExtensionBlacklisted(extension_a->id(), false);
 190   prefs_.prefs()->SetExtensionBlacklisted(extension_b->id(), false);
 191   {
 192     std::set<std::string> bc;
 193     bc.insert(extension_b->id());
 194     bc.insert(extension_c->id());
 195     safe_browsing_database_manager_->set_unsafe_ids(bc);
 196   }
 197   EXPECT_FALSE(IsBlacklisted(extension_a.get()));
 198   EXPECT_TRUE(IsBlacklisted(extension_b.get()));
 199   EXPECT_TRUE(IsBlacklisted(extension_c.get()));
 200 }
 201
 202 }  // namespace extensions
 203 }  // namespace