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(CorruptSizeInHeaderOfPath(db_path()));
 
   {
     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_TRUNCATE_AND_CREATE);
+  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_OPEN_AND_APPEND);

[Scott Hess - ex-Googler, 2015/06/17 19:32:58]

"wb" was truncate, but the "rb+" case is read/write overwriting from the
beginning of the file.  So in this case the file would still have many aspects
of "valid SQLite file".  Practically, there are multiple ways SQLite detects
badness, when originally written these two approaches threw different errors,
but now they're the same, so maybe the implementation changed to make the tests
redundant.

Beyond all that, I _think_ that "valid SQLite file with junk at the end" may be
acceptable under some circumstances.  I haven't personally understood those
circumstances, I've just seen comments that make me think that sometimes
truncation is expected not to work.

[Elliot Glaysher, 2015/06/17 21:59:34]

Changed name.

("TYPE_OPEN_AND_APPEND" actually opened and wrote to the beginning of the file.
The name was wrong.)

 
   // 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(CorruptSizeInHeaderOfPath(db_path()));
 
   // 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(CorruptSizeInHeaderOfPath(db_path()));
 
   {
     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(CorruptSizeInHeaderOfPath(db_path()));
 
   {
     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