On 11/13/2015 10:09 AM, Jakub Hrozek wrote:
Hi, patch 003 doesn't apply cleanly for me, can you rebase?
Patches are rebased now. I hope it will be ok now.
Petr
>From 3e43417db9b66bdb44d60b5f186156c5ac26ad4b Mon Sep 17 00:00:00 2001
From: Petr Cech <pc...@redhat.com>
Date: Fri, 2 Oct 2015 07:34:08 -0400
Subject: [PATCH 1/8] TEST: Add test_user_by_recent_filter_valid
Test users_by_filter_valid() was removed in past. We will add two new
tests instead of it. Logic of those tests is connected to RECENT
filter. It returns only records which have been wrote or updated after
filter was created (or another given time).
users_by_filter_valid() --> user_by_recent_filter_valid()
users_by_recent_filter_valid()
The first of new tests, user_by_recent_filter_valid(), counts with two
users. One is stored before filter request creation and the second user
is stored after filter request creation. So filter returns only one
user.
The second of new tests, users_by_recent_filter_valid(), counts with
three users. One is stored before filter request creation and two users
are stored after filter request creation. So filter returns two users.
This patch adds user_by_recent_filter_valid().
Resolves:
https://fedorahosted.org/sssd/ticket/2730
---
src/tests/cmocka/test_responder_cache_req.c | 50 +++++++++++++++++++++++++++++
1 file changed, 50 insertions(+)
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index 85d986bd7d159dc238bce4bc770272d18288f2dd..14a40ae6e56b2f6d0b18608bac09bc4680245153 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -1239,6 +1239,53 @@ static void cache_req_user_by_filter_test_done(struct tevent_req *req)
ctx->tctx->done = true;
}
+void test_user_by_recent_filter_valid(void **state)
+{
+ struct cache_req_test_ctx *test_ctx = NULL;
+ TALLOC_CTX *req_mem_ctx = NULL;
+ struct tevent_req *req = NULL;
+ const char *ldbname = NULL;
+ errno_t ret;
+
+ test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);
+ test_ctx->create_user = true;
+
+ ret = sysdb_store_user(test_ctx->tctx->dom, TEST_USER_NAME2,
+ "pwd", 1001, 1001, NULL, NULL, NULL,
+ "cn="TEST_USER_NAME2",dc=test",
+ NULL, NULL, 1000, time(NULL)-1);
+ assert_int_equal(ret, EOK);
+
+ req_mem_ctx = talloc_new(test_ctx->tctx);
+ check_leaks_push(req_mem_ctx);
+
+ /* Filters always go to DP */
+ will_return(__wrap_sss_dp_get_account_send, test_ctx);
+ mock_account_recv_simple();
+
+ /* User TEST_USER is created with a DP callback. */
+ req = cache_req_user_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,
+ test_ctx->rctx,
+ test_ctx->tctx->dom->name,
+ "test*");
+ assert_non_null(req);
+
+ tevent_req_set_callback(req, cache_req_user_by_filter_test_done, test_ctx);
+
+ ret = test_ev_loop(test_ctx->tctx);
+ assert_int_equal(ret, ERR_OK);
+ assert_true(check_leaks_pop(req_mem_ctx));
+
+ assert_non_null(test_ctx->result);
+ assert_int_equal(test_ctx->result->count, 1);
+
+ ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[0],
+ SYSDB_NAME, NULL);
+ assert_non_null(ldbname);
+ assert_string_equal(ldbname, TEST_USER_NAME);
+}
+
+
void test_users_by_filter_filter_old(void **state)
{
struct cache_req_test_ctx *test_ctx = NULL;
@@ -1476,11 +1523,14 @@ int main(int argc, const char *argv[])
new_multi_domain_test(group_by_id_multiple_domains_found),
new_multi_domain_test(group_by_id_multiple_domains_notfound),
+ new_single_domain_test(user_by_recent_filter_valid),
+
new_single_domain_test(users_by_filter_filter_old),
new_single_domain_test(users_by_filter_notfound),
new_multi_domain_test(users_by_filter_multiple_domains_notfound),
new_single_domain_test(groups_by_filter_notfound),
new_multi_domain_test(groups_by_filter_multiple_domains_notfound),
+
};
/* Set debug level to invalid value so we can deside if -d 0 was used. */
--
2.4.3
>From 94d583476335324c4f4b62e547a74241582f807f Mon Sep 17 00:00:00 2001
From: Petr Cech <pc...@redhat.com>
Date: Wed, 4 Nov 2015 06:50:33 -0500
Subject: [PATCH 2/8] TEST: Refactor of test_responder_cache_req.c
This patch only defines constant TEST_USER_FILTER. So code will be more
redeable.
Resolves:
https://fedorahosted.org/sssd/ticket/2730
---
src/tests/cmocka/test_responder_cache_req.c | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index 14a40ae6e56b2f6d0b18608bac09bc4680245153..5ff6c95681d899e2ae93bd7964b492e52a2d223a 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -42,6 +42,8 @@
#define TEST_USER_NAME2 "test-user2"
#define TEST_GROUP_NAME2 "test-group2"
+#define TEST_USER_PREFIX "test*"
+
#define new_single_domain_test(test) \
cmocka_unit_test_setup_teardown(test_ ## test, \
test_single_domain_setup, \
@@ -1267,7 +1269,7 @@ void test_user_by_recent_filter_valid(void **state)
req = cache_req_user_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,
test_ctx->rctx,
test_ctx->tctx->dom->name,
- "test*");
+ TEST_USER_PREFIX);
assert_non_null(req);
tevent_req_set_callback(req, cache_req_user_by_filter_test_done, test_ctx);
@@ -1314,7 +1316,7 @@ void test_users_by_filter_filter_old(void **state)
req = cache_req_user_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,
test_ctx->rctx,
test_ctx->tctx->dom->name,
- "test*");
+ TEST_USER_PREFIX);
assert_non_null(req);
tevent_req_set_callback(req, cache_req_user_by_filter_test_done, test_ctx);
--
2.4.3
>From 6d4f692acd988db17e62cf77863d8dab41a70b00 Mon Sep 17 00:00:00 2001
From: Petr Cech <pc...@redhat.com>
Date: Tue, 27 Oct 2015 03:53:18 -0400
Subject: [PATCH 3/8] TEST: Refactor of test_responder_cache_req.c
We need little more in background of responder_cache_req tests. There
will be tests which will use three test users. This patch add support
for it.
Resolves:
https://fedorahosted.org/sssd/ticket/2730
---
src/tests/cmocka/test_responder_cache_req.c | 61 ++++++++++++++++++++++-------
1 file changed, 46 insertions(+), 15 deletions(-)
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index 5ff6c95681d899e2ae93bd7964b492e52a2d223a..00c1119d56440ae7108cc0b5c80686c4eea9df27 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -39,8 +39,15 @@
#define TEST_GROUP_NAME "test-group"
#define TEST_GROUP_ID 1000
-#define TEST_USER_NAME2 "test-user2"
-#define TEST_GROUP_NAME2 "test-group2"
+#define TEST_USER_ID2 1001
+#define TEST_USER_NAME2 "test_user2"
+#define TEST_GROUP_NAME2 "test_group2"
+#define TEST_GROUP_ID2 1001
+
+#define TEST_USER_ID3 1002
+#define TEST_USER_NAME3 "test_user3"
+#define TEST_GROUP_NAME3 "test_group3"
+#define TEST_GROUP_ID3 1002
#define TEST_USER_PREFIX "test*"
@@ -84,7 +91,10 @@ struct cache_req_test_ctx {
struct sss_domain_info *domain;
char *name;
bool dp_called;
- bool create_user;
+
+ /* NOTE: Please, instead of adding new create_user bool, use bitshift. */
+ bool create_user1;
+ bool create_user2;
bool create_group;
};
@@ -159,10 +169,13 @@ static void cache_req_group_by_id_test_done(struct tevent_req *req)
ctx->tctx->done = true;
}
-static void prepare_user(TALLOC_CTX *mem_ctx,
- struct sss_domain_info *domain,
- uint64_t timeout,
- time_t transaction_time)
+static void prepare_concrete_user(TALLOC_CTX *mem_ctx,
+ struct sss_domain_info *domain,
+ const char* user_name,
+ int user_id,
+ int group_id,
+ uint64_t timeout,
+ time_t time)
{
struct sysdb_attrs *attrs;
errno_t ret;
@@ -173,13 +186,22 @@ static void prepare_user(TALLOC_CTX *mem_ctx,
ret = sysdb_attrs_add_string(attrs, SYSDB_UPN, TEST_UPN);
assert_int_equal(ret, EOK);
- ret = sysdb_store_user(domain, TEST_USER_NAME, "pwd",
- TEST_USER_ID, TEST_GROUP_ID, NULL, NULL, NULL,
+ ret = sysdb_store_user(domain, user_name, "pwd",
+ user_id, group_id, NULL, NULL, NULL,
"cn=test-user,dc=test", attrs, NULL,
timeout, transaction_time);
assert_int_equal(ret, EOK);
}
+static void prepare_user(TALLOC_CTX *mem_ctx,
+ struct sss_domain_info *domain,
+ uint64_t timeout,
+ time_t time)
+{
+ prepare_concrete_user(mem_ctx, domain, TEST_USER_NAME, TEST_USER_ID,
+ TEST_GROUP_ID, timeout, time);
+}
+
static void run_user_by_name(struct cache_req_test_ctx *test_ctx,
struct sss_domain_info *domain,
int cache_refresh_percent,
@@ -313,9 +335,13 @@ __wrap_sss_dp_get_account_send(TALLOC_CTX *mem_ctx,
ctx = sss_mock_ptr_type(struct cache_req_test_ctx*);
ctx->dp_called = true;
- if (ctx->create_user) {
+ if (ctx->create_user1) {
prepare_user(ctx, ctx->tctx->dom, 1000, time(NULL));
}
+ if (ctx->create_user2) {
+ prepare_concrete_user(mem_ctx, ctx->tctx->dom, TEST_USER_NAME2,
+ TEST_USER_ID2, TEST_GROUP_ID2, 1000, time(NULL));
+ }
if (ctx->create_group) {
ret = sysdb_store_group(ctx->tctx->dom, TEST_GROUP_NAME,
@@ -570,7 +596,8 @@ void test_user_by_name_missing_found(void **state)
will_return(__wrap_sss_dp_get_account_send, test_ctx);
mock_account_recv_simple();
- test_ctx->create_user = true;
+ test_ctx->create_user1 = true;
+ test_ctx->create_user2 = false;
/* Test. */
run_user_by_name(test_ctx, test_ctx->tctx->dom, 0, ERR_OK);
@@ -723,7 +750,8 @@ void test_user_by_upn_missing_found(void **state)
mock_account_recv_simple();
mock_parse_inp(NULL, NULL, ERR_DOMAIN_NOT_FOUND);
- test_ctx->create_user = true;
+ test_ctx->create_user1 = true;
+ test_ctx->create_user2 = false;
/* Test. */
run_user_by_upn(test_ctx, NULL, 0, ERR_OK);
@@ -865,7 +893,8 @@ void test_user_by_id_missing_found(void **state)
will_return(__wrap_sss_dp_get_account_send, test_ctx);
mock_account_recv_simple();
- test_ctx->create_user = true;
+ test_ctx->create_user1 = true;
+ test_ctx->create_user2 = false;
/* Test. */
run_user_by_id(test_ctx, test_ctx->tctx->dom, 0, ERR_OK);
@@ -1250,7 +1279,8 @@ void test_user_by_recent_filter_valid(void **state)
errno_t ret;
test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);
- test_ctx->create_user = true;
+ test_ctx->create_user1 = true;
+ test_ctx->create_user2 = false;
ret = sysdb_store_user(test_ctx->tctx->dom, TEST_USER_NAME2,
"pwd", 1001, 1001, NULL, NULL, NULL,
@@ -1297,7 +1327,8 @@ void test_users_by_filter_filter_old(void **state)
errno_t ret;
test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);
- test_ctx->create_user = true;
+ test_ctx->create_user1 = true;
+ test_ctx->create_user2 = false;
/* This user was updated in distant past, so it wont't be reported by
* the filter search */
--
2.4.3
>From ee268689fbc60b7b20e09ffb12889d1187b15834 Mon Sep 17 00:00:00 2001
From: Petr Cech <pc...@redhat.com>
Date: Tue, 10 Nov 2015 06:04:45 -0500
Subject: [PATCH 4/8] TEST: Add common function are_values_in_array()
This patch adds function are_values_in_array() to common test code. And
there is tc_are_values_in_array macro defined which is usefull for
talloc allocated values and arrays.
Resolves:
https://fedorahosted.org/sssd/ticket/2730
---
src/tests/common.c | 21 +++++++++++++++++++++
src/tests/common.h | 8 ++++++++
2 files changed, 29 insertions(+)
diff --git a/src/tests/common.c b/src/tests/common.c
index 9655cd3ce5f863d8f07c6a186d3f25177eb330af..8ba73a2ef100c69a7e990098d4c77a060a3dd1c3 100644
--- a/src/tests/common.c
+++ b/src/tests/common.c
@@ -118,3 +118,24 @@ bool ldb_modules_path_is_set(void)
return false;
}
+
+/* Returns true if all values are in array (else returns false) */
+bool are_values_in_array(const char **values, size_t values_len,
+ const char **array, size_t array_len)
+{
+ bool is_value_in_element = false;
+ bool is_value_in_array = false;
+ bool ret = true;
+
+ for (size_t i = 0; i < values_len; i++) {
+ is_value_in_array = false;
+ for (size_t j = 0; j < array_len; j++) {
+ is_value_in_element = strcmp(values[i], array[j]) == 0 ? \
+ true : false;
+ is_value_in_array = is_value_in_array || is_value_in_element;
+ }
+ ret = ret && is_value_in_array;
+ }
+
+ return ret;
+}
diff --git a/src/tests/common.h b/src/tests/common.h
index 794218c5b4646bd42d216d9bf45715e10c9ba866..c9b3815cd3e70b80d23da2d8b2363fe94cc170f9 100644
--- a/src/tests/common.h
+++ b/src/tests/common.h
@@ -143,4 +143,12 @@ struct sss_domain_info *named_domain(TALLOC_CTX *mem_ctx,
const char *name,
struct sss_domain_info *parent);
+/* Returns true if all values are in array (else returns false) */
+bool are_values_in_array(const char **values, size_t values_len,
+ const char **array, size_t array_len);
+
+#define tc_are_values_in_array(values, array) \
+ are_values_in_array(values, talloc_array_length(values), \
+ array, talloc_array_length(array))
+
#endif /* !__TESTS_COMMON_H__ */
--
2.4.3
>From 37c0cf0bec99c91d6d83c4febebcfc6a4b49d095 Mon Sep 17 00:00:00 2001
From: Petr Cech <pc...@redhat.com>
Date: Tue, 27 Oct 2015 04:02:46 -0400
Subject: [PATCH 5/8] TEST: Add test_users_by_recent_filter_valid
Test users_by_filter_valid() was removed in past. We will add two new
tests instead of it. Logic of those tests is connected to RECENT
filter. It returns only records which have been wrote or updated
after filter was created (or another given time).
users_by_filter_valid() --> user_by_recent_filter_valid()
users_by_recent_filter_valid()
The first of new tests, user_by_recent_filter_valid(), counts with
two users. One is stored before filter request creation and the second
user is stored after filter request creation. So filter returns only one
user.
The second of new tests, users_by_recent_filter_valid(), counts with
three users. One is stored before filter request creation and two
users are stored after filter request creation. So filter returns two
users.
This patch adds users_by_recent_filter_valid().
Resolves:
https://fedorahosted.org/sssd/ticket/2730
---
src/tests/cmocka/test_responder_cache_req.c | 68 ++++++++++++++++++++++++++++-
1 file changed, 67 insertions(+), 1 deletion(-)
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index 00c1119d56440ae7108cc0b5c80686c4eea9df27..763637a33576d05bb447a6af1651ec416c3e266f 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -318,7 +318,6 @@ static void check_group(struct cache_req_test_ctx *test_ctx,
assert_string_equal(exp_dom->name, test_ctx->domain->name);
}
-
struct tevent_req *
__wrap_sss_dp_get_account_send(TALLOC_CTX *mem_ctx,
struct resp_ctx *rctx,
@@ -1317,6 +1316,72 @@ void test_user_by_recent_filter_valid(void **state)
assert_string_equal(ldbname, TEST_USER_NAME);
}
+void test_users_by_recent_filter_valid(void **state)
+{
+ struct cache_req_test_ctx *test_ctx = NULL;
+ TALLOC_CTX *req_mem_ctx = NULL;
+ TALLOC_CTX *tmp_ctx = NULL;
+ struct tevent_req *req = NULL;
+ const char **user_names = NULL;
+ const char **ldb_results = NULL;
+ const char *ldbname = NULL;
+ errno_t ret;
+
+ test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);
+ test_ctx->create_user1 = true;
+ test_ctx->create_user2 = true;
+
+ ret = sysdb_store_user(test_ctx->tctx->dom, TEST_USER_NAME3,
+ "pwd", 1002, 1002, NULL, NULL, NULL,
+ "cn="TEST_USER_NAME3",dc=test",
+ NULL, NULL, 1000, time(NULL)-1);
+ assert_int_equal(ret, EOK);
+
+ req_mem_ctx = talloc_new(test_ctx->tctx);
+ check_leaks_push(req_mem_ctx);
+
+ /* Filters always go to DP */
+ will_return(__wrap_sss_dp_get_account_send, test_ctx);
+ mock_account_recv_simple();
+
+ /* User TEST_USER1 and TEST_USER2 are created with a DP callback. */
+ req = cache_req_user_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,
+ test_ctx->rctx,
+ test_ctx->tctx->dom->name,
+ TEST_USER_PREFIX);
+ assert_non_null(req);
+
+ tevent_req_set_callback(req, cache_req_user_by_filter_test_done, test_ctx);
+
+ ret = test_ev_loop(test_ctx->tctx);
+ assert_int_equal(ret, ERR_OK);
+ assert_true(check_leaks_pop(req_mem_ctx));
+
+ assert_non_null(test_ctx->result);
+ assert_int_equal(test_ctx->result->count, 2);
+
+ tmp_ctx = talloc_new(req_mem_ctx);
+
+ user_names = talloc_array(tmp_ctx, const char *, 2);
+ assert_non_null(user_names);
+ user_names[0] = TEST_USER_NAME;
+ user_names[1] = TEST_USER_NAME2;
+
+ ldb_results = talloc_array(tmp_ctx, const char *, 2);
+ assert_non_null(ldb_results);
+ for (int i = 0; i < 2; ++i) {
+ ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[i],
+ SYSDB_NAME, NULL);
+ assert_non_null(ldbname);
+ ldb_results[i] = ldbname;
+ }
+
+ assert_string_not_equal(ldb_results[0], ldb_results[1]);
+
+ assert_true(tc_are_values_in_array(user_names, ldb_results));
+
+ talloc_zfree(tmp_ctx);
+}
void test_users_by_filter_filter_old(void **state)
{
@@ -1557,6 +1622,7 @@ int main(int argc, const char *argv[])
new_multi_domain_test(group_by_id_multiple_domains_notfound),
new_single_domain_test(user_by_recent_filter_valid),
+ new_single_domain_test(users_by_recent_filter_valid),
new_single_domain_test(users_by_filter_filter_old),
new_single_domain_test(users_by_filter_notfound),
--
2.4.3
>From 371ceff15bf39598105f45e7eb2347630eb6b732 Mon Sep 17 00:00:00 2001
From: Petr Cech <pc...@redhat.com>
Date: Sun, 1 Nov 2015 07:09:28 -0500
Subject: [PATCH 6/8] TEST: Add test_group_by_recent_filter_valid
Test groups_by_filter_valid() was removed in past. We will add two new
tests instead of it. Logic of those tests is connected to RECENT
filter. It returns only records which have been wrote or updated after
filter was created (or another given time).
groups_by_filter_valid() --> group_by_recent_filter_valid()
grous_by_recent_filter_valid()
The first of new tests, group_by_recent_filter_valid(), counts with two
groups. One is stored before filter request creation and the second
group is stored after filter request creation. So filter returns only
one group.
The second of new tests, groups_by_recent_filter_valid(), counts with
three users. One is stored before filter request creation and two
groups are stored after filter request creation. So filter returns two
groups.
This patch adds group_by_recent_filter_valid().
Resolves:
https://fedorahosted.org/sssd/ticket/2730
---
src/tests/cmocka/test_responder_cache_req.c | 44 +++++++++++++++++++++++++++++
1 file changed, 44 insertions(+)
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index 763637a33576d05bb447a6af1651ec416c3e266f..4ce5cb1c5329c5cfad748a363652ccfbb4d20d48 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -1503,6 +1503,49 @@ static void cache_req_group_by_filter_test_done(struct tevent_req *req)
ctx->tctx->done = true;
}
+void test_group_by_recent_filter_valid(void **state)
+{
+ struct cache_req_test_ctx *test_ctx = NULL;
+ TALLOC_CTX *req_mem_ctx = NULL;
+ struct tevent_req *req = NULL;
+ const char *ldbname = NULL;
+ errno_t ret;
+
+ test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);
+ test_ctx->create_group = true;
+
+ ret = sysdb_store_group(test_ctx->tctx->dom, TEST_GROUP_NAME2,
+ 1001, NULL, 1001, time(NULL)-1);
+ assert_int_equal(ret, EOK);
+
+ req_mem_ctx = talloc_new(global_talloc_context);
+ check_leaks_push(req_mem_ctx);
+
+ /* Filters always go to DP */
+ will_return(__wrap_sss_dp_get_account_send, test_ctx);
+ mock_account_recv_simple();
+
+ /* Group TEST_GROUP is created with a DP callback. */
+ req = cache_req_group_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,
+ test_ctx->rctx,
+ test_ctx->tctx->dom->name,
+ TEST_USER_PREFIX);
+ assert_non_null(req);
+ tevent_req_set_callback(req, cache_req_group_by_filter_test_done, test_ctx);
+
+ ret = test_ev_loop(test_ctx->tctx);
+ assert_int_equal(ret, ERR_OK);
+ assert_true(check_leaks_pop(req_mem_ctx));
+
+ assert_non_null(test_ctx->result);
+ assert_int_equal(test_ctx->result->count, 1);
+
+ ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[0],
+ SYSDB_NAME, NULL);
+ assert_non_null(ldbname);
+ assert_string_equal(ldbname, TEST_GROUP_NAME);
+}
+
void test_groups_by_filter_notfound(void **state)
{
struct cache_req_test_ctx *test_ctx = NULL;
@@ -1623,6 +1666,7 @@ int main(int argc, const char *argv[])
new_single_domain_test(user_by_recent_filter_valid),
new_single_domain_test(users_by_recent_filter_valid),
+ new_single_domain_test(group_by_recent_filter_valid),
new_single_domain_test(users_by_filter_filter_old),
new_single_domain_test(users_by_filter_notfound),
--
2.4.3
>From 77d9c682b275f0a1b8cd685e482bb4434f557d2a Mon Sep 17 00:00:00 2001
From: Petr Cech <pc...@redhat.com>
Date: Sun, 1 Nov 2015 07:21:18 -0500
Subject: [PATCH 7/8] TEST: Refactor of test_responder_cache_req.c
We need little more in backroung of responder_cache_req tests. There
will be tests which will use three test groups. This patch add support
for it.
Resolves:
https://fedorahosted.org/sssd/ticket/2730
---
src/tests/cmocka/test_responder_cache_req.c | 23 +++++++++++++++++------
1 file changed, 17 insertions(+), 6 deletions(-)
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index 4ce5cb1c5329c5cfad748a363652ccfbb4d20d48..59f5594c0c5c1b9b6906541422003db04632b124 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -92,10 +92,12 @@ struct cache_req_test_ctx {
char *name;
bool dp_called;
- /* NOTE: Please, instead of adding new create_user bool, use bitshift. */
+ /* NOTE: Please, instead of adding new create_[user|group] bool,
+ * use bitshift. */
bool create_user1;
bool create_user2;
- bool create_group;
+ bool create_group1;
+ bool create_group2;
};
const char *domains[] = {"responder_cache_req_test_a",
@@ -342,11 +344,17 @@ __wrap_sss_dp_get_account_send(TALLOC_CTX *mem_ctx,
TEST_USER_ID2, TEST_GROUP_ID2, 1000, time(NULL));
}
- if (ctx->create_group) {
+ if (ctx->create_group1) {
ret = sysdb_store_group(ctx->tctx->dom, TEST_GROUP_NAME,
TEST_GROUP_ID, NULL, 1000, time(NULL));
assert_int_equal(ret, EOK);
}
+ if (ctx->create_group2) {
+ ret = sysdb_store_group(ctx->tctx->dom, TEST_GROUP_NAME2,
+ TEST_GROUP_ID2, NULL, 1000, time(NULL));
+ assert_int_equal(ret, EOK);
+ }
+
return test_req_succeed_send(mem_ctx, rctx->ev);
}
@@ -1093,7 +1101,8 @@ void test_group_by_name_missing_found(void **state)
will_return(__wrap_sss_dp_get_account_send, test_ctx);
mock_account_recv_simple();
- test_ctx->create_group = true;
+ test_ctx->create_group1 = true;
+ test_ctx->create_group2 = false;
/* Test. */
run_group_by_name(test_ctx, test_ctx->tctx->dom, 0, ERR_OK);
@@ -1233,7 +1242,8 @@ void test_group_by_id_missing_found(void **state)
will_return(__wrap_sss_dp_get_account_send, test_ctx);
mock_account_recv_simple();
- test_ctx->create_group = true;
+ test_ctx->create_group1 = true;
+ test_ctx->create_group2 = false;
/* Test. */
run_group_by_id(test_ctx, test_ctx->tctx->dom, 0, ERR_OK);
@@ -1512,7 +1522,8 @@ void test_group_by_recent_filter_valid(void **state)
errno_t ret;
test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);
- test_ctx->create_group = true;
+ test_ctx->create_group1 = true;
+ test_ctx->create_group2 = false;
ret = sysdb_store_group(test_ctx->tctx->dom, TEST_GROUP_NAME2,
1001, NULL, 1001, time(NULL)-1);
--
2.4.3
>From 91ac82ef87bb80c3fafc2fa17617bc5587c07427 Mon Sep 17 00:00:00 2001
From: Petr Cech <pc...@redhat.com>
Date: Sun, 1 Nov 2015 07:45:56 -0500
Subject: [PATCH 8/8] TEST: Add test_groups_by_recent_filter_valid
Test groups_by_filter_valid() was removed in past. We will add two new
tests instead of it. Logic of those tests is connected to RECENT
filter. It returns only records which have been wrote or updated after
filter was created (or another given time).
groups_by_filter_valid() --> group_by_recent_filter_valid()
grous_by_recent_filter_valid()
The first of new tests, group_by_recent_filter_valid(), counts with two
groups. One is stored before filter request creation and the second
group is stored after filter request creation. So filter returns only
one group.
The second of new tests, groups_by_recent_filter_valid(), counts with
three users. One is stored before filter request creation and two
groups are stored after filter request creation. So filter returns two
groups.
This patch adds groups_by_recent_filter_valid().
Resolves:
https://fedorahosted.org/sssd/ticket/2730
---
src/tests/cmocka/test_responder_cache_req.c | 68 +++++++++++++++++++++++++++++
1 file changed, 68 insertions(+)
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index 59f5594c0c5c1b9b6906541422003db04632b124..cd96df27ee693e67c095be39ae3e6db8cd6fa449 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -1557,6 +1557,73 @@ void test_group_by_recent_filter_valid(void **state)
assert_string_equal(ldbname, TEST_GROUP_NAME);
}
+void test_groups_by_recent_filter_valid(void **state)
+{
+ struct cache_req_test_ctx *test_ctx = NULL;
+ TALLOC_CTX *req_mem_ctx = NULL;
+ TALLOC_CTX *tmp_ctx = NULL;
+ struct tevent_req *req = NULL;
+ const char **group_names = NULL;
+ const char **ldb_results = NULL;
+ const char *ldbname = NULL;
+ errno_t ret;
+
+ test_ctx = talloc_get_type_abort(*state, struct cache_req_test_ctx);
+ test_ctx->create_group1 = true;
+ test_ctx->create_group2 = true;
+
+ ret = sysdb_store_group(test_ctx->tctx->dom, TEST_GROUP_NAME2,
+ 1001, NULL, 1001, time(NULL));
+ assert_int_equal(ret, EOK);
+
+ sleep(1);
+
+ req_mem_ctx = talloc_new(global_talloc_context);
+ check_leaks_push(req_mem_ctx);
+
+ /* Filters always go to DP */
+ will_return(__wrap_sss_dp_get_account_send, test_ctx);
+ mock_account_recv_simple();
+
+ /* Group TEST_GROUP1 and TEST_GROUP2 are created with a DP callback. */
+ req = cache_req_group_by_filter_send(req_mem_ctx, test_ctx->tctx->ev,
+ test_ctx->rctx,
+ test_ctx->tctx->dom->name,
+ TEST_USER_PREFIX);
+ assert_non_null(req);
+
+ tevent_req_set_callback(req, cache_req_group_by_filter_test_done, test_ctx);
+
+ ret = test_ev_loop(test_ctx->tctx);
+ assert_int_equal(ret, ERR_OK);
+ assert_true(check_leaks_pop(req_mem_ctx));
+
+ assert_non_null(test_ctx->result);
+ assert_int_equal(test_ctx->result->count, 2);
+
+ tmp_ctx = talloc_new(req_mem_ctx);
+
+ group_names = talloc_array(tmp_ctx, const char *, 2);
+ assert_non_null(group_names);
+ group_names[0] = TEST_GROUP_NAME;
+ group_names[1] = TEST_GROUP_NAME2;
+
+ ldb_results = talloc_array(tmp_ctx, const char *, 2);
+ assert_non_null(ldb_results);
+ for (int i = 0; i < 2; ++i) {
+ ldbname = ldb_msg_find_attr_as_string(test_ctx->result->msgs[i],
+ SYSDB_NAME, NULL);
+ assert_non_null(ldbname);
+ ldb_results[i] = ldbname;
+ }
+
+ assert_string_not_equal(ldb_results[0], ldb_results[1]);
+
+ assert_true(tc_are_values_in_array(group_names, ldb_results));
+
+ talloc_zfree(tmp_ctx);
+}
+
void test_groups_by_filter_notfound(void **state)
{
struct cache_req_test_ctx *test_ctx = NULL;
@@ -1678,6 +1745,7 @@ int main(int argc, const char *argv[])
new_single_domain_test(user_by_recent_filter_valid),
new_single_domain_test(users_by_recent_filter_valid),
new_single_domain_test(group_by_recent_filter_valid),
+ new_single_domain_test(groups_by_recent_filter_valid),
new_single_domain_test(users_by_filter_filter_old),
new_single_domain_test(users_by_filter_notfound),
--
2.4.3
_______________________________________________
sssd-devel mailing list
sssd-devel@lists.fedorahosted.org
https://lists.fedorahosted.org/mailman/listinfo/sssd-devel
