chrome/browser/extensions/extensions_quota_service_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 "base/message_loop/message_loop.h"
   6 #include "base/process/process.h"
   7 #include "base/stl_util.h"
   8 #include "base/strings/string_util.h"
   9 #include "chrome/browser/extensions/extension_function.h"
  10 #include "chrome/browser/extensions/extensions_quota_service.h"
  11 #include "content/public/test/test_browser_thread.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using base::TimeDelta;
  15 using base::TimeTicks;
  16 using content::BrowserThread;
  17
  18 typedef QuotaLimitHeuristic::Bucket Bucket;
  19 typedef QuotaLimitHeuristic::Config Config;
  20 typedef QuotaLimitHeuristic::BucketList BucketList;
  21 typedef ExtensionsQuotaService::TimedLimit TimedLimit;
  22 typedef ExtensionsQuotaService::SustainedLimit SustainedLimit;
  23
  24 namespace {
  25
  26 const char kGenericName[] = "name";
  27 const Config kFrozenConfig = { 0, TimeDelta::FromDays(0) };
  28 const Config k2PerMinute = { 2, TimeDelta::FromMinutes(1) };
  29 const Config k20PerHour = { 20, TimeDelta::FromHours(1) };
  30 const TimeTicks kStartTime = TimeTicks();
  31 const TimeTicks k1MinuteAfterStart = kStartTime + TimeDelta::FromMinutes(1);
  32
  33 class Mapper : public QuotaLimitHeuristic::BucketMapper {
  34  public:
  35   Mapper() {}
  36   virtual ~Mapper() { STLDeleteValues(&buckets_); }
  37   virtual void GetBucketsForArgs(const base::ListValue* args,
  38                                  BucketList* buckets) OVERRIDE {
  39     for (size_t i = 0; i < args->GetSize(); i++) {
  40       int id;
  41       ASSERT_TRUE(args->GetInteger(i, &id));
  42       if (buckets_.find(id) == buckets_.end())
  43         buckets_[id] = new Bucket();
  44       buckets->push_back(buckets_[id]);
  45     }
  46   }
  47  private:
  48   typedef std::map<int, Bucket*> BucketMap;
  49   BucketMap buckets_;
  50   DISALLOW_COPY_AND_ASSIGN(Mapper);
  51 };
  52
  53 class MockMapper : public QuotaLimitHeuristic::BucketMapper {
  54  public:
  55   virtual void GetBucketsForArgs(const base::ListValue* args,
  56                                  BucketList* buckets) OVERRIDE {
  57   }
  58 };
  59
  60 class MockFunction : public ExtensionFunction {
  61  public:
  62   explicit MockFunction(const std::string& name) { set_name(name); }
  63
  64   virtual void SetArgs(const base::ListValue* args) OVERRIDE {}
  65   virtual const std::string GetError() OVERRIDE { return std::string(); }
  66   virtual void SetError(const std::string& error) OVERRIDE {}
  67   virtual void Run() OVERRIDE {}
  68   virtual void Destruct() const OVERRIDE { delete this; }
  69   virtual bool RunImpl() OVERRIDE { return true; }
  70   virtual void SendResponse(bool) OVERRIDE { }
  71
  72  protected:
  73   virtual ~MockFunction() {}
  74 };
  75
  76 class TimedLimitMockFunction : public MockFunction {
  77  public:
  78   explicit TimedLimitMockFunction(const std::string& name)
  79       : MockFunction(name) {}
  80   virtual void GetQuotaLimitHeuristics(
  81       QuotaLimitHeuristics* heuristics) const OVERRIDE {
  82     heuristics->push_back(
  83         new TimedLimit(k2PerMinute, new Mapper(), kGenericName));
  84   }
  85
  86  private:
  87   virtual ~TimedLimitMockFunction() {}
  88 };
  89
  90 class ChainedLimitsMockFunction : public MockFunction {
  91  public:
  92   explicit ChainedLimitsMockFunction(const std::string& name)
  93       : MockFunction(name) {}
  94   virtual void GetQuotaLimitHeuristics(
  95       QuotaLimitHeuristics* heuristics) const OVERRIDE {
  96     // No more than 2 per minute sustained over 5 minutes.
  97     heuristics->push_back(new SustainedLimit(
  98         TimeDelta::FromMinutes(5), k2PerMinute, new Mapper(), kGenericName));
  99     // No more than 20 per hour.
 100     heuristics->push_back(
 101         new TimedLimit(k20PerHour, new Mapper(), kGenericName));
 102   }
 103
 104  private:
 105   virtual ~ChainedLimitsMockFunction() {}
 106 };
 107
 108 class FrozenMockFunction : public MockFunction {
 109  public:
 110   explicit FrozenMockFunction(const std::string& name) : MockFunction(name) {}
 111   virtual void GetQuotaLimitHeuristics(
 112       QuotaLimitHeuristics* heuristics) const OVERRIDE {
 113     heuristics->push_back(
 114         new TimedLimit(kFrozenConfig, new Mapper(), kGenericName));
 115   }
 116
 117  private:
 118   virtual ~FrozenMockFunction() {}
 119 };
 120 }  // namespace
 121
 122 class ExtensionsQuotaServiceTest : public testing::Test {
 123  public:
 124   ExtensionsQuotaServiceTest()
 125       : extension_a_("a"),
 126         extension_b_("b"),
 127         extension_c_("c"),
 128         loop_(),
 129         ui_thread_(BrowserThread::UI, &loop_) {
 130   }
 131   virtual void SetUp() {
 132     service_.reset(new ExtensionsQuotaService());
 133   }
 134   virtual void TearDown() {
 135     loop_.RunUntilIdle();
 136     service_.reset();
 137   }
 138  protected:
 139   std::string extension_a_;
 140   std::string extension_b_;
 141   std::string extension_c_;
 142   scoped_ptr<ExtensionsQuotaService> service_;
 143   base::MessageLoop loop_;
 144   content::TestBrowserThread ui_thread_;
 145 };
 146
 147 class QuotaLimitHeuristicTest : public testing::Test {
 148  public:
 149   static void DoMoreThan2PerMinuteFor5Minutes(const TimeTicks& start_time,
 150                                               QuotaLimitHeuristic* lim,
 151                                               Bucket* b,
 152                                               int an_unexhausted_minute) {
 153     for (int i = 0; i < 5; i++) {
 154       // Perform one operation in each minute.
 155       int m = i * 60;
 156       EXPECT_TRUE(lim->Apply(b, start_time + TimeDelta::FromSeconds(10 + m)));
 157       EXPECT_TRUE(b->has_tokens());
 158
 159       if (i == an_unexhausted_minute)
 160         continue;  // Don't exhaust all tokens this minute.
 161
 162       EXPECT_TRUE(lim->Apply(b, start_time + TimeDelta::FromSeconds(15 + m)));
 163       EXPECT_FALSE(b->has_tokens());
 164
 165       // These are OK because we haven't exhausted all buckets.
 166       EXPECT_TRUE(lim->Apply(b, start_time + TimeDelta::FromSeconds(20 + m)));
 167       EXPECT_FALSE(b->has_tokens());
 168       EXPECT_TRUE(lim->Apply(b, start_time + TimeDelta::FromSeconds(50 + m)));
 169       EXPECT_FALSE(b->has_tokens());
 170     }
 171   }
 172 };
 173
 174 TEST_F(QuotaLimitHeuristicTest, Timed) {
 175   TimedLimit lim(k2PerMinute, new MockMapper(), kGenericName);
 176   Bucket b;
 177
 178   b.Reset(k2PerMinute, kStartTime);
 179   EXPECT_TRUE(lim.Apply(&b, kStartTime));
 180   EXPECT_TRUE(b.has_tokens());
 181   EXPECT_TRUE(lim.Apply(&b, kStartTime + TimeDelta::FromSeconds(30)));
 182   EXPECT_FALSE(b.has_tokens());
 183   EXPECT_FALSE(lim.Apply(&b,  k1MinuteAfterStart));
 184
 185   b.Reset(k2PerMinute, kStartTime);
 186   EXPECT_TRUE(lim.Apply(&b, k1MinuteAfterStart - TimeDelta::FromSeconds(1)));
 187   EXPECT_TRUE(lim.Apply(&b, k1MinuteAfterStart));
 188   EXPECT_TRUE(lim.Apply(&b, k1MinuteAfterStart + TimeDelta::FromSeconds(1)));
 189   EXPECT_TRUE(lim.Apply(&b, k1MinuteAfterStart + TimeDelta::FromSeconds(2)));
 190   EXPECT_FALSE(lim.Apply(&b, k1MinuteAfterStart + TimeDelta::FromSeconds(3)));
 191 }
 192
 193 TEST_F(QuotaLimitHeuristicTest, Sustained) {
 194   SustainedLimit lim(
 195       TimeDelta::FromMinutes(5), k2PerMinute, new MockMapper(), kGenericName);
 196   Bucket bucket;
 197
 198   bucket.Reset(k2PerMinute, kStartTime);
 199   DoMoreThan2PerMinuteFor5Minutes(kStartTime, &lim, &bucket, -1);
 200   // This straw breaks the camel's back.
 201   EXPECT_FALSE(lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(6)));
 202
 203   // The heuristic resets itself on a safe request.
 204   EXPECT_TRUE(lim.Apply(&bucket, kStartTime + TimeDelta::FromDays(1)));
 205
 206   // Do the same as above except don't exhaust final bucket.
 207   bucket.Reset(k2PerMinute, kStartTime);
 208   DoMoreThan2PerMinuteFor5Minutes(kStartTime, &lim, &bucket, -1);
 209   EXPECT_TRUE(lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(7)));
 210
 211   // Do the same as above except don't exhaust the 3rd (w.l.o.g) bucket.
 212   bucket.Reset(k2PerMinute, kStartTime);
 213   DoMoreThan2PerMinuteFor5Minutes(kStartTime, &lim, &bucket, 3);
 214   // If the 3rd bucket were exhausted, this would fail (see first test).
 215   EXPECT_TRUE(lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(6)));
 216 }
 217
 218 TEST_F(ExtensionsQuotaServiceTest, NoHeuristic) {
 219   scoped_refptr<MockFunction> f(new MockFunction("foo"));
 220   base::ListValue args;
 221   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 222 }
 223
 224 TEST_F(ExtensionsQuotaServiceTest, FrozenHeuristic) {
 225   scoped_refptr<MockFunction> f(new FrozenMockFunction("foo"));
 226   base::ListValue args;
 227   args.Append(new base::FundamentalValue(1));
 228   EXPECT_NE("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 229 }
 230
 231 TEST_F(ExtensionsQuotaServiceTest, SingleHeuristic) {
 232   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
 233   base::ListValue args;
 234   args.Append(new base::FundamentalValue(1));
 235   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 236   EXPECT_EQ("",
 237             service_->Assess(extension_a_,
 238                              f.get(),
 239                              &args,
 240                              kStartTime + TimeDelta::FromSeconds(10)));
 241   EXPECT_NE("",
 242             service_->Assess(extension_a_,
 243                              f.get(),
 244                              &args,
 245                              kStartTime + TimeDelta::FromSeconds(15)));
 246
 247   base::ListValue args2;
 248   args2.Append(new base::FundamentalValue(1));
 249   args2.Append(new base::FundamentalValue(2));
 250   EXPECT_EQ("", service_->Assess(extension_b_, f.get(), &args2, kStartTime));
 251   EXPECT_EQ("",
 252             service_->Assess(extension_b_,
 253                              f.get(),
 254                              &args2,
 255                              kStartTime + TimeDelta::FromSeconds(10)));
 256
 257   TimeDelta peace = TimeDelta::FromMinutes(30);
 258   EXPECT_EQ("",
 259             service_->Assess(extension_b_, f.get(), &args, kStartTime + peace));
 260   EXPECT_EQ("",
 261             service_->Assess(extension_b_,
 262                              f.get(),
 263                              &args,
 264                              kStartTime + peace + TimeDelta::FromSeconds(10)));
 265   EXPECT_NE("",
 266             service_->Assess(extension_b_,
 267                              f.get(),
 268                              &args2,
 269                              kStartTime + peace + TimeDelta::FromSeconds(15)));
 270
 271   // Test that items are independent.
 272   base::ListValue args3;
 273   args3.Append(new base::FundamentalValue(3));
 274   EXPECT_EQ("", service_->Assess(extension_c_, f.get(), &args, kStartTime));
 275   EXPECT_EQ("",
 276             service_->Assess(extension_c_,
 277                              f.get(),
 278                              &args3,
 279                              kStartTime + TimeDelta::FromSeconds(10)));
 280   EXPECT_EQ("",
 281             service_->Assess(extension_c_,
 282                              f.get(),
 283                              &args,
 284                              kStartTime + TimeDelta::FromSeconds(15)));
 285   EXPECT_EQ("",
 286             service_->Assess(extension_c_,
 287                              f.get(),
 288                              &args3,
 289                              kStartTime + TimeDelta::FromSeconds(20)));
 290   EXPECT_NE("",
 291             service_->Assess(extension_c_,
 292                              f.get(),
 293                              &args,
 294                              kStartTime + TimeDelta::FromSeconds(25)));
 295   EXPECT_NE("",
 296             service_->Assess(extension_c_,
 297                              f.get(),
 298                              &args3,
 299                              kStartTime + TimeDelta::FromSeconds(30)));
 300 }
 301
 302 TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
 303   scoped_refptr<MockFunction> f(new ChainedLimitsMockFunction("foo"));
 304   base::ListValue args;
 305   args.Append(new base::FundamentalValue(1));
 306
 307   // First, test that the low limit can be avoided but the higher one is hit.
 308   // One event per minute for 20 minutes comes in under the sustained limit,
 309   // but is equal to the timed limit.
 310   for (int i = 0; i < 20; i++) {
 311     EXPECT_EQ(
 312         "",
 313         service_->Assess(extension_a_,
 314                          f.get(),
 315                          &args,
 316                          kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
 317   }
 318
 319   // This will bring us to 21 events in an hour, which is a violation.
 320   EXPECT_NE("",
 321             service_->Assess(extension_a_,
 322                              f.get(),
 323                              &args,
 324                              kStartTime + TimeDelta::FromMinutes(30)));
 325
 326   // Now, check that we can still hit the lower limit.
 327   for (int i = 0; i < 5; i++) {
 328     EXPECT_EQ(
 329         "",
 330         service_->Assess(extension_b_,
 331                          f.get(),
 332                          &args,
 333                          kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
 334     EXPECT_EQ(
 335         "",
 336         service_->Assess(extension_b_,
 337                          f.get(),
 338                          &args,
 339                          kStartTime + TimeDelta::FromSeconds(15 + i * 60)));
 340     EXPECT_EQ(
 341         "",
 342         service_->Assess(extension_b_,
 343                          f.get(),
 344                          &args,
 345                          kStartTime + TimeDelta::FromSeconds(20 + i * 60)));
 346   }
 347
 348   EXPECT_NE("",
 349             service_->Assess(extension_b_,
 350                              f.get(),
 351                              &args,
 352                              kStartTime + TimeDelta::FromMinutes(6)));
 353 }
 354
 355 TEST_F(ExtensionsQuotaServiceTest, MultipleFunctionsDontInterfere) {
 356   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
 357   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
 358
 359   base::ListValue args_f;
 360   base::ListValue args_g;
 361   args_f.Append(new base::FundamentalValue(1));
 362   args_g.Append(new base::FundamentalValue(2));
 363
 364   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args_f, kStartTime));
 365   EXPECT_EQ("", service_->Assess(extension_a_, g.get(), &args_g, kStartTime));
 366   EXPECT_EQ("",
 367             service_->Assess(extension_a_,
 368                              f.get(),
 369                              &args_f,
 370                              kStartTime + TimeDelta::FromSeconds(10)));
 371   EXPECT_EQ("",
 372             service_->Assess(extension_a_,
 373                              g.get(),
 374                              &args_g,
 375                              kStartTime + TimeDelta::FromSeconds(10)));
 376   EXPECT_NE("",
 377             service_->Assess(extension_a_,
 378                              f.get(),
 379                              &args_f,
 380                              kStartTime + TimeDelta::FromSeconds(15)));
 381   EXPECT_NE("",
 382             service_->Assess(extension_a_,
 383                              g.get(),
 384                              &args_g,
 385                              kStartTime + TimeDelta::FromSeconds(15)));
 386 }
 387
 388 TEST_F(ExtensionsQuotaServiceTest, ViolatorsWillBeViolators) {
 389   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
 390   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
 391   base::ListValue arg;
 392   arg.Append(new base::FundamentalValue(1));
 393   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &arg, kStartTime));
 394   EXPECT_EQ("",
 395             service_->Assess(extension_a_,
 396                              f.get(),
 397                              &arg,
 398                              kStartTime + TimeDelta::FromSeconds(10)));
 399   EXPECT_NE("",
 400             service_->Assess(extension_a_,
 401                              f.get(),
 402                              &arg,
 403                              kStartTime + TimeDelta::FromSeconds(15)));
 404
 405   // We don't allow this extension to use quota limited functions even if they
 406   // wait a while.
 407   EXPECT_NE(
 408       "",
 409       service_->Assess(
 410           extension_a_, f.get(), &arg, kStartTime + TimeDelta::FromDays(1)));
 411   EXPECT_NE(
 412       "",
 413       service_->Assess(
 414           extension_a_, g.get(), &arg, kStartTime + TimeDelta::FromDays(1)));
 415 }