Create a class to represent a DOM Storage Database.

webkit/dom_storage/dom_storage_database_unittest.cc

Index: webkit/dom_storage/dom_storage_database_unittest.cc
diff --git a/webkit/dom_storage/dom_storage_database_unittest.cc b/webkit/dom_storage/dom_storage_database_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6a5eb8e3d26e6fb911792a1721c32791257ca203
--- /dev/null
+++ b/webkit/dom_storage/dom_storage_database_unittest.cc
@@ -0,0 +1,367 @@
+// Copyright (c) 2012 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 "webkit/dom_storage/dom_storage_database.h"
+
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/path_service.h"
+#include "base/scoped_temp_dir.h"
+#include "base/utf_string_conversions.h"
+#include "sql/statement.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace dom_storage {
+
+DomStorageDatabase::DomStorageDatabase()
+    : db_(NULL),
+      failed_to_open_(false),
+      tried_to_recreate_(false) {
+}
+
+void CreateV1Table(sql::Connection* db) {
+  ASSERT_TRUE(db->is_open());
+  ASSERT_TRUE(db->Execute("DROP TABLE IF EXISTS ItemTable"));
+  ASSERT_TRUE(db->Execute(
+      "CREATE TABLE ItemTable ("
+      "key TEXT UNIQUE ON CONFLICT REPLACE, "
+      "value TEXT NOT NULL ON CONFLICT FAIL)"));
+}
+
+void CreateV2Table(sql::Connection* db) {
+  ASSERT_TRUE(db->is_open());
+  ASSERT_TRUE(db->Execute("DROP TABLE IF EXISTS ItemTable"));
+  ASSERT_TRUE(db->Execute(
+      "CREATE TABLE ItemTable ("
+      "key TEXT UNIQUE ON CONFLICT REPLACE, "
+      "value BLOB NOT NULL ON CONFLICT FAIL)"));
+}
+
+void CreateInvalidKeyColumnTable(sql::Connection* db) {
+  // Create a table with the key type as FLOAT - this is "invalid"
+  // as far as the DOM Storage db is concerned.
+  ASSERT_TRUE(db->is_open());
+  ASSERT_TRUE(db->Execute("DROP TABLE IF EXISTS ItemTable"));
+  ASSERT_TRUE(db->Execute(
+      "CREATE TABLE IF NOT EXISTS ItemTable ("
+      "key FLOAT UNIQUE ON CONFLICT REPLACE, "
+      "value BLOB NOT NULL ON CONFLICT FAIL)"));
+}
+void CreateInvalidValueColumnTable(sql::Connection* db) {
+  // Create a table with the value type as FLOAT - this is "invalid"
+  // as far as the DOM Storage db is concerned.
+  ASSERT_TRUE(db->is_open());
+  ASSERT_TRUE(db->Execute("DROP TABLE IF EXISTS ItemTable"));
+  ASSERT_TRUE(db->Execute(
+      "CREATE TABLE IF NOT EXISTS ItemTable ("
+      "key TEXT UNIQUE ON CONFLICT REPLACE, "
+      "value FLOAT NOT NULL ON CONFLICT FAIL)"));
+}
+
+void InsertDataV1(sql::Connection* db,
+                  const string16& key,
+                  const string16& value) {
+  sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE,
+      "INSERT INTO ItemTable VALUES (?,?)"));
+  statement.BindString16(0, key);
+  statement.BindString16(1, value);
+  ASSERT_TRUE(statement.is_valid());
+  statement.Run();
+}
+
+void CheckValuesMatch(DomStorageDatabase* db,
+                      const ValuesMap& expected) {
+  ValuesMap values_read;
+  db->ReadAllValues(&values_read);
+  EXPECT_EQ(expected.size(), values_read.size());
+
+  ValuesMap::const_iterator it = values_read.begin();
+  for (; it != values_read.end(); ++it) {
+    string16 key = it->first;
+    NullableString16 value = it->second;
+    NullableString16 expected_value = expected.find(key)->second;
+    EXPECT_EQ(expected_value.string(), value.string());
+    EXPECT_EQ(expected_value.is_null(), value.is_null());
+  }
+}
+
+void CreateMapWithValues(ValuesMap* values) {
+  string16 kCannedKeys[] = {
+      ASCIIToUTF16("test"),
+      ASCIIToUTF16("company"),
+      ASCIIToUTF16("date"),
+      ASCIIToUTF16("empty")
+  };
+  NullableString16 kCannedValues[] = {
+      NullableString16(ASCIIToUTF16("123"), false),
+      NullableString16(ASCIIToUTF16("Google"), false),
+      NullableString16(ASCIIToUTF16("18-01-2012"), false),
+      NullableString16(ASCIIToUTF16(""), false)
+  };
+  for (unsigned i = 0; i < sizeof(kCannedKeys) / sizeof(kCannedKeys[0]); i++)
+    (*values)[kCannedKeys[i]] = kCannedValues[i];
+}
+
+TEST(DomStorageDatabaseTest, SimpleOpenAndClose) {
+  DomStorageDatabase db;
+  EXPECT_FALSE(db.IsOpen());
+  ASSERT_TRUE(db.LazyOpen(true));
+  EXPECT_TRUE(db.IsOpen());
+  EXPECT_EQ(DomStorageDatabase::V2, db.DetectSchemaVersion());
+  db.Close();
+  EXPECT_FALSE(db.IsOpen());
+}
+
+TEST(DomStorageDatabaseTest, TestLazyOpenIsLazy) {
+  // This test needs to operate with a file on disk to ensure that we will
+  // open a file that already exists when only invoking ReadAllValues.
+  ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  FilePath file_name = temp_dir.path().AppendASCII("TestDomStorageDatabase.db");
+
+  DomStorageDatabase db(file_name);
+  EXPECT_FALSE(db.IsOpen());
+  ValuesMap values;
+  db.ReadAllValues(&values);
+  // Reading an empty db should not open the database.
+  EXPECT_FALSE(db.IsOpen());
+
+  values[ASCIIToUTF16("key")] = NullableString16(ASCIIToUTF16("value"), false);
+  db.CommitChanges(false, values);
+  // Writing content should open the database.
+  EXPECT_TRUE(db.IsOpen());
+
+  db.Close();
+  ASSERT_FALSE(db.IsOpen());
+
+  // Reading from an existing database should open the database.
+  db.ReadAllValues(&values);
+  EXPECT_TRUE(db.IsOpen());

[michaeln, 2012/02/08 22:12:08]

With minor mods, this test could serve to verify what TestOpenCloseDataPreserved
is meant to verify. Maybe worth it to perform less actual file io in test runs.

Instead of calling db.ReadAllValues() directly, a call to CheckValuesMatch()
would kick the lazy open case and verify that the expected values are preserved
(and the other test could be removed).

[benm (inactive), 2012/02/09 11:59:57]

Done.

+}
+
+TEST(DomStorageDatabaseTest, TestDetectSchemaVersion) {
+  {
+    DomStorageDatabase db;
+    db.db_.reset(new sql::Connection());
+    ASSERT_TRUE(db.db_->OpenInMemory());
+    CreateInvalidValueColumnTable(db.db_.get());
+    EXPECT_EQ(DomStorageDatabase::INVALID, db.DetectSchemaVersion());
+  }
+
+  {
+    DomStorageDatabase db;
+    db.db_.reset(new sql::Connection());
+    ASSERT_TRUE(db.db_->OpenInMemory());
+    CreateInvalidKeyColumnTable(db.db_.get());
+    EXPECT_EQ(DomStorageDatabase::INVALID, db.DetectSchemaVersion());
+  }
+
+  {
+    DomStorageDatabase db;
+    db.db_.reset(new sql::Connection());
+    ASSERT_TRUE(db.db_->OpenInMemory());
+    CreateV1Table(db.db_.get());
+    EXPECT_EQ(DomStorageDatabase::V1, db.DetectSchemaVersion());
+  }
+
+  {
+    DomStorageDatabase db;
+    db.db_.reset(new sql::Connection());
+    ASSERT_TRUE(db.db_->OpenInMemory());
+    CreateV2Table(db.db_.get());
+    EXPECT_EQ(DomStorageDatabase::V2, db.DetectSchemaVersion());

[michaeln, 2012/02/08 22:12:08]

looks like much of the boiler plate around each case could be eliminated since
each of the create table helpers drops any old table.

DomStorageDatabase db;
db.db_.reset(new sql::Connection());
ASSERT_TRUE(db.db_->OpenInMemory());

EXPECT_EQ(DomStorageDatabase::INVALID, db.DetectSchemaVersion());

CreateInvalidValueColumnTable(db.db_.get());
EXPECT_EQ(DomStorageDatabase::INVALID, db.DetectSchemaVersion());

CreateV1Table(db.db_.get());
EXPECT_EQ(DomStorageDatabase::V1, db.DetectSchemaVersion());

..etc...

[benm (inactive), 2012/02/09 11:59:57]

Thanks, done!

+  }
+}
+
+TEST(DomStorageDatabaseTest, TestLazyOpenUpgradesDatabase) {
+  // This test needs to operate with a file on disk so that we
+  // can create a table at version 1 and then close it again
+  // so that LazyOpen sees there is work to do (LazyOpen will return
+  // early if the database is already open).
+  ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  FilePath file_name = temp_dir.path().AppendASCII("TestDomStorageDatabase.db");
+
+  DomStorageDatabase db(file_name);
+  db.db_.reset(new sql::Connection());
+  ASSERT_TRUE(db.db_->Open(file_name));
+  CreateV1Table(db.db_.get());
+  db.Close();
+
+  EXPECT_TRUE(db.LazyOpen(true));
+  EXPECT_EQ(DomStorageDatabase::V2, db.DetectSchemaVersion());
+}
+
+TEST(DomStorageDatabaseTest, SimpleWriteAndReadBack) {
+  DomStorageDatabase db;
+
+  ValuesMap storage;
+  CreateMapWithValues(&storage);
+
+  // Test write.

[michaeln, 2012/02/08 22:12:08]

this comment and the one below probably can be removed, i think they're stating
the obvious

[benm (inactive), 2012/02/09 11:59:57]

Done.

+  EXPECT_TRUE(db.CommitChanges(false, storage));
+
+  // CheckValuesMatch will invoke DomStorageDatabase::ReadAllValues
+  // to test reading.
+  CheckValuesMatch(&db, storage);
+}
+
+TEST(DomStorageDatabaseTest, WriteWithClear) {
+  DomStorageDatabase db;
+
+  ValuesMap storage;
+  CreateMapWithValues(&storage);
+
+  ASSERT_TRUE(db.CommitChanges(false, storage));
+  CheckValuesMatch(&db, storage);
+
+  // Insert some values, clearing the database first.
+  storage.clear();
+  storage[ASCIIToUTF16("another_key")] =
+      NullableString16(ASCIIToUTF16("test"), false);
+  ASSERT_TRUE(db.CommitChanges(true, storage));
+  CheckValuesMatch(&db, storage);
+
+  // Now clear the values without inserting any new ones.
+  storage.clear();
+  ASSERT_TRUE(db.CommitChanges(true, storage));
+  CheckValuesMatch(&db, storage);
+}
+
+TEST(DomStorageDatabaseTest, UpgradeFromV1ToV2WithData) {
+  const string16 kCannedKey = ASCIIToUTF16("foo");
+  const NullableString16 kCannedValue(ASCIIToUTF16("bar"), false);
+  ValuesMap expected;
+  expected[kCannedKey] = kCannedValue;
+
+  DomStorageDatabase db;
+  db.db_.reset(new sql::Connection());
+  ASSERT_TRUE(db.db_->OpenInMemory());
+  CreateV1Table(db.db_.get());
+  InsertDataV1(db.db_.get(), kCannedKey, kCannedValue.string());
+
+  ASSERT_TRUE(db.UpgradeVersion1To2());
+
+  EXPECT_EQ(DomStorageDatabase::V2, db.DetectSchemaVersion());
+
+  CheckValuesMatch(&db, expected);
+}
+
+TEST(DomStorageDatabaseTest, TestOpenCloseDataPreserved) {
+  // This test needs to operate on a file on disk as data
+  // must be preserved through a call to Close().
+  ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  FilePath file_name = temp_dir.path().AppendASCII("TestDomStorageDatabase.db");
+  DomStorageDatabase db(file_name);
+
+  const string16 kCannedKey = ASCIIToUTF16("test");
+  const NullableString16 kCannedValue(ASCIIToUTF16("data"), false);
+  ValuesMap expected;
+  expected[kCannedKey] = kCannedValue;
+  ASSERT_TRUE(db.CommitChanges(false, expected));
+  db.Close();
+
+  CheckValuesMatch(&db, expected);
+}
+
+TEST(DomStorageDatabaseTest, TestSimpleRemoveOneValue) {
+  DomStorageDatabase db;
+
+  ASSERT_TRUE(db.LazyOpen(true));
+  const string16 kCannedKey = ASCIIToUTF16("test");
+  const NullableString16 kCannedValue(ASCIIToUTF16("data"), false);
+  ValuesMap expected;
+  expected[kCannedKey] = kCannedValue;
+
+  // First write some data into the database.
+  ASSERT_TRUE(db.CommitChanges(false, expected));
+  CheckValuesMatch(&db, expected);
+
+  ValuesMap values;
+  // A null string in the map should mean that that key gets
+  // removed.
+  values[kCannedKey] = NullableString16(true);
+  EXPECT_TRUE(db.CommitChanges(false, values));
+
+  expected.clear();
+  CheckValuesMatch(&db, expected);
+}
+
+// TODO(benm): Enable this test in follow up patch once the test data has
+// landed. (try-bots don't like adding binary files like test databases :) )
+TEST(DomStorageDatabaseTest, DISABLED_TestCanOpenAndReadWebCoreDatabase) {
+  FilePath webcore_database;
+  PathService::Get(base::DIR_SOURCE_ROOT, &webcore_database);
+  webcore_database = webcore_database.AppendASCII("webkit");
+  webcore_database = webcore_database.AppendASCII("data");
+  webcore_database = webcore_database.AppendASCII("dom_storage");
+  webcore_database =
+      webcore_database.AppendASCII("webcore_test_database.localstorage");
+
+  ASSERT_TRUE(file_util::PathExists(webcore_database));
+
+  DomStorageDatabase db(webcore_database);
+  ValuesMap values;
+  db.ReadAllValues(&values);
+  EXPECT_TRUE(db.IsOpen());
+  EXPECT_EQ(2u, values.size());
+
+  ValuesMap::const_iterator it =
+      values.find(ASCIIToUTF16("value"));
+  EXPECT_TRUE(it != values.end());
+  EXPECT_EQ(ASCIIToUTF16("I am in local storage!"), it->second.string());
+
+  it = values.find(ASCIIToUTF16("timestamp"));
+  EXPECT_TRUE(it != values.end());
+  EXPECT_EQ(ASCIIToUTF16("1326738338841"), it->second.string());
+
+  it = values.find(ASCIIToUTF16("not_there"));
+  EXPECT_TRUE(it == values.end());
+}
+
+TEST(DomStorageDatabaseTest, TestCanOpenFileThatIsNotADatabase) {
+  // Write into the temporary file first.
+  ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  FilePath file_name = temp_dir.path().AppendASCII("TestDomStorageDatabase.db");
+
+  const char kData[] = "I am not a database.";
+  file_util::WriteFile(file_name, kData, strlen(kData));
+
+  {
+    // Try and open the file. As it's not a database, we should end up deleting
+    // it and creating a new, valid file, so everything should actually
+    // succeed.
+    DomStorageDatabase db(file_name);
+    ValuesMap values;
+    CreateMapWithValues(&values);
+    EXPECT_TRUE(db.CommitChanges(true, values));
+    EXPECT_TRUE(db.CommitChanges(false, values));
+    EXPECT_TRUE(db.IsOpen());
+
+    CheckValuesMatch(&db, values);
+  }
+
+  {
+    // Try to open a directory, we should fail gracefully and not attempt
+    // to delete it.
+    DomStorageDatabase db(temp_dir.path());
+    ValuesMap values;
+    CreateMapWithValues(&values);
+    EXPECT_FALSE(db.CommitChanges(true, values));
+    EXPECT_FALSE(db.CommitChanges(false, values));
+    EXPECT_FALSE(db.IsOpen());
+
+    values.clear();
+
+    db.ReadAllValues(&values);
+    EXPECT_EQ(0u, values.size());
+    EXPECT_FALSE(db.IsOpen());
+
+    EXPECT_TRUE(file_util::PathExists(temp_dir.path()));
+  }
+}
+
+}  // namespace dom_storage