On 11/13/2015 11:32 AM, Jakub Hrozek wrote:
On Fri, Nov 13, 2015 at 10:52:08AM +0100, Petr Cech wrote:
>On 11/13/2015 10:30 AM, Petr Cech wrote:
> >On 11/13/2015 10:27 AM, Petr Cech wrote:
> >>
> >>Patches are rebased now. I hope it will be ok now.
> >>
> >>Petr
> >Sorry, now my local CI tests failed... I will rebase it again.
>
>Well, now it is right. Local CI tests passed. There has been patch:
>
> "TESTS: Fix warnings -Wshadow":
> commit df9e9a1f9b7dc255eb62c390163c25917b08f5a2
> Refs: sssd-1_13_1-137-gdf9e9a1
> Author: Lukas Slebodnik<lsleb...@redhat.com>
> AuthorDate: Mon Nov 9 10:59:55 2015 +0100
> Commit: Jakub Hrozek<jhro...@redhat.com>
> CommitDate: Tue Nov 10 15:34:41 2015 +0100
>
>There is change
># - time_t time)
># + time_t transaction_time)
>in static void prepare_user().
>My patches were in conflict with it.
>
>Regards
>
>Petr
> From 3ce6073dda27fd7a4626f5cbac1c765274ca5fe0 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);
I think the last question is whether we want to use this new context or
just call check_leaks_push(test_ctx) recursively. I don't really mind
too much, both would work for me.
Unless someone opposes, I would push the patch as-is.
OK.
>+
>+ /* 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);
> From df9717ca932f95f55b528024829758dd9b2f2f56 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
~~~~~~~~~~~~~~~~
TEST_USER_PREFIX is defined.
Fixed.
The code is fine.
> From ae448cc95f9ab9fbca3aba5107bb964caf8250ec 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.
ACK
Thanks.
> From 943d828ec283284269f954b3044292fb491cf5fa 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.
Thanks, ACK
Thanks.
> From 5e6274406deeb64e0c8a125d6409300b3bda6d61 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
Two remarks about memory contexts
>---
> 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
439084c85c97c8405227c2599621d89c3dc85fe4..b680bd8f24ede5b149d0f814fbf0a2aa9cbfa040
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;
[...]
>+ tmp_ctx = talloc_new(req_mem_ctx);
I don't see the need for tmp_ctx really, you can just use test_ctx..
Fixed.
>+
>+ 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);
Please either free both tmp_ctx and req_mem_ctx or none of them. I think
freeing none of them and relying on talloc to free them when test_ctx is
gone is fine.
Fixed.
> From 8a38a1c3d03f9c89725f9b9e686696882eed305e 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
ACK
Thanks.
> From 71347406a22bc0a9a6931abe83dcb65b8f3eca8a 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
ACK
Thanks.
> From 331a7b0f995aadb69dfa15a89aa46875e67d4377 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
5030d3e3fcee9223e855309c70403e4f7e25a749..7725c76651e2caf545b5b26488bc8b6417b9b2e5
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));
Can we use time(NULL)-1 and drop the sleep(1) ?
Yes, of course. I fixed it.
Otherwise ACK.
Thanks.
CI is still running..
There is new patch set attached.
Petr
>From 764a9e31e5b0169f0d92ec73170f76d491a64c58 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 ed7d5e6c85aeb1d076bf5ec0bf3bd19f4eb28926 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_PREFIX. 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 265802b8b4b760113cc71008e8b892c5a62f7846 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..439084c85c97c8405227c2599621d89c3dc85fe4 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 transaction_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 transaction_time)
+{
+ prepare_concrete_user(mem_ctx, domain, TEST_USER_NAME, TEST_USER_ID,
+ TEST_GROUP_ID, timeout, transaction_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 73f04246cfbf4abcc47455698539426bb746108f 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 ef85b167ea1517bb6057fe2b8b32d3b0712739d0 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 | 63 ++++++++++++++++++++++++++++-
1 file changed, 62 insertions(+), 1 deletion(-)
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index 439084c85c97c8405227c2599621d89c3dc85fe4..df3bd86979bdf46cd114b8ef74e694d255f0cee0 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,67 @@ 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;
+ 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);
+
+ user_names = talloc_array(test_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(test_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));
+}
void test_users_by_filter_filter_old(void **state)
{
@@ -1557,6 +1617,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 a3176e0ffafa8630757d21077c75d69d68c5fb58 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 df3bd86979bdf46cd114b8ef74e694d255f0cee0..52b1fbdafff76031ef5f15edfe5de2ca61095878 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -1498,6 +1498,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;
@@ -1618,6 +1661,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 d3d6da2d27ee90d9be1a0b30f1a7afba2fd6a381 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 52b1fbdafff76031ef5f15edfe5de2ca61095878..fa6c8fca36cf29ef38b108b519de336d4b2b77af 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);
@@ -1507,7 +1517,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 166bcf0269f6ee89b1ab1cd946d149e0eb558077 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 | 66 +++++++++++++++++++++++++++++
1 file changed, 66 insertions(+)
diff --git a/src/tests/cmocka/test_responder_cache_req.c b/src/tests/cmocka/test_responder_cache_req.c
index fa6c8fca36cf29ef38b108b519de336d4b2b77af..842f94a72b0d5c3c7b3b47f541bd9b00f7038d46 100644
--- a/src/tests/cmocka/test_responder_cache_req.c
+++ b/src/tests/cmocka/test_responder_cache_req.c
@@ -1552,6 +1552,71 @@ 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)-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_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;
@@ -1673,6 +1738,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
