lib/ldb/tests/ldb_key_value_sub_txn_test.c

   1 /*
   2  * Tests exercising the ldb key value operations.
   3  *
   4  *  Copyright (C) Andrew Bartlett <abartlet@samba.org> 2018
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 /*
  22  * from cmocka.c:
  23  * These headers or their equivalents should be included prior to
  24  * including
  25  * this header file.
  26  *
  27  * #include <stdarg.h>
  28  * #include <stddef.h>
  29  * #include <setjmp.h>
  30  *
  31  * This allows test applications to use custom definitions of C standard
  32  * library functions and types.
  33  *
  34  */
  35
  36 /*
  37  */
  38 #include <stdarg.h>
  39 #include <stddef.h>
  40 #include <setjmp.h>
  41 #include <cmocka.h>
  42
  43 #include <limits.h>
  44 #define NO_FAILURE INT_MAX
  45 #define FAILURE_LDB_ERR LDB_ERR_OTHER
  46
  47 /*
  48  * To test failure in ldb_kv_add, ldb_kv_delete, ldb_kv_modify and ldb_kv_rename
  49  * we use the following global variables and macros to trigger a failure in
  50  * the ldb_kv_<op>_internal functions. This allows testing of the sub
  51  * transaction commits and roll backs in those operations.
  52  *
  53  * NOTE: Not all back ends support nested/sub transactions
  54  */
  55 int cmocka_unit_test_fail_add_internal_after = NO_FAILURE;
  56 #define CMOCKA_UNIT_TEST_ADD_INTERNAL_FAIL \
  57         {\
  58                 cmocka_unit_test_fail_add_internal_after--;\
  59                 if (cmocka_unit_test_fail_add_internal_after <= 0) {\
  60                         assert_int_equal(LDB_SUCCESS, ret);\
  61                         ret = FAILURE_LDB_ERR;\
  62                 }\
  63         }\
  64
  65 int cmocka_unit_test_fail_delete_internal_after = NO_FAILURE;
  66 #define CMOCKA_UNIT_TEST_DELETE_INTERNAL_FAIL \
  67         {\
  68                 cmocka_unit_test_fail_delete_internal_after--;\
  69                 if (cmocka_unit_test_fail_delete_internal_after <= 0) {\
  70                         assert_int_equal(LDB_SUCCESS, ret);\
  71                         ret = FAILURE_LDB_ERR;\
  72                 }\
  73         }\
  74
  75 int cmocka_unit_test_fail_rename_internal_after = NO_FAILURE;
  76 #define CMOCKA_UNIT_TEST_RENAME_INTERNAL_FAIL \
  77         {\
  78                 cmocka_unit_test_fail_rename_internal_after--;\
  79                 if (cmocka_unit_test_fail_rename_internal_after <= 0) {\
  80                         assert_int_equal(LDB_SUCCESS, ret);\
  81                         ret = FAILURE_LDB_ERR;\
  82                 }\
  83         }\
  84
  85 int cmocka_unit_test_fail_modify_internal_after = NO_FAILURE;
  86 #define CMOCKA_UNIT_TEST_MODIFY_INTERNAL_FAIL \
  87         {\
  88                 cmocka_unit_test_fail_modify_internal_after--;\
  89                 if (cmocka_unit_test_fail_modify_internal_after <= 0) {\
  90                         assert_int_equal(LDB_SUCCESS, ret);\
  91                         ret = FAILURE_LDB_ERR;\
  92                 }\
  93         }\
  94
  95 #include "ldb_key_value/ldb_kv.c"
  96
  97
  98 #define DEFAULT_BE  "tdb"
  99
 100 #ifndef TEST_BE
 101 #define TEST_BE DEFAULT_BE
 102 #endif /* TEST_BE */
 103
 104 #define NUM_RECS 1024
 105
 106
 107 struct test_ctx {
 108         struct tevent_context *ev;
 109         struct ldb_context *ldb;
 110
 111         const char *dbfile;
 112         const char *lockfile;   /* lockfile is separate */
 113
 114         const char *dbpath;
 115 };
 116
 117 /*
 118  * Remove the database files
 119  */
 120 static void unlink_old_db(struct test_ctx *test_ctx)
 121 {
 122         int ret;
 123
 124         errno = 0;
 125         ret = unlink(test_ctx->lockfile);
 126         if (ret == -1 && errno != ENOENT) {
 127                 fail();
 128         }
 129
 130         errno = 0;
 131         ret = unlink(test_ctx->dbfile);
 132         if (ret == -1 && errno != ENOENT) {
 133                 fail();
 134         }
 135 }
 136
 137 /*
 138  * Test setup
 139  */
 140 static int noconn_setup(void **state)
 141 {
 142         struct test_ctx *test_ctx;
 143         cmocka_unit_test_fail_add_internal_after = NO_FAILURE;
 144         cmocka_unit_test_fail_delete_internal_after = NO_FAILURE;
 145         cmocka_unit_test_fail_rename_internal_after = NO_FAILURE;
 146         cmocka_unit_test_fail_modify_internal_after = NO_FAILURE;
 147
 148         test_ctx = talloc_zero(NULL, struct test_ctx);
 149         assert_non_null(test_ctx);
 150
 151         test_ctx->ev = tevent_context_init(test_ctx);
 152         assert_non_null(test_ctx->ev);
 153
 154         test_ctx->ldb = ldb_init(test_ctx, test_ctx->ev);
 155         assert_non_null(test_ctx->ldb);
 156
 157         test_ctx->dbfile = talloc_strdup(test_ctx, "kvopstest.ldb");
 158         assert_non_null(test_ctx->dbfile);
 159
 160         test_ctx->lockfile = talloc_asprintf(test_ctx, "%s-lock",
 161                                              test_ctx->dbfile);
 162         assert_non_null(test_ctx->lockfile);
 163
 164         test_ctx->dbpath = talloc_asprintf(test_ctx,
 165                         TEST_BE"://%s", test_ctx->dbfile);
 166         assert_non_null(test_ctx->dbpath);
 167
 168         unlink_old_db(test_ctx);
 169         *state = test_ctx;
 170         return 0;
 171 }
 172
 173 /*
 174  * Test teardown
 175  */
 176 static int noconn_teardown(void **state)
 177 {
 178         struct test_ctx *test_ctx = talloc_get_type_abort(*state,
 179                                                           struct test_ctx);
 180
 181         unlink_old_db(test_ctx);
 182         talloc_free(test_ctx);
 183         return 0;
 184 }
 185
 186 /*
 187  * Test setup
 188  */
 189 static int setup(void **state)
 190 {
 191         struct test_ctx *test_ctx;
 192         int ret;
 193         struct ldb_ldif *ldif;
 194         const char *index_ldif =                \
 195                 "dn: @INDEXLIST\n"
 196                 "@IDXGUID: objectUUID\n"
 197                 "@IDX_DN_GUID: GUID\n"
 198                 "\n";
 199
 200         noconn_setup((void **) &test_ctx);
 201
 202         ret = ldb_connect(test_ctx->ldb, test_ctx->dbpath, 0, NULL);
 203         assert_int_equal(ret, 0);
 204
 205         while ((ldif = ldb_ldif_read_string(test_ctx->ldb, &index_ldif))) {
 206                 ret = ldb_add(test_ctx->ldb, ldif->msg);
 207                 assert_int_equal(ret, LDB_SUCCESS);
 208         }
 209         *state = test_ctx;
 210         return 0;
 211 }
 212
 213 /*
 214  * Test teardown
 215  */
 216 static int teardown(void **state)
 217 {
 218         struct test_ctx *test_ctx = talloc_get_type_abort(*state,
 219                                                           struct test_ctx);
 220         noconn_teardown((void **) &test_ctx);
 221         return 0;
 222 }
 223
 224 /*
 225  * Build an ldb_kv_context that can be passed to the ldb_kv operation under test
 226  */
 227 static struct ldb_kv_context* build_ldb_kv_context(
 228         TALLOC_CTX *ctx,
 229         struct ldb_module *module,
 230         struct ldb_request *req)
 231 {
 232         struct ldb_kv_context *ldb_kv_ctx = NULL;
 233
 234         ldb_kv_ctx = talloc_zero(ctx, struct ldb_kv_context);
 235         assert_non_null(ldb_kv_ctx);
 236
 237         ldb_kv_ctx->module = module;
 238         ldb_kv_ctx->req = req;
 239
 240         return ldb_kv_ctx;
 241 }
 242
 243 /*
 244  * Build an add request
 245  */
 246 static struct ldb_request *build_add_request(
 247         TALLOC_CTX *ctx,
 248         struct ldb_context *ldb,
 249         const char* dc,
 250         const char* uuid,
 251         const char* cn)
 252 {
 253         int ret;
 254         struct ldb_message *msg;
 255         struct ldb_request *req;
 256
 257         msg = ldb_msg_new(ctx);
 258         assert_non_null(msg);
 259
 260         msg->dn = ldb_dn_new_fmt(msg, ldb, "dc=%s", dc);
 261         assert_non_null(msg->dn);
 262
 263         ret = ldb_msg_add_string(msg, "cn", cn);
 264         assert_int_equal(ret, 0);
 265
 266         ret = ldb_msg_add_string(msg, "objectUUID", uuid);
 267         assert_int_equal(ret, 0);
 268
 269         ret = ldb_msg_sanity_check(ldb, msg);
 270         assert_int_equal(ret, LDB_SUCCESS);
 271
 272         ret = ldb_build_add_req(
 273             &req, ldb, ldb, msg, NULL, NULL, ldb_op_default_callback, NULL);
 274         assert_int_equal(ret, LDB_SUCCESS);
 275         return req;
 276 }
 277
 278 /*
 279  * Build a delete request
 280  */
 281 static struct ldb_request *build_delete_request(
 282         TALLOC_CTX *ctx,
 283         struct ldb_context *ldb,
 284         const char* dc)
 285 {
 286         int ret = LDB_SUCCESS;
 287         struct ldb_dn *dn = NULL;
 288         struct ldb_request *req = NULL;
 289
 290         dn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", dc);
 291         assert_non_null(dn);
 292
 293         ret = ldb_build_del_req(
 294             &req, ldb, ctx, dn, NULL, NULL, ldb_op_default_callback, NULL);
 295         assert_int_equal(ret, LDB_SUCCESS);
 296         return req;
 297 }
 298
 299 /*
 300  * Build a rename request
 301  */
 302 static struct ldb_request *build_rename_request(
 303         TALLOC_CTX *ctx,
 304         struct ldb_context *ldb,
 305         const char* old_dc,
 306         const char* new_dc)
 307 {
 308         int ret = LDB_SUCCESS;
 309         struct ldb_dn *old_dn = NULL;
 310         struct ldb_dn *new_dn = NULL;
 311         struct ldb_request *req = NULL;
 312
 313         old_dn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", old_dc);
 314         assert_non_null(old_dn);
 315
 316         new_dn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", new_dc);
 317         assert_non_null(new_dn);
 318
 319         ret = ldb_build_rename_req(
 320                 &req,
 321                 ldb,
 322                 ctx,
 323                 old_dn,
 324                 new_dn,
 325                 NULL,
 326                 NULL,
 327                 ldb_op_default_callback,
 328                 NULL);
 329         assert_int_equal(ret, LDB_SUCCESS);
 330         return req;
 331 }
 332
 333 /*
 334  * Build a ldb modify request
 335  */
 336 static struct ldb_request *build_modify_request(
 337         TALLOC_CTX *ctx,
 338         struct ldb_context *ldb,
 339         const char* dc,
 340         const char* cn)
 341 {
 342         int ret;
 343         struct ldb_message *msg;
 344         struct ldb_request *req;
 345
 346         msg = ldb_msg_new(ctx);
 347         assert_non_null(msg);
 348
 349         msg->dn = ldb_dn_new_fmt(msg, ldb, "dc=%s", dc);
 350         assert_non_null(msg->dn);
 351
 352         ret = ldb_msg_add_empty(msg, "cn", LDB_FLAG_MOD_REPLACE, NULL);
 353         assert_int_equal(ret, LDB_SUCCESS);
 354         ret = ldb_msg_add_string(msg, "cn", cn);
 355         assert_int_equal(ret, LDB_SUCCESS);
 356
 357         ret = ldb_msg_sanity_check(ldb, msg);
 358         assert_int_equal(ret, LDB_SUCCESS);
 359
 360         ret = ldb_build_mod_req(
 361             &req, ldb, ldb, msg, NULL, NULL, ldb_op_default_callback, NULL);
 362         assert_int_equal(ret, LDB_SUCCESS);
 363         return req;
 364 }
 365
 366 /*
 367  * Delete a record from the database
 368  */
 369 static void delete_record(
 370         TALLOC_CTX *ctx,
 371         struct ldb_context *ldb,
 372         const char* dc)
 373 {
 374         struct ldb_kv_context *ldb_kv_ctx = NULL;
 375         struct ldb_dn *basedn = NULL;
 376         struct ldb_result *result = NULL;
 377         struct ldb_request *req = NULL;
 378         int ret = LDB_SUCCESS;
 379
 380         req = build_delete_request(ctx, ldb, dc);
 381         ldb_kv_ctx = build_ldb_kv_context(ctx, ldb->modules, req);
 382
 383         ret = ldb_transaction_start(ldb);
 384         assert_int_equal(ret, LDB_SUCCESS);
 385
 386         cmocka_unit_test_fail_delete_internal_after = NO_FAILURE;
 387         cmocka_unit_test_fail_modify_internal_after = NO_FAILURE;
 388         ret = ldb_kv_delete(ldb_kv_ctx);
 389         assert_int_equal(ret, LDB_SUCCESS);
 390         TALLOC_FREE(ldb_kv_ctx);
 391         TALLOC_FREE(req);
 392
 393         ret = ldb_transaction_commit(ldb);
 394         assert_int_equal(ret, LDB_SUCCESS);
 395
 396         /*
 397          * Ensure that the record was actually deleted.
 398          */
 399         basedn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", dc);
 400         assert_non_null(basedn);
 401
 402         /*
 403          * DN search, indexed
 404          */
 405         ret = ldb_search(ldb, ctx, &result, basedn, LDB_SCOPE_BASE, NULL, NULL);
 406         assert_int_equal(ret, LDB_SUCCESS);
 407         assert_non_null(result);
 408         assert_int_equal(result->count, 0);
 409         TALLOC_FREE(basedn);
 410         TALLOC_FREE(result);
 411 }
 412
 413 /*
 414  * Add a record to the database
 415  */
 416 static void add_record(
 417         TALLOC_CTX *ctx,
 418         struct ldb_context *ldb,
 419         const char* dc,
 420         const char* uuid,
 421         const char* cn)
 422 {
 423
 424         struct ldb_request *req = NULL;
 425         int ret = LDB_SUCCESS;
 426         struct ldb_kv_context *ldb_kv_ctx = NULL;
 427         struct ldb_dn *basedn = NULL;
 428         struct ldb_result *result = NULL;
 429
 430         req = build_add_request(ctx, ldb, dc, uuid, cn);
 431
 432         ldb_req_set_location(req, "add_record");
 433
 434         assert_int_equal(ret, LDB_SUCCESS);
 435
 436
 437         ldb_kv_ctx = build_ldb_kv_context(ctx, ldb->modules, req);
 438         cmocka_unit_test_fail_add_internal_after = NO_FAILURE;
 439         cmocka_unit_test_fail_modify_internal_after = NO_FAILURE;
 440
 441         ret = ldb_transaction_start(ldb);
 442         assert_int_equal(ret, LDB_SUCCESS);
 443
 444         ret = ldb_kv_add(ldb_kv_ctx);
 445         assert_int_equal(ret, LDB_SUCCESS);
 446         TALLOC_FREE(ldb_kv_ctx);
 447         TALLOC_FREE(req);
 448
 449         ret = ldb_transaction_commit(ldb);
 450         assert_int_equal(ret, LDB_SUCCESS);
 451
 452         /*
 453          * Ensure that the record was actually written.
 454          */
 455         basedn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", dc);
 456         assert_non_null(basedn);
 457
 458         /*
 459          * DN search, indexed
 460          */
 461         ret = ldb_search(ldb, ctx, &result, basedn, LDB_SCOPE_BASE, NULL, NULL);
 462         assert_int_equal(ret, LDB_SUCCESS);
 463         assert_non_null(result);
 464         assert_int_equal(result->count, 1);
 465         TALLOC_FREE(result);
 466
 467
 468         /*
 469          * CN search unindexed
 470          */
 471         ret = ldb_search(
 472                 ldb,
 473                 ctx,
 474                 &result,
 475                 basedn,
 476                 LDB_SCOPE_SUBTREE,
 477                 NULL,
 478                 "(cn=%s)",
 479                 cn);
 480         assert_int_equal(ret, LDB_SUCCESS);
 481         assert_non_null(result);
 482         assert_int_equal(result->count, 1);
 483         TALLOC_FREE(result);
 484         TALLOC_FREE(basedn);
 485 }
 486
 487 /*
 488  * Test that a failed add operation does not change the database.
 489  */
 490 static void test_add_failure(void **state)
 491 {
 492         int ret = LDB_SUCCESS;
 493         struct test_ctx *test_ctx = talloc_get_type_abort(*state,
 494                                                           struct test_ctx);
 495         struct ldb_request *req = NULL;
 496         struct ldb_dn *basedn = NULL;
 497         struct ldb_result *result = NULL;
 498         struct ldb_kv_context *ldb_kv_ctx = NULL;
 499
 500         TALLOC_CTX *tmp_ctx = talloc_new(test_ctx);
 501         assert_non_null(tmp_ctx);
 502
 503         req = build_add_request(
 504                 tmp_ctx,
 505                 test_ctx->ldb,
 506                 "test_add_failure",
 507                 "0123456789abcdef",
 508                 "test_add_failure_value");
 509
 510         ldb_req_set_location(req, "test_add_failure");
 511
 512         ldb_kv_ctx = build_ldb_kv_context(tmp_ctx, test_ctx->ldb->modules, req);
 513         cmocka_unit_test_fail_add_internal_after = 1;
 514
 515         ret = ldb_transaction_start(test_ctx->ldb);
 516         assert_int_equal(ret, LDB_SUCCESS);
 517
 518         ret = ldb_kv_add(ldb_kv_ctx);
 519
 520         assert_int_equal(ret, FAILURE_LDB_ERR);
 521         TALLOC_FREE(ldb_kv_ctx);
 522         TALLOC_FREE(req);
 523
 524
 525         /*
 526          * a search for "cn=test_add_failure_value" should fail
 527          * as the transaction containing the operation should have been
 528          * rolled back leaving the database consistent
 529          *
 530          * This should be an un-indexed search so the index caches won't be
 531          * used.
 532          */
 533         basedn = ldb_dn_new_fmt(
 534                 tmp_ctx,
 535                 test_ctx->ldb,
 536                 "dc=%s",
 537                 "test_add_failure");
 538         assert_non_null(basedn);
 539
 540         ret = ldb_search(
 541                 test_ctx->ldb, tmp_ctx,
 542                 &result,
 543                 basedn,
 544                 LDB_SCOPE_SUBTREE,
 545                 NULL,
 546                 "(cn=%s)",
 547                 "test_add_failure_value");
 548         assert_int_equal(ret, LDB_SUCCESS);
 549         assert_non_null(result);
 550         assert_int_equal(result->count, 0);
 551         TALLOC_FREE(basedn);
 552         TALLOC_FREE(result);
 553
 554         ldb_transaction_cancel(test_ctx->ldb);
 555         TALLOC_FREE(tmp_ctx);
 556 }
 557
 558
 559 /*
 560  * Test that a failed delete operation does not modify the database.
 561  */
 562 static void test_delete_failure(void **state)
 563 {
 564         int ret = LDB_SUCCESS;
 565         struct test_ctx *test_ctx = talloc_get_type_abort(*state,
 566                                                           struct test_ctx);
 567         struct ldb_request *req = NULL;
 568         struct ldb_dn *basedn = NULL;
 569         struct ldb_result *result = NULL;
 570         struct ldb_kv_context *ldb_kv_ctx = NULL;
 571
 572         TALLOC_CTX *tmp_ctx = talloc_new(test_ctx);
 573         assert_non_null(tmp_ctx);
 574
 575         add_record(
 576                 tmp_ctx,
 577                 test_ctx->ldb,
 578                 "test_delete_failure",
 579                 "0123456789abcded",
 580                 "test_delete_failure_value");
 581
 582         req = build_delete_request(
 583                 tmp_ctx,
 584                 test_ctx->ldb,
 585                 "test_delete_failure");
 586
 587         ldb_kv_ctx = build_ldb_kv_context(tmp_ctx, test_ctx->ldb->modules, req);
 588         cmocka_unit_test_fail_delete_internal_after = 1;
 589
 590         ret = ldb_transaction_start(test_ctx->ldb);
 591         assert_int_equal(ret, LDB_SUCCESS);
 592
 593         ret = ldb_kv_delete(ldb_kv_ctx);
 594         assert_int_equal(ret, FAILURE_LDB_ERR);
 595         TALLOC_FREE(ldb_kv_ctx);
 596         TALLOC_FREE(req);
 597
 598         /*
 599          * a search for "cn=test_add_failure_value" should succeed
 600          * as the transaction containing the operation should have been
 601          * rolled back leaving the database consistent
 602          *
 603          * This should be an un-indexed search so the index caches won't be
 604          * used.
 605          */
 606         basedn = ldb_dn_new_fmt(
 607                 tmp_ctx,
 608                 test_ctx->ldb,
 609                 "dc=%s",
 610                 "test_delete_failure");
 611         assert_non_null(basedn);
 612
 613         ret = ldb_search(
 614                 test_ctx->ldb, tmp_ctx,
 615                 &result,
 616                 basedn,
 617                 LDB_SCOPE_SUBTREE,
 618                 NULL,
 619                 "(cn=%s)",
 620                 "test_delete_failure_value");
 621         assert_int_equal(ret, LDB_SUCCESS);
 622         assert_non_null(result);
 623         assert_int_equal(result->count, 1);
 624         TALLOC_FREE(basedn);
 625         TALLOC_FREE(result);
 626
 627
 628         ldb_transaction_cancel(test_ctx->ldb);
 629         delete_record(
 630                 tmp_ctx,
 631                 test_ctx->ldb,
 632                 "test_delete_failure");
 633         TALLOC_FREE(tmp_ctx);
 634 }
 635
 636 /*
 637  * Test that a failed rename operation dies not change the database
 638  */
 639 static void test_rename_failure(void **state)
 640 {
 641         int ret = LDB_SUCCESS;
 642         struct test_ctx *test_ctx = talloc_get_type_abort(*state,
 643                                                           struct test_ctx);
 644         struct ldb_request *req = NULL;
 645         struct ldb_dn *basedn = NULL;
 646         struct ldb_result *result = NULL;
 647         struct ldb_kv_context *ldb_kv_ctx = NULL;
 648
 649         TALLOC_CTX *tmp_ctx = talloc_new(test_ctx);
 650         assert_non_null(tmp_ctx);
 651
 652         add_record(
 653                 tmp_ctx,
 654                 test_ctx->ldb,
 655                 "test_rename_failure",
 656                 "0123456789abcdec",
 657                 "test_rename_failure_value");
 658
 659         req = build_rename_request(
 660                 tmp_ctx,
 661                 test_ctx->ldb,
 662                 "test_rename_failure",
 663                 "test_rename_failure_renamed");
 664
 665         ldb_kv_ctx = build_ldb_kv_context(tmp_ctx, test_ctx->ldb->modules, req);
 666         cmocka_unit_test_fail_rename_internal_after = 1;
 667
 668         ret = ldb_transaction_start(test_ctx->ldb);
 669         assert_int_equal(ret, LDB_SUCCESS);
 670
 671         ret = ldb_kv_rename(ldb_kv_ctx);
 672         assert_int_equal(ret, FAILURE_LDB_ERR);
 673         TALLOC_FREE(ldb_kv_ctx);
 674         TALLOC_FREE(req);
 675
 676         /*
 677          * The original record should be present
 678          */
 679         basedn = ldb_dn_new_fmt(
 680                 tmp_ctx,
 681                 test_ctx->ldb,
 682                 "dc=%s",
 683                 "test_rename_failure");
 684         assert_non_null(basedn);
 685
 686         ret = ldb_search(
 687                 test_ctx->ldb, tmp_ctx,
 688                 &result,
 689                 basedn,
 690                 LDB_SCOPE_SUBTREE,
 691                 NULL,
 692                 "(cn=%s)",
 693                 "test_rename_failure_value");
 694         assert_int_equal(ret, LDB_SUCCESS);
 695         assert_non_null(result);
 696         assert_int_equal(result->count, 1);
 697         TALLOC_FREE(basedn);
 698         TALLOC_FREE(result);
 699
 700         /*
 701          * And the renamed record should not be present
 702          */
 703         basedn = ldb_dn_new_fmt(
 704                 tmp_ctx,
 705                 test_ctx->ldb,
 706                 "dc=%s",
 707                 "test_rename_failure_renamed");
 708         assert_non_null(basedn);
 709
 710         ret = ldb_search(
 711                 test_ctx->ldb, tmp_ctx,
 712                 &result,
 713                 basedn,
 714                 LDB_SCOPE_SUBTREE,
 715                 NULL,
 716                 "(cn=%s)",
 717                 "test_rename_failure_value");
 718         assert_int_equal(ret, LDB_SUCCESS);
 719         assert_non_null(result);
 720         assert_int_equal(result->count, 0);
 721         TALLOC_FREE(basedn);
 722         TALLOC_FREE(result);
 723
 724         ldb_transaction_cancel(test_ctx->ldb);
 725         delete_record(
 726                 tmp_ctx,
 727                 test_ctx->ldb,
 728                 "test_rename_failure");
 729         TALLOC_FREE(tmp_ctx);
 730 }
 731
 732 /*
 733  * Test that a failed modification operation does not change the database
 734  */
 735 static void test_modify_failure(void **state)
 736 {
 737         int ret = LDB_SUCCESS;
 738         struct test_ctx *test_ctx = talloc_get_type_abort(*state,
 739                                                           struct test_ctx);
 740         struct ldb_request *req = NULL;
 741         struct ldb_dn *basedn = NULL;
 742         struct ldb_result *result = NULL;
 743         struct ldb_kv_context *ldb_kv_ctx = NULL;
 744
 745         TALLOC_CTX *tmp_ctx = talloc_new(test_ctx);
 746         assert_non_null(tmp_ctx);
 747
 748         add_record(
 749                 tmp_ctx,
 750                 test_ctx->ldb,
 751                 "test_modify_failure",
 752                 "0123456789abcdeb",
 753                 "test_modify_failure_value");
 754
 755         req = build_modify_request(
 756                 tmp_ctx,
 757                 test_ctx->ldb,
 758                 "test_modify_failure",
 759                 "test_modify_failure_value_modified");
 760
 761         ldb_kv_ctx = build_ldb_kv_context(tmp_ctx, test_ctx->ldb->modules, req);
 762         cmocka_unit_test_fail_modify_internal_after = 2;
 763
 764         ret = ldb_transaction_start(test_ctx->ldb);
 765         assert_int_equal(ret, LDB_SUCCESS);
 766
 767         ret = ldb_kv_modify(ldb_kv_ctx);
 768         assert_int_equal(ret, FAILURE_LDB_ERR);
 769         TALLOC_FREE(ldb_kv_ctx);
 770         TALLOC_FREE(req);
 771
 772
 773         /*
 774          * The original value should be present
 775          */
 776         basedn = ldb_dn_new_fmt(
 777                 tmp_ctx,
 778                 test_ctx->ldb,
 779                 "dc=%s",
 780                 "test_modify_failure");
 781         assert_non_null(basedn);
 782
 783         ret = ldb_search(
 784                 test_ctx->ldb, tmp_ctx,
 785                 &result,
 786                 basedn,
 787                 LDB_SCOPE_SUBTREE,
 788                 NULL,
 789                 "(cn=%s)",
 790                 "test_modify_failure_value");
 791         assert_int_equal(ret, LDB_SUCCESS);
 792         assert_non_null(result);
 793         assert_int_equal(result->count, 1);
 794         TALLOC_FREE(result);
 795
 796         /*
 797          * And the modified record should not be present
 798          */
 799         ret = ldb_search(
 800                 test_ctx->ldb, tmp_ctx,
 801                 &result,
 802                 basedn,
 803                 LDB_SCOPE_SUBTREE,
 804                 NULL,
 805                 "(cn=%s)",
 806                 "test_modify_failure_value_modified");
 807         assert_int_equal(ret, LDB_SUCCESS);
 808         assert_non_null(result);
 809         assert_int_equal(result->count, 0);
 810         TALLOC_FREE(basedn);
 811         TALLOC_FREE(result);
 812
 813         ldb_transaction_cancel(test_ctx->ldb);
 814         delete_record(
 815                 tmp_ctx,
 816                 test_ctx->ldb,
 817                 "test_modify_failure");
 818         TALLOC_FREE(tmp_ctx);
 819 }
 820
 821 int main(int argc, const char **argv)
 822 {
 823         const struct CMUnitTest tests[] = {
 824                 cmocka_unit_test_setup_teardown(
 825                         test_add_failure,
 826                         setup,
 827                         teardown),
 828                 cmocka_unit_test_setup_teardown(
 829                         test_delete_failure,
 830                         setup,
 831                         teardown),
 832                 cmocka_unit_test_setup_teardown(
 833                         test_rename_failure,
 834                         setup,
 835                         teardown),
 836                 cmocka_unit_test_setup_teardown(
 837                         test_modify_failure,
 838                         setup,
 839                         teardown),
 840         };
 841
 842         return cmocka_run_group_tests(tests, NULL, NULL);
 843 }