OpenDNSSEC-enforcer 2.1.13
test_database_operations.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 2014 Jerry Lundström <lundstrom.jerry@gmail.com>
3 * Copyright (c) 2014 .SE (The Internet Infrastructure Foundation).
4 * Copyright (c) 2014 OpenDNSSEC AB (svb)
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
22 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
24 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30#include "config.h"
31
32#include "../db_configuration.h"
33#include "../db_connection.h"
34#include "../db_object.h"
35
36#include "CUnit/Basic.h"
37#include <string.h>
38
39typedef struct {
42 char* name;
43} test_t;
44
45typedef struct {
50
51static db_configuration_list_t* configuration_list = NULL;
52static db_configuration_t* configuration = NULL;
53static db_connection_t* connection = NULL;
54static test_t* test = NULL;
55static test_list_t* test_list = NULL;
56static db_value_t object2_id, object3_id;
57
59 db_object_field_list_t* object_field_list;
60 db_object_field_t* object_field;
61 db_object_t* object;
62
63 CU_ASSERT_PTR_NOT_NULL_FATAL((object = db_object_new()));
64
65 CU_ASSERT_FATAL(!db_object_set_connection(object, connection));
66 CU_ASSERT_FATAL(!db_object_set_table(object, "test"));
67 CU_ASSERT_FATAL(!db_object_set_primary_key_name(object, "id"));
68
69 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
70
71 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
72 CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "id"));
73 CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_PRIMARY_KEY));
74 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
75
76 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
77 CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
78 CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
79 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
80
81 CU_ASSERT_FATAL(!db_object_set_object_field_list(object, object_field_list));
82
83 return object;
84}
85
86test_t* test_new(const db_connection_t* connection) {
87 test_t* test =
88 (test_t*)calloc(1, sizeof(test_t));
89
90 if (test) {
91 CU_ASSERT_PTR_NOT_NULL_FATAL((test->dbo = __test_new_object(connection)));
92 CU_ASSERT_PTR_NOT_NULL_FATAL((test->id = db_value_new()));
93 }
94
95 return test;
96}
97
98void test_free(test_t* test) {
99 if (test) {
100 if (test->dbo) {
101 db_object_free(test->dbo);
102 }
103 if (test->id) {
104 db_value_free(test->id);
105 }
106 if (test->name) {
107 free(test->name);
108 }
109 free(test);
110 }
111}
112
113const db_value_t* test_id(const test_t* test) {
114 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
115
116 return test->id;
117}
118
119const char* test_name(const test_t* test) {
120 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
121
122 return test->name;
123}
124
125int test_set_name(test_t* test, const char *name) {
126 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
127 CU_ASSERT_PTR_NOT_NULL_FATAL(name);
128
129 if (test->name) {
130 free(test->name);
131 }
132 test->name = strdup(name);
133 CU_ASSERT_PTR_NOT_NULL_FATAL(test->name);
134 return 0;
135}
136
137int test_from_result(test_t* test, const db_result_t* result) {
138 const db_value_set_t* value_set;
139
140 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
141 CU_ASSERT_PTR_NOT_NULL_FATAL(result);
142
143 db_value_reset(test->id);
144 if (test->name) {
145 free(test->name);
146 }
147 test->name = NULL;
148
149 value_set = db_result_value_set(result);
150
151 CU_ASSERT_PTR_NOT_NULL_FATAL(value_set);
152 CU_ASSERT_FATAL(db_value_set_size(value_set) == 2);
153 CU_ASSERT_FATAL(!db_value_copy(test->id, db_value_set_at(value_set, 0)));
154 CU_ASSERT_FATAL(!db_value_to_text(db_value_set_at(value_set, 1), &(test->name)));
155 return 0;
156}
157
158int test_get_by_name(test_t* test, const char* name) {
159 db_clause_list_t* clause_list;
160 db_clause_t* clause;
161 db_result_list_t* result_list;
162 const db_result_t* result;
163 int ret;
164
165 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
166 CU_ASSERT_PTR_NOT_NULL_FATAL(name);
167
168 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
169 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
170 CU_ASSERT_FATAL(!db_clause_set_field(clause, "name"));
171 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
172 CU_ASSERT_FATAL(!db_value_from_text(db_clause_get_value(clause), name));
173 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
174 clause = NULL;
175
176 ret = 1;
177 result_list = db_object_read(test->dbo, NULL, clause_list);
178 if (result_list) {
179 result = db_result_list_next(result_list);
180 if (result) {
181 test_from_result(test, result);
182 ret = 0;
183 }
184 CU_ASSERT_PTR_NULL((result = db_result_list_next(result_list)));
185 if (result) {
186 db_result_list_free(result_list);
187 db_clause_list_free(clause_list);
188 return 1;
189 }
190 }
191
192 db_result_list_free(result_list);
193 db_clause_list_free(clause_list);
194 db_clause_free(clause);
195 return ret;
196}
197
198int test_get_by_id(test_t* test, const db_value_t* id) {
199 db_clause_list_t* clause_list;
200 db_clause_t* clause;
201 db_result_list_t* result_list;
202 const db_result_t* result;
203 int ret;
204
205 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
206 CU_ASSERT_PTR_NOT_NULL_FATAL(id);
207
208 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
209 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
210 CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
211 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
212 CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), id));
213 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
214 clause = NULL;
215
216 ret = 1;
217 result_list = db_object_read(test->dbo, NULL, clause_list);
218 if (result_list) {
219 result = db_result_list_next(result_list);
220 if (result) {
221 test_from_result(test, result);
222 ret = 0;
223 }
224 CU_ASSERT_PTR_NULL((result = db_result_list_next(result_list)));
225 if (result) {
226 db_result_list_free(result_list);
227 db_clause_list_free(clause_list);
228 return 1;
229 }
230 }
231
232 db_result_list_free(result_list);
233 db_clause_list_free(clause_list);
234 db_clause_free(clause);
235 return ret;
236}
237
238int test_create(test_t* test) {
239 db_object_field_list_t* object_field_list;
240 db_object_field_t* object_field;
241 db_value_set_t* value_set;
242 db_value_t* value;
243 int ret = 0;
244
245 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
246 CU_ASSERT_FATAL(db_value_not_empty(test->id));
247 CU_ASSERT_PTR_NOT_NULL_FATAL(test->name);
248
249 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
250 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
251 CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
252 CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
253 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
254 object_field = NULL;
255
256 CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(1)));
257 CU_ASSERT_PTR_NOT_NULL_FATAL((value = db_value_set_get(value_set, 0)));
258 CU_ASSERT_FATAL(!db_value_from_text(value, test->name));
259
260 if (db_object_create(test->dbo, object_field_list, value_set)) {
261 ret = 1;
262 }
263
264 db_value_set_free(value_set);
265 db_object_field_free(object_field);
266 db_object_field_list_free(object_field_list);
267 CU_ASSERT(!ret);
268 return ret;
269}
270
271int test_update(test_t* test) {
272 db_clause_list_t* clause_list;
273 db_clause_t* clause;
274 db_object_field_list_t* object_field_list;
275 db_object_field_t* object_field;
276 db_value_set_t* value_set;
277 db_value_t* value;
278 int ret = 0;
279
280 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
281 CU_ASSERT_FATAL(!db_value_not_empty(test->id));
282 CU_ASSERT_PTR_NOT_NULL_FATAL(test->name);
283
284 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
285 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
286 CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
287 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
288 CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test->id));
289 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
290 clause = NULL;
291
292 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
293 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
294 CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
295 CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
296 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
297 object_field = NULL;
298
299 CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(1)));
300 CU_ASSERT_PTR_NOT_NULL_FATAL((value = db_value_set_get(value_set, 0)));
301 CU_ASSERT_FATAL(!db_value_from_text(value, test->name));
302
303 if (db_object_update(test->dbo, object_field_list, value_set, clause_list)) {
304 ret = 1;
305 }
306
307 db_clause_list_free(clause_list);
308 db_clause_free(clause);
309 db_value_set_free(value_set);
310 db_object_field_free(object_field);
311 db_object_field_list_free(object_field_list);
312 CU_ASSERT(!ret);
313 return ret;
314}
315
316int test_delete(test_t* test) {
317 db_clause_list_t* clause_list;
318 db_clause_t* clause;
319 int ret = 0;
320
321 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
322 CU_ASSERT_FATAL(!db_value_not_empty(test->id));
323
324 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
325 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
326 CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
327 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
328 CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test->id));
329 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
330 clause = NULL;
331
332 if (db_object_delete(test->dbo, clause_list)) {
333 ret = 1;
334 }
335
336 db_clause_list_free(clause_list);
337 db_clause_free(clause);
338 CU_ASSERT(!ret);
339 return ret;
340}
341
342size_t test_count_by_name(test_t* test, const char* name) {
343 db_clause_list_t* clause_list;
344 db_clause_t* clause;
345 size_t ret = 0;
346
347 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
348 CU_ASSERT_PTR_NOT_NULL_FATAL(name);
349
350 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
351 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
352 CU_ASSERT_FATAL(!db_clause_set_field(clause, "name"));
353 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
354 CU_ASSERT_FATAL(!db_value_from_text(db_clause_get_value(clause), name));
355 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
356 clause = NULL;
357
358 CU_ASSERT(!db_object_count(test->dbo, NULL, clause_list, &ret));
359
360 db_clause_list_free(clause_list);
361 db_clause_free(clause);
362 return ret;
363}
364
365size_t test_count_by_id(test_t* test, const db_value_t* id) {
366 db_clause_list_t* clause_list;
367 db_clause_t* clause;
368 size_t ret = 0;
369
370 CU_ASSERT_PTR_NOT_NULL_FATAL(test);
371 CU_ASSERT_PTR_NOT_NULL_FATAL(id);
372
373 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
374 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
375 CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
376 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
377 CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), id));
378 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
379 clause = NULL;
380
381 CU_ASSERT(!db_object_count(test->dbo, NULL, clause_list, &ret));
382
383 db_clause_list_free(clause_list);
384 db_clause_free(clause);
385 return ret;
386}
387
389 test_list_t* test_list =
390 (test_list_t*)calloc(1, sizeof(test_list_t));
391
392 if (test_list) {
393 CU_ASSERT_PTR_NOT_NULL_FATAL((test_list->dbo = __test_new_object(connection)));
394 }
395
396 return test_list;
397}
398
399void test_list_free(test_list_t* test_list) {
400 if (test_list) {
401 if (test_list->dbo) {
402 db_object_free(test_list->dbo);
403 }
404 if (test_list->result_list) {
406 }
407 if (test_list->test) {
408 test_free(test_list->test);
409 }
410 free(test_list);
411 }
412}
413
414int test_list_get(test_list_t* test_list) {
415 CU_ASSERT_PTR_NOT_NULL_FATAL(test_list);
416 CU_ASSERT_PTR_NOT_NULL_FATAL(test_list->dbo);
417
418 if (test_list->result_list) {
420 }
421 CU_ASSERT_PTR_NOT_NULL((test_list->result_list = db_object_read(test_list->dbo, NULL, NULL)));
422 if (!test_list->result_list) {
423 return 1;
424 }
425 return 0;
426}
427
429 const db_result_t* result;
430
431 CU_ASSERT_PTR_NOT_NULL_FATAL(test_list);
432 CU_ASSERT_PTR_NOT_NULL_FATAL(test_list->result_list);
433
434 result = db_result_list_next(test_list->result_list);
435 if (!result) {
436 return NULL;
437 }
438 if (!test_list->test) {
439 CU_ASSERT_PTR_NOT_NULL_FATAL((test_list->test = test_new(db_object_connection(test_list->dbo))));
440 }
441 if (test_from_result(test_list->test, result)) {
442 return NULL;
443 }
444 return test_list->test;
445}
446
448 const db_result_t* result;
449
450 CU_ASSERT_PTR_NOT_NULL_FATAL(test_list);
451
452 result = db_result_list_next(test_list->result_list);
453 if (!result) {
454 return NULL;
455 }
456 if (!test_list->test) {
457 CU_ASSERT_PTR_NOT_NULL_FATAL((test_list->test = test_new(db_object_connection(test_list->dbo))));
458 }
459 if (test_from_result(test_list->test, result)) {
460 return NULL;
461 }
462 return test_list->test;
463}
464
465typedef struct {
469 char* name;
470} test2_t;
471
472static test2_t* test2 = NULL;
473static test2_t* test2_2 = NULL;
474
476 db_object_field_list_t* object_field_list;
477 db_object_field_t* object_field;
478 db_object_t* object;
479
480 CU_ASSERT_PTR_NOT_NULL_FATAL((object = db_object_new()));
481
482 CU_ASSERT_FATAL(!db_object_set_connection(object, connection));
483 CU_ASSERT_FATAL(!db_object_set_table(object, "test2"));
484 CU_ASSERT_FATAL(!db_object_set_primary_key_name(object, "id"));
485
486 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
487
488 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
489 CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "id"));
490 CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_PRIMARY_KEY));
491 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
492
493 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
494 CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "rev"));
495 CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_REVISION));
496 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
497
498 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
499 CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
500 CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
501 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
502
503 CU_ASSERT_FATAL(!db_object_set_object_field_list(object, object_field_list));
504
505 return object;
506}
507
508test2_t* test2_new(const db_connection_t* connection) {
509 test2_t* test2 =
510 (test2_t*)calloc(1, sizeof(test2_t));
511
512 if (test2) {
513 CU_ASSERT_PTR_NOT_NULL_FATAL((test2->dbo = __test2_new_object(connection)));
514 CU_ASSERT_PTR_NOT_NULL_FATAL((test2->id = db_value_new()));
515 CU_ASSERT_PTR_NOT_NULL_FATAL((test2->rev = db_value_new()));
516 }
517
518 return test2;
519}
520
521void test2_free(test2_t* test2) {
522 if (test2) {
523 if (test2->dbo) {
524 db_object_free(test2->dbo);
525 }
526 if (test2->id) {
527 db_value_free(test2->id);
528 }
529 if (test2->rev) {
530 db_value_free(test2->rev);
531 }
532 if (test2->name) {
533 free(test2->name);
534 }
535 free(test2);
536 }
537}
538
539const db_value_t* test2_id(const test2_t* test2) {
540 CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
541
542 return test2->id;
543}
544
545const char* test2_name(const test2_t* test2) {
546 CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
547
548 return test2->name;
549}
550
551int test2_set_name(test2_t* test2, const char *name) {
552 CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
553 CU_ASSERT_PTR_NOT_NULL_FATAL(name);
554
555 if (test2->name) {
556 free(test2->name);
557 }
558 test2->name = strdup(name);
559 CU_ASSERT_PTR_NOT_NULL_FATAL(test2->name);
560 return 0;
561}
562
563int test2_from_result(test2_t* test2, const db_result_t* result) {
564 const db_value_set_t* value_set;
565
566 CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
567 CU_ASSERT_PTR_NOT_NULL_FATAL(result);
568
569 db_value_reset(test2->id);
570 db_value_reset(test2->rev);
571 if (test2->name) {
572 free(test2->name);
573 }
574 test2->name = NULL;
575
576 value_set = db_result_value_set(result);
577
578 CU_ASSERT_PTR_NOT_NULL_FATAL(value_set);
579 CU_ASSERT_FATAL(db_value_set_size(value_set) == 3);
580 CU_ASSERT_FATAL(!db_value_copy(test2->id, db_value_set_at(value_set, 0)));
581 CU_ASSERT_FATAL(!db_value_copy(test2->rev, db_value_set_at(value_set, 1)));
582 CU_ASSERT_FATAL(!db_value_to_text(db_value_set_at(value_set, 2), &(test2->name)));
583 return 0;
584}
585
586int test2_get_by_name(test2_t* test2, const char* name) {
587 db_clause_list_t* clause_list;
588 db_clause_t* clause;
589 db_result_list_t* result_list;
590 const db_result_t* result;
591 int ret;
592
593 CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
594 CU_ASSERT_PTR_NOT_NULL_FATAL(name);
595
596 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
597 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
598 CU_ASSERT_FATAL(!db_clause_set_field(clause, "name"));
599 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
600 CU_ASSERT_FATAL(!db_value_from_text(db_clause_get_value(clause), name));
601 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
602 clause = NULL;
603
604 ret = 1;
605 result_list = db_object_read(test2->dbo, NULL, clause_list);
606 if (result_list) {
607 result = db_result_list_next(result_list);
608 if (result) {
609 test2_from_result(test2, result);
610 ret = 0;
611 }
612 CU_ASSERT_PTR_NULL((result = db_result_list_next(result_list)));
613 if (result) {
614 db_result_list_free(result_list);
615 db_clause_list_free(clause_list);
616 return 1;
617 }
618 }
619
620 db_result_list_free(result_list);
621 db_clause_list_free(clause_list);
622 db_clause_free(clause);
623 return ret;
624}
625
626int test2_get_by_id(test2_t* test2, const db_value_t* id) {
627 db_clause_list_t* clause_list;
628 db_clause_t* clause;
629 db_result_list_t* result_list;
630 const db_result_t* result;
631 int ret;
632
633 CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
634 CU_ASSERT_PTR_NOT_NULL_FATAL(id);
635
636 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
637 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
638 CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
639 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
640 CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), id));
641 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
642 clause = NULL;
643
644 ret = 1;
645 result_list = db_object_read(test2->dbo, NULL, clause_list);
646 if (result_list) {
647 result = db_result_list_next(result_list);
648 if (result) {
649 test2_from_result(test2, result);
650 ret = 0;
651 }
652 CU_ASSERT_PTR_NULL((result = db_result_list_next(result_list)));
653 if (result) {
654 db_result_list_free(result_list);
655 db_clause_list_free(clause_list);
656 return 1;
657 }
658 }
659
660 db_result_list_free(result_list);
661 db_clause_list_free(clause_list);
662 db_clause_free(clause);
663 return ret;
664}
665
667 db_object_field_list_t* object_field_list;
668 db_object_field_t* object_field;
669 db_value_set_t* value_set;
670 db_value_t* value;
671 int ret = 0;
672
673 CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
674 CU_ASSERT_FATAL(db_value_not_empty(test2->id));
675 CU_ASSERT_FATAL(db_value_not_empty(test2->rev));
676 CU_ASSERT_PTR_NOT_NULL_FATAL(test2->name);
677
678 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
679 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
680 CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
681 CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
682 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
683 object_field = NULL;
684
685 CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(1)));
686 CU_ASSERT_PTR_NOT_NULL_FATAL((value = db_value_set_get(value_set, 0)));
687 CU_ASSERT_FATAL(!db_value_from_text(value, test2->name));
688
689 if (db_object_create(test2->dbo, object_field_list, value_set)) {
690 ret = 1;
691 }
692
693 db_value_set_free(value_set);
694 db_object_field_free(object_field);
695 db_object_field_list_free(object_field_list);
696 CU_ASSERT(!ret);
697 return ret;
698}
699
701 db_clause_list_t* clause_list;
702 db_clause_t* clause;
703 db_object_field_list_t* object_field_list;
704 db_object_field_t* object_field;
705 db_value_set_t* value_set;
706 db_value_t* value;
707 int ret = 0;
708
709 CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
710 CU_ASSERT_FATAL(!db_value_not_empty(test2->id));
711 CU_ASSERT_FATAL(!db_value_not_empty(test2->rev));
712 CU_ASSERT_PTR_NOT_NULL_FATAL(test2->name);
713
714 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
715 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
716 CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
717 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
718 CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test2->id));
719 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
720 clause = NULL;
721 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
722 CU_ASSERT_FATAL(!db_clause_set_field(clause, "rev"));
723 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
724 CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test2->rev));
725 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
726 clause = NULL;
727
728 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
729 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
730 CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
731 CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
732 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
733 object_field = NULL;
734
735 CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(1)));
736 CU_ASSERT_PTR_NOT_NULL_FATAL((value = db_value_set_get(value_set, 0)));
737 CU_ASSERT_FATAL(!db_value_from_text(value, test2->name));
738
739 if (db_object_update(test2->dbo, object_field_list, value_set, clause_list)) {
740 ret = 1;
741 }
742
743 db_clause_list_free(clause_list);
744 db_clause_free(clause);
745 db_value_set_free(value_set);
746 db_object_field_free(object_field);
747 db_object_field_list_free(object_field_list);
748 return ret;
749}
750
752 db_clause_list_t* clause_list;
753 db_clause_t* clause;
754 int ret = 0;
755
756 CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
757 CU_ASSERT_FATAL(!db_value_not_empty(test2->id));
758 CU_ASSERT_FATAL(!db_value_not_empty(test2->rev));
759
760 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
761 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
762 CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
763 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
764 CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test2->id));
765 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
766 clause = NULL;
767 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
768 CU_ASSERT_FATAL(!db_clause_set_field(clause, "rev"));
769 CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
770 CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test2->rev));
771 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
772 clause = NULL;
773
774 if (db_object_delete(test2->dbo, clause_list)) {
775 ret = 1;
776 }
777
778 db_clause_list_free(clause_list);
779 db_clause_free(clause);
780 CU_ASSERT(!ret);
781 return ret;
782}
783
784#if defined(ENFORCER_DATABASE_SQLITE3)
785int init_suite_database_operations_sqlite(void) {
786 if (configuration_list) {
787 return 1;
788 }
789 if (configuration) {
790 return 1;
791 }
792 if (connection) {
793 return 1;
794 }
795 if (test) {
796 return 1;
797 }
798 if (test2) {
799 return 1;
800 }
801 if (test2_2) {
802 return 1;
803 }
804
805 /*
806 * Setup the configuration for the connection
807 */
808 if (!(configuration_list = db_configuration_list_new())) {
809 return 1;
810 }
811 if (!(configuration = db_configuration_new())
812 || db_configuration_set_name(configuration, "backend")
813 || db_configuration_set_value(configuration, "sqlite")
814 || db_configuration_list_add(configuration_list, configuration))
815 {
816 db_configuration_free(configuration);
817 configuration = NULL;
818 db_configuration_list_free(configuration_list);
819 configuration_list = NULL;
820 return 1;
821 }
822 configuration = NULL;
823 if (!(configuration = db_configuration_new())
824 || db_configuration_set_name(configuration, "file")
825 || db_configuration_set_value(configuration, "test.db")
826 || db_configuration_list_add(configuration_list, configuration))
827 {
828 db_configuration_free(configuration);
829 configuration = NULL;
830 db_configuration_list_free(configuration_list);
831 configuration_list = NULL;
832 return 1;
833 }
834 configuration = NULL;
835
836 /*
837 * Connect to the database
838 */
839 if (!(connection = db_connection_new())
840 || db_connection_set_configuration_list(connection, configuration_list))
841 {
842 db_connection_free(connection);
843 connection = NULL;
844 db_configuration_list_free(configuration_list);
845 configuration_list = NULL;
846 return 1;
847 }
848 configuration_list = NULL;
849
850 if (db_connection_setup(connection)
851 || db_connection_connect(connection))
852 {
853 db_connection_free(connection);
854 connection = NULL;
855 return 1;
856 }
857
858 return 0;
859}
860#endif
861
862#if defined(ENFORCER_DATABASE_MYSQL)
864 if (configuration_list) {
865 return 1;
866 }
867 if (configuration) {
868 return 1;
869 }
870 if (connection) {
871 return 1;
872 }
873 if (test) {
874 return 1;
875 }
876 if (test2) {
877 return 1;
878 }
879 if (test2_2) {
880 return 1;
881 }
882
883 /*
884 * Setup the configuration for the connection
885 */
886 if (!(configuration_list = db_configuration_list_new())) {
887 return 1;
888 }
889 if (!(configuration = db_configuration_new())
890 || db_configuration_set_name(configuration, "backend")
891 || db_configuration_set_value(configuration, "mysql")
892 || db_configuration_list_add(configuration_list, configuration))
893 {
894 db_configuration_free(configuration);
895 configuration = NULL;
896 db_configuration_list_free(configuration_list);
897 configuration_list = NULL;
898 return 1;
899 }
900 configuration = NULL;
901 if (!(configuration = db_configuration_new())
902 || db_configuration_set_name(configuration, "host")
903 || db_configuration_set_value(configuration, ENFORCER_DB_HOST)
904 || db_configuration_list_add(configuration_list, configuration))
905 {
906 db_configuration_free(configuration);
907 configuration = NULL;
908 db_configuration_list_free(configuration_list);
909 configuration_list = NULL;
910 return 1;
911 }
912 configuration = NULL;
913 if (!(configuration = db_configuration_new())
914 || db_configuration_set_name(configuration, "port")
915 || db_configuration_set_value(configuration, ENFORCER_DB_PORT_TEXT)
916 || db_configuration_list_add(configuration_list, configuration))
917 {
918 db_configuration_free(configuration);
919 configuration = NULL;
920 db_configuration_list_free(configuration_list);
921 configuration_list = NULL;
922 return 1;
923 }
924 configuration = NULL;
925 if (!(configuration = db_configuration_new())
926 || db_configuration_set_name(configuration, "user")
927 || db_configuration_set_value(configuration, ENFORCER_DB_USERNAME)
928 || db_configuration_list_add(configuration_list, configuration))
929 {
930 db_configuration_free(configuration);
931 configuration = NULL;
932 db_configuration_list_free(configuration_list);
933 configuration_list = NULL;
934 return 1;
935 }
936 configuration = NULL;
937 if (!(configuration = db_configuration_new())
938 || db_configuration_set_name(configuration, "pass")
939 || db_configuration_set_value(configuration, ENFORCER_DB_PASSWORD)
940 || db_configuration_list_add(configuration_list, configuration))
941 {
942 db_configuration_free(configuration);
943 configuration = NULL;
944 db_configuration_list_free(configuration_list);
945 configuration_list = NULL;
946 return 1;
947 }
948 configuration = NULL;
949 if (!(configuration = db_configuration_new())
950 || db_configuration_set_name(configuration, "db")
951 || db_configuration_set_value(configuration, ENFORCER_DB_DATABASE)
952 || db_configuration_list_add(configuration_list, configuration))
953 {
954 db_configuration_free(configuration);
955 configuration = NULL;
956 db_configuration_list_free(configuration_list);
957 configuration_list = NULL;
958 return 1;
959 }
960 configuration = NULL;
961
962 /*
963 * Connect to the database
964 */
965 if (!(connection = db_connection_new())
966 || db_connection_set_configuration_list(connection, configuration_list))
967 {
968 db_connection_free(connection);
969 connection = NULL;
970 db_configuration_list_free(configuration_list);
971 configuration_list = NULL;
972 return 1;
973 }
974 configuration_list = NULL;
975
976 if (db_connection_setup(connection)
977 || db_connection_connect(connection))
978 {
979 db_connection_free(connection);
980 connection = NULL;
981 return 1;
982 }
983
984 return 0;
985}
986#endif
987
989 test_free(test);
990 test = NULL;
991 test_list_free(test_list);
992 test_list = NULL;
993 test2_free(test2);
994 test2 = NULL;
995 test2_free(test2_2);
996 test2_2 = NULL;
997 db_connection_free(connection);
998 connection = NULL;
999 db_configuration_free(configuration);
1000 configuration = NULL;
1001 db_configuration_list_free(configuration_list);
1002 configuration_list = NULL;
1003 db_value_reset(&object2_id);
1004 db_value_reset(&object3_id);
1005 return 0;
1006}
1007
1008void __check_id(const db_value_t* id, int id_int, const char* id_text) {
1009 db_type_int32_t int32;
1010 db_type_uint32_t uint32;
1011 db_type_int64_t int64;
1012 db_type_uint64_t uint64;
1013 const char* text;
1014
1015 CU_ASSERT_PTR_NOT_NULL(id);
1016 switch (db_value_type(id)) {
1017 case DB_TYPE_INT32:
1018 CU_ASSERT(!db_value_to_int32(id, &int32));
1019 CU_ASSERT(int32 == (db_type_int32_t)id_int);
1020 break;
1021
1022 case DB_TYPE_UINT32:
1023 CU_ASSERT(!db_value_to_uint32(id, &uint32));
1024 CU_ASSERT(uint32 == (db_type_uint32_t)id_int);
1025 break;
1026
1027 case DB_TYPE_INT64:
1028 CU_ASSERT(!db_value_to_int64(id, &int64));
1029 CU_ASSERT(int64 == (db_type_int64_t)id_int);
1030 break;
1031
1032 case DB_TYPE_UINT64:
1033 CU_ASSERT(!db_value_to_uint64(id, &uint64));
1034 CU_ASSERT(uint64 == (db_type_uint64_t)id_int);
1035 break;
1036
1037 case DB_TYPE_TEXT:
1038 CU_ASSERT_PTR_NOT_NULL_FATAL((text = db_value_text(id)));
1039 CU_ASSERT(!strcmp(text, id_text));
1040 break;
1041
1042 default:
1043 CU_FAIL("db_value_type(id)");
1044 }
1045}
1046
1048 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1049 CU_ASSERT_FATAL(!test_get_by_name(test, "test"));
1050 __check_id(test_id(test), 1, "1");
1051 CU_ASSERT_PTR_NOT_NULL_FATAL(test_name(test));
1052 CU_ASSERT(!strcmp(test_name(test), "test"));
1053
1054 test_free(test);
1055 test = NULL;
1056 CU_PASS("test_free");
1057}
1058
1060 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1061 CU_ASSERT_FATAL(!test_set_name(test, "name 2"));
1062 CU_ASSERT(!strcmp(test_name(test), "name 2"));
1063 CU_ASSERT_FATAL(!test_create(test));
1064
1065 test_free(test);
1066 test = NULL;
1067 CU_PASS("test_free");
1068
1069 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1070 CU_ASSERT_FATAL(!test_get_by_name(test, "name 2"));
1071 db_value_reset(&object2_id);
1072 CU_ASSERT(!db_value_copy(&object2_id, test_id(test)));
1073 CU_ASSERT(!strcmp(test_name(test), "name 2"));
1074
1075 test_free(test);
1076 test = NULL;
1077 CU_PASS("test_free");
1078}
1079
1081 int cmp = 0;
1082
1083 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1084 CU_ASSERT_FATAL(!test_get_by_id(test, &object2_id));
1085 CU_ASSERT(!db_value_cmp(test_id(test), &object2_id, &cmp));
1086 CU_ASSERT(!cmp);
1087 CU_ASSERT(!strcmp(test_name(test), "name 2"));
1088
1089 test_free(test);
1090 test = NULL;
1091 CU_PASS("test_free");
1092}
1093
1095 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1096 CU_ASSERT_FATAL(!test_get_by_id(test, &object2_id));
1097 CU_ASSERT_FATAL(!test_set_name(test, "name 3"));
1098 CU_ASSERT(!strcmp(test_name(test), "name 3"));
1099 CU_ASSERT_FATAL(!test_update(test));
1100
1101 test_free(test);
1102 test = NULL;
1103 CU_PASS("test_free");
1104
1105 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1106 CU_ASSERT_FATAL(!test_get_by_id(test, &object2_id));
1107 CU_ASSERT(!strcmp(test_name(test), "name 3"));
1108
1109 test_free(test);
1110 test = NULL;
1111 CU_PASS("test_free");
1112}
1113
1115 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1116 CU_ASSERT_FATAL(!test_get_by_id(test, &object2_id));
1117 CU_ASSERT_FATAL(!test_delete(test));
1118
1119 test_free(test);
1120 test = NULL;
1121 CU_PASS("test_free");
1122
1123 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1124 CU_ASSERT_FATAL(test_get_by_id(test, &object2_id));
1125
1126 test_free(test);
1127 test = NULL;
1128 CU_PASS("test_free");
1129}
1130
1132 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1133 CU_ASSERT_FATAL(!test_set_name(test, "name 3"));
1134 CU_ASSERT(!strcmp(test_name(test), "name 3"));
1135 CU_ASSERT_FATAL(!test_create(test));
1136
1137 test_free(test);
1138 test = NULL;
1139 CU_PASS("test_free");
1140
1141 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1142 CU_ASSERT_FATAL(!test_get_by_name(test, "name 3"));
1143 db_value_reset(&object3_id);
1144 CU_ASSERT(!db_value_copy(&object3_id, test_id(test)));
1145 CU_ASSERT(!strcmp(test_name(test), "name 3"));
1146
1147 test_free(test);
1148 test = NULL;
1149 CU_PASS("test_free");
1150}
1151
1153 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1154 CU_ASSERT_FATAL(!test_get_by_id(test, &object3_id));
1155 CU_ASSERT_FATAL(!test_delete(test));
1156
1157 test_free(test);
1158 test = NULL;
1159 CU_PASS("test_free");
1160
1161 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1162 CU_ASSERT_FATAL(test_get_by_id(test, &object3_id));
1163
1164 test_free(test);
1165 test = NULL;
1166 CU_PASS("test_free");
1167}
1168
1170 const test_t* local_test;
1171 int count = 0;
1172
1173 CU_ASSERT_PTR_NOT_NULL_FATAL((test_list = test_list_new(connection)));
1174 CU_ASSERT_FATAL(!test_list_get(test_list));
1175 local_test = test_list_begin(test_list);
1176 while (local_test) {
1177 count++;
1178 local_test = test_list_next(test_list);
1179 }
1180 CU_ASSERT(count == 3);
1181
1182 test_list_free(test_list);
1183 test_list = NULL;
1184 CU_PASS("test_list_free");
1185}
1186
1188 CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1189 CU_ASSERT(test_count_by_name(test, "test") == 1);
1190 CU_ASSERT(test_count_by_id(test, &object2_id) == 1);
1191 CU_ASSERT(test_count_by_id(test, &object3_id) == 1);
1192 CU_ASSERT(test_count_by_name(test, "name 3") == 2);
1193 test_free(test);
1194 test = NULL;
1195 CU_PASS("test_free");
1196}
1197
1199 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1200 CU_ASSERT_FATAL(!test2_get_by_name(test2, "test"));
1201 __check_id(test2_id(test2), 1, "1");
1202 CU_ASSERT_PTR_NOT_NULL_FATAL(test2_name(test2));
1203 CU_ASSERT(!strcmp(test2_name(test2), "test"));
1204
1205 test2_free(test2);
1206 test2 = NULL;
1207 CU_PASS("test2_free");
1208}
1209
1211 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1212 CU_ASSERT_FATAL(!test2_set_name(test2, "name 2"));
1213 CU_ASSERT(!strcmp(test2_name(test2), "name 2"));
1214 CU_ASSERT_FATAL(!test2_create(test2));
1215
1216 test2_free(test2);
1217 test2 = NULL;
1218 CU_PASS("test2_free");
1219
1220 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1221 CU_ASSERT_FATAL(!test2_get_by_name(test2, "name 2"));
1222 db_value_reset(&object2_id);
1223 CU_ASSERT(!db_value_copy(&object2_id, test2_id(test2)));
1224 CU_ASSERT(!strcmp(test2_name(test2), "name 2"));
1225
1226 test2_free(test2);
1227 test2 = NULL;
1228 CU_PASS("test2_free");
1229}
1230
1232 int cmp = 0;
1233
1234 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1235 CU_ASSERT_FATAL(!test2_get_by_id(test2, &object2_id));
1236 CU_ASSERT(!db_value_cmp(test2_id(test2), &object2_id, &cmp));
1237 CU_ASSERT(!cmp);
1238 CU_ASSERT(!strcmp(test2_name(test2), "name 2"));
1239
1240 test2_free(test2);
1241 test2 = NULL;
1242 CU_PASS("test2_free");
1243}
1244
1246 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1247 CU_ASSERT_FATAL(!test2_get_by_id(test2, &object2_id));
1248 CU_ASSERT_FATAL(!test2_set_name(test2, "name 3"));
1249 CU_ASSERT(!strcmp(test2_name(test2), "name 3"));
1250 CU_ASSERT_FATAL(!test2_update(test2));
1251
1252 test2_free(test2);
1253 test2 = NULL;
1254 CU_PASS("test2_free");
1255
1256 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1257 CU_ASSERT_FATAL(!test2_get_by_id(test2, &object2_id));
1258 CU_ASSERT(!strcmp(test2_name(test2), "name 3"));
1259
1260 test2_free(test2);
1261 test2 = NULL;
1262 CU_PASS("test2_free");
1263}
1264
1266 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1267 CU_ASSERT_FATAL(!test2_set_name(test2, "name 4"));
1268 CU_ASSERT(!strcmp(test2_name(test2), "name 4"));
1269 CU_ASSERT_FATAL(!test2_create(test2));
1270
1271 test2_free(test2);
1272 test2 = NULL;
1273 CU_PASS("test2_free");
1274
1275 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1276 CU_ASSERT_FATAL(!test2_get_by_name(test2, "name 4"));
1277 CU_ASSERT(!strcmp(test2_name(test2), "name 4"));
1278
1279 CU_ASSERT_PTR_NOT_NULL_FATAL((test2_2 = test2_new(connection)));
1280 CU_ASSERT_FATAL(!test2_get_by_name(test2_2, "name 4"));
1281 CU_ASSERT(!strcmp(test2_name(test2_2), "name 4"));
1282
1283 CU_ASSERT_FATAL(!test2_set_name(test2_2, "name 5"));
1284 CU_ASSERT(!strcmp(test2_name(test2_2), "name 5"));
1285 CU_ASSERT_FATAL(!test2_update(test2_2));
1286
1287 CU_ASSERT_FATAL(!test2_set_name(test2, "name 5"));
1288 CU_ASSERT(!strcmp(test2_name(test2), "name 5"));
1289 CU_ASSERT_FATAL(test2_update(test2));
1290
1291 test2_free(test2);
1292 test2 = NULL;
1293 CU_PASS("test2_free");
1294
1295 test2_free(test2_2);
1296 test2_2 = NULL;
1297 CU_PASS("test2_free");
1298}
1299
1301 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1302 CU_ASSERT_FATAL(!test2_get_by_id(test2, &object2_id));
1303 CU_ASSERT_FATAL(!test2_delete(test2));
1304
1305 test2_free(test2);
1306 test2 = NULL;
1307 CU_PASS("test2_free");
1308
1309 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1310 CU_ASSERT_FATAL(test2_get_by_id(test2, &object2_id));
1311
1312 test2_free(test2);
1313 test2 = NULL;
1314 CU_PASS("test2_free");
1315}
1316
1318 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1319 CU_ASSERT_FATAL(!test2_set_name(test2, "name 3"));
1320 CU_ASSERT(!strcmp(test2_name(test2), "name 3"));
1321 CU_ASSERT_FATAL(!test2_create(test2));
1322
1323 test2_free(test2);
1324 test2 = NULL;
1325 CU_PASS("test2_free");
1326
1327 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1328 CU_ASSERT_FATAL(!test2_get_by_name(test2, "name 3"));
1329 db_value_reset(&object3_id);
1330 CU_ASSERT(!db_value_copy(&object3_id, test2_id(test2)));
1331 CU_ASSERT(!strcmp(test2_name(test2), "name 3"));
1332
1333 test2_free(test2);
1334 test2 = NULL;
1335 CU_PASS("test2_free");
1336}
1337
1339 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1340 CU_ASSERT_FATAL(!test2_get_by_id(test2, &object3_id));
1341 CU_ASSERT_FATAL(!test2_delete(test2));
1342
1343 test2_free(test2);
1344 test2 = NULL;
1345 CU_PASS("test2_free");
1346
1347 CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1348 CU_ASSERT_FATAL(test2_get_by_id(test2, &object3_id));
1349
1350 test2_free(test2);
1351 test2 = NULL;
1352 CU_PASS("test2_free");
1353}
void db_clause_free(db_clause_t *clause)
Definition: db_clause.c:56
db_clause_list_t * db_clause_list_new(void)
Definition: db_clause.c:202
db_clause_t * db_clause_new(void)
Definition: db_clause.c:43
db_value_t * db_clause_get_value(db_clause_t *clause)
Definition: db_clause.c:187
int db_clause_list_add(db_clause_list_t *clause_list, db_clause_t *clause)
Definition: db_clause.c:226
void db_clause_list_free(db_clause_list_t *clause_list)
Definition: db_clause.c:209
int db_clause_set_field(db_clause_t *clause, const char *field)
Definition: db_clause.c:109
int db_clause_set_type(db_clause_t *clause, db_clause_type_t type)
Definition: db_clause.c:130
@ DB_CLAUSE_EQUAL
Definition: db_clause.h:44
db_configuration_t * db_configuration_new(void)
db_configuration_list_t * db_configuration_list_new(void)
void db_configuration_free(db_configuration_t *configuration)
int db_configuration_set_name(db_configuration_t *configuration, const char *name)
int db_configuration_list_add(db_configuration_list_t *configuration_list, db_configuration_t *configuration)
int db_configuration_set_value(db_configuration_t *configuration, const char *value)
void db_configuration_list_free(db_configuration_list_t *configuration_list)
int db_connection_connect(const db_connection_t *connection)
Definition: db_connection.c:88
db_connection_t * db_connection_new(void)
Definition: db_connection.c:38
int db_connection_setup(db_connection_t *connection)
Definition: db_connection.c:66
void db_connection_free(db_connection_t *connection)
Definition: db_connection.c:45
int db_connection_set_configuration_list(db_connection_t *connection, const db_configuration_list_t *configuration_list)
Definition: db_connection.c:54
const db_connection_t * db_object_connection(const db_object_t *object)
Definition: db_object.c:320
db_object_field_t * db_object_field_new(void)
Definition: db_object.c:40
int db_object_update(const db_object_t *object, const db_object_field_list_t *object_field_list, const db_value_set_t *value_set, const db_clause_list_t *clause_list)
Definition: db_object.c:441
int db_object_field_list_add(db_object_field_list_t *object_field_list, db_object_field_t *object_field)
Definition: db_object.c:254
db_object_t * db_object_new(void)
Definition: db_object.c:304
int db_object_set_table(db_object_t *object, const char *table)
Definition: db_object.c:356
int db_object_field_set_name(db_object_field_t *object_field, const char *name)
Definition: db_object.c:110
int db_object_set_connection(db_object_t *object, const db_connection_t *connection)
Definition: db_object.c:341
db_result_list_t * db_object_read(const db_object_t *object, const db_join_list_t *join_list, const db_clause_list_t *clause_list)
Definition: db_object.c:424
int db_object_field_set_type(db_object_field_t *object_field, db_type_t type)
Definition: db_object.c:122
void db_object_free(db_object_t *object)
Definition: db_object.c:311
db_object_field_list_t * db_object_field_list_new(void)
Definition: db_object.c:174
int db_object_set_object_field_list(db_object_t *object, db_object_field_list_t *object_field_list)
Definition: db_object.c:386
void db_object_field_free(db_object_field_t *object_field)
Definition: db_object.c:69
int db_object_create(const db_object_t *object, const db_object_field_list_t *object_field_list, const db_value_set_t *value_set)
Definition: db_object.c:401
int db_object_delete(const db_object_t *object, const db_clause_list_t *clause_list)
Definition: db_object.c:464
void db_object_field_list_free(db_object_field_list_t *object_field_list)
Definition: db_object.c:199
int db_object_count(const db_object_t *object, const db_join_list_t *join_list, const db_clause_list_t *clause_list, size_t *count)
Definition: db_object.c:481
int db_object_set_primary_key_name(db_object_t *object, const char *primary_key_name)
Definition: db_object.c:371
const db_result_t * db_result_list_next(db_result_list_t *result_list)
Definition: db_result.c:310
void db_result_list_free(db_result_list_t *result_list)
Definition: db_result.c:160
const db_value_set_t * db_result_value_set(const db_result_t *result)
Definition: db_result.c:97
@ DB_TYPE_INT64
Definition: db_type.h:74
@ DB_TYPE_UINT64
Definition: db_type.h:78
@ DB_TYPE_PRIMARY_KEY
Definition: db_type.h:62
@ DB_TYPE_REVISION
Definition: db_type.h:97
@ DB_TYPE_TEXT
Definition: db_type.h:82
@ DB_TYPE_INT32
Definition: db_type.h:66
@ DB_TYPE_UINT32
Definition: db_type.h:70
uint64_t db_type_uint64_t
Definition: db_type.h:50
uint32_t db_type_uint32_t
Definition: db_type.h:42
int64_t db_type_int64_t
Definition: db_type.h:46
int32_t db_type_int32_t
Definition: db_type.h:38
int db_value_to_int32(const db_value_t *value, db_type_int32_t *to_int32)
Definition: db_value.c:357
db_type_t db_value_type(const db_value_t *value)
Definition: db_value.c:269
const db_value_t * db_value_set_at(const db_value_set_t *value_set, size_t at)
Definition: db_value.c:742
db_value_t * db_value_set_get(db_value_set_t *value_set, size_t at)
Definition: db_value.c:756
void db_value_set_free(db_value_set_t *value_set)
Definition: db_value.c:697
db_value_set_t * db_value_set_new(size_t size)
Definition: db_value.c:622
int db_value_to_int64(const db_value_t *value, db_type_int64_t *to_int64)
Definition: db_value.c:387
int db_value_from_text(db_value_t *value, const char *from_text)
Definition: db_value.c:531
int db_value_copy(db_value_t *value, const db_value_t *from_value)
Definition: db_value.c:77
int db_value_cmp(const db_value_t *value_a, const db_value_t *value_b, int *result)
Definition: db_value.c:102
size_t db_value_set_size(const db_value_set_t *value_set)
Definition: db_value.c:734
int db_value_to_uint32(const db_value_t *value, db_type_uint32_t *to_uint32)
Definition: db_value.c:372
db_value_t * db_value_new()
Definition: db_value.c:40
int db_value_to_text(const db_value_t *value, char **to_text)
Definition: db_value.c:417
void db_value_free(db_value_t *value)
Definition: db_value.c:51
int db_value_not_empty(const db_value_t *value)
Definition: db_value.c:347
int db_value_to_uint64(const db_value_t *value, db_type_uint64_t *to_uint64)
Definition: db_value.c:402
void db_value_reset(db_value_t *value)
Definition: db_value.c:60
const char * db_value_text(const db_value_t *value)
Definition: db_value.c:321
db_object_t * dbo
db_value_t * rev
db_result_list_t * result_list
db_object_t * dbo
db_value_t * id
int init_suite_database_operations_mysql(void)
int test_list_get(test_list_t *test_list)
void test_free(test_t *test)
void test_database_operations_create_object3_2(void)
int test_get_by_id(test_t *test, const db_value_t *id)
void test_database_operations_count(void)
const char * test_name(const test_t *test)
const char * test2_name(const test2_t *test2)
void test_database_operations_create_object2_2(void)
int test_delete(test_t *test)
int test2_create(test2_t *test2)
db_object_t * __test2_new_object(const db_connection_t *connection)
test_t * test_new(const db_connection_t *connection)
void __check_id(const db_value_t *id, int id_int, const char *id_text)
void test_database_operations_create_object3(void)
void test_database_operations_delete_object3(void)
void test_database_operations_delete_object2(void)
void test_database_operations_read_object1(void)
void test_database_operations_update_object2(void)
int test_get_by_name(test_t *test, const char *name)
int test2_update(test2_t *test2)
int test_update(test_t *test)
void test_database_operations_create_object2(void)
void test_database_operations_read_object1_2(void)
int test_set_name(test_t *test, const char *name)
const test_t * test_list_begin(test_list_t *test_list)
const db_value_t * test_id(const test_t *test)
const db_value_t * test2_id(const test2_t *test2)
void test2_free(test2_t *test2)
void test_database_operations_read_object2_2(void)
int clean_suite_database_operations(void)
int test_from_result(test_t *test, const db_result_t *result)
test_list_t * test_list_new(const db_connection_t *connection)
void test_database_operations_read_all(void)
size_t test_count_by_id(test_t *test, const db_value_t *id)
void test_database_operations_update_objects_revisions(void)
int test2_get_by_name(test2_t *test2, const char *name)
const test_t * test_list_next(test_list_t *test_list)
void test_database_operations_update_object2_2(void)
int test2_get_by_id(test2_t *test2, const db_value_t *id)
int test2_delete(test2_t *test2)
void test_database_operations_delete_object3_2(void)
test2_t * test2_new(const db_connection_t *connection)
db_object_t * __test_new_object(const db_connection_t *connection)
void test_list_free(test_list_t *test_list)
void test_database_operations_read_object2(void)
int test2_from_result(test2_t *test2, const db_result_t *result)
void test_database_operations_delete_object2_2(void)
int test_create(test_t *test)
size_t test_count_by_name(test_t *test, const char *name)
int test2_set_name(test2_t *test2, const char *name)