1 // Copyright 2011 The Kyua Authors.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of Google Inc. nor the names of its contributors
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #include "utils/sqlite/database.hpp"
31 #include <atf-c++.hpp>
33 #include "utils/fs/operations.hpp"
34 #include "utils/fs/path.hpp"
35 #include "utils/optional.ipp"
36 #include "utils/sqlite/statement.ipp"
37 #include "utils/sqlite/test_utils.hpp"
38 #include "utils/sqlite/transaction.hpp"
40 namespace fs = utils::fs;
41 namespace sqlite = utils::sqlite;
43 using utils::optional;
46 ATF_TEST_CASE_WITHOUT_HEAD(in_memory);
47 ATF_TEST_CASE_BODY(in_memory)
49 sqlite::database db = sqlite::database::in_memory();
50 create_test_table(raw(db));
51 verify_test_table(raw(db));
53 ATF_REQUIRE(!fs::exists(fs::path(":memory:")));
57 ATF_TEST_CASE_WITHOUT_HEAD(open__readonly__ok);
58 ATF_TEST_CASE_BODY(open__readonly__ok)
62 ATF_REQUIRE_EQ(SQLITE_OK, ::sqlite3_open_v2("test.db", &db,
63 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL));
64 create_test_table(db);
68 sqlite::database db = sqlite::database::open(fs::path("test.db"),
69 sqlite::open_readonly);
70 verify_test_table(raw(db));
75 ATF_TEST_CASE_WITHOUT_HEAD(open__readonly__fail);
76 ATF_TEST_CASE_BODY(open__readonly__fail)
78 REQUIRE_API_ERROR("sqlite3_open_v2",
79 sqlite::database::open(fs::path("missing.db"), sqlite::open_readonly));
80 ATF_REQUIRE(!fs::exists(fs::path("missing.db")));
84 ATF_TEST_CASE_WITHOUT_HEAD(open__create__ok);
85 ATF_TEST_CASE_BODY(open__create__ok)
88 sqlite::database db = sqlite::database::open(fs::path("test.db"),
89 sqlite::open_readwrite | sqlite::open_create);
90 ATF_REQUIRE(fs::exists(fs::path("test.db")));
91 create_test_table(raw(db));
95 ATF_REQUIRE_EQ(SQLITE_OK, ::sqlite3_open_v2("test.db", &db,
96 SQLITE_OPEN_READONLY, NULL));
97 verify_test_table(db);
103 ATF_TEST_CASE(open__create__fail);
104 ATF_TEST_CASE_HEAD(open__create__fail)
106 set_md_var("require.user", "unprivileged");
108 ATF_TEST_CASE_BODY(open__create__fail)
110 fs::mkdir(fs::path("protected"), 0555);
111 REQUIRE_API_ERROR("sqlite3_open_v2",
112 sqlite::database::open(fs::path("protected/test.db"),
113 sqlite::open_readwrite | sqlite::open_create));
117 ATF_TEST_CASE_WITHOUT_HEAD(temporary);
118 ATF_TEST_CASE_BODY(temporary)
120 // We could validate if files go to disk by setting the temp_store_directory
121 // PRAGMA to a subdirectory of pwd, and then ensuring the subdirectory is
122 // not empty. However, there does not seem to be a way to force SQLite to
123 // unconditionally write the temporary database to disk (even with
124 // temp_store = FILE), so this scenary is hard to reproduce.
125 sqlite::database db = sqlite::database::temporary();
126 create_test_table(raw(db));
127 verify_test_table(raw(db));
131 ATF_TEST_CASE_WITHOUT_HEAD(close);
132 ATF_TEST_CASE_BODY(close)
134 sqlite::database db = sqlite::database::in_memory();
136 // The destructor for the database will run now. If it does a second close,
137 // we may crash, so let's see if we don't.
141 ATF_TEST_CASE_WITHOUT_HEAD(copy);
142 ATF_TEST_CASE_BODY(copy)
144 sqlite::database db1 = sqlite::database::in_memory();
146 sqlite::database db2 = sqlite::database::in_memory();
147 create_test_table(raw(db2));
149 verify_test_table(raw(db1));
151 // db2 went out of scope. If the destruction is not properly managed, the
152 // memory of db1 may have been invalidated and this would not work.
153 verify_test_table(raw(db1));
157 ATF_TEST_CASE_WITHOUT_HEAD(db_filename__in_memory);
158 ATF_TEST_CASE_BODY(db_filename__in_memory)
160 const sqlite::database db = sqlite::database::in_memory();
161 ATF_REQUIRE(!db.db_filename());
165 ATF_TEST_CASE_WITHOUT_HEAD(db_filename__file);
166 ATF_TEST_CASE_BODY(db_filename__file)
168 const sqlite::database db = sqlite::database::open(fs::path("test.db"),
169 sqlite::open_readwrite | sqlite::open_create);
170 ATF_REQUIRE(db.db_filename());
171 ATF_REQUIRE_EQ(fs::path("test.db"), db.db_filename().get());
175 ATF_TEST_CASE_WITHOUT_HEAD(db_filename__temporary);
176 ATF_TEST_CASE_BODY(db_filename__temporary)
178 const sqlite::database db = sqlite::database::temporary();
179 ATF_REQUIRE(!db.db_filename());
183 ATF_TEST_CASE_WITHOUT_HEAD(db_filename__ok_after_close);
184 ATF_TEST_CASE_BODY(db_filename__ok_after_close)
186 sqlite::database db = sqlite::database::open(fs::path("test.db"),
187 sqlite::open_readwrite | sqlite::open_create);
188 const optional< fs::path > db_filename = db.db_filename();
189 ATF_REQUIRE(db_filename);
191 ATF_REQUIRE_EQ(db_filename, db.db_filename());
195 ATF_TEST_CASE_WITHOUT_HEAD(exec__ok);
196 ATF_TEST_CASE_BODY(exec__ok)
198 sqlite::database db = sqlite::database::in_memory();
199 db.exec(create_test_table_sql);
200 verify_test_table(raw(db));
204 ATF_TEST_CASE_WITHOUT_HEAD(exec__fail);
205 ATF_TEST_CASE_BODY(exec__fail)
207 sqlite::database db = sqlite::database::in_memory();
208 REQUIRE_API_ERROR("sqlite3_exec",
209 db.exec("SELECT * FROM test"));
210 REQUIRE_API_ERROR("sqlite3_exec",
211 db.exec("CREATE TABLE test (col INTEGER PRIMARY KEY);"
213 db.exec("SELECT * FROM test");
217 ATF_TEST_CASE_WITHOUT_HEAD(create_statement__ok);
218 ATF_TEST_CASE_BODY(create_statement__ok)
220 sqlite::database db = sqlite::database::in_memory();
221 sqlite::statement stmt = db.create_statement("SELECT 3");
222 // Statement testing happens in statement_test. We are only interested here
223 // in ensuring that the API call exists and runs.
227 ATF_TEST_CASE_WITHOUT_HEAD(begin_transaction);
228 ATF_TEST_CASE_BODY(begin_transaction)
230 sqlite::database db = sqlite::database::in_memory();
231 sqlite::transaction stmt = db.begin_transaction();
232 // Transaction testing happens in transaction_test. We are only interested
233 // here in ensuring that the API call exists and runs.
237 ATF_TEST_CASE_WITHOUT_HEAD(create_statement__fail);
238 ATF_TEST_CASE_BODY(create_statement__fail)
240 sqlite::database db = sqlite::database::in_memory();
241 REQUIRE_API_ERROR("sqlite3_prepare_v2",
242 db.create_statement("SELECT * FROM missing"));
246 ATF_TEST_CASE_WITHOUT_HEAD(last_insert_rowid);
247 ATF_TEST_CASE_BODY(last_insert_rowid)
249 sqlite::database db = sqlite::database::in_memory();
250 db.exec("CREATE TABLE test (a INTEGER PRIMARY KEY, b INTEGER)");
251 db.exec("INSERT INTO test VALUES (723, 5)");
252 ATF_REQUIRE_EQ(723, db.last_insert_rowid());
253 db.exec("INSERT INTO test VALUES (145, 20)");
254 ATF_REQUIRE_EQ(145, db.last_insert_rowid());
258 ATF_INIT_TEST_CASES(tcs)
260 ATF_ADD_TEST_CASE(tcs, in_memory);
262 ATF_ADD_TEST_CASE(tcs, open__readonly__ok);
263 ATF_ADD_TEST_CASE(tcs, open__readonly__fail);
264 ATF_ADD_TEST_CASE(tcs, open__create__ok);
265 ATF_ADD_TEST_CASE(tcs, open__create__fail);
267 ATF_ADD_TEST_CASE(tcs, temporary);
269 ATF_ADD_TEST_CASE(tcs, close);
271 ATF_ADD_TEST_CASE(tcs, copy);
273 ATF_ADD_TEST_CASE(tcs, db_filename__in_memory);
274 ATF_ADD_TEST_CASE(tcs, db_filename__file);
275 ATF_ADD_TEST_CASE(tcs, db_filename__temporary);
276 ATF_ADD_TEST_CASE(tcs, db_filename__ok_after_close);
278 ATF_ADD_TEST_CASE(tcs, exec__ok);
279 ATF_ADD_TEST_CASE(tcs, exec__fail);
281 ATF_ADD_TEST_CASE(tcs, begin_transaction);
283 ATF_ADD_TEST_CASE(tcs, create_statement__ok);
284 ATF_ADD_TEST_CASE(tcs, create_statement__fail);
286 ATF_ADD_TEST_CASE(tcs, last_insert_rowid);