test/testdbd.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "testutil.h"
  18 #include "apr.h"
  19 #include "apu.h"
  20 #include "apr_pools.h"
  21 #include "apr_dbd.h"
  22 #include "apr_strings.h"
  23
  24 static void test_dbd_init(abts_case *tc, void *data)
  25 {
  26     apr_pool_t *pool = p;
  27     apr_status_t rv;
  28
  29     rv = apr_dbd_init(pool);
  30     ABTS_ASSERT(tc, "failed to init apr_dbd", rv == APR_SUCCESS);
  31 }
  32
  33 #if APU_HAVE_SQLITE2 || APU_HAVE_SQLITE3
  34 static void test_statement(abts_case *tc, apr_dbd_t* handle,
  35                            const apr_dbd_driver_t* driver, const char* sql)
  36 {
  37     int nrows;
  38     apr_status_t rv;
  39
  40     rv = apr_dbd_query(driver, handle, &nrows, sql);
  41
  42     ABTS_ASSERT(tc, sql, rv == APR_SUCCESS);
  43 }
  44
  45 static void create_table(abts_case *tc, apr_dbd_t* handle,
  46                          const apr_dbd_driver_t* driver)
  47 {
  48     const char *sql = "CREATE TABLE apr_dbd_test ("
  49                              "col1 varchar(40) not null,"
  50                              "col2 varchar(40),"
  51                              "col3 integer)";
  52
  53     test_statement(tc, handle, driver, sql);
  54 }
  55
  56 static void drop_table(abts_case *tc, apr_dbd_t* handle,
  57                        const apr_dbd_driver_t* driver)
  58 {
  59     const char *sql = "DROP TABLE apr_dbd_test";
  60     test_statement(tc, handle, driver, sql);
  61 }
  62
  63 static void delete_rows(abts_case *tc, apr_dbd_t* handle,
  64                         const apr_dbd_driver_t* driver)
  65 {
  66     const char *sql = "DELETE FROM apr_dbd_test";
  67     test_statement(tc, handle, driver, sql);
  68 }
  69
  70
  71 static void insert_data(abts_case *tc, apr_dbd_t* handle,
  72                         const apr_dbd_driver_t* driver, int count)
  73 {
  74     apr_pool_t* pool = p;
  75     const char* sql = "INSERT INTO apr_dbd_test VALUES('%d', '%d', %d)";
  76     char* sqf = NULL;
  77     int i;
  78     int nrows;
  79     apr_status_t rv;
  80
  81     for (i=0; i<count; i++) {
  82         sqf = apr_psprintf(pool, sql, i, i, i);
  83         rv = apr_dbd_query(driver, handle, &nrows, sqf);
  84         ABTS_ASSERT(tc, sqf, rv == APR_SUCCESS);
  85         ABTS_ASSERT(tc, sqf, 1 == nrows);
  86     }
  87 }
  88
  89 static void select_rows(abts_case *tc, apr_dbd_t* handle,
  90                         const apr_dbd_driver_t* driver, int count)
  91 {
  92     apr_status_t rv;
  93     apr_pool_t* pool = p;
  94     apr_pool_t* tpool;
  95     const char* sql = "SELECT * FROM apr_dbd_test ORDER BY col1";
  96     apr_dbd_results_t *res = NULL;
  97     apr_dbd_row_t *row = NULL;
  98     int i;
  99
 100     rv = apr_dbd_select(driver, pool, handle, &res, sql, 0);
 101     ABTS_ASSERT(tc, sql, rv == APR_SUCCESS);
 102     ABTS_PTR_NOTNULL(tc, res);
 103
 104     apr_pool_create(&tpool, pool);
 105     i = count;
 106     while (i > 0) {
 107         row = NULL;
 108         rv = apr_dbd_get_row(driver, pool, res, &row, -1);
 109         ABTS_ASSERT(tc, sql, rv == APR_SUCCESS);
 110         ABTS_PTR_NOTNULL(tc, row);
 111         apr_pool_clear(tpool);
 112         i--;
 113     }
 114     ABTS_ASSERT(tc, "Missing Rows!", i == 0);
 115
 116     res = NULL;
 117     i = count;
 118
 119     rv = apr_dbd_select(driver, pool, handle, &res, sql, 1);
 120     ABTS_ASSERT(tc, sql, rv == APR_SUCCESS);
 121     ABTS_PTR_NOTNULL(tc, res);
 122
 123     rv = apr_dbd_num_tuples(driver, res);
 124     ABTS_ASSERT(tc, "invalid row count", rv == count);
 125
 126     while (i > 0) {
 127         row = NULL;
 128         rv = apr_dbd_get_row(driver, pool, res, &row, i);
 129         ABTS_ASSERT(tc, sql, rv == APR_SUCCESS);
 130         ABTS_PTR_NOTNULL(tc, row);
 131         apr_pool_clear(tpool);
 132         i--;
 133     }
 134     ABTS_ASSERT(tc, "Missing Rows!", i == 0);
 135     rv = apr_dbd_get_row(driver, pool, res, &row, count+100);
 136     ABTS_ASSERT(tc, "If we overseek, get_row should return -1", rv == -1);
 137 }
 138
 139 static void test_escape(abts_case *tc, apr_dbd_t *handle,
 140                         const apr_dbd_driver_t *driver)
 141 {
 142   const char *escaped = apr_dbd_escape(driver, p, "foo'bar", handle);
 143
 144   ABTS_STR_EQUAL(tc, "foo''bar", escaped);
 145 }
 146
 147 static void test_dbd_generic(abts_case *tc, apr_dbd_t* handle,
 148                              const apr_dbd_driver_t* driver)
 149 {
 150     void* native;
 151     apr_pool_t *pool = p;
 152     apr_status_t rv;
 153
 154     native = apr_dbd_native_handle(driver, handle);
 155     ABTS_PTR_NOTNULL(tc, native);
 156
 157     rv = apr_dbd_check_conn(driver, pool, handle);
 158
 159     create_table(tc, handle, driver);
 160     select_rows(tc, handle, driver, 0);
 161     insert_data(tc, handle, driver, 5);
 162     select_rows(tc, handle, driver, 5);
 163     delete_rows(tc, handle, driver);
 164     select_rows(tc, handle, driver, 0);
 165     drop_table(tc, handle, driver);
 166
 167     test_escape(tc, handle, driver);
 168
 169     rv = apr_dbd_close(driver, handle);
 170     ABTS_ASSERT(tc, "failed to close database", rv == APR_SUCCESS);
 171 }
 172 #endif
 173
 174 #if APU_HAVE_SQLITE2
 175 static void test_dbd_sqlite2(abts_case *tc, void *data)
 176 {
 177     apr_pool_t *pool = p;
 178     apr_status_t rv;
 179     const apr_dbd_driver_t* driver = NULL;
 180     apr_dbd_t* handle = NULL;
 181
 182     rv = apr_dbd_get_driver(pool, "sqlite2", &driver);
 183     ABTS_ASSERT(tc, "failed to fetch driver", rv == APR_SUCCESS);
 184     ABTS_PTR_NOTNULL(tc, driver);
 185
 186     ABTS_STR_EQUAL(tc, "sqlite2", apr_dbd_name(driver));
 187
 188     rv = apr_dbd_open(driver, pool, "data/sqlite2.db:600", &handle);
 189     ABTS_ASSERT(tc, "failed to open database", rv == APR_SUCCESS);
 190     ABTS_PTR_NOTNULL(tc, handle);
 191
 192     test_dbd_generic(tc, handle, driver);
 193 }
 194 #endif
 195
 196 #if APU_HAVE_SQLITE3
 197 static void test_dbd_sqlite3(abts_case *tc, void *data)
 198 {
 199     apr_pool_t *pool = p;
 200     apr_status_t rv;
 201     const apr_dbd_driver_t* driver = NULL;
 202     apr_dbd_t* handle = NULL;
 203
 204     rv = apr_dbd_get_driver(pool, "sqlite3", &driver);
 205     ABTS_ASSERT(tc, "failed to fetch driver", rv == APR_SUCCESS);
 206     ABTS_PTR_NOTNULL(tc, driver);
 207
 208     ABTS_STR_EQUAL(tc, "sqlite3", apr_dbd_name(driver));
 209
 210     rv = apr_dbd_open(driver, pool, "data/sqlite3.db", &handle);
 211     ABTS_ASSERT(tc, "failed to open database", rv == APR_SUCCESS);
 212     ABTS_PTR_NOTNULL(tc, handle);
 213
 214     test_dbd_generic(tc, handle, driver);
 215 }
 216 #endif
 217
 218 abts_suite *testdbd(abts_suite *suite)
 219 {
 220     suite = ADD_SUITE(suite);
 221
 222
 223     abts_run_test(suite, test_dbd_init, NULL);
 224
 225 #if APU_HAVE_SQLITE2
 226     abts_run_test(suite, test_dbd_sqlite2, NULL);
 227 #endif
 228
 229 #if APU_HAVE_SQLITE3
 230     abts_run_test(suite, test_dbd_sqlite3, NULL);
 231 #endif
 232     return suite;
 233 }