From 1429d88ff0da2bc56130d8580553208d3cfe1029 Mon Sep 17 00:00:00 2001
From: Petr Cech <pcech@redhat.com>
Date: Mon, 9 May 2016 04:03:32 -0400
Subject: [PATCH 2/2] TEST: New tests for negative caching of locals

Negative cache has special timeout for local entities (users, groups).
This patch adds new tests for such behaviour. The tests are based on
cwrap.

Resolves:
https://fedorahosted.org/sssd/ticket/2928
---
 src/tests/cwrap/Makefile.am     |  32 ++
 src/tests/cwrap/group           |   1 +
 src/tests/cwrap/test_negcache.c | 673 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 706 insertions(+)
 create mode 100644 src/tests/cwrap/test_negcache.c

diff --git a/src/tests/cwrap/Makefile.am b/src/tests/cwrap/Makefile.am
index ba30bab6ecc1afbf451707c2af777480cfe6fd0d..44a0bca7899b6a10f853415ba8225a9f0fe27599 100644
--- a/src/tests/cwrap/Makefile.am
+++ b/src/tests/cwrap/Makefile.am
@@ -35,6 +35,20 @@ SSSD_LIBS = \
     $(OPENLDAP_LIBS) \
     $(TDB_LIBS)
 
+SSSD_RESPONDER_OBJ = \
+    ../../../src/responder/common/negcache_files.c \
+    ../../../src/responder/common/negcache.c \
+    ../../../src/responder/common/responder_cmd.c \
+    ../../../src/responder/common/responder_common.c \
+    ../../../src/responder/common/responder_dp.c \
+    ../../../src/responder/common/responder_packet.c \
+    ../../../src/responder/common/responder_get_domains.c \
+    ../../../src/responder/common/responder_utils.c \
+    ../../../src/responder/common/responder_cache_req.c \
+    ../../../src/monitor/monitor_iface_generated.c \
+    ../../../src/providers/data_provider_iface_generated.c \
+    ../../../src/providers/data_provider_req.c
+
 dist_noinst_DATA = \
     group \
     passwd \
@@ -49,6 +63,7 @@ check_PROGRAMS += \
     server-tests \
     usertools-tests \
     responder_common-tests \
+    negcache-tests \
     $(NULL)
 endif # HAVE_UID_WRAPPER
 endif # HAVE_NSS_WRAPPER
@@ -124,4 +139,21 @@ responder_common_tests_LDADD = \
     $(abs_top_builddir)/libsss_test_common.la \
     $(NULL)
 
+negcache_tests_SOURCES =\
+    $(SSSD_RESPONDER_OBJ) \
+    test_negcache.c \
+    $(NULL)
+negcache_tests_CFLAGS = \
+    $(AM_CFLAGS) \
+    -DBASE_FILE_STEM=\"$(*F)\" \
+    $(NULL)
+negcache_tests_LDADD = \
+    $(CMOCKA_LIBS) \
+    $(SSSD_LIBS) \
+    $(SELINUX_LIBS) \
+    $(abs_top_builddir)/libsss_util.la \
+    $(abs_top_builddir)/libsss_debug.la \
+    $(abs_top_builddir)/libsss_test_common.la \
+    $(NULL)
+
 tests: $(check_PROGRAMS)
diff --git a/src/tests/cwrap/group b/src/tests/cwrap/group
index 61e428c41a3df9d18cd216864d90c7f2603e8820..d0cea659ea030d14a293f5d941f473f8f3786886 100644
--- a/src/tests/cwrap/group
+++ b/src/tests/cwrap/group
@@ -1 +1,2 @@
 sssd:x:123:
+foogroup:x:10001:
diff --git a/src/tests/cwrap/test_negcache.c b/src/tests/cwrap/test_negcache.c
new file mode 100644
index 0000000000000000000000000000000000000000..ee6f102dc8e636c88cf02ad2729cf3571751eb02
--- /dev/null
+++ b/src/tests/cwrap/test_negcache.c
@@ -0,0 +1,673 @@
+/*
+    Authors:
+        Petr Čech <pcech@redhat.com>
+
+    Copyright (C) 2016 Red Hat
+
+    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/>.
+*/
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <cmocka.h>
+#include <popt.h>
+
+#include "tests/common.h"
+#include "responder/common/negcache.h"
+#include "responder/common/negcache_files.h"
+#include "responder/common/responder.h"
+
+#define TESTS_PATH "tp_" BASE_FILE_STEM
+#define TEST_CONF_DB "test_sysdb_sudorules.ldb"
+#define TEST_DOM_NAME "test_domain.test"
+
+#define TEST_LOCAL_USER_NAME_1 "foobar"
+#define TEST_LOCAL_USER_NAME_2 "sssd"
+
+#define TEST_LOCAL_USER_UID_1 10001
+#define TEST_LOCAL_USER_UID_2 123
+
+#define TEST_LOCAL_GROUP_NAME_1 "foogroup"
+#define TEST_LOCAL_GROUP_NAME_2 "sssd"
+
+#define TEST_LOCAL_GID_1 10001
+#define TEST_LOCAL_GID_2 123
+
+struct test_user {
+    const char *name;
+    uid_t uid;
+    gid_t gid;
+} users[] = { { "test_user1", 1001, 50001 },
+              { "test_user2", 1002, 50002 } };
+
+static void create_users(struct sss_domain_info *domain)
+{
+    errno_t ret;
+
+    for (int i = 0; i < 2; i++) {
+        ret = sysdb_add_user(domain, users[i].name, users[i].uid, users[i].gid,
+                             users[i].name, NULL, "/bin/bash", domain->name,
+                             NULL, 30, time(NULL));
+        assert_int_equal(ret, EOK);
+    }
+}
+
+struct test_group {
+    const char *name;
+    gid_t gid;
+} groups[] = { { "test_group1", 50001 },
+               { "test_group2", 50002 } };
+
+struct ncache_test_ctx {
+    struct sss_test_ctx *tctx;
+    struct sss_nc_ctx *ncache;
+};
+
+static void create_groups(struct sss_domain_info *domain)
+{
+    errno_t ret;
+
+    for (int i = 0; i < 2; i++) {
+        ret = sysdb_add_group(domain, groups[i].name, groups[i].gid,
+                              NULL, 30, time(NULL));
+        assert_int_equal(ret, EOK);
+    }
+}
+
+/* register_cli_protocol_version is required in test since it links with
+ * responder_common.c module
+ */
+struct cli_protocol_version *register_cli_protocol_version(void)
+{
+    static struct cli_protocol_version responder_test_cli_protocol_version[] = {
+        {0, NULL, NULL}
+    };
+
+    return responder_test_cli_protocol_version;
+}
+
+static int test_ncache_setup(void **state)
+{
+    struct ncache_test_ctx *test_ctx;
+
+    assert_true(leak_check_setup());
+
+    test_ctx = talloc_zero(global_talloc_context, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    test_dom_suite_setup(TESTS_PATH);
+
+    test_ctx->tctx = create_dom_test_ctx(test_ctx, TESTS_PATH, TEST_CONF_DB,
+                                         TEST_DOM_NAME, "ipa", NULL);
+    assert_non_null(test_ctx->tctx);
+
+    create_groups(test_ctx->tctx->dom);
+    create_users(test_ctx->tctx->dom);
+
+    check_leaks_push(test_ctx);
+
+    *state = (void *)test_ctx;
+
+    return 0;
+}
+
+static int test_ncache_teardown(void **state)
+{
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+
+    test_dom_suite_cleanup(TESTS_PATH, TEST_CONF_DB, TEST_DOM_NAME);
+
+    assert_true(check_leaks_pop(test_ctx));
+    talloc_zfree(test_ctx);
+    assert_true(leak_check_teardown());
+
+    return 0;
+}
+
+/* user utils */
+
+static void set_users(struct ncache_test_ctx *test_ctx)
+{
+    int ret;
+
+    ret = sss_ncache_set_user(test_ctx->ncache, false, test_ctx->tctx->dom,
+                              users[0].name);
+    assert_int_equal(ret, EOK);
+
+    ret = sss_ncache_set_user(test_ctx->ncache, false, test_ctx->tctx->dom,
+                              TEST_LOCAL_USER_NAME_1);
+    assert_int_equal(ret, EOK);
+}
+
+static void check_users(struct ncache_test_ctx *test_ctx,
+                        int case_a, int case_b, int case_c, int case_d)
+{
+    int ret;
+
+    ret = sss_ncache_check_user(test_ctx->ncache, test_ctx->tctx->dom,
+                                users[0].name);
+    assert_int_equal(ret, case_a);
+
+    ret = sss_ncache_check_user(test_ctx->ncache, test_ctx->tctx->dom,
+                                users[1].name);
+    assert_int_equal(ret, case_b);
+
+    ret = sss_ncache_check_user(test_ctx->ncache, test_ctx->tctx->dom,
+                                TEST_LOCAL_USER_NAME_1);
+    assert_int_equal(ret, case_c);
+
+    ret = sss_ncache_check_user(test_ctx->ncache, test_ctx->tctx->dom,
+                                TEST_LOCAL_USER_NAME_2);
+    assert_int_equal(ret, case_d);
+}
+
+/* user tests */
+
+void test_ncache_nocache_user(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 0, 0, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_users(test_ctx);
+
+    check_users(test_ctx, ENOENT, ENOENT, ENOENT, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_local_user(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 0, 10, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_users(test_ctx);
+
+    check_users(test_ctx, ENOENT, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_domain_user(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 10, 0, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_users(test_ctx);
+
+    check_users(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_both_user(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 10, 10, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_users(test_ctx);
+
+    check_users(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+/* uid utils */
+
+static void set_uids(struct ncache_test_ctx *test_ctx)
+{
+    int ret;
+
+    ret = sss_ncache_set_uid(test_ctx->ncache, false, test_ctx->tctx->dom,
+                             users[0].uid);
+    assert_int_equal(ret, EOK);
+
+    ret = sss_ncache_set_uid(test_ctx->ncache, false, test_ctx->tctx->dom,
+                             TEST_LOCAL_USER_UID_1);
+    assert_int_equal(ret, EOK);
+}
+
+static void check_uids(struct ncache_test_ctx *test_ctx,
+                       int case_a, int case_b, int case_c, int case_d)
+{
+    int ret;
+
+    ret = sss_ncache_check_uid(test_ctx->ncache, test_ctx->tctx->dom,
+                               users[0].uid);
+    assert_int_equal(ret, case_a);
+
+    ret = sss_ncache_check_uid(test_ctx->ncache, test_ctx->tctx->dom,
+                               users[1].uid);
+    assert_int_equal(ret, case_b);
+
+    ret = sss_ncache_check_uid(test_ctx->ncache, test_ctx->tctx->dom,
+                               TEST_LOCAL_USER_UID_1);
+    assert_int_equal(ret, case_c);
+
+    ret = sss_ncache_check_uid(test_ctx->ncache, test_ctx->tctx->dom,
+                               TEST_LOCAL_USER_UID_2);
+    assert_int_equal(ret, case_d);
+}
+
+/* uid tests */
+
+void test_ncache_nocache_uid(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 0, 0, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_uids(test_ctx);
+
+    check_uids(test_ctx, ENOENT, ENOENT, ENOENT, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_local_uid(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 0, 10, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_uids(test_ctx);
+
+    check_uids(test_ctx, ENOENT, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_domain_uid(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 10, 0, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_uids(test_ctx);
+
+    check_uids(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_both_uid(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 10, 10, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_uids(test_ctx);
+
+    check_uids(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+/* group utils */
+
+static void set_groups(struct ncache_test_ctx *test_ctx)
+{
+    int ret;
+
+    ret = sss_ncache_set_group(test_ctx->ncache, false, test_ctx->tctx->dom,
+                               groups[0].name);
+    assert_int_equal(ret, EOK);
+
+    ret = sss_ncache_set_group(test_ctx->ncache, false, test_ctx->tctx->dom,
+                               TEST_LOCAL_GROUP_NAME_1);
+    assert_int_equal(ret, EOK);
+}
+
+static void check_groups(struct ncache_test_ctx *test_ctx,
+                         int case_a, int case_b, int case_c, int case_d)
+{
+    int ret;
+
+    ret = sss_ncache_check_group(test_ctx->ncache, test_ctx->tctx->dom,
+                                 groups[0].name);
+    assert_int_equal(ret, case_a);
+
+    ret = sss_ncache_check_group(test_ctx->ncache, test_ctx->tctx->dom,
+                                 groups[1].name);
+    assert_int_equal(ret, case_b);
+
+    ret = sss_ncache_check_group(test_ctx->ncache, test_ctx->tctx->dom,
+                                 TEST_LOCAL_GROUP_NAME_1);
+    assert_int_equal(ret, case_c);
+
+    ret = sss_ncache_check_group(test_ctx->ncache, test_ctx->tctx->dom,
+                                 TEST_LOCAL_GROUP_NAME_2);
+    assert_int_equal(ret, case_d);
+}
+
+/* group tests */
+
+void test_ncache_nocache_group(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 0, 0, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_groups(test_ctx);
+
+    check_groups(test_ctx, ENOENT, ENOENT, ENOENT, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_local_group(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 0, 10, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_groups(test_ctx);
+
+    check_groups(test_ctx, ENOENT, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_domain_group(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 10, 0, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_groups(test_ctx);
+
+    check_groups(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_both_group(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 10, 10, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_groups(test_ctx);
+
+    check_groups(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+/* gid utils */
+
+static void set_gids(struct ncache_test_ctx *test_ctx)
+{
+    int ret;
+
+    ret = sss_ncache_set_gid(test_ctx->ncache, false, test_ctx->tctx->dom,
+                             users[0].gid);
+    assert_int_equal(ret, EOK);
+
+    ret = sss_ncache_set_gid(test_ctx->ncache, false, test_ctx->tctx->dom,
+                             TEST_LOCAL_GID_1);
+    assert_int_equal(ret, EOK);
+}
+
+static void check_gids(struct ncache_test_ctx *test_ctx,
+                       int case_a, int case_b, int case_c, int case_d)
+{
+    int ret;
+
+    ret = sss_ncache_check_gid(test_ctx->ncache, test_ctx->tctx->dom,
+                               users[0].gid);
+    assert_int_equal(ret, case_a);
+
+    ret = sss_ncache_check_gid(test_ctx->ncache, test_ctx->tctx->dom,
+                               users[1].gid);
+    assert_int_equal(ret, case_b);
+
+    ret = sss_ncache_check_gid(test_ctx->ncache, test_ctx->tctx->dom,
+                               TEST_LOCAL_GID_1);
+    assert_int_equal(ret, case_c);
+
+    ret = sss_ncache_check_gid(test_ctx->ncache, test_ctx->tctx->dom,
+                               TEST_LOCAL_GID_2);
+    assert_int_equal(ret, case_d);
+}
+
+/* uid tests */
+
+void test_ncache_nocache_gid(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 0, 0, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_gids(test_ctx);
+
+    check_gids(test_ctx, ENOENT, ENOENT, ENOENT, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_local_gid(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 0, 10, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_gids(test_ctx);
+
+    check_gids(test_ctx, ENOENT, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_domain_gid(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 10, 0, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_gids(test_ctx);
+
+    check_gids(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+void test_ncache_both_gid(void **state)
+{
+    errno_t ret;
+    struct ncache_test_ctx *test_ctx;
+
+    test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
+    assert_non_null(test_ctx);
+
+    ret = sss_ncache_init(test_ctx, 10, 10, &test_ctx->ncache);
+    assert_int_equal(ret, EOK);
+
+    set_gids(test_ctx);
+
+    check_gids(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
+
+    talloc_zfree(test_ctx->ncache);
+}
+
+int main(int argc, const char *argv[])
+{
+    int rv;
+    poptContext pc;
+    int opt;
+    struct poptOption long_options[] = {
+        POPT_AUTOHELP
+        SSSD_DEBUG_OPTS
+        POPT_TABLEEND
+    };
+
+    const struct CMUnitTest tests[] = {
+        /* user */
+        cmocka_unit_test_setup_teardown(test_ncache_nocache_user,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_local_user,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_domain_user,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_both_user,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        /* uid */
+        cmocka_unit_test_setup_teardown(test_ncache_nocache_uid,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_local_uid,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_domain_uid,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_both_uid,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        /* group */
+        cmocka_unit_test_setup_teardown(test_ncache_nocache_group,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_local_group,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_domain_group,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_both_group,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        /* gid */
+        cmocka_unit_test_setup_teardown(test_ncache_nocache_gid,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_local_gid,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_domain_gid,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+        cmocka_unit_test_setup_teardown(test_ncache_both_gid,
+                                        test_ncache_setup,
+                                        test_ncache_teardown),
+    };
+
+    /* Set debug level to invalid value so we can deside if -d 0 was used. */
+    debug_level = SSSDBG_INVALID;
+
+    pc = poptGetContext(argv[0], argc, argv, long_options, 0);
+    while ((opt = poptGetNextOpt(pc)) != -1) {
+        switch (opt) {
+        default:
+            fprintf(stderr, "\nInvalid option %s: %s\n\n",
+                    poptBadOption(pc, 0), poptStrerror(opt));
+            poptPrintUsage(pc, stderr, 0);
+            return 1;
+        }
+    }
+    poptFreeContext(pc);
+
+    DEBUG_CLI_INIT(debug_level);
+
+    tests_set_cwd();
+    test_dom_suite_cleanup(TESTS_PATH, TEST_CONF_DB, TEST_DOM_NAME);
+    rv = cmocka_run_group_tests(tests, NULL, NULL);
+
+    return rv;
+}
\ No newline at end of file
-- 
2.5.5

