mandoline filesystem: add a sqlite3 vfs to proxy filesystem usage.

sql/connection_unittest.cc

 // 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 "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/test/histogram_tester.h"
 #include "sql/connection.h"
+#include "sql/correct_sql_test_base.h"
 #include "sql/meta_table.h"
 #include "sql/proxy.h"
 #include "sql/statement.h"
 #include "sql/test/error_callback_support.h"
 #include "sql/test/scoped_error_ignorer.h"
 #include "sql/test/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
 
 namespace sql {
@@ skipping 177 matching lines @@
   explicit ScopedUmaskSetter(mode_t target_mask) {
     old_umask_ = umask(target_mask);
   }
   ~ScopedUmaskSetter() { umask(old_umask_); }
  private:
   mode_t old_umask_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedUmaskSetter);
 };
 #endif
 
-class SQLConnectionTest : public testing::Test {
+class SQLConnectionTest : public sql::SQLTestBase {
  public:
   void SetUp() override {
     // Any macro histograms which fire before the recorder is initialized cannot
     // be tested.  So this needs to be ahead of Open().
     base::StatisticsRecorder::Initialize();
 
-    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    db_path_ = temp_dir_.path().AppendASCII("SQLConnectionTest.db");
-    ASSERT_TRUE(db_.Open(db_path_));
+    SQLTestBase::SetUp();
   }
 
-  void TearDown() override { db_.Close(); }
-
-  sql::Connection& db() { return db_; }
-  const base::FilePath& db_path() { return db_path_; }
-
   // Handle errors by blowing away the database.
   void RazeErrorCallback(int expected_error, int error, sql::Statement* stmt) {
     EXPECT_EQ(expected_error, error);
-    db_.RazeAndClose();
+    db().RazeAndClose();
   }
-
- private:
-  sql::Connection db_;
-  base::FilePath db_path_;
-  base::ScopedTempDir temp_dir_;
 };
 
 TEST_F(SQLConnectionTest, Execute) {
   // Valid statement should return true.
   ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
   EXPECT_EQ(SQLITE_OK, db().GetErrorCode());
 
   // Invalid statement should fail.
   ASSERT_EQ(SQLITE_ERROR,
             db().ExecuteAndReturnErrorCode("CREATE TAB foo (a, b"));
@@ skipping 112 matching lines @@
 // with ScopedErrorIgnorer.
 TEST_F(SQLConnectionTest, ScopedIgnoreUntracked) {
   const char* kCreateSql = "CREATE TABLE foo (id INTEGER UNIQUE)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_FALSE(db().DoesTableExist("bar"));
   ASSERT_TRUE(db().DoesTableExist("foo"));
   ASSERT_TRUE(db().DoesColumnExist("foo", "id"));
   db().Close();
 
   // Corrupt the database so that nothing works, including PRAGMAs.
-  ASSERT_TRUE(sql::test::CorruptSizeInHeader(db_path()));
+  ASSERT_TRUE(CorruptSizeInHeaderOfDB());
 
   {
     sql::ScopedErrorIgnorer ignore_errors;
     ignore_errors.IgnoreError(SQLITE_CORRUPT);
     ASSERT_TRUE(db().Open(db_path()));
     ASSERT_FALSE(db().DoesTableExist("bar"));
     ASSERT_FALSE(db().DoesTableExist("foo"));
     ASSERT_FALSE(db().DoesColumnExist("foo", "id"));
     ASSERT_TRUE(ignore_errors.CheckIgnoredErrors());
   }
@@ skipping 147 matching lines @@
 
   // Check that the second connection sees the table.
   ASSERT_EQ(1, SqliteMasterCount(&other_db));
 
   ASSERT_TRUE(db().Raze());
 
   // The second connection sees the updated database.
   ASSERT_EQ(0, SqliteMasterCount(&other_db));
 }
 
+// TODO(erg): Enable this in the next patch once I add locking.
+#if !defined(MOJO_APPTEST_IMPL)
 TEST_F(SQLConnectionTest, RazeLocked) {
   const char* kCreateSql = "CREATE TABLE foo (id INTEGER PRIMARY KEY, value)";
   ASSERT_TRUE(db().Execute(kCreateSql));
 
   // Open a transaction and write some data in a second connection.
   // This will acquire a PENDING or EXCLUSIVE transaction, which will
   // cause the raze to fail.
   sql::Connection other_db;
   ASSERT_TRUE(other_db.Open(db_path()));
   ASSERT_TRUE(other_db.BeginTransaction());
@@ skipping 14 matching lines @@
   // blocks raze.
   const char *kQuery = "SELECT COUNT(*) FROM foo";
   sql::Statement s(other_db.GetUniqueStatement(kQuery));
   ASSERT_TRUE(s.Step());
   ASSERT_FALSE(db().Raze());
 
   // Complete the statement unlocks the database.
   ASSERT_FALSE(s.Step());
   ASSERT_TRUE(db().Raze());
 }
+#endif
 
 // Verify that Raze() can handle an empty file.  SQLite should treat
 // this as an empty database.
 TEST_F(SQLConnectionTest, RazeEmptyDB) {
   const char* kCreateSql = "CREATE TABLE foo (id INTEGER PRIMARY KEY, value)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   db().Close();
 
-  {
-    base::ScopedFILE file(base::OpenFile(db_path(), "rb+"));
-    ASSERT_TRUE(file.get() != NULL);
-    ASSERT_EQ(0, fseek(file.get(), 0, SEEK_SET));
-    ASSERT_TRUE(base::TruncateFile(file.get()));
-  }
+  TruncateDatabase();
 
   ASSERT_TRUE(db().Open(db_path()));
   ASSERT_TRUE(db().Raze());
   EXPECT_EQ(0, SqliteMasterCount(&db()));
 }
 
 // Verify that Raze() can handle a file of junk.
 TEST_F(SQLConnectionTest, RazeNOTADB) {
   db().Close();
   sql::Connection::Delete(db_path());
-  ASSERT_FALSE(base::PathExists(db_path()));
+  ASSERT_FALSE(GetPathExists(db_path()));
 
-  {
-    base::ScopedFILE file(base::OpenFile(db_path(), "wb"));
-    ASSERT_TRUE(file.get() != NULL);
-
-    const char* kJunk = "This is the hour of our discontent.";
-    fputs(kJunk, file.get());
-  }
-  ASSERT_TRUE(base::PathExists(db_path()));
+  WriteJunkToDatabase(SQLTestBase::TYPE_OVERWRITE_AND_TRUNCATE);
+  ASSERT_TRUE(GetPathExists(db_path()));
 
   // SQLite will successfully open the handle, but fail when running PRAGMA
   // statements that access the database.
   {
     sql::ScopedErrorIgnorer ignore_errors;
 
     // Earlier versions of Chromium compiled against SQLite 3.6.7.3, which
     // returned SQLITE_IOERR_SHORT_READ in this case.  Some platforms may still
     // compile against an earlier SQLite via USE_SYSTEM_SQLITE.
     if (ignore_errors.SQLiteLibVersionNumber() < 3008005) {
@@ skipping 13 matching lines @@
   EXPECT_EQ(0, SqliteMasterCount(&db()));
 }
 
 // Verify that Raze() can handle a database overwritten with garbage.
 TEST_F(SQLConnectionTest, RazeNOTADB2) {
   const char* kCreateSql = "CREATE TABLE foo (id INTEGER PRIMARY KEY, value)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_EQ(1, SqliteMasterCount(&db()));
   db().Close();
 
-  {
-    base::ScopedFILE file(base::OpenFile(db_path(), "rb+"));
-    ASSERT_TRUE(file.get() != NULL);
-    ASSERT_EQ(0, fseek(file.get(), 0, SEEK_SET));
-
-    const char* kJunk = "This is the hour of our discontent.";
-    fputs(kJunk, file.get());
-  }
+  WriteJunkToDatabase(SQLTestBase::TYPE_OVERWRITE);
 
   // SQLite will successfully open the handle, but will fail with
   // SQLITE_NOTADB on pragma statemenets which attempt to read the
   // corrupted header.
   {
     sql::ScopedErrorIgnorer ignore_errors;
     ignore_errors.IgnoreError(SQLITE_NOTADB);
     EXPECT_TRUE(db().Open(db_path()));
     ASSERT_TRUE(ignore_errors.CheckIgnoredErrors());
   }
   EXPECT_TRUE(db().Raze());
   db().Close();
 
   // Now empty, the open should succeed with an empty database.
   EXPECT_TRUE(db().Open(db_path()));
   EXPECT_EQ(0, SqliteMasterCount(&db()));
 }
 
 // Test that a callback from Open() can raze the database.  This is
 // essential for cases where the Open() can fail entirely, so the
 // Raze() cannot happen later.  Additionally test that when the
 // callback does this during Open(), the open is retried and succeeds.
 TEST_F(SQLConnectionTest, RazeCallbackReopen) {
   const char* kCreateSql = "CREATE TABLE foo (id INTEGER PRIMARY KEY, value)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_EQ(1, SqliteMasterCount(&db()));
   db().Close();
 
   // Corrupt the database so that nothing works, including PRAGMAs.
-  ASSERT_TRUE(sql::test::CorruptSizeInHeader(db_path()));
+  ASSERT_TRUE(CorruptSizeInHeaderOfDB());
 
   // Open() will succeed, even though the PRAGMA calls within will
   // fail with SQLITE_CORRUPT, as will this PRAGMA.
   {
     sql::ScopedErrorIgnorer ignore_errors;
     ignore_errors.IgnoreError(SQLITE_CORRUPT);
     ASSERT_TRUE(db().Open(db_path()));
     ASSERT_FALSE(db().Execute("PRAGMA auto_vacuum"));
     db().Close();
     ASSERT_TRUE(ignore_errors.CheckIgnoredErrors());
@@ skipping 124 matching lines @@
 }
 #endif
 
 TEST_F(SQLConnectionTest, Delete) {
   EXPECT_TRUE(db().Execute("CREATE TABLE x (x)"));
   db().Close();
 
   // Should have both a main database file and a journal file because
   // of journal_mode TRUNCATE.
   base::FilePath journal(db_path().value() + FILE_PATH_LITERAL("-journal"));
-  ASSERT_TRUE(base::PathExists(db_path()));
-  ASSERT_TRUE(base::PathExists(journal));
+  ASSERT_TRUE(GetPathExists(db_path()));
+  ASSERT_TRUE(GetPathExists(journal));
 
   sql::Connection::Delete(db_path());
-  EXPECT_FALSE(base::PathExists(db_path()));
-  EXPECT_FALSE(base::PathExists(journal));
+  EXPECT_FALSE(GetPathExists(db_path()));
+  EXPECT_FALSE(GetPathExists(journal));
 }
 
-#if defined(OS_POSIX)
+// This test manually sets on disk permissions; this doesn't apply to the mojo
+// fork.
+#if defined(OS_POSIX) && !defined(MOJO_APPTEST_IMPL)
 // Test that set_restrict_to_user() trims database permissions so that
 // only the owner (and root) can read.
 TEST_F(SQLConnectionTest, UserPermission) {
   // If the bots all had a restrictive umask setting such that
   // databases are always created with only the owner able to read
   // them, then the code could break without breaking the tests.
   // Temporarily provide a more permissive umask.
   db().Close();
   sql::Connection::Delete(db_path());
-  ASSERT_FALSE(base::PathExists(db_path()));
+  ASSERT_FALSE(GetPathExists(db_path()));
   ScopedUmaskSetter permissive_umask(S_IWGRP | S_IWOTH);
   ASSERT_TRUE(db().Open(db_path()));
 
   // Cause the journal file to be created.  If the default
   // journal_mode is changed back to DELETE, then parts of this test
   // will need to be updated.
   EXPECT_TRUE(db().Execute("CREATE TABLE x (x)"));
 
   base::FilePath journal(db_path().value() + FILE_PATH_LITERAL("-journal"));
   int mode;
 
   // Given a permissive umask, the database is created with permissive
   // read access for the database and journal.
-  ASSERT_TRUE(base::PathExists(db_path()));
-  ASSERT_TRUE(base::PathExists(journal));
+  ASSERT_TRUE(GetPathExists(db_path()));
+  ASSERT_TRUE(GetPathExists(journal));
   mode = base::FILE_PERMISSION_MASK;
   EXPECT_TRUE(base::GetPosixFilePermissions(db_path(), &mode));
   ASSERT_NE((mode & base::FILE_PERMISSION_USER_MASK), mode);
   mode = base::FILE_PERMISSION_MASK;
   EXPECT_TRUE(base::GetPosixFilePermissions(journal, &mode));
   ASSERT_NE((mode & base::FILE_PERMISSION_USER_MASK), mode);
 
   // Re-open with restricted permissions and verify that the modes
   // changed for both the main database and the journal.
   db().Close();
   db().set_restrict_to_user();
   ASSERT_TRUE(db().Open(db_path()));
-  ASSERT_TRUE(base::PathExists(db_path()));
-  ASSERT_TRUE(base::PathExists(journal));
+  ASSERT_TRUE(GetPathExists(db_path()));
+  ASSERT_TRUE(GetPathExists(journal));
   mode = base::FILE_PERMISSION_MASK;
   EXPECT_TRUE(base::GetPosixFilePermissions(db_path(), &mode));
   ASSERT_EQ((mode & base::FILE_PERMISSION_USER_MASK), mode);
   mode = base::FILE_PERMISSION_MASK;
   EXPECT_TRUE(base::GetPosixFilePermissions(journal, &mode));
   ASSERT_EQ((mode & base::FILE_PERMISSION_USER_MASK), mode);
 
   // Delete and re-create the database, the restriction should still apply.
   db().Close();
   sql::Connection::Delete(db_path());
   ASSERT_TRUE(db().Open(db_path()));
-  ASSERT_TRUE(base::PathExists(db_path()));
-  ASSERT_FALSE(base::PathExists(journal));
+  ASSERT_TRUE(GetPathExists(db_path()));
+  ASSERT_FALSE(GetPathExists(journal));
   mode = base::FILE_PERMISSION_MASK;
   EXPECT_TRUE(base::GetPosixFilePermissions(db_path(), &mode));
   ASSERT_EQ((mode & base::FILE_PERMISSION_USER_MASK), mode);
 
   // Verify that journal creation inherits the restriction.
   EXPECT_TRUE(db().Execute("CREATE TABLE x (x)"));
-  ASSERT_TRUE(base::PathExists(journal));
+  ASSERT_TRUE(GetPathExists(journal));
   mode = base::FILE_PERMISSION_MASK;
   EXPECT_TRUE(base::GetPosixFilePermissions(journal, &mode));
   ASSERT_EQ((mode & base::FILE_PERMISSION_USER_MASK), mode);
 }
 #endif  // defined(OS_POSIX)
 
 // Test that errors start happening once Poison() is called.
 TEST_F(SQLConnectionTest, Poison) {
   EXPECT_TRUE(db().Execute("CREATE TABLE x (x)"));
 
@@ skipping 85 matching lines @@
 
   EXPECT_FALSE(db().IsSQLValid("SELECT count(*) from other.bar"));
 }
 
 TEST_F(SQLConnectionTest, Basic_QuickIntegrityCheck) {
   const char* kCreateSql = "CREATE TABLE foo (id INTEGER PRIMARY KEY, value)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   EXPECT_TRUE(db().QuickIntegrityCheck());
   db().Close();
 
-  ASSERT_TRUE(sql::test::CorruptSizeInHeader(db_path()));
+  ASSERT_TRUE(CorruptSizeInHeaderOfDB());
 
   {
     sql::ScopedErrorIgnorer ignore_errors;
     ignore_errors.IgnoreError(SQLITE_CORRUPT);
     ASSERT_TRUE(db().Open(db_path()));
     EXPECT_FALSE(db().QuickIntegrityCheck());
     ASSERT_TRUE(ignore_errors.CheckIgnoredErrors());
   }
 }
 
 TEST_F(SQLConnectionTest, Basic_FullIntegrityCheck) {
   const std::string kOk("ok");
   std::vector<std::string> messages;
 
   const char* kCreateSql = "CREATE TABLE foo (id INTEGER PRIMARY KEY, value)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   EXPECT_TRUE(db().FullIntegrityCheck(&messages));
   EXPECT_EQ(1u, messages.size());
   EXPECT_EQ(kOk, messages[0]);
   db().Close();
 
-  ASSERT_TRUE(sql::test::CorruptSizeInHeader(db_path()));
+  ASSERT_TRUE(CorruptSizeInHeaderOfDB());
 
   {
     sql::ScopedErrorIgnorer ignore_errors;
     ignore_errors.IgnoreError(SQLITE_CORRUPT);
     ASSERT_TRUE(db().Open(db_path()));
     EXPECT_TRUE(db().FullIntegrityCheck(&messages));
     EXPECT_LT(1u, messages.size());
     EXPECT_NE(kOk, messages[0]);
     ASSERT_TRUE(ignore_errors.CheckIgnoredErrors());
   }
@@ skipping 291 matching lines @@
   samples = tester.GetHistogramSamplesSinceCreation(kCommitTime);
   ASSERT_TRUE(samples);
   // 100 for commit adjust, 1 for measuring COMMIT.
   EXPECT_EQ(101, samples->sum());
 
   samples = tester.GetHistogramSamplesSinceCreation(kAutoCommitTime);
   EXPECT_TRUE(!samples || samples->sum() == 0);
 }
 
 }  // namespace