content/browser/indexed_db/indexed_db_transaction_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 "content/browser/indexed_db/indexed_db_transaction.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "content/browser/indexed_db/indexed_db_fake_backing_store.h"
  12 #include "content/browser/indexed_db/mock_indexed_db_database_callbacks.h"
  13 #include "content/browser/indexed_db/mock_indexed_db_factory.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace content {
  17
  18 class AbortObserver {
  19  public:
  20   AbortObserver() : abort_task_called_(false) {}
  21
  22   void AbortTask(IndexedDBTransaction* transaction) {
  23     abort_task_called_ = true;
  24   }
  25
  26   bool abort_task_called() const { return abort_task_called_; }
  27
  28  private:
  29   bool abort_task_called_;
  30   DISALLOW_COPY_AND_ASSIGN(AbortObserver);
  31 };
  32
  33 class IndexedDBTransactionTest : public testing::Test {
  34  public:
  35   IndexedDBTransactionTest() : factory_(new MockIndexedDBFactory()) {
  36     backing_store_ = new IndexedDBFakeBackingStore();
  37     CreateDB();
  38   }
  39
  40   void CreateDB() {
  41     // DB is created here instead of the constructor to workaround a
  42     // "peculiarity of C++". More info at
  43     // https://code.google.com/p/googletest/wiki/FAQ#My_compiler_complains_that_a_constructor_(or_destructor)_cannot
  44     leveldb::Status s;
  45     db_ = IndexedDBDatabase::Create(base::ASCIIToUTF16("db"),
  46                                     backing_store_.get(),
  47                                     factory_.get(),
  48                                     IndexedDBDatabase::Identifier(),
  49                                     &s);
  50     ASSERT_TRUE(s.ok());
  51   }
  52
  53   void RunPostedTasks() { message_loop_.RunUntilIdle(); }
  54   void DummyOperation(IndexedDBTransaction* transaction) {}
  55   void AbortableOperation(AbortObserver* observer,
  56                           IndexedDBTransaction* transaction) {
  57     transaction->ScheduleAbortTask(
  58         base::Bind(&AbortObserver::AbortTask, base::Unretained(observer)));
  59   }
  60
  61  protected:
  62   scoped_refptr<IndexedDBFakeBackingStore> backing_store_;
  63   scoped_refptr<IndexedDBDatabase> db_;
  64
  65  private:
  66   base::MessageLoop message_loop_;
  67   scoped_refptr<MockIndexedDBFactory> factory_;
  68
  69   DISALLOW_COPY_AND_ASSIGN(IndexedDBTransactionTest);
  70 };
  71
  72 class IndexedDBTransactionTestMode
  73     : public IndexedDBTransactionTest,
  74       public testing::WithParamInterface<blink::WebIDBTransactionMode> {
  75  public:
  76   IndexedDBTransactionTestMode() {}
  77  private:
  78   DISALLOW_COPY_AND_ASSIGN(IndexedDBTransactionTestMode);
  79 };
  80
  81 TEST_F(IndexedDBTransactionTest, Timeout) {
  82   const int64 id = 0;
  83   const std::set<int64> scope;
  84   const leveldb::Status commit_success = leveldb::Status::OK();
  85   scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction(
  86       id,
  87       new MockIndexedDBDatabaseCallbacks(),
  88       scope,
  89       blink::WebIDBTransactionModeReadWrite,
  90       db_.get(),
  91       new IndexedDBFakeBackingStore::FakeTransaction(commit_success));
  92   db_->TransactionCreated(transaction.get());
  93
  94   // No conflicting transactions, so coordinator will start it immediately:
  95   EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state());
  96   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
  97   EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled);
  98   EXPECT_EQ(0, transaction->diagnostics().tasks_completed);
  99
 100   // Schedule a task - timer won't be started until it's processed.
 101   transaction->ScheduleTask(base::Bind(
 102       &IndexedDBTransactionTest::DummyOperation, base::Unretained(this)));
 103   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 104   EXPECT_EQ(1, transaction->diagnostics().tasks_scheduled);
 105   EXPECT_EQ(0, transaction->diagnostics().tasks_completed);
 106
 107   RunPostedTasks();
 108   EXPECT_TRUE(transaction->IsTimeoutTimerRunning());
 109
 110   transaction->Timeout();
 111   EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state());
 112   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 113   EXPECT_EQ(1, transaction->diagnostics().tasks_scheduled);
 114   EXPECT_EQ(1, transaction->diagnostics().tasks_completed);
 115
 116   // This task will be ignored.
 117   transaction->ScheduleTask(base::Bind(
 118       &IndexedDBTransactionTest::DummyOperation, base::Unretained(this)));
 119   EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state());
 120   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 121   EXPECT_EQ(1, transaction->diagnostics().tasks_scheduled);
 122   EXPECT_EQ(1, transaction->diagnostics().tasks_completed);
 123 }
 124
 125 TEST_F(IndexedDBTransactionTest, NoTimeoutReadOnly) {
 126   const int64 id = 0;
 127   const std::set<int64> scope;
 128   const leveldb::Status commit_success = leveldb::Status::OK();
 129   scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction(
 130       id,
 131       new MockIndexedDBDatabaseCallbacks(),
 132       scope,
 133       blink::WebIDBTransactionModeReadOnly,
 134       db_.get(),
 135       new IndexedDBFakeBackingStore::FakeTransaction(commit_success));
 136   db_->TransactionCreated(transaction.get());
 137
 138   // No conflicting transactions, so coordinator will start it immediately:
 139   EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state());
 140   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 141
 142   // Schedule a task - timer won't be started until it's processed.
 143   transaction->ScheduleTask(base::Bind(
 144       &IndexedDBTransactionTest::DummyOperation, base::Unretained(this)));
 145   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 146
 147   // Transaction is read-only, so no need to time it out.
 148   RunPostedTasks();
 149   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 150
 151   // Clean up to avoid leaks.
 152   transaction->Abort();
 153   EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state());
 154   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 155 }
 156
 157 TEST_P(IndexedDBTransactionTestMode, ScheduleNormalTask) {
 158   const int64 id = 0;
 159   const std::set<int64> scope;
 160   const leveldb::Status commit_success = leveldb::Status::OK();
 161   scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction(
 162       id,
 163       new MockIndexedDBDatabaseCallbacks(),
 164       scope,
 165       GetParam(),
 166       db_.get(),
 167       new IndexedDBFakeBackingStore::FakeTransaction(commit_success));
 168
 169   EXPECT_FALSE(transaction->HasPendingTasks());
 170   EXPECT_TRUE(transaction->IsTaskQueueEmpty());
 171   EXPECT_TRUE(transaction->task_queue_.empty());
 172   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 173   EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled);
 174   EXPECT_EQ(0, transaction->diagnostics().tasks_completed);
 175
 176   db_->TransactionCreated(transaction.get());
 177
 178   EXPECT_FALSE(transaction->HasPendingTasks());
 179   EXPECT_TRUE(transaction->IsTaskQueueEmpty());
 180   EXPECT_TRUE(transaction->task_queue_.empty());
 181   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 182
 183   transaction->ScheduleTask(
 184       blink::WebIDBTaskTypeNormal,
 185       base::Bind(&IndexedDBTransactionTest::DummyOperation,
 186                  base::Unretained(this)));
 187
 188   EXPECT_EQ(1, transaction->diagnostics().tasks_scheduled);
 189   EXPECT_EQ(0, transaction->diagnostics().tasks_completed);
 190
 191   EXPECT_TRUE(transaction->HasPendingTasks());
 192   EXPECT_FALSE(transaction->IsTaskQueueEmpty());
 193   EXPECT_FALSE(transaction->task_queue_.empty());
 194   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 195
 196   // Pump the message loop so that the transaction completes all pending tasks,
 197   // otherwise it will defer the commit.
 198   base::MessageLoop::current()->RunUntilIdle();
 199   EXPECT_FALSE(transaction->HasPendingTasks());
 200   EXPECT_TRUE(transaction->IsTaskQueueEmpty());
 201   EXPECT_TRUE(transaction->task_queue_.empty());
 202   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 203   EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state());
 204   EXPECT_EQ(1, transaction->diagnostics().tasks_scheduled);
 205   EXPECT_EQ(1, transaction->diagnostics().tasks_completed);
 206
 207   transaction->Commit();
 208
 209   EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state());
 210   EXPECT_FALSE(transaction->HasPendingTasks());
 211   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 212   EXPECT_TRUE(transaction->IsTaskQueueEmpty());
 213   EXPECT_TRUE(transaction->task_queue_.empty());
 214   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 215   EXPECT_EQ(1, transaction->diagnostics().tasks_scheduled);
 216   EXPECT_EQ(1, transaction->diagnostics().tasks_completed);
 217 }
 218
 219 TEST_F(IndexedDBTransactionTest, SchedulePreemptiveTask) {
 220   const int64 id = 0;
 221   const std::set<int64> scope;
 222   const leveldb::Status commit_failure = leveldb::Status::Corruption("Ouch.");
 223   scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction(
 224       id,
 225       new MockIndexedDBDatabaseCallbacks(),
 226       scope,
 227       blink::WebIDBTransactionModeVersionChange,
 228       db_.get(),
 229       new IndexedDBFakeBackingStore::FakeTransaction(commit_failure));
 230
 231   EXPECT_FALSE(transaction->HasPendingTasks());
 232   EXPECT_TRUE(transaction->IsTaskQueueEmpty());
 233   EXPECT_TRUE(transaction->task_queue_.empty());
 234   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 235   EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled);
 236   EXPECT_EQ(0, transaction->diagnostics().tasks_completed);
 237
 238   db_->TransactionCreated(transaction.get());
 239
 240   EXPECT_FALSE(transaction->HasPendingTasks());
 241   EXPECT_TRUE(transaction->IsTaskQueueEmpty());
 242   EXPECT_TRUE(transaction->task_queue_.empty());
 243   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 244
 245   transaction->ScheduleTask(
 246       blink::WebIDBTaskTypePreemptive,
 247       base::Bind(&IndexedDBTransactionTest::DummyOperation,
 248                  base::Unretained(this)));
 249   transaction->AddPreemptiveEvent();
 250
 251   EXPECT_TRUE(transaction->HasPendingTasks());
 252   EXPECT_FALSE(transaction->IsTaskQueueEmpty());
 253   EXPECT_TRUE(transaction->task_queue_.empty());
 254   EXPECT_FALSE(transaction->preemptive_task_queue_.empty());
 255
 256   // Pump the message loop so that the transaction completes all pending tasks,
 257   // otherwise it will defer the commit.
 258   base::MessageLoop::current()->RunUntilIdle();
 259   EXPECT_TRUE(transaction->HasPendingTasks());
 260   EXPECT_TRUE(transaction->IsTaskQueueEmpty());
 261   EXPECT_TRUE(transaction->task_queue_.empty());
 262   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 263   EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state());
 264   EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled);
 265   EXPECT_EQ(0, transaction->diagnostics().tasks_completed);
 266
 267   transaction->DidCompletePreemptiveEvent();
 268   transaction->Commit();
 269
 270   EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state());
 271   EXPECT_FALSE(transaction->HasPendingTasks());
 272   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 273   EXPECT_TRUE(transaction->IsTaskQueueEmpty());
 274   EXPECT_TRUE(transaction->task_queue_.empty());
 275   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 276   EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled);
 277   EXPECT_EQ(0, transaction->diagnostics().tasks_completed);
 278 }
 279
 280 TEST_P(IndexedDBTransactionTestMode, AbortTasks) {
 281   const int64 id = 0;
 282   const std::set<int64> scope;
 283   const leveldb::Status commit_failure = leveldb::Status::Corruption("Ouch.");
 284   scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction(
 285       id,
 286       new MockIndexedDBDatabaseCallbacks(),
 287       scope,
 288       GetParam(),
 289       db_.get(),
 290       new IndexedDBFakeBackingStore::FakeTransaction(commit_failure));
 291   db_->TransactionCreated(transaction.get());
 292
 293   AbortObserver observer;
 294   transaction->ScheduleTask(
 295       base::Bind(&IndexedDBTransactionTest::AbortableOperation,
 296                  base::Unretained(this),
 297                  base::Unretained(&observer)));
 298
 299   // Pump the message loop so that the transaction completes all pending tasks,
 300   // otherwise it will defer the commit.
 301   base::MessageLoop::current()->RunUntilIdle();
 302
 303   EXPECT_FALSE(observer.abort_task_called());
 304   transaction->Commit();
 305   EXPECT_TRUE(observer.abort_task_called());
 306   EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state());
 307   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 308 }
 309
 310 TEST_P(IndexedDBTransactionTestMode, AbortPreemptive) {
 311   const int64 id = 0;
 312   const std::set<int64> scope;
 313   const leveldb::Status commit_success = leveldb::Status::OK();
 314   scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction(
 315       id,
 316       new MockIndexedDBDatabaseCallbacks(),
 317       scope,
 318       GetParam(),
 319       db_.get(),
 320       new IndexedDBFakeBackingStore::FakeTransaction(commit_success));
 321   db_->TransactionCreated(transaction.get());
 322
 323   // No conflicting transactions, so coordinator will start it immediately:
 324   EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state());
 325   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 326
 327   transaction->ScheduleTask(
 328       blink::WebIDBTaskTypePreemptive,
 329       base::Bind(&IndexedDBTransactionTest::DummyOperation,
 330                  base::Unretained(this)));
 331   EXPECT_EQ(0, transaction->pending_preemptive_events_);
 332   transaction->AddPreemptiveEvent();
 333   EXPECT_EQ(1, transaction->pending_preemptive_events_);
 334
 335   RunPostedTasks();
 336
 337   transaction->Abort();
 338   EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state());
 339   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 340   EXPECT_EQ(0, transaction->pending_preemptive_events_);
 341   EXPECT_TRUE(transaction->preemptive_task_queue_.empty());
 342   EXPECT_TRUE(transaction->task_queue_.empty());
 343   EXPECT_FALSE(transaction->HasPendingTasks());
 344   EXPECT_EQ(transaction->diagnostics().tasks_completed,
 345             transaction->diagnostics().tasks_scheduled);
 346   EXPECT_FALSE(transaction->should_process_queue_);
 347   EXPECT_TRUE(transaction->backing_store_transaction_begun_);
 348   EXPECT_TRUE(transaction->used_);
 349   EXPECT_FALSE(transaction->commit_pending_);
 350
 351   // This task will be ignored.
 352   transaction->ScheduleTask(base::Bind(
 353       &IndexedDBTransactionTest::DummyOperation, base::Unretained(this)));
 354   EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state());
 355   EXPECT_FALSE(transaction->IsTimeoutTimerRunning());
 356   EXPECT_FALSE(transaction->HasPendingTasks());
 357   EXPECT_EQ(transaction->diagnostics().tasks_completed,
 358             transaction->diagnostics().tasks_scheduled);
 359 }
 360
 361 static const blink::WebIDBTransactionMode kTestModes[] = {
 362     blink::WebIDBTransactionModeReadOnly, blink::WebIDBTransactionModeReadWrite,
 363     blink::WebIDBTransactionModeVersionChange};
 364
 365 INSTANTIATE_TEST_CASE_P(IndexedDBTransactions,
 366                         IndexedDBTransactionTestMode,
 367                         ::testing::ValuesIn(kTestModes));
 368
 369 }  // namespace content