Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(771)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/extensions/extensions_quota_service_unittest.cc

Issue 10871034: Make all quota-exceeding messages in the storage API explain what the failure (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 8 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« chrome/browser/extensions/api/web_request/web_request_api.cc ('K') | « chrome/browser/extensions/extensions_quota_service.cc ('k') | chrome/browser/extensions/settings/settings_api.cc » ('j') | chrome/browser/extensions/settings/settings_api.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/extensions/extensions_quota_service_unittest.cc
diff --git a/chrome/browser/extensions/extensions_quota_service_unittest.cc b/chrome/browser/extensions/extensions_quota_service_unittest.cc
index 96cfdb713da0fb5d0a8dcac95598f41af94dad78..99833a03dfdd7baa3763184f5eeb69dc9a510468 100644
--- a/chrome/browser/extensions/extensions_quota_service_unittest.cc
+++ b/chrome/browser/extensions/extensions_quota_service_unittest.cc
@@ -21,14 +21,15 @@ typedef QuotaLimitHeuristic::BucketList BucketList;
typedef ExtensionsQuotaService::TimedLimit TimedLimit;
typedef ExtensionsQuotaService::SustainedLimit SustainedLimit;
-static const Config kFrozenConfig = { 0, TimeDelta::FromDays(0) };
-static const Config k2PerMinute = { 2, TimeDelta::FromMinutes(1) };
-static const Config k20PerHour = { 20, TimeDelta::FromHours(1) };
-static const TimeTicks kStartTime = TimeTicks();
-static const TimeTicks k1MinuteAfterStart =
- kStartTime + TimeDelta::FromMinutes(1);
-
namespace {
+
+const char kGenericName[] = "name";
+const Config kFrozenConfig = { 0, TimeDelta::FromDays(0) };
+const Config k2PerMinute = { 2, TimeDelta::FromMinutes(1) };
+const Config k20PerHour = { 20, TimeDelta::FromHours(1) };
+const TimeTicks kStartTime = TimeTicks();
+const TimeTicks k1MinuteAfterStart = kStartTime + TimeDelta::FromMinutes(1);
+
class Mapper : public QuotaLimitHeuristic::BucketMapper {
public:
Mapper() {}
@@ -75,7 +76,8 @@ class TimedLimitMockFunction : public MockFunction {
: MockFunction(name) {}
virtual void GetQuotaLimitHeuristics(
QuotaLimitHeuristics* heuristics) const {
- heuristics->push_back(new TimedLimit(k2PerMinute, new Mapper()));
+ heuristics->push_back(
+ new TimedLimit(k2PerMinute, new Mapper(), kGenericName));
}
private:
@@ -89,10 +91,11 @@ class ChainedLimitsMockFunction : public MockFunction {
virtual void GetQuotaLimitHeuristics(
QuotaLimitHeuristics* heuristics) const {
// No more than 2 per minute sustained over 5 minutes.
- heuristics->push_back(new SustainedLimit(TimeDelta::FromMinutes(5),
- k2PerMinute, new Mapper()));
+ heuristics->push_back(new SustainedLimit(
+ TimeDelta::FromMinutes(5), k2PerMinute, new Mapper(), kGenericName));
// No more than 20 per hour.
- heuristics->push_back(new TimedLimit(k20PerHour, new Mapper()));
+ heuristics->push_back(
+ new TimedLimit(k20PerHour, new Mapper(), kGenericName));
}
private:
@@ -104,7 +107,8 @@ class FrozenMockFunction : public MockFunction {
explicit FrozenMockFunction(const std::string& name) : MockFunction(name) {}
virtual void GetQuotaLimitHeuristics(
QuotaLimitHeuristics* heuristics) const {
- heuristics->push_back(new TimedLimit(kFrozenConfig, new Mapper()));
+ heuristics->push_back(
+ new TimedLimit(kFrozenConfig, new Mapper(), kGenericName));
}
private:
@@ -146,118 +150,120 @@ class QuotaLimitHeuristicTest : public testing::Test {
for (int i = 0; i < 5; i++) {
// Perform one operation in each minute.
int m = i * 60;
- EXPECT_TRUE(lim->Apply(b, start_time + TimeDelta::FromSeconds(10 + m)));
+ EXPECT_EQ("", lim->Apply(b, start_time + TimeDelta::FromSeconds(10 + m)));
EXPECT_TRUE(b->has_tokens());
if (i == an_unexhausted_minute)
continue; // Don't exhaust all tokens this minute.
- EXPECT_TRUE(lim->Apply(b, start_time + TimeDelta::FromSeconds(15 + m)));
+ EXPECT_EQ("", lim->Apply(b, start_time + TimeDelta::FromSeconds(15 + m)));
EXPECT_FALSE(b->has_tokens());
// These are OK because we haven't exhausted all buckets.
- EXPECT_TRUE(lim->Apply(b, start_time + TimeDelta::FromSeconds(20 + m)));
+ EXPECT_EQ("", lim->Apply(b, start_time + TimeDelta::FromSeconds(20 + m)));
EXPECT_FALSE(b->has_tokens());
- EXPECT_TRUE(lim->Apply(b, start_time + TimeDelta::FromSeconds(50 + m)));
+ EXPECT_EQ("", lim->Apply(b, start_time + TimeDelta::FromSeconds(50 + m)));
EXPECT_FALSE(b->has_tokens());
}
}
};
TEST_F(QuotaLimitHeuristicTest, Timed) {
- TimedLimit lim(k2PerMinute, new MockMapper());
+ TimedLimit lim(k2PerMinute, new MockMapper(), kGenericName);
Bucket b;
b.Reset(k2PerMinute, kStartTime);
- EXPECT_TRUE(lim.Apply(&b, kStartTime));
+ EXPECT_EQ("", lim.Apply(&b, kStartTime));
EXPECT_TRUE(b.has_tokens());
- EXPECT_TRUE(lim.Apply(&b, kStartTime + TimeDelta::FromSeconds(30)));
+ EXPECT_EQ("", lim.Apply(&b, kStartTime + TimeDelta::FromSeconds(30)));
EXPECT_FALSE(b.has_tokens());
- EXPECT_FALSE(lim.Apply(&b, k1MinuteAfterStart));
+ EXPECT_NE("", lim.Apply(&b, k1MinuteAfterStart));
b.Reset(k2PerMinute, kStartTime);
- EXPECT_TRUE(lim.Apply(&b, k1MinuteAfterStart - TimeDelta::FromSeconds(1)));
- EXPECT_TRUE(lim.Apply(&b, k1MinuteAfterStart));
- EXPECT_TRUE(lim.Apply(&b, k1MinuteAfterStart + TimeDelta::FromSeconds(1)));
- EXPECT_TRUE(lim.Apply(&b, k1MinuteAfterStart + TimeDelta::FromSeconds(2)));
- EXPECT_FALSE(lim.Apply(&b, k1MinuteAfterStart + TimeDelta::FromSeconds(3)));
+ EXPECT_EQ("", lim.Apply(&b, k1MinuteAfterStart - TimeDelta::FromSeconds(1)));
+ EXPECT_EQ("", lim.Apply(&b, k1MinuteAfterStart));
+ EXPECT_EQ("", lim.Apply(&b, k1MinuteAfterStart + TimeDelta::FromSeconds(1)));
+ EXPECT_EQ("", lim.Apply(&b, k1MinuteAfterStart + TimeDelta::FromSeconds(2)));
+ EXPECT_NE("", lim.Apply(&b, k1MinuteAfterStart + TimeDelta::FromSeconds(3)));
}
TEST_F(QuotaLimitHeuristicTest, Sustained) {
- SustainedLimit lim(TimeDelta::FromMinutes(5), k2PerMinute, new MockMapper());
+ SustainedLimit lim(
+ TimeDelta::FromMinutes(5), k2PerMinute, new MockMapper(), kGenericName);
Bucket bucket;
bucket.Reset(k2PerMinute, kStartTime);
DoMoreThan2PerMinuteFor5Minutes(kStartTime, &lim, &bucket, -1);
// This straw breaks the camel's back.
- EXPECT_FALSE(lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(6)));
+ EXPECT_NE("", lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(6)));
// The heuristic resets itself on a safe request.
- EXPECT_TRUE(lim.Apply(&bucket, kStartTime + TimeDelta::FromDays(1)));
+ EXPECT_EQ("", lim.Apply(&bucket, kStartTime + TimeDelta::FromDays(1)));
// Do the same as above except don't exhaust final bucket.
bucket.Reset(k2PerMinute, kStartTime);
DoMoreThan2PerMinuteFor5Minutes(kStartTime, &lim, &bucket, -1);
- EXPECT_TRUE(lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(7)));
+ EXPECT_EQ("", lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(7)));
// Do the same as above except don't exhaust the 3rd (w.l.o.g) bucket.
bucket.Reset(k2PerMinute, kStartTime);
DoMoreThan2PerMinuteFor5Minutes(kStartTime, &lim, &bucket, 3);
// If the 3rd bucket were exhausted, this would fail (see first test).
- EXPECT_TRUE(lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(6)));
+ EXPECT_EQ("", lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(6)));
}
TEST_F(ExtensionsQuotaServiceTest, NoHeuristic) {
scoped_refptr<MockFunction> f(new MockFunction("foo"));
ListValue args;
- EXPECT_TRUE(service_->Assess(extension_a_, f, &args, kStartTime));
+ EXPECT_EQ("", service_->Assess(extension_a_, f, &args, kStartTime));
}
TEST_F(ExtensionsQuotaServiceTest, FrozenHeuristic) {
scoped_refptr<MockFunction> f(new FrozenMockFunction("foo"));
ListValue args;
args.Append(new base::FundamentalValue(1));
- EXPECT_FALSE(service_->Assess(extension_a_, f, &args, kStartTime));
+ EXPECT_NE("", service_->Assess(extension_a_, f, &args, kStartTime));
}
TEST_F(ExtensionsQuotaServiceTest, SingleHeuristic) {
scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
ListValue args;
args.Append(new base::FundamentalValue(1));
- EXPECT_TRUE(service_->Assess(extension_a_, f, &args, kStartTime));
- EXPECT_TRUE(service_->Assess(extension_a_, f, &args,
- kStartTime + TimeDelta::FromSeconds(10)));
- EXPECT_FALSE(service_->Assess(extension_a_, f, &args,
+ EXPECT_EQ("", service_->Assess(extension_a_, f, &args, kStartTime));
+ EXPECT_EQ("", service_->Assess(extension_a_, f, &args,
+ kStartTime + TimeDelta::FromSeconds(10)));
+ EXPECT_NE("", service_->Assess(extension_a_, f, &args,
kStartTime + TimeDelta::FromSeconds(15)));
ListValue args2;
args2.Append(new base::FundamentalValue(1));
args2.Append(new base::FundamentalValue(2));
- EXPECT_TRUE(service_->Assess(extension_b_, f, &args2, kStartTime));
- EXPECT_TRUE(service_->Assess(extension_b_, f, &args2,
- kStartTime + TimeDelta::FromSeconds(10)));
+ EXPECT_EQ("", service_->Assess(extension_b_, f, &args2, kStartTime));
+ EXPECT_EQ("", service_->Assess(extension_b_, f, &args2,
+ kStartTime + TimeDelta::FromSeconds(10)));
TimeDelta peace = TimeDelta::FromMinutes(30);
- EXPECT_TRUE(service_->Assess(extension_b_, f, &args, kStartTime + peace));
- EXPECT_TRUE(service_->Assess(extension_b_, f, &args,
- kStartTime + peace + TimeDelta::FromSeconds(10)));
- EXPECT_FALSE(service_->Assess(extension_b_, f, &args2,
+ EXPECT_EQ("", service_->Assess(extension_b_, f, &args, kStartTime + peace));
+ EXPECT_EQ("", service_->Assess(
+ extension_b_, f, &args,
+ kStartTime + peace + TimeDelta::FromSeconds(10)));
+ EXPECT_NE("", service_->Assess(extension_b_, f, &args2,
kStartTime + peace + TimeDelta::FromSeconds(15)));
// Test that items are independent.
ListValue args3;
args3.Append(new base::FundamentalValue(3));
- EXPECT_TRUE(service_->Assess(extension_c_, f, &args, kStartTime));
- EXPECT_TRUE(service_->Assess(extension_c_, f, &args3,
- kStartTime + TimeDelta::FromSeconds(10)));
- EXPECT_TRUE(service_->Assess(extension_c_, f, &args,
- kStartTime + TimeDelta::FromSeconds(15)));
- EXPECT_TRUE(service_->Assess(extension_c_, f, &args3,
- kStartTime + TimeDelta::FromSeconds(20)));
- EXPECT_FALSE(service_->Assess(extension_c_, f, &args,
- kStartTime + TimeDelta::FromSeconds(25)));
- EXPECT_FALSE(service_->Assess(extension_c_, f, &args3,
- kStartTime + TimeDelta::FromSeconds(30)));
+ EXPECT_EQ("", service_->Assess(extension_c_, f, &args, kStartTime));
+ EXPECT_EQ("", service_->Assess(extension_c_, f, &args3,
+ kStartTime + TimeDelta::FromSeconds(10)));
+ EXPECT_EQ("", service_->Assess(extension_c_, f, &args,
+ kStartTime + TimeDelta::FromSeconds(15)));
+ EXPECT_EQ("", service_->Assess(extension_c_, f, &args3,
+ kStartTime + TimeDelta::FromSeconds(20)));
+ EXPECT_NE("", service_->Assess(extension_c_, f, &args,
+ kStartTime + TimeDelta::FromSeconds(25)));
+ EXPECT_NE("", service_->Assess(extension_c_, f, &args3,
+ kStartTime + TimeDelta::FromSeconds(30)));
}
TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
@@ -269,25 +275,29 @@ TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
// One event per minute for 20 minutes comes in under the sustained limit,
// but is equal to the timed limit.
for (int i = 0; i < 20; i++) {
- EXPECT_TRUE(service_->Assess(extension_a_, f, &args,
- kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
+ EXPECT_EQ("", service_->Assess(
+ extension_a_, f, &args,
+ kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
}
// This will bring us to 21 events in an hour, which is a violation.
- EXPECT_FALSE(service_->Assess(extension_a_, f, &args,
- kStartTime + TimeDelta::FromMinutes(30)));
+ EXPECT_NE("", service_->Assess(extension_a_, f, &args,
+ kStartTime + TimeDelta::FromMinutes(30)));
// Now, check that we can still hit the lower limit.
for (int i = 0; i < 5; i++) {
- EXPECT_TRUE(service_->Assess(extension_b_, f, &args,
- kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
- EXPECT_TRUE(service_->Assess(extension_b_, f, &args,
- kStartTime + TimeDelta::FromSeconds(15 + i * 60)));
- EXPECT_TRUE(service_->Assess(extension_b_, f, &args,
- kStartTime + TimeDelta::FromSeconds(20 + i * 60)));
+ EXPECT_EQ("", service_->Assess(
+ extension_b_, f, &args,
+ kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
+ EXPECT_EQ("", service_->Assess(
+ extension_b_, f, &args,
+ kStartTime + TimeDelta::FromSeconds(15 + i * 60)));
+ EXPECT_EQ("", service_->Assess(
+ extension_b_, f, &args,
+ kStartTime + TimeDelta::FromSeconds(20 + i * 60)));
}
- EXPECT_FALSE(service_->Assess(extension_b_, f, &args,
+ EXPECT_NE("", service_->Assess(extension_b_, f, &args,
kStartTime + TimeDelta::FromMinutes(6)));
}
@@ -300,16 +310,16 @@ TEST_F(ExtensionsQuotaServiceTest, MultipleFunctionsDontInterfere) {
args_f.Append(new base::FundamentalValue(1));
args_g.Append(new base::FundamentalValue(2));
- EXPECT_TRUE(service_->Assess(extension_a_, f, &args_f, kStartTime));
- EXPECT_TRUE(service_->Assess(extension_a_, g, &args_g, kStartTime));
- EXPECT_TRUE(service_->Assess(extension_a_, f, &args_f,
- kStartTime + TimeDelta::FromSeconds(10)));
- EXPECT_TRUE(service_->Assess(extension_a_, g, &args_g,
- kStartTime + TimeDelta::FromSeconds(10)));
- EXPECT_FALSE(service_->Assess(extension_a_, f, &args_f,
- kStartTime + TimeDelta::FromSeconds(15)));
- EXPECT_FALSE(service_->Assess(extension_a_, g, &args_g,
- kStartTime + TimeDelta::FromSeconds(15)));
+ EXPECT_EQ("", service_->Assess(extension_a_, f, &args_f, kStartTime));
+ EXPECT_EQ("", service_->Assess(extension_a_, g, &args_g, kStartTime));
+ EXPECT_EQ("", service_->Assess(extension_a_, f, &args_f,
+ kStartTime + TimeDelta::FromSeconds(10)));
+ EXPECT_EQ("", service_->Assess(extension_a_, g, &args_g,
+ kStartTime + TimeDelta::FromSeconds(10)));
+ EXPECT_NE("", service_->Assess(extension_a_, f, &args_f,
+ kStartTime + TimeDelta::FromSeconds(15)));
+ EXPECT_NE("", service_->Assess(extension_a_, g, &args_g,
+ kStartTime + TimeDelta::FromSeconds(15)));
}
TEST_F(ExtensionsQuotaServiceTest, ViolatorsWillBeViolators) {
@@ -317,16 +327,16 @@ TEST_F(ExtensionsQuotaServiceTest, ViolatorsWillBeViolators) {
scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
ListValue arg;
arg.Append(new base::FundamentalValue(1));
- EXPECT_TRUE(service_->Assess(extension_a_, f, &arg, kStartTime));
- EXPECT_TRUE(service_->Assess(extension_a_, f, &arg,
- kStartTime + TimeDelta::FromSeconds(10)));
- EXPECT_FALSE(service_->Assess(extension_a_, f, &arg,
- kStartTime + TimeDelta::FromSeconds(15)));
+ EXPECT_EQ("", service_->Assess(extension_a_, f, &arg, kStartTime));
+ EXPECT_EQ("", service_->Assess(extension_a_, f, &arg,
+ kStartTime + TimeDelta::FromSeconds(10)));
+ EXPECT_NE("", service_->Assess(extension_a_, f, &arg,
+ kStartTime + TimeDelta::FromSeconds(15)));
// We don't allow this extension to use quota limited functions even if they
// wait a while.
- EXPECT_FALSE(service_->Assess(extension_a_, f, &arg,
- kStartTime + TimeDelta::FromDays(1)));
- EXPECT_FALSE(service_->Assess(extension_a_, g, &arg,
- kStartTime + TimeDelta::FromDays(1)));
+ EXPECT_NE("", service_->Assess(extension_a_, f, &arg,
+ kStartTime + TimeDelta::FromDays(1)));
+ EXPECT_NE("", service_->Assess(extension_a_, g, &arg,
+ kStartTime + TimeDelta::FromDays(1)));
}
« chrome/browser/extensions/api/web_request/web_request_api.cc ('K') | « chrome/browser/extensions/extensions_quota_service.cc ('k') | chrome/browser/extensions/settings/settings_api.cc » ('j') | chrome/browser/extensions/settings/settings_api.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698