minix/external/bsd/kyua-cli/dist/utils/sqlite/database_test.cpp

242 lines
7.6 KiB
C++
Raw Normal View History

// Copyright 2011 Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of Google Inc. nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "utils/sqlite/database.hpp"
#include <atf-c++.hpp>
#include "utils/fs/operations.hpp"
#include "utils/fs/path.hpp"
#include "utils/sqlite/statement.ipp"
#include "utils/sqlite/test_utils.hpp"
#include "utils/sqlite/transaction.hpp"
namespace fs = utils::fs;
namespace sqlite = utils::sqlite;
ATF_TEST_CASE_WITHOUT_HEAD(in_memory);
ATF_TEST_CASE_BODY(in_memory)
{
sqlite::database db = sqlite::database::in_memory();
create_test_table(raw(db));
verify_test_table(raw(db));
ATF_REQUIRE(!fs::exists(fs::path(":memory:")));
}
ATF_TEST_CASE_WITHOUT_HEAD(open__readonly__ok);
ATF_TEST_CASE_BODY(open__readonly__ok)
{
{
::sqlite3* db;
ATF_REQUIRE_EQ(SQLITE_OK, ::sqlite3_open_v2("test.db", &db,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL));
create_test_table(db);
::sqlite3_close(db);
}
{
sqlite::database db = sqlite::database::open(fs::path("test.db"),
sqlite::open_readonly);
verify_test_table(raw(db));
}
}
ATF_TEST_CASE_WITHOUT_HEAD(open__readonly__fail);
ATF_TEST_CASE_BODY(open__readonly__fail)
{
REQUIRE_API_ERROR("sqlite3_open_v2",
sqlite::database::open(fs::path("missing.db"), sqlite::open_readonly));
ATF_REQUIRE(!fs::exists(fs::path("missing.db")));
}
ATF_TEST_CASE_WITHOUT_HEAD(open__create__ok);
ATF_TEST_CASE_BODY(open__create__ok)
{
{
sqlite::database db = sqlite::database::open(fs::path("test.db"),
sqlite::open_readwrite | sqlite::open_create);
ATF_REQUIRE(fs::exists(fs::path("test.db")));
create_test_table(raw(db));
}
{
::sqlite3* db;
ATF_REQUIRE_EQ(SQLITE_OK, ::sqlite3_open_v2("test.db", &db,
SQLITE_OPEN_READONLY, NULL));
verify_test_table(db);
::sqlite3_close(db);
}
}
ATF_TEST_CASE(open__create__fail);
ATF_TEST_CASE_HEAD(open__create__fail)
{
set_md_var("require.user", "unprivileged");
}
ATF_TEST_CASE_BODY(open__create__fail)
{
fs::mkdir(fs::path("protected"), 0555);
REQUIRE_API_ERROR("sqlite3_open_v2",
sqlite::database::open(fs::path("protected/test.db"),
sqlite::open_readwrite | sqlite::open_create));
}
ATF_TEST_CASE_WITHOUT_HEAD(temporary);
ATF_TEST_CASE_BODY(temporary)
{
// We could validate if files go to disk by setting the temp_store_directory
// PRAGMA to a subdirectory of pwd, and then ensuring the subdirectory is
// not empty. However, there does not seem to be a way to force SQLite to
// unconditionally write the temporary database to disk (even with
// temp_store = FILE), so this scenary is hard to reproduce.
sqlite::database db = sqlite::database::temporary();
create_test_table(raw(db));
verify_test_table(raw(db));
}
ATF_TEST_CASE_WITHOUT_HEAD(close);
ATF_TEST_CASE_BODY(close)
{
sqlite::database db = sqlite::database::in_memory();
db.close();
// The destructor for the database will run now. If it does a second close,
// we may crash, so let's see if we don't.
}
ATF_TEST_CASE_WITHOUT_HEAD(copy);
ATF_TEST_CASE_BODY(copy)
{
sqlite::database db1 = sqlite::database::in_memory();
{
sqlite::database db2 = sqlite::database::in_memory();
create_test_table(raw(db2));
db1 = db2;
verify_test_table(raw(db1));
}
// db2 went out of scope. If the destruction is not properly managed, the
// memory of db1 may have been invalidated and this would not work.
verify_test_table(raw(db1));
}
ATF_TEST_CASE_WITHOUT_HEAD(exec__ok);
ATF_TEST_CASE_BODY(exec__ok)
{
sqlite::database db = sqlite::database::in_memory();
db.exec(create_test_table_sql);
verify_test_table(raw(db));
}
ATF_TEST_CASE_WITHOUT_HEAD(exec__fail);
ATF_TEST_CASE_BODY(exec__fail)
{
sqlite::database db = sqlite::database::in_memory();
REQUIRE_API_ERROR("sqlite3_exec",
db.exec("SELECT * FROM test"));
REQUIRE_API_ERROR("sqlite3_exec",
db.exec("CREATE TABLE test (col INTEGER PRIMARY KEY);"
"FOO BAR"));
db.exec("SELECT * FROM test");
}
ATF_TEST_CASE_WITHOUT_HEAD(create_statement__ok);
ATF_TEST_CASE_BODY(create_statement__ok)
{
sqlite::database db = sqlite::database::in_memory();
sqlite::statement stmt = db.create_statement("SELECT 3");
// Statement testing happens in statement_test. We are only interested here
// in ensuring that the API call exists and runs.
}
ATF_TEST_CASE_WITHOUT_HEAD(begin_transaction);
ATF_TEST_CASE_BODY(begin_transaction)
{
sqlite::database db = sqlite::database::in_memory();
sqlite::transaction stmt = db.begin_transaction();
// Transaction testing happens in transaction_test. We are only interested
// here in ensuring that the API call exists and runs.
}
ATF_TEST_CASE_WITHOUT_HEAD(create_statement__fail);
ATF_TEST_CASE_BODY(create_statement__fail)
{
sqlite::database db = sqlite::database::in_memory();
REQUIRE_API_ERROR("sqlite3_prepare_v2",
db.create_statement("SELECT * FROM missing"));
}
ATF_TEST_CASE_WITHOUT_HEAD(last_insert_rowid);
ATF_TEST_CASE_BODY(last_insert_rowid)
{
sqlite::database db = sqlite::database::in_memory();
db.exec("CREATE TABLE test (a INTEGER PRIMARY KEY, b INTEGER)");
db.exec("INSERT INTO test VALUES (723, 5)");
ATF_REQUIRE_EQ(723, db.last_insert_rowid());
db.exec("INSERT INTO test VALUES (145, 20)");
ATF_REQUIRE_EQ(145, db.last_insert_rowid());
}
ATF_INIT_TEST_CASES(tcs)
{
ATF_ADD_TEST_CASE(tcs, in_memory);
ATF_ADD_TEST_CASE(tcs, open__readonly__ok);
ATF_ADD_TEST_CASE(tcs, open__readonly__fail);
ATF_ADD_TEST_CASE(tcs, open__create__ok);
ATF_ADD_TEST_CASE(tcs, open__create__fail);
ATF_ADD_TEST_CASE(tcs, temporary);
ATF_ADD_TEST_CASE(tcs, close);
ATF_ADD_TEST_CASE(tcs, copy);
ATF_ADD_TEST_CASE(tcs, exec__ok);
ATF_ADD_TEST_CASE(tcs, exec__fail);
ATF_ADD_TEST_CASE(tcs, begin_transaction);
ATF_ADD_TEST_CASE(tcs, create_statement__ok);
ATF_ADD_TEST_CASE(tcs, create_statement__fail);
ATF_ADD_TEST_CASE(tcs, last_insert_rowid);
}