Add Dump{Quota,LastAccessTime}Table

webkit/quota/quota_database_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
 #include "app/sql/connection.h"
+#include "app/sql/statement.h"
+#include "app/sql/transaction.h"
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/quota/quota_database.h"
 
 namespace {
 
 const base::Time kZeroTime;
 
 class TestErrorDelegate : public sql::ErrorDelegate {
  public:
   virtual ~TestErrorDelegate() { }
   virtual int OnError(
       int error, sql::Connection* connection, sql::Statement* stmt) {
     return error;
   }
 };
-
 }  // namespace
 
 namespace quota {
 
 class QuotaDatabaseTest : public testing::Test {
  protected:
+  typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
+  typedef QuotaDatabase::QuotaTableCallback QuotaTableCallback;
+  typedef QuotaDatabase::LastAccessTimeTableEntry LastAccessTimeTableEntry;
+  typedef QuotaDatabase::LastAccessTimeTableCallback
+    LastAccessTimeTableCallback;
+
+  template<typename Iterator>
+  bool AssignQuotaTable(
+      QuotaDatabase* quota_database, Iterator itr, Iterator end) {
+    if (!quota_database->LazyOpen(true))
+      return false;
+
+    sql::Transaction transaction(quota_database->db_.get());
+    if (!transaction.Begin())
+      return false;
+
+    for (;itr != end; ++itr) {
+      const char* kSql =
+          "INSERT INTO HostQuotaTable"
+          " (host, type, quota)"
+          " VALUES (?, ?, ?)";
+      sql::Statement statement;
+      statement.Assign(
+          quota_database->db_->GetCachedStatement(
+              SQL_FROM_HERE, kSql));
+      EXPECT_TRUE(statement.is_valid());
+
+      statement.BindString(0, itr->host);
+      statement.BindInt(1, static_cast<int>(itr->type));
+      statement.BindInt64(2, itr->quota);
+      if (!statement.Run())
+        return false;
+    }
+
+    return transaction.Commit();
+  }
+
+  template<typename Iterator>
+  bool AssignLastAccessTimeTable(
+      QuotaDatabase* quota_database, Iterator itr, Iterator end) {
+    if (!quota_database->LazyOpen(true))
+      return false;
+
+    sql::Transaction transaction(quota_database->db_.get());
+    if (!transaction.Begin())
+      return false;
+
+    for (;itr != end; ++itr) {
+      const char* kSql =
+          "INSERT INTO OriginLastAccessTable"
+          " (origin, type, used_count, last_access_time)"
+          " VALUES (?, ?, ?, ?)";
+      sql::Statement statement;
+      statement.Assign(
+          quota_database->db_->GetCachedStatement(
+              SQL_FROM_HERE, kSql));
+      EXPECT_TRUE(statement.is_valid());
+
+      statement.BindString(0, itr->origin.spec());
+      statement.BindInt(1, static_cast<int>(itr->type));
+      statement.BindInt(2, itr->used_count);
+      statement.BindInt64(3, itr->last_access_time.ToInternalValue());
+      if (!statement.Run())
+        return false;
+    }
+
+    return transaction.Commit();
+  }
+
   void LazyOpen(const FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
     EXPECT_FALSE(db.LazyOpen(false));
     ASSERT_TRUE(db.LazyOpen(true));
     EXPECT_TRUE(db.db_.get());
     EXPECT_TRUE(kDbFile.empty() || file_util::PathExists(kDbFile));
   }
 
   void HostQuota(const FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
@@ skipping 140 matching lines @@
     EXPECT_TRUE(db.RegisterOrigins(origins,
                                    kStorageTypeTemporary,
                                    base::Time()));
 
     used_count = -1;
     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
                                        kStorageTypeTemporary,
                                        &used_count));
     EXPECT_EQ(1, used_count);
   }
+
+  template<typename EntryType>
+  struct EntryVerifier {
+    std::set<EntryType> table;
+
+    template<typename Iterator>
+    EntryVerifier(Iterator itr, Iterator end)
+        :table(itr, end) {}
+
+    bool Run(const EntryType& entry) {
+      EXPECT_EQ(1u, table.erase(entry));
+      return true;
+    }
+  };
+
+  void DumpQuotaTable(const FilePath& kDbFile) {
+    QuotaTableEntry kTableEntries[] = {
+      {"http://go/", kStorageTypeTemporary, 1},
+      {"http://oo/", kStorageTypeTemporary, 2},
+      {"http://gle/", kStorageTypePersistent, 3}
+    };
+    QuotaTableEntry* begin = kTableEntries;
+    QuotaTableEntry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
+
+    QuotaDatabase db(kDbFile);
+    EXPECT_TRUE(AssignQuotaTable(&db, begin, end));
+
+    typedef EntryVerifier<QuotaTableEntry> Verifier;
+    Verifier verifier(begin, end);
+    QuotaTableCallback callback = base::Bind(&Verifier::Run,
+                                             base::Unretained(&verifier));
+    EXPECT_TRUE(db.DumpQuotaTable(&callback));
+    EXPECT_TRUE(verifier.table.empty());
+  }
+
+  void DumpLastAccessTimeTable(const FilePath& kDbFile) {
+    base::Time now(base::Time::Now());
+    LastAccessTimeTableEntry kTableEntries[] = {
+      {GURL("http://go/"), kStorageTypeTemporary, 2147483647, now},
+      {GURL("http://oo/"), kStorageTypeTemporary, 0, now},
+      {GURL("http://gle/"), kStorageTypeTemporary, 1, now},
+    };
+    LastAccessTimeTableEntry* begin = kTableEntries;
+    LastAccessTimeTableEntry* end = kTableEntries +
+        ARRAYSIZE_UNSAFE(kTableEntries);
+
+    QuotaDatabase db(kDbFile);
+    EXPECT_TRUE(AssignLastAccessTimeTable(&db, begin, end));
+
+    typedef EntryVerifier<LastAccessTimeTableEntry> Verifier;
+    Verifier verifier(begin, end);
+    LastAccessTimeTableCallback callback =
+        base::Bind(&Verifier::Run,
+                   base::Unretained(&verifier));
+    EXPECT_TRUE(db.DumpLastAccessTimeTable(&callback));
+    EXPECT_TRUE(verifier.table.empty());
+  }
 };
 
 TEST_F(QuotaDatabaseTest, LazyOpen) {
   ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   LazyOpen(kDbFile);
   LazyOpen(FilePath());
 }
 
@@ skipping 35 matching lines @@
   EXPECT_FALSE(db.IsOriginDatabaseBootstrapped());
 }
 
 TEST_F(QuotaDatabaseTest, RegisterOrigins) {
   ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   RegisterOrigins(kDbFile);
   RegisterOrigins(FilePath());
 }
+
+TEST_F(QuotaDatabaseTest, DumpQuotaTable) {
+  ScopedTempDir data_dir;
+  ASSERT_TRUE(data_dir.CreateUniqueTempDir());
+  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  DumpQuotaTable(kDbFile);
+  DumpQuotaTable(FilePath());
+}
+
+TEST_F(QuotaDatabaseTest, DumpLastAccessTimeTable) {
+  ScopedTempDir data_dir;
+  ASSERT_TRUE(data_dir.CreateUniqueTempDir());
+  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  DumpLastAccessTimeTable(kDbFile);
+  DumpLastAccessTimeTable(FilePath());
+}
 }  // namespace quota