aboutsummaryrefslogtreecommitdiffstats
path: root/store/read_transaction_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'store/read_transaction_test.cpp')
-rw-r--r--store/read_transaction_test.cpp262
1 files changed, 262 insertions, 0 deletions
diff --git a/store/read_transaction_test.cpp b/store/read_transaction_test.cpp
new file mode 100644
index 000000000000..711faa674fbe
--- /dev/null
+++ b/store/read_transaction_test.cpp
@@ -0,0 +1,262 @@
+// Copyright 2011 The Kyua Authors.
+// 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 "store/read_transaction.hpp"
+
+#include <map>
+#include <string>
+
+#include <atf-c++.hpp>
+
+#include "model/context.hpp"
+#include "model/metadata.hpp"
+#include "model/test_program.hpp"
+#include "model/test_result.hpp"
+#include "store/exceptions.hpp"
+#include "store/read_backend.hpp"
+#include "store/write_backend.hpp"
+#include "store/write_transaction.hpp"
+#include "utils/datetime.hpp"
+#include "utils/fs/path.hpp"
+#include "utils/logging/operations.hpp"
+#include "utils/optional.ipp"
+#include "utils/sqlite/database.hpp"
+#include "utils/sqlite/statement.ipp"
+
+namespace datetime = utils::datetime;
+namespace fs = utils::fs;
+namespace logging = utils::logging;
+namespace sqlite = utils::sqlite;
+
+
+ATF_TEST_CASE(get_context__missing);
+ATF_TEST_CASE_HEAD(get_context__missing)
+{
+ logging::set_inmemory();
+ set_md_var("require.files", store::detail::schema_file().c_str());
+}
+ATF_TEST_CASE_BODY(get_context__missing)
+{
+ store::write_backend::open_rw(fs::path("test.db")); // Create database.
+ store::read_backend backend = store::read_backend::open_ro(
+ fs::path("test.db"));
+
+ store::read_transaction tx = backend.start_read();
+ ATF_REQUIRE_THROW_RE(store::error, "context: no data", tx.get_context());
+}
+
+
+ATF_TEST_CASE(get_context__invalid_cwd);
+ATF_TEST_CASE_HEAD(get_context__invalid_cwd)
+{
+ logging::set_inmemory();
+ set_md_var("require.files", store::detail::schema_file().c_str());
+}
+ATF_TEST_CASE_BODY(get_context__invalid_cwd)
+{
+ {
+ store::write_backend backend = store::write_backend::open_rw(
+ fs::path("test.db"));
+
+ sqlite::statement stmt = backend.database().create_statement(
+ "INSERT INTO contexts (cwd) VALUES (:cwd)");
+ const char buffer[10] = "foo bar";
+ stmt.bind(":cwd", sqlite::blob(buffer, sizeof(buffer)));
+ stmt.step_without_results();
+ }
+
+ store::read_backend backend = store::read_backend::open_ro(
+ fs::path("test.db"));
+ store::read_transaction tx = backend.start_read();
+ ATF_REQUIRE_THROW_RE(store::error, "context: .*cwd.*not a string",
+ tx.get_context());
+}
+
+
+ATF_TEST_CASE(get_context__invalid_env_vars);
+ATF_TEST_CASE_HEAD(get_context__invalid_env_vars)
+{
+ logging::set_inmemory();
+ set_md_var("require.files", store::detail::schema_file().c_str());
+}
+ATF_TEST_CASE_BODY(get_context__invalid_env_vars)
+{
+ {
+ store::write_backend backend = store::write_backend::open_rw(
+ fs::path("test-bad-name.db"));
+ backend.database().exec("INSERT INTO contexts (cwd) "
+ "VALUES ('/foo/bar')");
+ const char buffer[10] = "foo bar";
+
+ sqlite::statement stmt = backend.database().create_statement(
+ "INSERT INTO env_vars (var_name, var_value) "
+ "VALUES (:var_name, 'abc')");
+ stmt.bind(":var_name", sqlite::blob(buffer, sizeof(buffer)));
+ stmt.step_without_results();
+ }
+ {
+ store::read_backend backend = store::read_backend::open_ro(
+ fs::path("test-bad-name.db"));
+ store::read_transaction tx = backend.start_read();
+ ATF_REQUIRE_THROW_RE(store::error, "context: .*var_name.*not a string",
+ tx.get_context());
+ }
+
+ {
+ store::write_backend backend = store::write_backend::open_rw(
+ fs::path("test-bad-value.db"));
+ backend.database().exec("INSERT INTO contexts (cwd) "
+ "VALUES ('/foo/bar')");
+ const char buffer[10] = "foo bar";
+
+ sqlite::statement stmt = backend.database().create_statement(
+ "INSERT INTO env_vars (var_name, var_value) "
+ "VALUES ('abc', :var_value)");
+ stmt.bind(":var_value", sqlite::blob(buffer, sizeof(buffer)));
+ stmt.step_without_results();
+ }
+ {
+ store::read_backend backend = store::read_backend::open_ro(
+ fs::path("test-bad-value.db"));
+ store::read_transaction tx = backend.start_read();
+ ATF_REQUIRE_THROW_RE(store::error, "context: .*var_value.*not a string",
+ tx.get_context());
+ }
+}
+
+
+ATF_TEST_CASE(get_results__none);
+ATF_TEST_CASE_HEAD(get_results__none)
+{
+ logging::set_inmemory();
+ set_md_var("require.files", store::detail::schema_file().c_str());
+}
+ATF_TEST_CASE_BODY(get_results__none)
+{
+ store::write_backend::open_rw(fs::path("test.db")); // Create database.
+ store::read_backend backend = store::read_backend::open_ro(
+ fs::path("test.db"));
+ store::read_transaction tx = backend.start_read();
+ store::results_iterator iter = tx.get_results();
+ ATF_REQUIRE(!iter);
+}
+
+
+ATF_TEST_CASE(get_results__many);
+ATF_TEST_CASE_HEAD(get_results__many)
+{
+ logging::set_inmemory();
+ set_md_var("require.files", store::detail::schema_file().c_str());
+}
+ATF_TEST_CASE_BODY(get_results__many)
+{
+ store::write_backend backend = store::write_backend::open_rw(
+ fs::path("test.db"));
+
+ store::write_transaction tx = backend.start_write();
+
+ const model::context context(fs::path("/foo/bar"),
+ std::map< std::string, std::string >());
+ tx.put_context(context);
+
+ const datetime::timestamp start_time1 = datetime::timestamp::from_values(
+ 2012, 01, 30, 22, 10, 00, 0);
+ const datetime::timestamp end_time1 = datetime::timestamp::from_values(
+ 2012, 01, 30, 22, 15, 30, 1234);
+ const datetime::timestamp start_time2 = datetime::timestamp::from_values(
+ 2012, 01, 30, 22, 15, 40, 987);
+ const datetime::timestamp end_time2 = datetime::timestamp::from_values(
+ 2012, 01, 30, 22, 16, 0, 0);
+
+ atf::utils::create_file("unused.txt", "unused file\n");
+
+ const model::test_program test_program_1 = model::test_program_builder(
+ "plain", fs::path("a/prog1"), fs::path("/the/root"), "suite1")
+ .add_test_case("main")
+ .build();
+ const model::test_result result_1(model::test_result_passed);
+ {
+ const int64_t tp_id = tx.put_test_program(test_program_1);
+ const int64_t tc_id = tx.put_test_case(test_program_1, "main", tp_id);
+ atf::utils::create_file("prog1.out", "stdout of prog1\n");
+ tx.put_test_case_file("__STDOUT__", fs::path("prog1.out"), tc_id);
+ tx.put_test_case_file("unused.txt", fs::path("unused.txt"), tc_id);
+ tx.put_result(result_1, tc_id, start_time1, end_time1);
+ }
+
+ const model::test_program test_program_2 = model::test_program_builder(
+ "plain", fs::path("b/prog2"), fs::path("/the/root"), "suite2")
+ .add_test_case("main")
+ .build();
+ const model::test_result result_2(model::test_result_failed,
+ "Some text");
+ {
+ const int64_t tp_id = tx.put_test_program(test_program_2);
+ const int64_t tc_id = tx.put_test_case(test_program_2, "main", tp_id);
+ atf::utils::create_file("prog2.err", "stderr of prog2\n");
+ tx.put_test_case_file("__STDERR__", fs::path("prog2.err"), tc_id);
+ tx.put_test_case_file("unused.txt", fs::path("unused.txt"), tc_id);
+ tx.put_result(result_2, tc_id, start_time2, end_time2);
+ }
+
+ tx.commit();
+ backend.close();
+
+ store::read_backend backend2 = store::read_backend::open_ro(
+ fs::path("test.db"));
+ store::read_transaction tx2 = backend2.start_read();
+ store::results_iterator iter = tx2.get_results();
+ ATF_REQUIRE(iter);
+ ATF_REQUIRE_EQ(test_program_1, *iter.test_program());
+ ATF_REQUIRE_EQ("main", iter.test_case_name());
+ ATF_REQUIRE_EQ("stdout of prog1\n", iter.stdout_contents());
+ ATF_REQUIRE(iter.stderr_contents().empty());
+ ATF_REQUIRE_EQ(result_1, iter.result());
+ ATF_REQUIRE_EQ(start_time1, iter.start_time());
+ ATF_REQUIRE_EQ(end_time1, iter.end_time());
+ ATF_REQUIRE(++iter);
+ ATF_REQUIRE_EQ(test_program_2, *iter.test_program());
+ ATF_REQUIRE_EQ("main", iter.test_case_name());
+ ATF_REQUIRE(iter.stdout_contents().empty());
+ ATF_REQUIRE_EQ("stderr of prog2\n", iter.stderr_contents());
+ ATF_REQUIRE_EQ(result_2, iter.result());
+ ATF_REQUIRE_EQ(start_time2, iter.start_time());
+ ATF_REQUIRE_EQ(end_time2, iter.end_time());
+ ATF_REQUIRE(!++iter);
+}
+
+
+ATF_INIT_TEST_CASES(tcs)
+{
+ ATF_ADD_TEST_CASE(tcs, get_context__missing);
+ ATF_ADD_TEST_CASE(tcs, get_context__invalid_cwd);
+ ATF_ADD_TEST_CASE(tcs, get_context__invalid_env_vars);
+
+ ATF_ADD_TEST_CASE(tcs, get_results__none);
+ ATF_ADD_TEST_CASE(tcs, get_results__many);
+}