/*
 * Tests exercising the ldb key value operations.
 *
 *  Copyright (C) Andrew Bartlett <abartlet@samba.org> 2018
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * from cmocka.c:
 * These headers or their equivalents should be included prior to
 * including
 * this header file.
 *
 * #include <stdarg.h>
 * #include <stddef.h>
 * #include <setjmp.h>
 *
 * This allows test applications to use custom definitions of C standard
 * library functions and types.
 *
 */

/*
 */
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>

#include <limits.h>
#define NO_FAILURE INT_MAX
#define FAILURE_LDB_ERR LDB_ERR_OTHER

/*
 * To test failure in ldb_kv_add, ldb_kv_delete, ldb_kv_modify and ldb_kv_rename
 * we use the following global variables and macros to trigger a failure in
 * the ldb_kv_<op>_internal functions. This allows testing of the sub
 * transaction commits and roll backs in those operations.
 *
 * NOTE: Not all back ends support nested/sub transactions
 */
int cmocka_unit_test_fail_add_internal_after = NO_FAILURE;
#define CMOCKA_UNIT_TEST_ADD_INTERNAL_FAIL \
	{\
		cmocka_unit_test_fail_add_internal_after--;\
		if (cmocka_unit_test_fail_add_internal_after <= 0) {\
			assert_int_equal(LDB_SUCCESS, ret);\
			ret = FAILURE_LDB_ERR;\
		}\
	}\

int cmocka_unit_test_fail_delete_internal_after = NO_FAILURE;
#define CMOCKA_UNIT_TEST_DELETE_INTERNAL_FAIL \
	{\
		cmocka_unit_test_fail_delete_internal_after--;\
		if (cmocka_unit_test_fail_delete_internal_after <= 0) {\
			assert_int_equal(LDB_SUCCESS, ret);\
			ret = FAILURE_LDB_ERR;\
		}\
	}\

int cmocka_unit_test_fail_rename_internal_after = NO_FAILURE;
#define CMOCKA_UNIT_TEST_RENAME_INTERNAL_FAIL \
	{\
		cmocka_unit_test_fail_rename_internal_after--;\
		if (cmocka_unit_test_fail_rename_internal_after <= 0) {\
			assert_int_equal(LDB_SUCCESS, ret);\
			ret = FAILURE_LDB_ERR;\
		}\
	}\

int cmocka_unit_test_fail_modify_internal_after = NO_FAILURE;
#define CMOCKA_UNIT_TEST_MODIFY_INTERNAL_FAIL \
	{\
		cmocka_unit_test_fail_modify_internal_after--;\
		if (cmocka_unit_test_fail_modify_internal_after <= 0) {\
			assert_int_equal(LDB_SUCCESS, ret);\
			ret = FAILURE_LDB_ERR;\
		}\
	}\

#include "ldb_key_value/ldb_kv.c"


#define DEFAULT_BE  "tdb"

#ifndef TEST_BE
#define TEST_BE DEFAULT_BE
#endif /* TEST_BE */

#define NUM_RECS 1024


struct test_ctx {
	struct tevent_context *ev;
	struct ldb_context *ldb;

	const char *dbfile;
	const char *lockfile;   /* lockfile is separate */

	const char *dbpath;
};

/*
 * Remove the database files
 */
static void unlink_old_db(struct test_ctx *test_ctx)
{
	int ret;

	errno = 0;
	ret = unlink(test_ctx->lockfile);
	if (ret == -1 && errno != ENOENT) {
		fail();
	}

	errno = 0;
	ret = unlink(test_ctx->dbfile);
	if (ret == -1 && errno != ENOENT) {
		fail();
	}
}

/*
 * Test setup
 */
static int noconn_setup(void **state)
{
	struct test_ctx *test_ctx;
	cmocka_unit_test_fail_add_internal_after = NO_FAILURE;
	cmocka_unit_test_fail_delete_internal_after = NO_FAILURE;
	cmocka_unit_test_fail_rename_internal_after = NO_FAILURE;
	cmocka_unit_test_fail_modify_internal_after = NO_FAILURE;

	test_ctx = talloc_zero(NULL, struct test_ctx);
	assert_non_null(test_ctx);

	test_ctx->ev = tevent_context_init(test_ctx);
	assert_non_null(test_ctx->ev);

	test_ctx->ldb = ldb_init(test_ctx, test_ctx->ev);
	assert_non_null(test_ctx->ldb);

	test_ctx->dbfile = talloc_strdup(test_ctx, "kvopstest.ldb");
	assert_non_null(test_ctx->dbfile);

	test_ctx->lockfile = talloc_asprintf(test_ctx, "%s-lock",
					     test_ctx->dbfile);
	assert_non_null(test_ctx->lockfile);

	test_ctx->dbpath = talloc_asprintf(test_ctx,
			TEST_BE"://%s", test_ctx->dbfile);
	assert_non_null(test_ctx->dbpath);

	unlink_old_db(test_ctx);
	*state = test_ctx;
	return 0;
}

/*
 * Test teardown
 */
static int noconn_teardown(void **state)
{
	struct test_ctx *test_ctx = talloc_get_type_abort(*state,
							  struct test_ctx);

	unlink_old_db(test_ctx);
	talloc_free(test_ctx);
	return 0;
}

/*
 * Test setup
 */
static int setup(void **state)
{
	struct test_ctx *test_ctx;
	int ret;
	struct ldb_ldif *ldif;
	const char *index_ldif =		\
		"dn: @INDEXLIST\n"
		"@IDXGUID: objectUUID\n"
		"@IDX_DN_GUID: GUID\n"
		"\n";

	noconn_setup((void **) &test_ctx);

	ret = ldb_connect(test_ctx->ldb, test_ctx->dbpath, 0, NULL);
	assert_int_equal(ret, 0);

	while ((ldif = ldb_ldif_read_string(test_ctx->ldb, &index_ldif))) {
		ret = ldb_add(test_ctx->ldb, ldif->msg);
		assert_int_equal(ret, LDB_SUCCESS);
	}
	*state = test_ctx;
	return 0;
}

/*
 * Test teardown
 */
static int teardown(void **state)
{
	struct test_ctx *test_ctx = talloc_get_type_abort(*state,
							  struct test_ctx);
	noconn_teardown((void **) &test_ctx);
	return 0;
}

/*
 * Build an ldb_kv_context that can be passed to the ldb_kv operation under test
 */
static struct ldb_kv_context* build_ldb_kv_context(
	TALLOC_CTX *ctx,
	struct ldb_module *module,
	struct ldb_request *req)
{
	struct ldb_kv_context *ldb_kv_ctx = NULL;

	ldb_kv_ctx = talloc_zero(ctx, struct ldb_kv_context);
	assert_non_null(ldb_kv_ctx);

	ldb_kv_ctx->module = module;
	ldb_kv_ctx->req = req;

	return ldb_kv_ctx;
}

/*
 * Build an add request
 */
static struct ldb_request *build_add_request(
	TALLOC_CTX *ctx,
	struct ldb_context *ldb,
	const char* dc,
	const char* uuid,
	const char* cn)
{
	int ret;
	struct ldb_message *msg;
	struct ldb_request *req;

	msg = ldb_msg_new(ctx);
	assert_non_null(msg);

	msg->dn = ldb_dn_new_fmt(msg, ldb, "dc=%s", dc);
	assert_non_null(msg->dn);

	ret = ldb_msg_add_string(msg, "cn", cn);
	assert_int_equal(ret, 0);

	ret = ldb_msg_add_string(msg, "objectUUID", uuid);
	assert_int_equal(ret, 0);

	ret = ldb_msg_sanity_check(ldb, msg);
	assert_int_equal(ret, LDB_SUCCESS);

	ret = ldb_build_add_req(
	    &req, ldb, ldb, msg, NULL, NULL, ldb_op_default_callback, NULL);
	assert_int_equal(ret, LDB_SUCCESS);
	return req;
}

/*
 * Build a delete request
 */
static struct ldb_request *build_delete_request(
	TALLOC_CTX *ctx,
	struct ldb_context *ldb,
	const char* dc)
{
	int ret = LDB_SUCCESS;
	struct ldb_dn *dn = NULL;
	struct ldb_request *req = NULL;

	dn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", dc);
	assert_non_null(dn);

	ret = ldb_build_del_req(
	    &req, ldb, ctx, dn, NULL, NULL, ldb_op_default_callback, NULL);
	assert_int_equal(ret, LDB_SUCCESS);
	return req;
}

/*
 * Build a rename request
 */
static struct ldb_request *build_rename_request(
	TALLOC_CTX *ctx,
	struct ldb_context *ldb,
	const char* old_dc,
	const char* new_dc)
{
	int ret = LDB_SUCCESS;
	struct ldb_dn *old_dn = NULL;
	struct ldb_dn *new_dn = NULL;
	struct ldb_request *req = NULL;

	old_dn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", old_dc);
	assert_non_null(old_dn);

	new_dn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", new_dc);
	assert_non_null(new_dn);

	ret = ldb_build_rename_req(
		&req,
		ldb,
		ctx,
		old_dn,
		new_dn,
		NULL,
		NULL,
		ldb_op_default_callback,
		NULL);
	assert_int_equal(ret, LDB_SUCCESS);
	return req;
}

/*
 * Build a ldb modify request
 */
static struct ldb_request *build_modify_request(
	TALLOC_CTX *ctx,
	struct ldb_context *ldb,
	const char* dc,
	const char* cn)
{
	int ret;
	struct ldb_message *msg;
	struct ldb_request *req;

	msg = ldb_msg_new(ctx);
	assert_non_null(msg);

	msg->dn = ldb_dn_new_fmt(msg, ldb, "dc=%s", dc);
	assert_non_null(msg->dn);

	ret = ldb_msg_add_empty(msg, "cn", LDB_FLAG_MOD_REPLACE, NULL);
	assert_int_equal(ret, LDB_SUCCESS);
	ret = ldb_msg_add_string(msg, "cn", cn);
	assert_int_equal(ret, LDB_SUCCESS);

	ret = ldb_msg_sanity_check(ldb, msg);
	assert_int_equal(ret, LDB_SUCCESS);

	ret = ldb_build_mod_req(
	    &req, ldb, ldb, msg, NULL, NULL, ldb_op_default_callback, NULL);
	assert_int_equal(ret, LDB_SUCCESS);
	return req;
}

/*
 * Delete a record from the database
 */
static void delete_record(
	TALLOC_CTX *ctx,
	struct ldb_context *ldb,
	const char* dc)
{
	struct ldb_kv_context *ldb_kv_ctx = NULL;
	struct ldb_dn *basedn = NULL;
	struct ldb_result *result = NULL;
	struct ldb_request *req = NULL;
	int ret = LDB_SUCCESS;

	req = build_delete_request(ctx, ldb, dc);
	ldb_kv_ctx = build_ldb_kv_context(ctx, ldb->modules, req);

	ret = ldb_transaction_start(ldb);
	assert_int_equal(ret, LDB_SUCCESS);

	cmocka_unit_test_fail_delete_internal_after = NO_FAILURE;
	cmocka_unit_test_fail_modify_internal_after = NO_FAILURE;
	ret = ldb_kv_delete(ldb_kv_ctx);
	assert_int_equal(ret, LDB_SUCCESS);
	TALLOC_FREE(ldb_kv_ctx);
	TALLOC_FREE(req);

	ret = ldb_transaction_commit(ldb);
	assert_int_equal(ret, LDB_SUCCESS);

	/*
	 * Ensure that the record was actually deleted.
	 */
	basedn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", dc);
	assert_non_null(basedn);

	/*
	 * DN search, indexed
	 */
	ret = ldb_search(ldb, ctx, &result, basedn, LDB_SCOPE_BASE, NULL, NULL);
	assert_int_equal(ret, LDB_SUCCESS);
	assert_non_null(result);
	assert_int_equal(result->count, 0);
	TALLOC_FREE(basedn);
	TALLOC_FREE(result);
}

/*
 * Add a record to the database
 */
static void add_record(
	TALLOC_CTX *ctx,
	struct ldb_context *ldb,
	const char* dc,
	const char* uuid,
	const char* cn)
{

	struct ldb_request *req = NULL;
	int ret = LDB_SUCCESS;
	struct ldb_kv_context *ldb_kv_ctx = NULL;
	struct ldb_dn *basedn = NULL;
	struct ldb_result *result = NULL;

	req = build_add_request(ctx, ldb, dc, uuid, cn);

	ldb_req_set_location(req, "add_record");

	assert_int_equal(ret, LDB_SUCCESS);


	ldb_kv_ctx = build_ldb_kv_context(ctx, ldb->modules, req);
	cmocka_unit_test_fail_add_internal_after = NO_FAILURE;
	cmocka_unit_test_fail_modify_internal_after = NO_FAILURE;

	ret = ldb_transaction_start(ldb);
	assert_int_equal(ret, LDB_SUCCESS);

	ret = ldb_kv_add(ldb_kv_ctx);
	assert_int_equal(ret, LDB_SUCCESS);
	TALLOC_FREE(ldb_kv_ctx);
	TALLOC_FREE(req);

	ret = ldb_transaction_commit(ldb);
	assert_int_equal(ret, LDB_SUCCESS);

	/*
	 * Ensure that the record was actually written.
	 */
	basedn = ldb_dn_new_fmt(ctx, ldb, "dc=%s", dc);
	assert_non_null(basedn);

	/*
	 * DN search, indexed
	 */
	ret = ldb_search(ldb, ctx, &result, basedn, LDB_SCOPE_BASE, NULL, NULL);
	assert_int_equal(ret, LDB_SUCCESS);
	assert_non_null(result);
	assert_int_equal(result->count, 1);
	TALLOC_FREE(result);


	/*
	 * CN search unindexed
	 */
	ret = ldb_search(
		ldb,
		ctx,
		&result,
		basedn,
		LDB_SCOPE_SUBTREE,
		NULL,
		"(cn=%s)",
		cn);
	assert_int_equal(ret, LDB_SUCCESS);
	assert_non_null(result);
	assert_int_equal(result->count, 1);
	TALLOC_FREE(result);
	TALLOC_FREE(basedn);
}

/*
 * Test that a failed add operation does not change the database.
 */
static void test_add_failure(void **state)
{
	int ret = LDB_SUCCESS;
	struct test_ctx *test_ctx = talloc_get_type_abort(*state,
							  struct test_ctx);
	struct ldb_request *req = NULL;
	struct ldb_dn *basedn = NULL;
	struct ldb_result *result = NULL;
	struct ldb_kv_context *ldb_kv_ctx = NULL;

	TALLOC_CTX *tmp_ctx = talloc_new(test_ctx);
	assert_non_null(tmp_ctx);

	req = build_add_request(
		tmp_ctx,
		test_ctx->ldb,
		"test_add_failure",
		"0123456789abcdef",
		"test_add_failure_value");

	ldb_req_set_location(req, "test_add_failure");

	ldb_kv_ctx = build_ldb_kv_context(tmp_ctx, test_ctx->ldb->modules, req);
	cmocka_unit_test_fail_add_internal_after = 1;

	ret = ldb_transaction_start(test_ctx->ldb);
	assert_int_equal(ret, LDB_SUCCESS);

	ret = ldb_kv_add(ldb_kv_ctx);

	assert_int_equal(ret, FAILURE_LDB_ERR);
	TALLOC_FREE(ldb_kv_ctx);
	TALLOC_FREE(req);


	/*
	 * a search for "cn=test_add_failure_value" should fail
	 * as the transaction containing the operation should have been
	 * rolled back leaving the database consistent
	 *
	 * This should be an un-indexed search so the index caches won't be
	 * used.
	 */
	basedn = ldb_dn_new_fmt(
		tmp_ctx,
		test_ctx->ldb,
		"dc=%s",
		"test_add_failure");
	assert_non_null(basedn);

	ret = ldb_search(
		test_ctx->ldb, tmp_ctx,
		&result,
		basedn,
		LDB_SCOPE_SUBTREE,
		NULL,
		"(cn=%s)",
		"test_add_failure_value");
	assert_int_equal(ret, LDB_SUCCESS);
	assert_non_null(result);
	assert_int_equal(result->count, 0);
	TALLOC_FREE(basedn);
	TALLOC_FREE(result);

	ldb_transaction_cancel(test_ctx->ldb);
	TALLOC_FREE(tmp_ctx);
}


/*
 * Test that a failed delete operation does not modify the database.
 */
static void test_delete_failure(void **state)
{
	int ret = LDB_SUCCESS;
	struct test_ctx *test_ctx = talloc_get_type_abort(*state,
							  struct test_ctx);
	struct ldb_request *req = NULL;
	struct ldb_dn *basedn = NULL;
	struct ldb_result *result = NULL;
	struct ldb_kv_context *ldb_kv_ctx = NULL;

	TALLOC_CTX *tmp_ctx = talloc_new(test_ctx);
	assert_non_null(tmp_ctx);

	add_record(
		tmp_ctx,
		test_ctx->ldb,
		"test_delete_failure",
		"0123456789abcded",
		"test_delete_failure_value");

	req = build_delete_request(
		tmp_ctx,
		test_ctx->ldb,
		"test_delete_failure");

	ldb_kv_ctx = build_ldb_kv_context(tmp_ctx, test_ctx->ldb->modules, req);
	cmocka_unit_test_fail_delete_internal_after = 1;

	ret = ldb_transaction_start(test_ctx->ldb);
	assert_int_equal(ret, LDB_SUCCESS);

	ret = ldb_kv_delete(ldb_kv_ctx);
	assert_int_equal(ret, FAILURE_LDB_ERR);
	TALLOC_FREE(ldb_kv_ctx);
	TALLOC_FREE(req);

	/*
	 * a search for "cn=test_add_failure_value" should succeed
	 * as the transaction containing the operation should have been
	 * rolled back leaving the database consistent
	 *
	 * This should be an un-indexed search so the index caches won't be
	 * used.
	 */
	basedn = ldb_dn_new_fmt(
		tmp_ctx,
		test_ctx->ldb,
		"dc=%s",
		"test_delete_failure");
	assert_non_null(basedn);

	ret = ldb_search(
		test_ctx->ldb, tmp_ctx,
		&result,
		basedn,
		LDB_SCOPE_SUBTREE,
		NULL,
		"(cn=%s)",
		"test_delete_failure_value");
	assert_int_equal(ret, LDB_SUCCESS);
	assert_non_null(result);
	assert_int_equal(result->count, 1);
	TALLOC_FREE(basedn);
	TALLOC_FREE(result);


	ldb_transaction_cancel(test_ctx->ldb);
	delete_record(
		tmp_ctx,
		test_ctx->ldb,
		"test_delete_failure");
	TALLOC_FREE(tmp_ctx);
}

/*
 * Test that a failed rename operation dies not change the database
 */
static void test_rename_failure(void **state)
{
	int ret = LDB_SUCCESS;
	struct test_ctx *test_ctx = talloc_get_type_abort(*state,
							  struct test_ctx);
	struct ldb_request *req = NULL;
	struct ldb_dn *basedn = NULL;
	struct ldb_result *result = NULL;
	struct ldb_kv_context *ldb_kv_ctx = NULL;

	TALLOC_CTX *tmp_ctx = talloc_new(test_ctx);
	assert_non_null(tmp_ctx);

	add_record(
		tmp_ctx,
		test_ctx->ldb,
		"test_rename_failure",
		"0123456789abcdec",
		"test_rename_failure_value");

	req = build_rename_request(
		tmp_ctx,
		test_ctx->ldb,
		"test_rename_failure",
		"test_rename_failure_renamed");

	ldb_kv_ctx = build_ldb_kv_context(tmp_ctx, test_ctx->ldb->modules, req);
	cmocka_unit_test_fail_rename_internal_after = 1;

	ret = ldb_transaction_start(test_ctx->ldb);
	assert_int_equal(ret, LDB_SUCCESS);

	ret = ldb_kv_rename(ldb_kv_ctx);
	assert_int_equal(ret, FAILURE_LDB_ERR);
	TALLOC_FREE(ldb_kv_ctx);
	TALLOC_FREE(req);

	/*
	 * The original record should be present
	 */
	basedn = ldb_dn_new_fmt(
		tmp_ctx,
		test_ctx->ldb,
		"dc=%s",
		"test_rename_failure");
	assert_non_null(basedn);

	ret = ldb_search(
		test_ctx->ldb, tmp_ctx,
		&result,
		basedn,
		LDB_SCOPE_SUBTREE,
		NULL,
		"(cn=%s)",
		"test_rename_failure_value");
	assert_int_equal(ret, LDB_SUCCESS);
	assert_non_null(result);
	assert_int_equal(result->count, 1);
	TALLOC_FREE(basedn);
	TALLOC_FREE(result);

	/*
	 * And the renamed record should not be present
	 */
	basedn = ldb_dn_new_fmt(
		tmp_ctx,
		test_ctx->ldb,
		"dc=%s",
		"test_rename_failure_renamed");
	assert_non_null(basedn);

	ret = ldb_search(
		test_ctx->ldb, tmp_ctx,
		&result,
		basedn,
		LDB_SCOPE_SUBTREE,
		NULL,
		"(cn=%s)",
		"test_rename_failure_value");
	assert_int_equal(ret, LDB_SUCCESS);
	assert_non_null(result);
	assert_int_equal(result->count, 0);
	TALLOC_FREE(basedn);
	TALLOC_FREE(result);

	ldb_transaction_cancel(test_ctx->ldb);
	delete_record(
		tmp_ctx,
		test_ctx->ldb,
		"test_rename_failure");
	TALLOC_FREE(tmp_ctx);
}

/*
 * Test that a failed modification operation does not change the database
 */
static void test_modify_failure(void **state)
{
	int ret = LDB_SUCCESS;
	struct test_ctx *test_ctx = talloc_get_type_abort(*state,
							  struct test_ctx);
	struct ldb_request *req = NULL;
	struct ldb_dn *basedn = NULL;
	struct ldb_result *result = NULL;
	struct ldb_kv_context *ldb_kv_ctx = NULL;

	TALLOC_CTX *tmp_ctx = talloc_new(test_ctx);
	assert_non_null(tmp_ctx);

	add_record(
		tmp_ctx,
		test_ctx->ldb,
		"test_modify_failure",
		"0123456789abcdeb",
		"test_modify_failure_value");

	req = build_modify_request(
		tmp_ctx,
		test_ctx->ldb,
		"test_modify_failure",
		"test_modify_failure_value_modified");

	ldb_kv_ctx = build_ldb_kv_context(tmp_ctx, test_ctx->ldb->modules, req);
	cmocka_unit_test_fail_modify_internal_after = 2;

	ret = ldb_transaction_start(test_ctx->ldb);
	assert_int_equal(ret, LDB_SUCCESS);

	ret = ldb_kv_modify(ldb_kv_ctx);
	assert_int_equal(ret, FAILURE_LDB_ERR);
	TALLOC_FREE(ldb_kv_ctx);
	TALLOC_FREE(req);


	/*
	 * The original value should be present
	 */
	basedn = ldb_dn_new_fmt(
		tmp_ctx,
		test_ctx->ldb,
		"dc=%s",
		"test_modify_failure");
	assert_non_null(basedn);

	ret = ldb_search(
		test_ctx->ldb, tmp_ctx,
		&result,
		basedn,
		LDB_SCOPE_SUBTREE,
		NULL,
		"(cn=%s)",
		"test_modify_failure_value");
	assert_int_equal(ret, LDB_SUCCESS);
	assert_non_null(result);
	assert_int_equal(result->count, 1);
	TALLOC_FREE(result);

	/*
	 * And the modified record should not be present
	 */
	ret = ldb_search(
		test_ctx->ldb, tmp_ctx,
		&result,
		basedn,
		LDB_SCOPE_SUBTREE,
		NULL,
		"(cn=%s)",
		"test_modify_failure_value_modified");
	assert_int_equal(ret, LDB_SUCCESS);
	assert_non_null(result);
	assert_int_equal(result->count, 0);
	TALLOC_FREE(basedn);
	TALLOC_FREE(result);

	ldb_transaction_cancel(test_ctx->ldb);
	delete_record(
		tmp_ctx,
		test_ctx->ldb,
		"test_modify_failure");
	TALLOC_FREE(tmp_ctx);
}

int main(int argc, const char **argv)
{
	const struct CMUnitTest tests[] = {
		cmocka_unit_test_setup_teardown(
			test_add_failure,
			setup,
			teardown),
		cmocka_unit_test_setup_teardown(
			test_delete_failure,
			setup,
			teardown),
		cmocka_unit_test_setup_teardown(
			test_rename_failure,
			setup,
			teardown),
		cmocka_unit_test_setup_teardown(
			test_modify_failure,
			setup,
			teardown),
	};

	return cmocka_run_group_tests(tests, NULL, NULL);
}
