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