Mercurial > hg > orthanc

comparison UnitTestsSources/SQLiteChromium.cpp @ 632:17815b9d4280

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rename the UnitTests directory to avoid clashes in filenames
author Sebastien Jodogne <s.jodogne@gmail.com>
date Mon, 28 Oct 2013 16:26:51 +0100
parents UnitTests/SQLiteChromium.cpp@f333c0398f6e
children 3d6f9b7d0add
comparison
equal deleted inserted replaced
631:fc6ad5b97219 632:17815b9d4280
1 #include "gtest/gtest.h"
2
3 #include "../Core/Toolbox.h"
4 #include "../Core/SQLite/Connection.h"
5 #include "../Core/SQLite/Statement.h"
6 #include "../Core/SQLite/Transaction.h"
7
8 #include <sqlite3.h>
9
10
11 using namespace Orthanc;
12 using namespace Orthanc::SQLite;
13
14
15 /********************************************************************
16 ** Tests from
17 ** http://src.chromium.org/viewvc/chrome/trunk/src/sql/connection_unittest.cc
18 ********************************************************************/
19
20 class SQLConnectionTest : public testing::Test
21 {
22 public:
23 SQLConnectionTest()
24 {
25 }
26
27 virtual ~SQLConnectionTest()
28 {
29 }
30
31 virtual void SetUp()
32 {
33 db_.OpenInMemory();
34 }
35
36 virtual void TearDown()
37 {
38 db_.Close();
39 }
40
41 Connection& db()
42 {
43 return db_;
44 }
45
46 private:
47 Connection db_;
48 };
49
50
51
52 TEST_F(SQLConnectionTest, Execute)
53 {
54 // Valid statement should return true.
55 ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
56 EXPECT_EQ(SQLITE_OK, db().GetErrorCode());
57
58 // Invalid statement should fail.
59 ASSERT_EQ(SQLITE_ERROR,
60 db().ExecuteAndReturnErrorCode("CREATE TAB foo (a, b"));
61 EXPECT_EQ(SQLITE_ERROR, db().GetErrorCode());
62 }
63
64 TEST_F(SQLConnectionTest, ExecuteWithErrorCode) {
65 ASSERT_EQ(SQLITE_OK,
66 db().ExecuteAndReturnErrorCode("CREATE TABLE foo (a, b)"));
67 ASSERT_EQ(SQLITE_ERROR,
68 db().ExecuteAndReturnErrorCode("CREATE TABLE TABLE"));
69 ASSERT_EQ(SQLITE_ERROR,
70 db().ExecuteAndReturnErrorCode(
71 "INSERT INTO foo(a, b) VALUES (1, 2, 3, 4)"));
72 }
73
74 TEST_F(SQLConnectionTest, CachedStatement) {
75 StatementId id1("foo", 12);
76 ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
77 ASSERT_TRUE(db().Execute("INSERT INTO foo(a, b) VALUES (12, 13)"));
78
79 // Create a new cached statement.
80 {
81 Statement s(db(), id1, "SELECT a FROM foo");
82 ASSERT_TRUE(s.Step());
83 EXPECT_EQ(12, s.ColumnInt(0));
84 }
85
86 // The statement should be cached still.
87 EXPECT_TRUE(db().HasCachedStatement(id1));
88
89 {
90 // Get the same statement using different SQL. This should ignore our
91 // SQL and use the cached one (so it will be valid).
92 Statement s(db(), id1, "something invalid(");
93 ASSERT_TRUE(s.Step());
94 EXPECT_EQ(12, s.ColumnInt(0));
95 }
96
97 // Make sure other statements aren't marked as cached.
98 EXPECT_FALSE(db().HasCachedStatement(SQLITE_FROM_HERE));
99 }
100
101 TEST_F(SQLConnectionTest, IsSQLValidTest) {
102 ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
103 ASSERT_TRUE(db().IsSQLValid("SELECT a FROM foo"));
104 ASSERT_FALSE(db().IsSQLValid("SELECT no_exist FROM foo"));
105 }
106
107
108
109 TEST_F(SQLConnectionTest, DoesStuffExist) {
110 // Test DoesTableExist.
111 EXPECT_FALSE(db().DoesTableExist("foo"));
112 ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
113 EXPECT_TRUE(db().DoesTableExist("foo"));
114
115 // Should be case sensitive.
116 EXPECT_FALSE(db().DoesTableExist("FOO"));
117
118 // Test DoesColumnExist.
119 EXPECT_FALSE(db().DoesColumnExist("foo", "bar"));
120 EXPECT_TRUE(db().DoesColumnExist("foo", "a"));
121
122 // Testing for a column on a nonexistent table.
123 EXPECT_FALSE(db().DoesColumnExist("bar", "b"));
124 }
125
126 TEST_F(SQLConnectionTest, GetLastInsertRowId) {
127 ASSERT_TRUE(db().Execute("CREATE TABLE foo (id INTEGER PRIMARY KEY, value)"));
128
129 ASSERT_TRUE(db().Execute("INSERT INTO foo (value) VALUES (12)"));
130
131 // Last insert row ID should be valid.
132 int64_t row = db().GetLastInsertRowId();
133 EXPECT_LT(0, row);
134
135 // It should be the primary key of the row we just inserted.
136 Statement s(db(), "SELECT value FROM foo WHERE id=?");
137 s.BindInt64(0, row);
138 ASSERT_TRUE(s.Step());
139 EXPECT_EQ(12, s.ColumnInt(0));
140 }
141
142 TEST_F(SQLConnectionTest, Rollback) {
143 ASSERT_TRUE(db().BeginTransaction());
144 ASSERT_TRUE(db().BeginTransaction());
145 EXPECT_EQ(2, db().GetTransactionNesting());
146 db().RollbackTransaction();
147 EXPECT_FALSE(db().CommitTransaction());
148 EXPECT_TRUE(db().BeginTransaction());
149 }
150
151
152
153
154 /********************************************************************
155 ** Tests from
156 ** http://src.chromium.org/viewvc/chrome/trunk/src/sql/statement_unittest.cc
157 ********************************************************************/
158
159 namespace Orthanc
160 {
161 namespace SQLite
162 {
163 class SQLStatementTest : public SQLConnectionTest
164 {
165 };
166
167 TEST_F(SQLStatementTest, Run) {
168 ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
169 ASSERT_TRUE(db().Execute("INSERT INTO foo (a, b) VALUES (3, 12)"));
170
171 Statement s(db(), "SELECT b FROM foo WHERE a=?");
172 // Stepping it won't work since we haven't bound the value.
173 EXPECT_FALSE(s.Step());
174
175 // Run should fail since this produces output, and we should use Step(). This
176 // gets a bit wonky since sqlite says this is OK so succeeded is set.
177 s.Reset(true);
178 s.BindInt(0, 3);
179 EXPECT_FALSE(s.Run());
180 EXPECT_EQ(SQLITE_ROW, db().GetErrorCode());
181
182 // Resetting it should put it back to the previous state (not runnable).
183 s.Reset(true);
184
185 // Binding and stepping should produce one row.
186 s.BindInt(0, 3);
187 EXPECT_TRUE(s.Step());
188 EXPECT_EQ(12, s.ColumnInt(0));
189 EXPECT_FALSE(s.Step());
190 }
191
192 TEST_F(SQLStatementTest, BasicErrorCallback) {
193 ASSERT_TRUE(db().Execute("CREATE TABLE foo (a INTEGER PRIMARY KEY, b)"));
194 // Insert in the foo table the primary key. It is an error to insert
195 // something other than an number. This error causes the error callback
196 // handler to be called with SQLITE_MISMATCH as error code.
197 Statement s(db(), "INSERT INTO foo (a) VALUES (?)");
198 s.BindCString(0, "bad bad");
199 EXPECT_THROW(s.Run(), OrthancException);
200 }
201
202 TEST_F(SQLStatementTest, Reset) {
203 ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
204 ASSERT_TRUE(db().Execute("INSERT INTO foo (a, b) VALUES (3, 12)"));
205 ASSERT_TRUE(db().Execute("INSERT INTO foo (a, b) VALUES (4, 13)"));
206
207 Statement s(db(), "SELECT b FROM foo WHERE a = ? ");
208 s.BindInt(0, 3);
209 ASSERT_TRUE(s.Step());
210 EXPECT_EQ(12, s.ColumnInt(0));
211 ASSERT_FALSE(s.Step());
212
213 s.Reset(false);
214 // Verify that we can get all rows again.
215 ASSERT_TRUE(s.Step());
216 EXPECT_EQ(12, s.ColumnInt(0));
217 EXPECT_FALSE(s.Step());
218
219 s.Reset(true);
220 ASSERT_FALSE(s.Step());
221 }
222 }
223 }
224
225
226
227
228
229
230 /********************************************************************
231 ** Tests from
232 ** http://src.chromium.org/viewvc/chrome/trunk/src/sql/transaction_unittest.cc
233 ********************************************************************/
234
235 class SQLTransactionTest : public SQLConnectionTest
236 {
237 public:
238 virtual void SetUp()
239 {
240 SQLConnectionTest::SetUp();
241 ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
242 }
243
244 // Returns the number of rows in table "foo".
245 int CountFoo()
246 {
247 Statement count(db(), "SELECT count(*) FROM foo");
248 count.Step();
249 return count.ColumnInt(0);
250 }
251 };
252
253
254 TEST_F(SQLTransactionTest, Commit) {
255 {
256 Transaction t(db());
257 EXPECT_FALSE(t.IsOpen());
258 t.Begin();
259 EXPECT_TRUE(t.IsOpen());
260
261 EXPECT_TRUE(db().Execute("INSERT INTO foo (a, b) VALUES (1, 2)"));
262
263 t.Commit();
264 EXPECT_FALSE(t.IsOpen());
265 }
266
267 EXPECT_EQ(1, CountFoo());
268 }
269
270 TEST_F(SQLTransactionTest, Rollback) {
271 // Test some basic initialization, and that rollback runs when you exit the
272 // scope.
273 {
274 Transaction t(db());
275 EXPECT_FALSE(t.IsOpen());
276 t.Begin();
277 EXPECT_TRUE(t.IsOpen());
278
279 EXPECT_TRUE(db().Execute("INSERT INTO foo (a, b) VALUES (1, 2)"));
280 }
281
282 // Nothing should have been committed since it was implicitly rolled back.
283 EXPECT_EQ(0, CountFoo());
284
285 // Test explicit rollback.
286 Transaction t2(db());
287 EXPECT_FALSE(t2.IsOpen());
288 t2.Begin();
289
290 EXPECT_TRUE(db().Execute("INSERT INTO foo (a, b) VALUES (1, 2)"));
291 t2.Rollback();
292 EXPECT_FALSE(t2.IsOpen());
293
294 // Nothing should have been committed since it was explicitly rolled back.
295 EXPECT_EQ(0, CountFoo());
296 }
297
298 // Rolling back any part of a transaction should roll back all of them.
299 TEST_F(SQLTransactionTest, NestedRollback) {
300 EXPECT_EQ(0, db().GetTransactionNesting());
301
302 // Outermost transaction.
303 {
304 Transaction outer(db());
305 outer.Begin();
306 EXPECT_EQ(1, db().GetTransactionNesting());
307
308 // The first inner one gets committed.
309 {
310 Transaction inner1(db());
311 inner1.Begin();
312 EXPECT_TRUE(db().Execute("INSERT INTO foo (a, b) VALUES (1, 2)"));
313 EXPECT_EQ(2, db().GetTransactionNesting());
314
315 inner1.Commit();
316 EXPECT_EQ(1, db().GetTransactionNesting());
317 }
318
319 // One row should have gotten inserted.
320 EXPECT_EQ(1, CountFoo());
321
322 // The second inner one gets rolled back.
323 {
324 Transaction inner2(db());
325 inner2.Begin();
326 EXPECT_TRUE(db().Execute("INSERT INTO foo (a, b) VALUES (1, 2)"));
327 EXPECT_EQ(2, db().GetTransactionNesting());
328
329 inner2.Rollback();
330 EXPECT_EQ(1, db().GetTransactionNesting());
331 }
332
333 // A third inner one will fail in Begin since one has already been rolled
334 // back.
335 EXPECT_EQ(1, db().GetTransactionNesting());
336 {
337 Transaction inner3(db());
338 EXPECT_THROW(inner3.Begin(), OrthancException);
339 EXPECT_EQ(1, db().GetTransactionNesting());
340 }
341 }
342 EXPECT_EQ(0, db().GetTransactionNesting());
343 EXPECT_EQ(0, CountFoo());
344 }