[sql] Test helpers to ease testing of simple queries.

sql/recovery_unittest.cc

 // Copyright 2013 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 "sql/recovery.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 11 matching lines @@
 #include "sql/statement.h"
 #include "sql/test/paths.h"
 #include "sql/test/scoped_error_expecter.h"
 #include "sql/test/sql_test_base.h"
 #include "sql/test/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
 
 namespace {
 
-// Execute |sql|, and stringify the results with |column_sep| between
-// columns and |row_sep| between rows.
-// TODO(shess): Promote this to a central testing helper.
-std::string ExecuteWithResults(sql::Connection* db,
-                               const char* sql,
-                               const char* column_sep,
-                               const char* row_sep) {
-  sql::Statement s(db->GetUniqueStatement(sql));
-  std::string ret;
-  while (s.Step()) {
-    if (!ret.empty())
-      ret += row_sep;
-    for (int i = 0; i < s.ColumnCount(); ++i) {
-      if (i > 0)
-        ret += column_sep;
-      if (s.ColumnType(i) == sql::COLUMN_TYPE_NULL) {
-        ret += "<null>";
-      } else if (s.ColumnType(i) == sql::COLUMN_TYPE_BLOB) {
-        ret += "<x'";
-        ret += base::HexEncode(s.ColumnBlob(i), s.ColumnByteLength(i));
-        ret += "'>";
-      } else {
-        ret += s.ColumnString(i);
-      }
-    }
-  }
-  return ret;
-}
+using sql::test::ExecuteWithResults;
+using sql::test::ExecuteWithResult;
 
 // Dump consistent human-readable representation of the database
 // schema.  For tables or indices, this will contain the sql command
 // to create the table or index.  For certain automatic SQLite
 // structures with no sql, the name is used.
 std::string GetSchema(sql::Connection* db) {
   const char kSql[] =
       "SELECT COALESCE(sql, name) FROM sqlite_master ORDER BY 1";
   return ExecuteWithResults(db, kSql, "|", "\n");
 }
@@ skipping 76 matching lines @@
 
     // Successfully recovered.
     ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
   EXPECT_FALSE(db().is_open());
   ASSERT_TRUE(Reopen());
   EXPECT_TRUE(db().is_open());
   ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
   const char* kXSql = "SELECT * FROM x ORDER BY 1";
-  ASSERT_EQ("That was a test",
-            ExecuteWithResults(&db(), kXSql, "|", "\n"));
+  ASSERT_EQ("That was a test", ExecuteWithResult(&db(), kXSql));
 
   // Reset the database contents.
   ASSERT_TRUE(db().Execute("DELETE FROM x"));
   ASSERT_TRUE(db().Execute(kInsertSql));
 
   // Rollback() discards recovery progress and leaves the database as it was.
   {
     std::unique_ptr<sql::Recovery> recovery =
         sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery.get());
 
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
     ASSERT_TRUE(recovery->db()->Execute(kAltInsertSql));
 
     sql::Recovery::Rollback(std::move(recovery));
   }
   EXPECT_FALSE(db().is_open());
   ASSERT_TRUE(Reopen());
   EXPECT_TRUE(db().is_open());
   ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
-  ASSERT_EQ("This is a test",
-            ExecuteWithResults(&db(), kXSql, "|", "\n"));
+  ASSERT_EQ("This is a test", ExecuteWithResult(&db(), kXSql));
 }
 
 // Test operation of the virtual table used by sql::Recovery.
 TEST_F(SQLRecoveryTest, VirtualTable) {
   const char kCreateSql[] = "CREATE TABLE x (t TEXT)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('This is a test')"));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('That was a test')"));
 
   // Successfully recover the database.
@@ skipping 142 matching lines @@
   ASSERT_TRUE(sql::test::CorruptTableOrIndex(db_path(), "x", kDeleteSql));
 
   ASSERT_TRUE(Reopen());
 
   int error = SQLITE_OK;
   db().set_error_callback(base::Bind(&RecoveryCallback, &db(), db_path(),
                                      kCreateTable, kCreateIndex, &error));
 
   // Index shows one less than originally inserted.
   const char kCountSql[] = "SELECT COUNT (*) FROM x";
-  EXPECT_EQ("9", ExecuteWithResults(&db(), kCountSql, "|", ","));
+  EXPECT_EQ("9", ExecuteWithResult(&db(), kCountSql));
 
   // A full table scan shows all of the original data.  Using column [v] to
   // force use of the table rather than the index.
   const char kDistinctSql[] = "SELECT DISTINCT COUNT (v) FROM x";
-  EXPECT_EQ("10", ExecuteWithResults(&db(), kDistinctSql, "|", ","));
+  EXPECT_EQ("10", ExecuteWithResult(&db(), kDistinctSql));
 
   // Insert id 0 again.  Since it is not in the index, the insert
   // succeeds, but results in a duplicate value in the table.
   const char kInsertSql[] = "INSERT INTO x (id, v) VALUES (0, 100)";
   ASSERT_TRUE(db().Execute(kInsertSql));
 
   // Duplication is visible.
-  EXPECT_EQ("10", ExecuteWithResults(&db(), kCountSql, "|", ","));
-  EXPECT_EQ("11", ExecuteWithResults(&db(), kDistinctSql, "|", ","));
+  EXPECT_EQ("10", ExecuteWithResult(&db(), kCountSql));
+  EXPECT_EQ("11", ExecuteWithResult(&db(), kDistinctSql));
 
   // This works before the callback is called.
   const char kTrivialSql[] = "SELECT COUNT(*) FROM sqlite_master";
   EXPECT_TRUE(db().IsSQLValid(kTrivialSql));
 
   // TODO(shess): Figure out a statement which causes SQLite to notice the
   // corruption.  SELECT doesn't see errors because missing index values aren't
   // visible.  UPDATE or DELETE against v=0 don't see errors, even though the
   // index item is missing.  I suspect SQLite only deletes the key in these
   // cases, but doesn't verify that one or more keys were deleted.
   ASSERT_FALSE(db().Execute("INSERT INTO x (id, v) VALUES (0, 101)"));
   EXPECT_EQ(SQLITE_CONSTRAINT_UNIQUE, error);
 
   // Database handle has been poisoned.
   EXPECT_FALSE(db().IsSQLValid(kTrivialSql));
 
   ASSERT_TRUE(Reopen());
 
   // The recovered table has consistency between the index and the table.
-  EXPECT_EQ("10", ExecuteWithResults(&db(), kCountSql, "|", ","));
-  EXPECT_EQ("10", ExecuteWithResults(&db(), kDistinctSql, "|", ","));
+  EXPECT_EQ("10", ExecuteWithResult(&db(), kCountSql));
+  EXPECT_EQ("10", ExecuteWithResult(&db(), kDistinctSql));
 
   // Only one of the values is retained.
   const char kSelectSql[] = "SELECT v FROM x WHERE id = 0";
-  const std::string results = ExecuteWithResults(&db(), kSelectSql, "|", ",");
+  const std::string results = ExecuteWithResult(&db(), kSelectSql);
   EXPECT_TRUE(results=="100" || results=="0") << "Actual results: " << results;
 }
 
 TEST_F(SQLRecoveryTest, Meta) {
   const int kVersion = 3;
   const int kCompatibleVersion = 2;
 
   {
     sql::MetaTable meta;
     EXPECT_TRUE(meta.Init(&db(), kVersion, kCompatibleVersion));
@@ skipping 468 matching lines @@
 
     ASSERT_TRUE(expecter.SawExpectedErrors());
   }
 
   // Verify that the failure was in the right place with the expected code.
   tester.ExpectBucketCount(kEventHistogramName, kEventEnum, 1);
   tester.ExpectBucketCount(kErrorHistogramName, SQLITE_NOTADB, 1);
 }
 
 }  // namespace