quota_service_unittest.cc revision f2477e01787aa58f445919b809d89e252beef54f 
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
14using base::TimeDelta;
15using base::TimeTicks;
16using content::BrowserThread;
17
18namespace extensions {
19
20typedef QuotaLimitHeuristic::Bucket Bucket;
21typedef QuotaLimitHeuristic::Config Config;
22typedef QuotaLimitHeuristic::BucketList BucketList;
23typedef QuotaService::TimedLimit TimedLimit;
24typedef QuotaService::SustainedLimit SustainedLimit;
25
26namespace {
27
28const char kGenericName[] = "name";
29const Config kFrozenConfig = {0, TimeDelta::FromDays(0)};
30const Config k2PerMinute = {2, TimeDelta::FromMinutes(1)};
31const Config k20PerHour = {20, TimeDelta::FromHours(1)};
32const TimeTicks kStartTime = TimeTicks();
33const TimeTicks k1MinuteAfterStart = kStartTime + TimeDelta::FromMinutes(1);
34
35class 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
56class MockMapper : public QuotaLimitHeuristic::BucketMapper {
57 public:
58  virtual void GetBucketsForArgs(const base::ListValue* args,
59                                 BucketList* buckets) OVERRIDE {}
60};
61
62class 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 const std::string GetError() OVERRIDE { return std::string(); }
68  virtual void SetError(const std::string& error) OVERRIDE {}
69  virtual void Run() OVERRIDE {}
70  virtual void Destruct() const OVERRIDE { delete this; }
71  virtual bool RunImpl() OVERRIDE { return true; }
72  virtual void SendResponse(bool) OVERRIDE {}
73
74 protected:
75  virtual ~MockFunction() {}
76};
77
78class TimedLimitMockFunction : public MockFunction {
79 public:
80  explicit TimedLimitMockFunction(const std::string& name)
81      : MockFunction(name) {}
82  virtual void GetQuotaLimitHeuristics(QuotaLimitHeuristics* heuristics) const
83      OVERRIDE {
84    heuristics->push_back(
85        new TimedLimit(k2PerMinute, new Mapper(), kGenericName));
86  }
87
88 private:
89  virtual ~TimedLimitMockFunction() {}
90};
91
92class ChainedLimitsMockFunction : public MockFunction {
93 public:
94  explicit ChainedLimitsMockFunction(const std::string& name)
95      : MockFunction(name) {}
96  virtual void GetQuotaLimitHeuristics(QuotaLimitHeuristics* heuristics) const
97      OVERRIDE {
98    // No more than 2 per minute sustained over 5 minutes.
99    heuristics->push_back(new SustainedLimit(
100        TimeDelta::FromMinutes(5), k2PerMinute, new Mapper(), kGenericName));
101    // No more than 20 per hour.
102    heuristics->push_back(
103        new TimedLimit(k20PerHour, new Mapper(), kGenericName));
104  }
105
106 private:
107  virtual ~ChainedLimitsMockFunction() {}
108};
109
110class FrozenMockFunction : public MockFunction {
111 public:
112  explicit FrozenMockFunction(const std::string& name) : MockFunction(name) {}
113  virtual void GetQuotaLimitHeuristics(QuotaLimitHeuristics* heuristics) const
114      OVERRIDE {
115    heuristics->push_back(
116        new TimedLimit(kFrozenConfig, new Mapper(), kGenericName));
117  }
118
119 private:
120  virtual ~FrozenMockFunction() {}
121};
122}  // namespace
123
124class QuotaServiceTest : public testing::Test {
125 public:
126  QuotaServiceTest()
127      : extension_a_("a"),
128        extension_b_("b"),
129        extension_c_("c"),
130        loop_(),
131        ui_thread_(BrowserThread::UI, &loop_) {}
132  virtual void SetUp() { service_.reset(new QuotaService()); }
133  virtual void TearDown() {
134    loop_.RunUntilIdle();
135    service_.reset();
136  }
137
138 protected:
139  std::string extension_a_;
140  std::string extension_b_;
141  std::string extension_c_;
142  scoped_ptr<QuotaService> service_;
143  base::MessageLoop loop_;
144  content::TestBrowserThread ui_thread_;
145};
146
147class 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
174TEST_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
193TEST_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
218TEST_F(QuotaServiceTest, 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
224TEST_F(QuotaServiceTest, 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
231TEST_F(QuotaServiceTest, 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
302TEST_F(QuotaServiceTest, 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
355TEST_F(QuotaServiceTest, 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
388TEST_F(QuotaServiceTest, 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}
416
417}  // namespace extensions
418