extensions/browser/api/storage/settings_quota_unittest.cc

   1 // Copyright 2014 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/json/json_writer.h"
   6 #include "base/memory/ref_counted.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/values.h"
   9 #include "extensions/browser/api/storage/settings_storage_quota_enforcer.h"
  10 #include "extensions/browser/value_store/testing_value_store.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 using base::DictionaryValue;
  14 using base::ListValue;
  15 using base::Value;
  16
  17 namespace extensions {
  18
  19 // To save typing ValueStore::DEFAULTS/IGNORE_QUOTA everywhere.
  20 const ValueStore::WriteOptions DEFAULTS = ValueStore::DEFAULTS;
  21 const ValueStore::WriteOptions IGNORE_QUOTA =
  22     ValueStore::IGNORE_QUOTA;
  23
  24 class ExtensionSettingsQuotaTest : public testing::Test {
  25  public:
  26   ExtensionSettingsQuotaTest()
  27       : byte_value_1_(new base::FundamentalValue(1)),
  28         byte_value_16_(new base::StringValue("sixteen bytes.")),
  29         byte_value_256_(new base::ListValue()),
  30         delegate_(new TestingValueStore()) {
  31     for (int i = 1; i < 89; ++i) {
  32       byte_value_256_->Append(new base::FundamentalValue(i));
  33     }
  34     ValidateByteValues();
  35   }
  36
  37   void ValidateByteValues() {
  38     std::string validate_sizes;
  39     base::JSONWriter::Write(byte_value_1_.get(), &validate_sizes);
  40     ASSERT_EQ(1u, validate_sizes.size());
  41     base::JSONWriter::Write(byte_value_16_.get(), &validate_sizes);
  42     ASSERT_EQ(16u, validate_sizes.size());
  43     base::JSONWriter::Write(byte_value_256_.get(), &validate_sizes);
  44     ASSERT_EQ(256u, validate_sizes.size());
  45   }
  46
  47   virtual void TearDown() OVERRIDE {
  48     ASSERT_TRUE(storage_.get() != NULL);
  49   }
  50
  51  protected:
  52   // Creates |storage_|.  Must only be called once.
  53   void CreateStorage(
  54       size_t quota_bytes, size_t quota_bytes_per_item, size_t max_items) {
  55     ASSERT_TRUE(storage_.get() == NULL);
  56     SettingsStorageQuotaEnforcer::Limits limits =
  57         { quota_bytes, quota_bytes_per_item, max_items };
  58     storage_.reset(new SettingsStorageQuotaEnforcer(limits, delegate_));
  59   }
  60
  61   // Returns whether the settings in |storage_| and |delegate_| are the same as
  62   // |settings|.
  63   bool SettingsEqual(const base::DictionaryValue& settings) {
  64     return settings.Equals(&storage_->Get()->settings()) &&
  65            settings.Equals(&delegate_->Get()->settings());
  66   }
  67
  68   // Values with different serialized sizes.
  69   scoped_ptr<base::Value> byte_value_1_;
  70   scoped_ptr<base::Value> byte_value_16_;
  71   scoped_ptr<base::ListValue> byte_value_256_;
  72
  73   // Quota enforcing storage area being tested.
  74   scoped_ptr<SettingsStorageQuotaEnforcer> storage_;
  75
  76   // In-memory storage area being delegated to.  Always owned by |storage_|.
  77   TestingValueStore* delegate_;
  78 };
  79
  80 TEST_F(ExtensionSettingsQuotaTest, ZeroQuotaBytes) {
  81   base::DictionaryValue empty;
  82   CreateStorage(0, UINT_MAX, UINT_MAX);
  83
  84   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
  85   EXPECT_FALSE(storage_->Remove("a")->HasError());
  86   EXPECT_FALSE(storage_->Remove("b")->HasError());
  87   EXPECT_TRUE(SettingsEqual(empty));
  88 }
  89
  90 TEST_F(ExtensionSettingsQuotaTest, KeySizeTakenIntoAccount) {
  91   base::DictionaryValue empty;
  92   CreateStorage(8u, UINT_MAX, UINT_MAX);
  93   EXPECT_TRUE(
  94       storage_->Set(DEFAULTS, "Really long key", *byte_value_1_)->HasError());
  95   EXPECT_TRUE(SettingsEqual(empty));
  96 }
  97
  98 TEST_F(ExtensionSettingsQuotaTest, SmallByteQuota) {
  99   base::DictionaryValue settings;
 100   CreateStorage(8u, UINT_MAX, UINT_MAX);
 101
 102   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 103   settings.Set("a", byte_value_1_->DeepCopy());
 104   EXPECT_TRUE(SettingsEqual(settings));
 105
 106   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 107   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 108   EXPECT_TRUE(SettingsEqual(settings));
 109 }
 110
 111 TEST_F(ExtensionSettingsQuotaTest, MediumByteQuota) {
 112   base::DictionaryValue settings;
 113   CreateStorage(40, UINT_MAX, UINT_MAX);
 114
 115   base::DictionaryValue to_set;
 116   to_set.Set("a", byte_value_1_->DeepCopy());
 117   to_set.Set("b", byte_value_16_->DeepCopy());
 118   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 119   settings.Set("a", byte_value_1_->DeepCopy());
 120   settings.Set("b", byte_value_16_->DeepCopy());
 121   EXPECT_TRUE(SettingsEqual(settings));
 122
 123   // Should be able to set value to other under-quota value.
 124   to_set.Set("a", byte_value_16_->DeepCopy());
 125   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 126   settings.Set("a", byte_value_16_->DeepCopy());
 127   EXPECT_TRUE(SettingsEqual(settings));
 128
 129   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 130   EXPECT_TRUE(SettingsEqual(settings));
 131 }
 132
 133 TEST_F(ExtensionSettingsQuotaTest, ZeroMaxKeys) {
 134   base::DictionaryValue empty;
 135   CreateStorage(UINT_MAX, UINT_MAX, 0);
 136
 137   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 138   EXPECT_FALSE(storage_->Remove("a")->HasError());
 139   EXPECT_FALSE(storage_->Remove("b")->HasError());
 140   EXPECT_TRUE(SettingsEqual(empty));
 141 }
 142
 143 TEST_F(ExtensionSettingsQuotaTest, SmallMaxKeys) {
 144   base::DictionaryValue settings;
 145   CreateStorage(UINT_MAX, UINT_MAX, 1);
 146
 147   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 148   settings.Set("a", byte_value_1_->DeepCopy());
 149   EXPECT_TRUE(SettingsEqual(settings));
 150
 151   // Should be able to set existing key to other value without going over quota.
 152   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
 153   settings.Set("a", byte_value_16_->DeepCopy());
 154   EXPECT_TRUE(SettingsEqual(settings));
 155
 156   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 157   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 158   EXPECT_TRUE(SettingsEqual(settings));
 159 }
 160
 161 TEST_F(ExtensionSettingsQuotaTest, MediumMaxKeys) {
 162   base::DictionaryValue settings;
 163   CreateStorage(UINT_MAX, UINT_MAX, 2);
 164
 165   base::DictionaryValue to_set;
 166   to_set.Set("a", byte_value_1_->DeepCopy());
 167   to_set.Set("b", byte_value_16_->DeepCopy());
 168   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 169   settings.Set("a", byte_value_1_->DeepCopy());
 170   settings.Set("b", byte_value_16_->DeepCopy());
 171   EXPECT_TRUE(SettingsEqual(settings));
 172
 173   // Should be able to set existing keys to other values without going over
 174   // quota.
 175   to_set.Set("a", byte_value_16_->DeepCopy());
 176   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 177   settings.Set("a", byte_value_16_->DeepCopy());
 178   EXPECT_TRUE(SettingsEqual(settings));
 179
 180   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 181   EXPECT_TRUE(SettingsEqual(settings));
 182 }
 183
 184 TEST_F(ExtensionSettingsQuotaTest, RemovingExistingSettings) {
 185   base::DictionaryValue settings;
 186   CreateStorage(266, UINT_MAX, 2);
 187
 188   storage_->Set(DEFAULTS, "b", *byte_value_16_);
 189   settings.Set("b", byte_value_16_->DeepCopy());
 190   // Not enough quota.
 191   storage_->Set(DEFAULTS, "c", *byte_value_256_);
 192   EXPECT_TRUE(SettingsEqual(settings));
 193
 194   // Try again with "b" removed, enough quota.
 195   EXPECT_FALSE(storage_->Remove("b")->HasError());
 196   settings.Remove("b", NULL);
 197   EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 198   settings.Set("c", byte_value_256_->DeepCopy());
 199   EXPECT_TRUE(SettingsEqual(settings));
 200
 201   // Enough byte quota but max keys not high enough.
 202   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 203   settings.Set("a", byte_value_1_->DeepCopy());
 204   EXPECT_TRUE(SettingsEqual(settings));
 205
 206   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 207   EXPECT_TRUE(SettingsEqual(settings));
 208
 209   // Back under max keys.
 210   EXPECT_FALSE(storage_->Remove("a")->HasError());
 211   settings.Remove("a", NULL);
 212   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 213   settings.Set("b", byte_value_1_->DeepCopy());
 214   EXPECT_TRUE(SettingsEqual(settings));
 215 }
 216
 217 TEST_F(ExtensionSettingsQuotaTest, RemovingNonexistentSettings) {
 218   base::DictionaryValue settings;
 219   CreateStorage(36, UINT_MAX, 3);
 220
 221   // Max out bytes.
 222   base::DictionaryValue to_set;
 223   to_set.Set("b1", byte_value_16_->DeepCopy());
 224   to_set.Set("b2", byte_value_16_->DeepCopy());
 225   storage_->Set(DEFAULTS, to_set);
 226   settings.Set("b1", byte_value_16_->DeepCopy());
 227   settings.Set("b2", byte_value_16_->DeepCopy());
 228   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 229   EXPECT_TRUE(SettingsEqual(settings));
 230
 231   // Remove some settings that don't exist.
 232   std::vector<std::string> to_remove;
 233   to_remove.push_back("a1");
 234   to_remove.push_back("a2");
 235   EXPECT_FALSE(storage_->Remove(to_remove)->HasError());
 236   EXPECT_FALSE(storage_->Remove("b")->HasError());
 237   EXPECT_TRUE(SettingsEqual(settings));
 238
 239   // Still no quota.
 240   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 241   EXPECT_TRUE(SettingsEqual(settings));
 242
 243   // Max out key count.
 244   to_set.Clear();
 245   to_set.Set("b1", byte_value_1_->DeepCopy());
 246   to_set.Set("b2", byte_value_1_->DeepCopy());
 247   storage_->Set(DEFAULTS, to_set);
 248   settings.Set("b1", byte_value_1_->DeepCopy());
 249   settings.Set("b2", byte_value_1_->DeepCopy());
 250   storage_->Set(DEFAULTS, "b3", *byte_value_1_);
 251   settings.Set("b3", byte_value_1_->DeepCopy());
 252   EXPECT_TRUE(SettingsEqual(settings));
 253
 254   // Remove some settings that don't exist.
 255   to_remove.clear();
 256   to_remove.push_back("a1");
 257   to_remove.push_back("a2");
 258   EXPECT_FALSE(storage_->Remove(to_remove)->HasError());
 259   EXPECT_FALSE(storage_->Remove("b")->HasError());
 260   EXPECT_TRUE(SettingsEqual(settings));
 261
 262   // Still no quota.
 263   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 264   EXPECT_TRUE(SettingsEqual(settings));
 265 }
 266
 267 TEST_F(ExtensionSettingsQuotaTest, Clear) {
 268   base::DictionaryValue settings;
 269   CreateStorage(40, UINT_MAX, 5);
 270
 271   // Test running out of byte quota.
 272   {
 273     base::DictionaryValue to_set;
 274     to_set.Set("a", byte_value_16_->DeepCopy());
 275     to_set.Set("b", byte_value_16_->DeepCopy());
 276     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 277     EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 278
 279     EXPECT_FALSE(storage_->Clear()->HasError());
 280
 281     // (repeat)
 282     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 283     EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 284   }
 285
 286   // Test reaching max keys.
 287   storage_->Clear();
 288   {
 289     base::DictionaryValue to_set;
 290     to_set.Set("a", byte_value_1_->DeepCopy());
 291     to_set.Set("b", byte_value_1_->DeepCopy());
 292     to_set.Set("c", byte_value_1_->DeepCopy());
 293     to_set.Set("d", byte_value_1_->DeepCopy());
 294     to_set.Set("e", byte_value_1_->DeepCopy());
 295     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 296     EXPECT_TRUE(storage_->Set(DEFAULTS, "f", *byte_value_1_)->HasError());
 297
 298     storage_->Clear();
 299
 300     // (repeat)
 301     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 302     EXPECT_TRUE(storage_->Set(DEFAULTS, "f", *byte_value_1_)->HasError());
 303   }
 304 }
 305
 306 TEST_F(ExtensionSettingsQuotaTest, ChangingUsedBytesWithSet) {
 307   base::DictionaryValue settings;
 308   CreateStorage(20, UINT_MAX, UINT_MAX);
 309
 310   // Change a setting to make it go over quota.
 311   storage_->Set(DEFAULTS, "a", *byte_value_16_);
 312   settings.Set("a", byte_value_16_->DeepCopy());
 313   EXPECT_TRUE(SettingsEqual(settings));
 314
 315   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_256_)->HasError());
 316   EXPECT_TRUE(SettingsEqual(settings));
 317
 318   // Change a setting to reduce usage and room for another setting.
 319   EXPECT_TRUE(storage_->Set(DEFAULTS, "foobar", *byte_value_1_)->HasError());
 320   storage_->Set(DEFAULTS, "a", *byte_value_1_);
 321   settings.Set("a", byte_value_1_->DeepCopy());
 322
 323   EXPECT_FALSE(storage_->Set(DEFAULTS, "foobar", *byte_value_1_)->HasError());
 324   settings.Set("foobar", byte_value_1_->DeepCopy());
 325   EXPECT_TRUE(SettingsEqual(settings));
 326 }
 327
 328 TEST_F(ExtensionSettingsQuotaTest, SetsOnlyEntirelyCompletedWithByteQuota) {
 329   base::DictionaryValue settings;
 330   CreateStorage(40, UINT_MAX, UINT_MAX);
 331
 332   storage_->Set(DEFAULTS, "a", *byte_value_16_);
 333   settings.Set("a", byte_value_16_->DeepCopy());
 334
 335   // The entire change is over quota.
 336   base::DictionaryValue to_set;
 337   to_set.Set("b", byte_value_16_->DeepCopy());
 338   to_set.Set("c", byte_value_16_->DeepCopy());
 339   EXPECT_TRUE(storage_->Set(DEFAULTS, to_set)->HasError());
 340   EXPECT_TRUE(SettingsEqual(settings));
 341
 342   // The entire change is over quota, but quota reduced in existing key.
 343   to_set.Set("a", byte_value_1_->DeepCopy());
 344   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 345   settings.Set("a", byte_value_1_->DeepCopy());
 346   settings.Set("b", byte_value_16_->DeepCopy());
 347   settings.Set("c", byte_value_16_->DeepCopy());
 348   EXPECT_TRUE(SettingsEqual(settings));
 349 }
 350
 351 TEST_F(ExtensionSettingsQuotaTest, SetsOnlyEntireCompletedWithMaxKeys) {
 352   base::DictionaryValue settings;
 353   CreateStorage(UINT_MAX, UINT_MAX, 2);
 354
 355   storage_->Set(DEFAULTS, "a", *byte_value_1_);
 356   settings.Set("a", byte_value_1_->DeepCopy());
 357
 358   base::DictionaryValue to_set;
 359   to_set.Set("b", byte_value_16_->DeepCopy());
 360   to_set.Set("c", byte_value_16_->DeepCopy());
 361   EXPECT_TRUE(storage_->Set(DEFAULTS, to_set)->HasError());
 362   EXPECT_TRUE(SettingsEqual(settings));
 363 }
 364
 365 TEST_F(ExtensionSettingsQuotaTest, WithInitialDataAndByteQuota) {
 366   base::DictionaryValue settings;
 367   delegate_->Set(DEFAULTS, "a", *byte_value_256_);
 368   settings.Set("a", byte_value_256_->DeepCopy());
 369
 370   CreateStorage(280, UINT_MAX, UINT_MAX);
 371   EXPECT_TRUE(SettingsEqual(settings));
 372
 373   // Add some data.
 374   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 375   settings.Set("b", byte_value_16_->DeepCopy());
 376   EXPECT_TRUE(SettingsEqual(settings));
 377
 378   // Not enough quota.
 379   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 380   EXPECT_TRUE(SettingsEqual(settings));
 381
 382   // Reduce usage of original setting so that "c" can fit.
 383   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
 384   settings.Set("a", byte_value_16_->DeepCopy());
 385   EXPECT_TRUE(SettingsEqual(settings));
 386
 387   EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 388   settings.Set("c", byte_value_16_->DeepCopy());
 389   EXPECT_TRUE(SettingsEqual(settings));
 390
 391   // Remove to free up some more data.
 392   EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_256_)->HasError());
 393
 394   std::vector<std::string> to_remove;
 395   to_remove.push_back("a");
 396   to_remove.push_back("b");
 397   storage_->Remove(to_remove);
 398   settings.Remove("a", NULL);
 399   settings.Remove("b", NULL);
 400   EXPECT_TRUE(SettingsEqual(settings));
 401
 402   EXPECT_FALSE(storage_->Set(DEFAULTS, "d", *byte_value_256_)->HasError());
 403   settings.Set("d", byte_value_256_->DeepCopy());
 404   EXPECT_TRUE(SettingsEqual(settings));
 405 }
 406
 407 TEST_F(ExtensionSettingsQuotaTest, WithInitialDataAndMaxKeys) {
 408   base::DictionaryValue settings;
 409   delegate_->Set(DEFAULTS, "a", *byte_value_1_);
 410   settings.Set("a", byte_value_1_->DeepCopy());
 411   CreateStorage(UINT_MAX, UINT_MAX, 2);
 412
 413   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 414   settings.Set("b", byte_value_1_->DeepCopy());
 415
 416   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_1_)->HasError());
 417
 418   EXPECT_TRUE(SettingsEqual(settings));
 419 }
 420
 421 TEST_F(ExtensionSettingsQuotaTest, InitiallyOverByteQuota) {
 422   base::DictionaryValue settings;
 423   settings.Set("a", byte_value_16_->DeepCopy());
 424   settings.Set("b", byte_value_16_->DeepCopy());
 425   settings.Set("c", byte_value_16_->DeepCopy());
 426   delegate_->Set(DEFAULTS, settings);
 427
 428   CreateStorage(40, UINT_MAX, UINT_MAX);
 429   EXPECT_TRUE(SettingsEqual(settings));
 430
 431   EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_16_)->HasError());
 432
 433   // Take under quota by reducing size of an existing setting
 434   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 435   settings.Set("a", byte_value_1_->DeepCopy());
 436   EXPECT_TRUE(SettingsEqual(settings));
 437
 438   // Should be able set another small setting.
 439   EXPECT_FALSE(storage_->Set(DEFAULTS, "d", *byte_value_1_)->HasError());
 440   settings.Set("d", byte_value_1_->DeepCopy());
 441   EXPECT_TRUE(SettingsEqual(settings));
 442 }
 443
 444 TEST_F(ExtensionSettingsQuotaTest, InitiallyOverMaxKeys) {
 445   base::DictionaryValue settings;
 446   settings.Set("a", byte_value_16_->DeepCopy());
 447   settings.Set("b", byte_value_16_->DeepCopy());
 448   settings.Set("c", byte_value_16_->DeepCopy());
 449   delegate_->Set(DEFAULTS, settings);
 450
 451   CreateStorage(UINT_MAX, UINT_MAX, 2);
 452   EXPECT_TRUE(SettingsEqual(settings));
 453
 454   // Can't set either an existing or new setting.
 455   EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_16_)->HasError());
 456   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 457   EXPECT_TRUE(SettingsEqual(settings));
 458
 459   // Should be able after removing 2.
 460   storage_->Remove("a");
 461   settings.Remove("a", NULL);
 462   storage_->Remove("b");
 463   settings.Remove("b", NULL);
 464   EXPECT_TRUE(SettingsEqual(settings));
 465
 466   EXPECT_FALSE(storage_->Set(DEFAULTS, "e", *byte_value_1_)->HasError());
 467   settings.Set("e", byte_value_1_->DeepCopy());
 468   EXPECT_TRUE(SettingsEqual(settings));
 469
 470   // Still can't set any.
 471   EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_16_)->HasError());
 472   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 473   EXPECT_TRUE(SettingsEqual(settings));
 474 }
 475
 476 TEST_F(ExtensionSettingsQuotaTest, ZeroQuotaBytesPerSetting) {
 477   base::DictionaryValue empty;
 478   CreateStorage(UINT_MAX, 0, UINT_MAX);
 479
 480   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 481   EXPECT_FALSE(storage_->Remove("a")->HasError());
 482   EXPECT_FALSE(storage_->Remove("b")->HasError());
 483   EXPECT_TRUE(SettingsEqual(empty));
 484 }
 485
 486 TEST_F(ExtensionSettingsQuotaTest, QuotaBytesPerSetting) {
 487   base::DictionaryValue settings;
 488
 489   CreateStorage(UINT_MAX, 20, UINT_MAX);
 490
 491   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 492   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
 493   settings.Set("a", byte_value_16_->DeepCopy());
 494   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_256_)->HasError());
 495
 496   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 497   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 498   settings.Set("b", byte_value_16_->DeepCopy());
 499   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_256_)->HasError());
 500
 501   EXPECT_TRUE(SettingsEqual(settings));
 502 }
 503
 504 TEST_F(ExtensionSettingsQuotaTest, QuotaBytesPerSettingWithInitialSettings) {
 505   base::DictionaryValue settings;
 506
 507   delegate_->Set(DEFAULTS, "a", *byte_value_1_);
 508   delegate_->Set(DEFAULTS, "b", *byte_value_16_);
 509   delegate_->Set(DEFAULTS, "c", *byte_value_256_);
 510   CreateStorage(UINT_MAX, 20, UINT_MAX);
 511
 512   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 513   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
 514   settings.Set("a", byte_value_16_->DeepCopy());
 515   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_256_)->HasError());
 516
 517   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 518   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 519   settings.Set("b", byte_value_16_->DeepCopy());
 520   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_256_)->HasError());
 521
 522   EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_1_)->HasError());
 523   EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 524   settings.Set("c", byte_value_16_->DeepCopy());
 525   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 526
 527   EXPECT_TRUE(SettingsEqual(settings));
 528 }
 529
 530 TEST_F(ExtensionSettingsQuotaTest,
 531     QuotaBytesPerSettingWithInitialSettingsForced) {
 532   // This is a lazy test to make sure IGNORE_QUOTA lets through changes: the
 533   // test above copied, but using IGNORE_QUOTA and asserting nothing is ever
 534   // rejected...
 535   base::DictionaryValue settings;
 536
 537   delegate_->Set(DEFAULTS, "a", *byte_value_1_);
 538   delegate_->Set(DEFAULTS, "b", *byte_value_16_);
 539   delegate_->Set(DEFAULTS, "c", *byte_value_256_);
 540   CreateStorage(UINT_MAX, 20, UINT_MAX);
 541
 542   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", *byte_value_1_)->HasError());
 543   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", *byte_value_16_)->HasError());
 544   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", *byte_value_256_)->HasError());
 545   settings.Set("a", byte_value_256_->DeepCopy());
 546
 547   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", *byte_value_1_)->HasError());
 548   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", *byte_value_16_)->HasError());
 549   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", *byte_value_256_)->HasError());
 550   settings.Set("b", byte_value_256_->DeepCopy());
 551
 552   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "c", *byte_value_1_)->HasError());
 553   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "c", *byte_value_16_)->HasError());
 554   settings.Set("c", byte_value_16_->DeepCopy());
 555
 556   // ... except the last.  Make sure it can still fail.
 557   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 558
 559   EXPECT_TRUE(SettingsEqual(settings));
 560 }
 561
 562 TEST_F(ExtensionSettingsQuotaTest, GetBytesInUse) {
 563   // Just testing GetBytesInUse, no need for a quota.
 564   CreateStorage(UINT_MAX, UINT_MAX, UINT_MAX);
 565
 566   std::vector<std::string> ab;
 567   ab.push_back("a");
 568   ab.push_back("b");
 569
 570   EXPECT_EQ(0u, storage_->GetBytesInUse());
 571   EXPECT_EQ(0u, storage_->GetBytesInUse("a"));
 572   EXPECT_EQ(0u, storage_->GetBytesInUse("b"));
 573   EXPECT_EQ(0u, storage_->GetBytesInUse(ab));
 574
 575   storage_->Set(DEFAULTS, "a", *byte_value_1_);
 576
 577   EXPECT_EQ(2u, storage_->GetBytesInUse());
 578   EXPECT_EQ(2u, storage_->GetBytesInUse("a"));
 579   EXPECT_EQ(0u, storage_->GetBytesInUse("b"));
 580   EXPECT_EQ(2u, storage_->GetBytesInUse(ab));
 581
 582   storage_->Set(DEFAULTS, "b", *byte_value_1_);
 583
 584   EXPECT_EQ(4u, storage_->GetBytesInUse());
 585   EXPECT_EQ(2u, storage_->GetBytesInUse("a"));
 586   EXPECT_EQ(2u, storage_->GetBytesInUse("b"));
 587   EXPECT_EQ(4u, storage_->GetBytesInUse(ab));
 588
 589   storage_->Set(DEFAULTS, "c", *byte_value_1_);
 590
 591   EXPECT_EQ(6u, storage_->GetBytesInUse());
 592   EXPECT_EQ(2u, storage_->GetBytesInUse("a"));
 593   EXPECT_EQ(2u, storage_->GetBytesInUse("b"));
 594   EXPECT_EQ(4u, storage_->GetBytesInUse(ab));
 595 }
 596
 597 }  // namespace extensions