rpms/sssd
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
87763840cd
sssd/0009-NSS-TESTS-add-unit-tests-for-_EX-requests.patch

590 lines
22 KiB
Diff
Raw Normal View History

Backport extended NSS API from upstream master branch
2017-11-17 17:06:26 +00:00
From 85da8a5e90bffc8b0fef5e0ea364a8d3cb50de86 Mon Sep 17 00:00:00 2001
From: Sumit Bose <sbose@redhat.com>
Date: Wed, 25 Oct 2017 21:31:54 +0200
Subject: [PATCH 09/11] NSS/TESTS: add unit tests for *_EX requests
The patch adds unit tests for the new *_EX requests with different input
types and flags.
Related to https://pagure.io/SSSD/sssd/issue/2478
Reviewed-by: Jakub Hrozek <jhrozek@redhat.com>
---
src/tests/cmocka/test_nss_srv.c | 539 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 539 insertions(+)
diff --git a/src/tests/cmocka/test_nss_srv.c b/src/tests/cmocka/test_nss_srv.c
index ccedf96beaecfaa4232bbe456d5e5a8394098483..6aa726153183b5a871a75d398727ea7132358ca6 100644
--- a/src/tests/cmocka/test_nss_srv.c
+++ b/src/tests/cmocka/test_nss_srv.c
@@ -255,6 +255,45 @@ static void mock_input_user_or_group(const char *input)
mock_parse_inp(shortname, domname, EOK);
}
+static void mock_input_user_or_group_ex(bool do_parse_inp, const char *input,
+ uint32_t flags)
+{
+ const char *copy;
+ const char *shortname;
+ const char *domname;
+ char *separator;
+ uint8_t *data;
+ size_t len;
+
+ len = strlen(input);
+ len++;
+ data = talloc_size(nss_test_ctx, len + sizeof(uint32_t));
+ assert_non_null(data);
+ memcpy(data, input, len);
+ SAFEALIGN_COPY_UINT32(data + len, &flags, NULL);
+
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
+ will_return(__wrap_sss_packet_get_body, data);
+ will_return(__wrap_sss_packet_get_body, len + sizeof(uint32_t));
+
+ if (do_parse_inp) {
+ copy = talloc_strdup(nss_test_ctx, input);
+ assert_non_null(copy);
+
+ separator = strrchr(copy, '@');
+ if (separator == NULL) {
+ shortname = input;
+ domname = NULL;
+ } else {
+ *separator = '\0';
+ shortname = copy;
+ domname = separator + 1;
+ }
+
+ mock_parse_inp(shortname, domname, EOK);
+ }
+}
+
static void mock_input_upn(const char *upn)
{
will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
@@ -291,6 +330,20 @@ static void mock_input_id(TALLOC_CTX *mem_ctx, uint32_t id)
will_return(__wrap_sss_packet_get_body, sizeof(uint32_t));
}
+static void mock_input_id_ex(TALLOC_CTX *mem_ctx, uint32_t id, uint32_t flags)
+{
+ uint8_t *body;
+
+ body = talloc_zero_array(mem_ctx, uint8_t, 8);
+ if (body == NULL) return;
+
+ SAFEALIGN_SETMEM_UINT32(body, id, NULL);
+ SAFEALIGN_SETMEM_UINT32(body + sizeof(uint32_t), flags, NULL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
+ will_return(__wrap_sss_packet_get_body, body);
+ will_return(__wrap_sss_packet_get_body, 2 * sizeof(uint32_t));
+}
+
static void mock_fill_user(void)
{
/* One packet for the entry and one for num entries */
@@ -4143,6 +4196,482 @@ void test_nss_getsidbyname_neg(void **state)
assert_int_equal(ret, ENOENT);
}
+static int test_nss_EINVAL_check(uint32_t status, uint8_t *body, size_t blen)
+{
+ assert_int_equal(status, EINVAL);
+ assert_int_equal(blen, 0);
+
+ return EOK;
+}
+
+#define RESET_TCTX do { \
+ nss_test_ctx->tctx->done = false; \
+ nss_test_ctx->tctx->error = EIO; \
+} while (0)
+
+void test_nss_getpwnam_ex(void **state)
+{
+ errno_t ret;
+
+ ret = store_user(nss_test_ctx, nss_test_ctx->tctx->dom,
+ &getpwnam_usr, NULL, 0);
+ assert_int_equal(ret, EOK);
+
+ mock_input_user_or_group_ex(true, "testuser", 0);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWNAM_EX);
+ mock_fill_user();
+
+ /* Query for that user, call a callback when command finishes */
+ set_cmd_cb(test_nss_getpwnam_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use old input format, expect EINVAL */
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
+ will_return(__wrap_sss_packet_get_body, "testuser");
+ will_return(__wrap_sss_packet_get_body, 0);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWNAM_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use unsupported flag combination, expect EINVAL */
+ mock_input_user_or_group_ex(false, "testuser",
+ SSS_NSS_EX_FLAG_NO_CACHE
+ |SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWNAM_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_NO_CACHE,
+ * will cause a backend lookup -> mock_account_recv_simple() */
+ mock_input_user_or_group_ex(true, "testuser", SSS_NSS_EX_FLAG_NO_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWNAM_EX);
+ mock_fill_user();
+ mock_account_recv_simple();
+
+ set_cmd_cb(test_nss_getpwnam_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_INVALIDATE_CACHE */
+ mock_input_user_or_group_ex(true, "testuser",
+ SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWNAM_EX);
+ mock_fill_user();
+
+ set_cmd_cb(test_nss_getpwnam_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+}
+
+void test_nss_getpwuid_ex(void **state)
+{
+ errno_t ret;
+ uint32_t id = 101;
+
+ /* Prime the cache with a valid user */
+ ret = store_user(nss_test_ctx, nss_test_ctx->tctx->dom,
+ &getpwuid_usr, NULL, 0);
+ assert_int_equal(ret, EOK);
+
+ mock_input_id_ex(nss_test_ctx, id, 0);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWUID_EX);
+ mock_fill_user();
+
+ /* Query for that id, call a callback when command finishes */
+ set_cmd_cb(test_nss_getpwuid_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWUID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use old input format, expect failure */
+ mock_input_id(nss_test_ctx, id);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWUID_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWUID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use unsupported flag combination, expect EINVAL */
+ mock_input_id_ex(nss_test_ctx, id, SSS_NSS_EX_FLAG_NO_CACHE
+ |SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWUID_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWUID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_NO_CACHE,
+ * will cause a backend lookup -> mock_account_recv_simple() */
+ mock_input_id_ex(nss_test_ctx, id, SSS_NSS_EX_FLAG_NO_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWUID_EX);
+ mock_fill_user();
+ mock_account_recv_simple();
+
+ set_cmd_cb(test_nss_getpwuid_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWUID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_INVALIDATE_CACHE */
+ mock_input_id_ex(nss_test_ctx, id, SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETPWUID_EX);
+ mock_fill_user();
+
+ set_cmd_cb(test_nss_getpwuid_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETPWUID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+}
+
+void test_nss_getgrnam_ex_no_members(void **state)
+{
+ errno_t ret;
+
+ /* Test group is still in the cache */
+
+ mock_input_user_or_group_ex(true, getgrnam_no_members.gr_name, 0);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRNAM_EX);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+
+ /* Query for that group, call a callback when command finishes */
+ set_cmd_cb(test_nss_getgrnam_no_members_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use old input format, expect failure */
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
+ will_return(__wrap_sss_packet_get_body, "testgroup");
+ will_return(__wrap_sss_packet_get_body, 0);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRNAM_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use unsupported flag combination, expect EINVAL */
+ mock_input_user_or_group_ex(false, getgrnam_no_members.gr_name,
+ SSS_NSS_EX_FLAG_NO_CACHE
+ |SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRNAM_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_NO_CACHE,
+ * will cause a backend lookup -> mock_account_recv_simple() */
+ mock_input_user_or_group_ex(true, getgrnam_no_members.gr_name,
+ SSS_NSS_EX_FLAG_NO_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRNAM_EX);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ mock_account_recv_simple();
+
+ set_cmd_cb(test_nss_getgrnam_no_members_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_INVALIDATE_CACHE */
+ mock_input_user_or_group_ex(true, getgrnam_no_members.gr_name,
+ SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRNAM_EX);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+
+ set_cmd_cb(test_nss_getgrnam_no_members_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRNAM_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+}
+
+void test_nss_getgrgid_ex_no_members(void **state)
+{
+ errno_t ret;
+
+ /* Test group is still in the cache */
+
+ mock_input_id_ex(nss_test_ctx, getgrnam_no_members.gr_gid, 0);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRGID_EX);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ mock_account_recv_simple();
+
+ /* Query for that group, call a callback when command finishes */
+ set_cmd_cb(test_nss_getgrnam_no_members_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRGID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use old input format, expect failure */
+ mock_input_id(nss_test_ctx, getgrnam_no_members.gr_gid);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRGID_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRGID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use unsupported flag combination, expect EINVAL */
+ mock_input_id_ex(nss_test_ctx, getgrnam_no_members.gr_gid,
+ SSS_NSS_EX_FLAG_NO_CACHE
+ |SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRGID_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRGID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_NO_CACHE,
+ * will cause a backend lookup -> mock_account_recv_simple() */
+ mock_input_id_ex(nss_test_ctx, getgrnam_no_members.gr_gid,
+ SSS_NSS_EX_FLAG_NO_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRGID_EX);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ mock_account_recv_simple();
+ mock_account_recv_simple();
+
+ set_cmd_cb(test_nss_getgrnam_no_members_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRGID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_INVALIDATE_CACHE */
+ mock_input_id_ex(nss_test_ctx, getgrnam_no_members.gr_gid,
+ SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETGRGID_EX);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
+
+ set_cmd_cb(test_nss_getgrnam_no_members_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETGRGID_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+}
+
+void test_nss_initgroups_ex(void **state)
+{
+ errno_t ret;
+ struct sysdb_attrs *attrs;
+
+ attrs = sysdb_new_attrs(nss_test_ctx);
+ assert_non_null(attrs);
+
+ ret = sysdb_attrs_add_time_t(attrs, SYSDB_INITGR_EXPIRE,
+ time(NULL) + 300);
+ assert_int_equal(ret, EOK);
+
+ ret = sysdb_attrs_add_string(attrs, SYSDB_UPN, "upninitgr@upndomain.test");
+ assert_int_equal(ret, EOK);
+
+ ret = store_user(nss_test_ctx, nss_test_ctx->tctx->dom,
+ &testinitgr_usr, attrs, 0);
+ assert_int_equal(ret, EOK);
+
+ mock_input_user_or_group_ex(true, "testinitgr", 0);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_INITGR_EX);
+ mock_fill_user();
+
+ /* Query for that user, call a callback when command finishes */
+ set_cmd_cb(test_nss_initgr_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_INITGR_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use old input format, expect failure */
+ will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
+ will_return(__wrap_sss_packet_get_body, "testinitgr");
+ will_return(__wrap_sss_packet_get_body, 0);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_INITGR_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_INITGR_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use unsupported flag combination, expect EINVAL */
+ mock_input_user_or_group_ex(false, "testinitgr",
+ SSS_NSS_EX_FLAG_NO_CACHE
+ |SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_INITGR_EX);
+
+ set_cmd_cb(test_nss_EINVAL_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_INITGR_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_NO_CACHE,
+ * will cause a backend lookup -> mock_account_recv_simple() */
+ mock_input_user_or_group_ex(true, "testinitgr",
+ SSS_NSS_EX_FLAG_NO_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_INITGR_EX);
+ mock_fill_user();
+ mock_account_recv_simple();
+
+ set_cmd_cb(test_nss_initgr_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_INITGR_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+ RESET_TCTX;
+
+ /* Use flag SSS_NSS_EX_FLAG_INVALIDATE_CACHE */
+ mock_input_user_or_group_ex(true, "testinitgr",
+ SSS_NSS_EX_FLAG_INVALIDATE_CACHE);
+ will_return(__wrap_sss_packet_get_cmd, SSS_NSS_INITGR_EX);
+ mock_fill_user();
+
+ set_cmd_cb(test_nss_initgr_check);
+ ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_INITGR_EX,
+ nss_test_ctx->nss_cmds);
+ assert_int_equal(ret, EOK);
+
+ /* Wait until the test finishes with EOK */
+ ret = test_ev_loop(nss_test_ctx->tctx);
+ assert_int_equal(ret, EOK);
+}
+
int main(int argc, const char *argv[])
{
int rv;
@@ -4288,6 +4817,16 @@ int main(int argc, const char *argv[])
nss_test_setup, nss_test_teardown),
cmocka_unit_test_setup_teardown(test_nss_getsidbyname_neg,
nss_test_setup, nss_test_teardown),
+ cmocka_unit_test_setup_teardown(test_nss_getpwnam_ex,
+ nss_test_setup, nss_test_teardown),
+ cmocka_unit_test_setup_teardown(test_nss_getpwuid_ex,
+ nss_test_setup, nss_test_teardown),
+ cmocka_unit_test_setup_teardown(test_nss_getgrnam_ex_no_members,
+ nss_test_setup, nss_test_teardown),
+ cmocka_unit_test_setup_teardown(test_nss_getgrgid_ex_no_members,
+ nss_test_setup, nss_test_teardown),
+ cmocka_unit_test_setup_teardown(test_nss_initgroups_ex,
+ nss_test_setup, nss_test_teardown),
};
/* Set debug level to invalid value so we can deside if -d 0 was used. */
--
2.14.3
Reference in New Issue Copy Permalink