Branch data Line data Source code
1 : : /*
2 : : SSSD
3 : :
4 : : System Database
5 : :
6 : : Copyright (C) Stephen Gallagher <sgallagh@redhat.com> 2009
7 : :
8 : : This program is free software; you can redistribute it and/or modify
9 : : it under the terms of the GNU General Public License as published by
10 : : the Free Software Foundation; either version 3 of the License, or
11 : : (at your option) any later version.
12 : :
13 : : This program is distributed in the hope that it will be useful,
14 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
15 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 : : GNU General Public License for more details.
17 : :
18 : : You should have received a copy of the GNU General Public License
19 : : along with this program. If not, see <http://www.gnu.org/licenses/>.
20 : : */
21 : :
22 : : #include <stdlib.h>
23 : : #include <check.h>
24 : : #include <talloc.h>
25 : : #include <tevent.h>
26 : : #include <popt.h>
27 : : #include <sys/stat.h>
28 : : #include <sys/types.h>
29 : : #include "util/util.h"
30 : : #include "confdb/confdb_setup.h"
31 : : #include "db/sysdb_private.h"
32 : : #include "db/sysdb_services.h"
33 : : #include "db/sysdb_autofs.h"
34 : : #include "tests/common.h"
35 : :
36 : : #define TESTS_PATH "tests_sysdb"
37 : : #define TEST_CONF_FILE "tests_conf.ldb"
38 : :
39 : : #define TEST_ATTR_NAME "test_attr_name"
40 : : #define TEST_ATTR_VALUE "test_attr_value"
41 : : #define TEST_ATTR_UPDATE_VALUE "test_attr_update_value"
42 : : #define TEST_ATTR_ADD_NAME "test_attr_add_name"
43 : : #define TEST_ATTR_ADD_VALUE "test_attr_add_value"
44 : : #define CUSTOM_TEST_CONTAINER "custom_test_container"
45 : : #define CUSTOM_TEST_OBJECT "custom_test_object"
46 : :
47 : : #define ASQ_TEST_USER "testuser27010"
48 : : #define ASQ_TEST_USER_UID 27010
49 : :
50 : : #define MBO_USER_BASE 27500
51 : : #define MBO_GROUP_BASE 28500
52 : : #define NUM_GHOSTS 10
53 : :
54 : : #define TEST_AUTOFS_MAP_BASE 29500
55 : :
56 : : struct sysdb_test_ctx {
57 : : struct sysdb_ctx *sysdb;
58 : : struct confdb_ctx *confdb;
59 : : struct tevent_context *ev;
60 : : struct sss_domain_info *domain;
61 : : };
62 : :
63 : 623 : static int setup_sysdb_tests(struct sysdb_test_ctx **ctx)
64 : : {
65 : : struct sysdb_test_ctx *test_ctx;
66 : : char *conf_db;
67 : : int ret;
68 : :
69 : : const char *val[2];
70 : 623 : val[1] = NULL;
71 : :
72 : : /* Create tests directory if it doesn't exist */
73 : : /* (relative to current dir) */
74 : 623 : ret = mkdir(TESTS_PATH, 0775);
75 [ + - ][ - + ]: 623 : if (ret == -1 && errno != EEXIST) {
76 : 0 : fail("Could not create %s directory", TESTS_PATH);
77 : : return EFAULT;
78 : : }
79 : :
80 : 623 : test_ctx = talloc_zero(NULL, struct sysdb_test_ctx);
81 [ - + ]: 623 : if (test_ctx == NULL) {
82 : 0 : fail("Could not allocate memory for test context");
83 : : return ENOMEM;
84 : : }
85 : :
86 : : /* Create an event context
87 : : * It will not be used except in confdb_init and sysdb_init
88 : : */
89 : 623 : test_ctx->ev = tevent_context_init(test_ctx);
90 [ - + ]: 623 : if (test_ctx->ev == NULL) {
91 : 0 : fail("Could not create event context");
92 : 0 : talloc_free(test_ctx);
93 : : return EIO;
94 : : }
95 : :
96 : 623 : conf_db = talloc_asprintf(test_ctx, "%s/%s", TESTS_PATH, TEST_CONF_FILE);
97 [ - + ]: 623 : if (conf_db == NULL) {
98 : 0 : fail("Out of memory, aborting!");
99 : 0 : talloc_free(test_ctx);
100 : : return ENOMEM;
101 : : }
102 [ + - ][ + - ]: 623 : DEBUG(3, ("CONFDB: %s\n", conf_db));
[ - + ][ # # ]
[ # # ]
103 : :
104 : : /* Connect to the conf db */
105 : 623 : ret = confdb_init(test_ctx, &test_ctx->confdb, conf_db);
106 [ - + ]: 623 : if (ret != EOK) {
107 : 0 : fail("Could not initialize connection to the confdb");
108 : 0 : talloc_free(test_ctx);
109 : : return ret;
110 : : }
111 : :
112 : 623 : val[0] = "LOCAL";
113 : 623 : ret = confdb_add_param(test_ctx->confdb, true,
114 : : "config/sssd", "domains", val);
115 [ - + ]: 623 : if (ret != EOK) {
116 : 0 : fail("Could not initialize domains placeholder");
117 : 0 : talloc_free(test_ctx);
118 : : return ret;
119 : : }
120 : :
121 : 623 : val[0] = "local";
122 : 623 : ret = confdb_add_param(test_ctx->confdb, true,
123 : : "config/domain/LOCAL", "id_provider", val);
124 [ - + ]: 623 : if (ret != EOK) {
125 : 0 : fail("Could not initialize provider");
126 : 0 : talloc_free(test_ctx);
127 : : return ret;
128 : : }
129 : :
130 : 623 : val[0] = "TRUE";
131 : 623 : ret = confdb_add_param(test_ctx->confdb, true,
132 : : "config/domain/LOCAL", "enumerate", val);
133 [ - + ]: 623 : if (ret != EOK) {
134 : 0 : fail("Could not initialize LOCAL domain");
135 : 0 : talloc_free(test_ctx);
136 : : return ret;
137 : : }
138 : :
139 : 623 : val[0] = "TRUE";
140 : 623 : ret = confdb_add_param(test_ctx->confdb, true,
141 : : "config/domain/LOCAL", "cache_credentials", val);
142 [ - + ]: 623 : if (ret != EOK) {
143 : 0 : fail("Could not initialize LOCAL domain");
144 : 0 : talloc_free(test_ctx);
145 : : return ret;
146 : : }
147 : :
148 : 623 : ret = sysdb_init_domain_and_sysdb(test_ctx, test_ctx->confdb, "local",
149 : : TESTS_PATH,
150 : : &test_ctx->domain, &test_ctx->sysdb);
151 [ - + ]: 623 : if (ret != EOK) {
152 : 0 : fail("Could not initialize connection to the sysdb (%d)", ret);
153 : 0 : talloc_free(test_ctx);
154 : : return ret;
155 : : }
156 : :
157 : 623 : *ctx = test_ctx;
158 : : return EOK;
159 : : }
160 : :
161 : : struct test_data {
162 : : struct tevent_context *ev;
163 : : struct sysdb_test_ctx *ctx;
164 : :
165 : : const char *username;
166 : : const char *groupname;
167 : : const char *netgrname;
168 : : const char *autofsmapname;
169 : : uid_t uid;
170 : : gid_t gid;
171 : : const char *shell;
172 : :
173 : : bool finished;
174 : : int error;
175 : :
176 : : struct sysdb_attrs *attrs;
177 : : const char **attrlist;
178 : : char **memberlist;
179 : : struct ldb_message *msg;
180 : :
181 : : size_t msgs_count;
182 : : struct ldb_message **msgs;
183 : : };
184 : :
185 : 10 : static int test_add_user(struct test_data *data)
186 : : {
187 : : char *homedir;
188 : : char *gecos;
189 : : int ret;
190 : :
191 : 10 : homedir = talloc_asprintf(data, "/home/testuser%d", data->uid);
192 : 10 : gecos = talloc_asprintf(data, "Test User %d", data->uid);
193 : :
194 : 10 : ret = sysdb_add_user(data->ctx->sysdb, data->username,
195 : : data->uid, 0, gecos, homedir, "/bin/bash",
196 : : NULL, NULL, 0, 0);
197 : 10 : return ret;
198 : : }
199 : :
200 : 45 : static int test_store_user(struct test_data *data)
201 : : {
202 : : char *homedir;
203 : : char *gecos;
204 : : int ret;
205 : :
206 : 45 : homedir = talloc_asprintf(data, "/home/testuser%d", data->uid);
207 : 45 : gecos = talloc_asprintf(data, "Test User %d", data->uid);
208 : :
209 [ + + ]: 45 : ret = sysdb_store_user(data->ctx->sysdb, data->username, "x",
210 : : data->uid, 0, gecos, homedir,
211 : 45 : data->shell ? data->shell : "/bin/bash",
212 : : NULL, NULL, NULL, -1, 0);
213 : 45 : return ret;
214 : : }
215 : :
216 : 10 : static int test_remove_user(struct test_data *data)
217 : : {
218 : : struct ldb_dn *user_dn;
219 : : int ret;
220 : :
221 : 10 : user_dn = sysdb_user_dn(data->ctx->sysdb, data, data->username);
222 [ + - ]: 10 : if (!user_dn) return ENOMEM;
223 : :
224 : 10 : ret = sysdb_delete_entry(data->ctx->sysdb, user_dn, true);
225 : 10 : return ret;
226 : : }
227 : :
228 : 15 : static int test_remove_user_by_uid(struct test_data *data)
229 : : {
230 : : int ret;
231 : :
232 : 15 : ret = sysdb_delete_user(data->ctx->sysdb, NULL, data->uid);
233 : 15 : return ret;
234 : : }
235 : :
236 : 1 : static int test_remove_nonexistent_group(struct test_data *data)
237 : : {
238 : : int ret;
239 : :
240 : 1 : ret = sysdb_delete_group(data->ctx->sysdb, NULL, data->uid);
241 : 1 : return ret;
242 : : }
243 : :
244 : 1 : static int test_remove_nonexistent_user(struct test_data *data)
245 : : {
246 : : int ret;
247 : :
248 : 1 : ret = sysdb_delete_user(data->ctx->sysdb, NULL, data->uid);
249 : 1 : return ret;
250 : : }
251 : :
252 : 10 : static int test_add_group(struct test_data *data)
253 : : {
254 : : int ret;
255 : :
256 : 10 : ret = sysdb_add_group(data->ctx->sysdb, data->groupname,
257 : : data->gid, data->attrs, 0, 0);
258 : 10 : return ret;
259 : : }
260 : :
261 : 10 : static int test_add_incomplete_group(struct test_data *data)
262 : : {
263 : : int ret;
264 : :
265 : 10 : ret = sysdb_add_incomplete_group(data->ctx->sysdb, data->groupname,
266 : : data->gid, NULL, true, 0);
267 : 10 : return ret;
268 : : }
269 : :
270 : 20 : static int test_store_group(struct test_data *data)
271 : : {
272 : : int ret;
273 : :
274 : 20 : ret = sysdb_store_group(data->ctx->sysdb, data->groupname,
275 : : data->gid, data->attrs, -1, 0);
276 : 20 : return ret;
277 : : }
278 : :
279 : 10 : static int test_remove_group(struct test_data *data)
280 : : {
281 : : struct ldb_dn *group_dn;
282 : : int ret;
283 : :
284 : 10 : group_dn = sysdb_group_dn(data->ctx->sysdb, data, data->groupname);
285 [ + - ]: 10 : if (!group_dn) return ENOMEM;
286 : :
287 : 10 : ret = sysdb_delete_entry(data->ctx->sysdb, group_dn, true);
288 : 10 : return ret;
289 : : }
290 : :
291 : 62 : static int test_remove_group_by_gid(struct test_data *data)
292 : : {
293 : : int ret;
294 : :
295 : 62 : ret = sysdb_delete_group(data->ctx->sysdb, NULL, data->gid);
296 [ + + ]: 62 : if (ret == ENOENT) {
297 : 2 : ret = EOK;
298 : : }
299 : 62 : return ret;
300 : : }
301 : :
302 : 10 : static int test_set_user_attr(struct test_data *data)
303 : : {
304 : : int ret;
305 : :
306 : 10 : ret = sysdb_set_user_attr(data->ctx->sysdb, data->username,
307 : : data->attrs, SYSDB_MOD_REP);
308 : 10 : return ret;
309 : : }
310 : :
311 : 39 : static int test_add_group_member(struct test_data *data)
312 : : {
313 : : const char *username;
314 : : int ret;
315 : :
316 : 39 : username = talloc_asprintf(data, "testuser%d", data->uid);
317 [ + - ]: 39 : if (username == NULL) {
318 : : return ENOMEM;
319 : : }
320 : :
321 : 39 : ret = sysdb_add_group_member(data->ctx->sysdb,
322 : : data->groupname, username,
323 : : SYSDB_MEMBER_USER);
324 : 39 : return ret;
325 : : }
326 : :
327 : 10 : static int test_remove_group_member(struct test_data *data)
328 : : {
329 : : const char *username;
330 : : int ret;
331 : :
332 : 10 : username = talloc_asprintf(data, "testuser%d", data->uid);
333 [ + - ]: 10 : if (username == NULL) {
334 : : return ENOMEM;
335 : : }
336 : :
337 : 10 : ret = sysdb_remove_group_member(data->ctx->sysdb,
338 : : data->groupname, username,
339 : : SYSDB_MEMBER_USER);
340 : 10 : return ret;
341 : : }
342 : :
343 : 11 : static int test_store_custom(struct test_data *data)
344 : : {
345 : : char *object_name;
346 : : int ret;
347 : :
348 : 11 : object_name = talloc_asprintf(data, "%s_%d", CUSTOM_TEST_OBJECT, data->uid);
349 [ + - ]: 11 : if (!object_name) {
350 : : return ENOMEM;
351 : : }
352 : :
353 : 11 : ret = sysdb_store_custom(data->ctx->sysdb, object_name,
354 : : CUSTOM_TEST_CONTAINER, data->attrs);
355 : 11 : return ret;
356 : : }
357 : :
358 : 1 : static int test_delete_custom(struct test_data *data)
359 : : {
360 : : int ret;
361 : :
362 : 1 : ret = sysdb_delete_custom(data->ctx->sysdb,
363 : : CUSTOM_TEST_OBJECT, CUSTOM_TEST_CONTAINER);
364 : 1 : return ret;
365 : : }
366 : :
367 : 1 : static int test_search_all_users(struct test_data *data)
368 : : {
369 : : struct ldb_dn *base_dn;
370 : : int ret;
371 : :
372 : 1 : base_dn = ldb_dn_new_fmt(data, data->ctx->sysdb->ldb, SYSDB_TMPL_USER_BASE,
373 : : "LOCAL");
374 [ + - ]: 1 : if (base_dn == NULL) {
375 : : return ENOMEM;
376 : : }
377 : :
378 : 1 : ret = sysdb_search_entry(data, data->ctx->sysdb, base_dn,
379 : : LDB_SCOPE_SUBTREE, "objectClass=user",
380 : : data->attrlist, &data->msgs_count, &data->msgs);
381 : 1 : return ret;
382 : : }
383 : :
384 : 1 : static int test_delete_recursive(struct test_data *data)
385 : : {
386 : : struct ldb_dn *dn;
387 : : int ret;
388 : :
389 : 1 : dn = ldb_dn_new_fmt(data, data->ctx->sysdb->ldb, SYSDB_DOM_BASE,
390 : : "LOCAL");
391 [ + - ]: 1 : if (!dn) {
392 : : return ENOMEM;
393 : : }
394 : :
395 : 1 : ret = sysdb_delete_recursive(data->ctx->sysdb, dn, false);
396 : 1 : fail_unless(ret == EOK, "sysdb_delete_recursive returned [%d]", ret);
397 : 1 : return ret;
398 : : }
399 : :
400 : 21 : static int test_memberof_store_group(struct test_data *data)
401 : : {
402 : : int ret;
403 : 21 : struct sysdb_attrs *attrs = NULL;
404 : : char *member;
405 : : int i;
406 : :
407 : 21 : attrs = sysdb_new_attrs(data);
408 [ + - ]: 21 : if (!attrs) {
409 : : return ENOMEM;
410 : : }
411 [ + + ][ + + ]: 40 : for (i = 0; data->attrlist && data->attrlist[i]; i++) {
412 : 19 : member = sysdb_group_strdn(data, data->ctx->domain->name,
413 : : data->attrlist[i]);
414 [ + - ]: 19 : if (!member) {
415 : : return ENOMEM;
416 : : }
417 : 19 : ret = sysdb_attrs_steal_string(attrs, SYSDB_MEMBER, member);
418 [ + - ]: 19 : if (ret != EOK) {
419 : : return ret;
420 : : }
421 : : }
422 : :
423 : 21 : ret = sysdb_store_group(data->ctx->sysdb, data->groupname,
424 : : data->gid, attrs, -1, 0);
425 : 21 : return ret;
426 : : }
427 : :
428 : 10 : static int test_memberof_store_group_with_ghosts(struct test_data *data)
429 : : {
430 : : int ret;
431 : 10 : struct sysdb_attrs *attrs = NULL;
432 : : char *member;
433 : : int i;
434 : :
435 : 10 : attrs = sysdb_new_attrs(data);
436 [ + - ]: 10 : if (!attrs) {
437 : : return ENOMEM;
438 : : }
439 : :
440 [ + - ][ + + ]: 20 : for (i = 0; data->attrlist && data->attrlist[i]; i++) {
441 : 10 : member = sysdb_group_strdn(data, data->ctx->domain->name,
442 : : data->attrlist[i]);
443 [ + - ]: 10 : if (!member) {
444 : : return ENOMEM;
445 : : }
446 : 10 : ret = sysdb_attrs_steal_string(attrs, SYSDB_MEMBER, member);
447 [ + - ]: 10 : if (ret != EOK) {
448 : : return ret;
449 : : }
450 : : }
451 : :
452 [ + - ][ + + ]: 20 : for (i = 0; data->memberlist && data->memberlist[i]; i++) {
453 : 10 : ret = sysdb_attrs_steal_string(attrs, SYSDB_GHOST,
454 : : data->memberlist[i]);
455 [ + - ]: 10 : if (ret != EOK) {
456 : : return ret;
457 : : }
458 : : }
459 : :
460 : 10 : ret = sysdb_store_group(data->ctx->sysdb, data->groupname,
461 : : data->gid, attrs, -1, 0);
462 : 10 : return ret;
463 : : }
464 : :
465 : 10 : static int test_add_basic_netgroup(struct test_data *data)
466 : : {
467 : : const char *description;
468 : : int ret;
469 : :
470 : 10 : description = talloc_asprintf(data, "Test Netgroup %d", data->uid);
471 : :
472 : 10 : ret = sysdb_add_basic_netgroup(data->ctx->sysdb,
473 : : data->netgrname, description);
474 : 10 : return ret;
475 : : }
476 : :
477 : 5 : static int test_remove_netgroup_entry(struct test_data *data)
478 : : {
479 : : struct ldb_dn *netgroup_dn;
480 : : int ret;
481 : :
482 : 5 : netgroup_dn = sysdb_netgroup_dn(data->ctx->sysdb, data, data->netgrname);
483 [ + - ]: 5 : if (!netgroup_dn) return ENOMEM;
484 : :
485 : 5 : ret = sysdb_delete_entry(data->ctx->sysdb, netgroup_dn, true);
486 : 5 : return ret;
487 : : }
488 : :
489 : 5 : static int test_remove_netgroup_by_name(struct test_data *data)
490 : : {
491 : : int ret;
492 : :
493 : 5 : ret = sysdb_delete_netgroup(data->ctx->sysdb, data->netgrname);
494 : 5 : return ret;
495 : : }
496 : :
497 : 10 : static int test_set_netgroup_attr(struct test_data *data)
498 : : {
499 : : int ret;
500 : : const char *description;
501 : 10 : struct sysdb_attrs *attrs = NULL;
502 : :
503 : 10 : description = talloc_asprintf(data, "Sysdb Netgroup %d", data->uid);
504 : :
505 : 10 : attrs = sysdb_new_attrs(data);
506 [ + - ]: 10 : if (!attrs) {
507 : : return ENOMEM;
508 : : }
509 : :
510 : 10 : ret = sysdb_attrs_add_string(attrs, SYSDB_DESCRIPTION, description);
511 [ + - ]: 10 : if (ret) {
512 : : return ret;
513 : : }
514 : :
515 : 10 : ret = sysdb_set_netgroup_attr(data->ctx->sysdb,
516 : : data->netgrname, attrs, SYSDB_MOD_REP);
517 : 10 : return ret;
518 : : }
519 : :
520 : 10 : START_TEST (test_sysdb_store_user)
521 : : {
522 : : struct sysdb_test_ctx *test_ctx;
523 : : struct test_data *data;
524 : : int ret;
525 : :
526 : : /* Setup */
527 : 10 : ret = setup_sysdb_tests(&test_ctx);
528 [ - + ]: 10 : if (ret != EOK) {
529 : 0 : fail("Could not set up the test");
530 : 10 : return;
531 : : }
532 : :
533 : 10 : data = talloc_zero(test_ctx, struct test_data);
534 : 10 : data->ctx = test_ctx;
535 : 10 : data->ev = test_ctx->ev;
536 : 10 : data->uid = _i;
537 : 10 : data->gid = _i;
538 : 10 : data->username = talloc_asprintf(data, "testuser%d", _i);
539 : :
540 : 10 : ret = test_store_user(data);
541 : :
542 : 10 : fail_if(ret != EOK, "Could not store user %s", data->username);
543 : 10 : talloc_free(test_ctx);
544 : : }
545 : : END_TEST
546 : :
547 : 10 : START_TEST (test_sysdb_store_user_existing)
548 : : {
549 : : struct sysdb_test_ctx *test_ctx;
550 : : struct test_data *data;
551 : : int ret;
552 : :
553 : : /* Setup */
554 : 10 : ret = setup_sysdb_tests(&test_ctx);
555 [ - + ]: 10 : if (ret != EOK) {
556 : 0 : fail("Could not set up the test");
557 : 10 : return;
558 : : }
559 : :
560 : 10 : data = talloc_zero(test_ctx, struct test_data);
561 : 10 : data->ctx = test_ctx;
562 : 10 : data->ev = test_ctx->ev;
563 : 10 : data->uid = _i;
564 : 10 : data->gid = _i;
565 : 10 : data->username = talloc_asprintf(data, "testuser%d", _i);
566 : 10 : data->shell = talloc_asprintf(data, "/bin/ksh");
567 : :
568 : 10 : ret = test_store_user(data);
569 : :
570 : 10 : fail_if(ret != EOK, "Could not store user %s", data->username);
571 : 10 : talloc_free(test_ctx);
572 : : }
573 : : END_TEST
574 : :
575 : 10 : START_TEST (test_sysdb_store_group)
576 : : {
577 : : struct sysdb_test_ctx *test_ctx;
578 : : struct test_data *data;
579 : : int ret;
580 : :
581 : : /* Setup */
582 : 10 : ret = setup_sysdb_tests(&test_ctx);
583 [ - + ]: 10 : if (ret != EOK) {
584 : 0 : fail("Could not set up the test");
585 : 10 : return;
586 : : }
587 : :
588 : 10 : data = talloc_zero(test_ctx, struct test_data);
589 : 10 : data->ctx = test_ctx;
590 : 10 : data->ev = test_ctx->ev;
591 : 10 : data->gid = _i;
592 : 10 : data->groupname = talloc_asprintf(data, "testgroup%d", _i);
593 : :
594 : 10 : ret = test_store_group(data);
595 : :
596 : 10 : fail_if(ret != EOK, "Could not store POSIX group #%d", _i);
597 : 10 : talloc_free(test_ctx);
598 : : }
599 : : END_TEST
600 : :
601 : 10 : START_TEST (test_sysdb_remove_local_user)
602 : : {
603 : : struct sysdb_test_ctx *test_ctx;
604 : : struct test_data *data;
605 : : int ret;
606 : :
607 : : /* Setup */
608 : 10 : ret = setup_sysdb_tests(&test_ctx);
609 [ - + ]: 10 : if (ret != EOK) {
610 : 0 : fail("Could not set up the test");
611 : 10 : return;
612 : : }
613 : :
614 : 10 : data = talloc_zero(test_ctx, struct test_data);
615 : 10 : data->ctx = test_ctx;
616 : 10 : data->ev = test_ctx->ev;
617 : 10 : data->username = talloc_asprintf(data, "testuser%d", _i);
618 : :
619 : 10 : ret = test_remove_user(data);
620 : :
621 : 10 : fail_if(ret != EOK, "Could not remove user %s", data->username);
622 : 10 : talloc_free(test_ctx);
623 : : }
624 : : END_TEST
625 : :
626 : 10 : START_TEST (test_sysdb_remove_local_user_by_uid)
627 : : {
628 : : struct sysdb_test_ctx *test_ctx;
629 : : struct test_data *data;
630 : : int ret;
631 : :
632 : : /* Setup */
633 : 10 : ret = setup_sysdb_tests(&test_ctx);
634 [ - + ]: 10 : if (ret != EOK) {
635 : 0 : fail("Could not set up the test");
636 : 10 : return;
637 : : }
638 : :
639 : 10 : data = talloc_zero(test_ctx, struct test_data);
640 : 10 : data->ctx = test_ctx;
641 : 10 : data->ev = test_ctx->ev;
642 : 10 : data->uid = _i;
643 : :
644 : 10 : ret = test_remove_user_by_uid(data);
645 : :
646 : 10 : fail_if(ret != EOK, "Could not remove user with uid %d", _i);
647 : 10 : talloc_free(test_ctx);
648 : : }
649 : : END_TEST
650 : :
651 : 10 : START_TEST (test_sysdb_remove_local_group)
652 : : {
653 : : struct sysdb_test_ctx *test_ctx;
654 : : struct test_data *data;
655 : : int ret;
656 : :
657 : : /* Setup */
658 : 10 : ret = setup_sysdb_tests(&test_ctx);
659 [ - + ]: 10 : if (ret != EOK) {
660 : 0 : fail("Could not set up the test");
661 : 10 : return;
662 : : }
663 : :
664 : 10 : data = talloc_zero(test_ctx, struct test_data);
665 : 10 : data->ctx = test_ctx;
666 : 10 : data->ev = test_ctx->ev;
667 : 10 : data->groupname = talloc_asprintf(data, "testgroup%d", _i);
668 : :
669 : 10 : ret = test_remove_group(data);
670 : :
671 : 10 : fail_if(ret != EOK, "Could not remove group %s", data->groupname);
672 : 10 : talloc_free(test_ctx);
673 : : }
674 : : END_TEST
675 : :
676 : 62 : START_TEST (test_sysdb_remove_local_group_by_gid)
677 : : {
678 : : struct sysdb_test_ctx *test_ctx;
679 : : struct test_data *data;
680 : : int ret;
681 : :
682 : : /* Setup */
683 : 62 : ret = setup_sysdb_tests(&test_ctx);
684 [ - + ]: 62 : if (ret != EOK) {
685 : 0 : fail("Could not set up the test");
686 : 62 : return;
687 : : }
688 : :
689 : 62 : data = talloc_zero(test_ctx, struct test_data);
690 : 62 : data->ctx = test_ctx;
691 : 62 : data->ev = test_ctx->ev;
692 : 62 : data->gid = _i;
693 : :
694 : 62 : ret = test_remove_group_by_gid(data);
695 : :
696 : 62 : fail_if(ret != EOK, "Could not remove group with gid %d", _i);
697 : 62 : talloc_free(test_ctx);
698 : : }
699 : : END_TEST
700 : :
701 : 10 : START_TEST (test_sysdb_add_user)
702 : : {
703 : : struct sysdb_test_ctx *test_ctx;
704 : : struct test_data *data;
705 : : int ret;
706 : :
707 : : /* Setup */
708 : 10 : ret = setup_sysdb_tests(&test_ctx);
709 [ - + ]: 10 : if (ret != EOK) {
710 : 0 : fail("Could not set up the test");
711 : 10 : return;
712 : : }
713 : :
714 : 10 : data = talloc_zero(test_ctx, struct test_data);
715 : 10 : data->ctx = test_ctx;
716 : 10 : data->ev = test_ctx->ev;
717 : 10 : data->uid = _i;
718 : 10 : data->gid = _i;
719 : 10 : data->username = talloc_asprintf(data, "testuser%d", _i);
720 : :
721 : 10 : ret = test_add_user(data);
722 : :
723 : 10 : fail_if(ret != EOK, "Could not add user %s", data->username);
724 : 10 : talloc_free(test_ctx);
725 : : }
726 : : END_TEST
727 : :
728 : 10 : START_TEST (test_sysdb_add_group)
729 : : {
730 : : struct sysdb_test_ctx *test_ctx;
731 : : struct test_data *data;
732 : : int ret;
733 : :
734 : : /* Setup */
735 : 10 : ret = setup_sysdb_tests(&test_ctx);
736 [ - + ]: 10 : if (ret != EOK) {
737 : 0 : fail("Could not set up the test");
738 : 10 : return;
739 : : }
740 : :
741 : 10 : data = talloc_zero(test_ctx, struct test_data);
742 : 10 : data->ctx = test_ctx;
743 : 10 : data->ev = test_ctx->ev;
744 : 10 : data->uid = _i;
745 : 10 : data->gid = _i;
746 : 10 : data->groupname = talloc_asprintf(data, "testgroup%d", _i);
747 : :
748 : 10 : ret = test_add_group(data);
749 : :
750 : 10 : fail_if(ret != EOK, "Could not add group %s", data->groupname);
751 : 10 : talloc_free(test_ctx);
752 : : }
753 : : END_TEST
754 : :
755 : 10 : START_TEST (test_sysdb_add_group_with_ghosts)
756 : : {
757 : : struct sysdb_test_ctx *test_ctx;
758 : : struct test_data *data;
759 : : int ret;
760 : : char *membername;
761 : : int j;
762 : :
763 : : /* Setup */
764 : 10 : ret = setup_sysdb_tests(&test_ctx);
765 [ - + ]: 10 : if (ret != EOK) {
766 : 0 : fail("Could not set up the test");
767 : : return;
768 : : }
769 : :
770 : 10 : data = talloc_zero(test_ctx, struct test_data);
771 : 10 : data->ctx = test_ctx;
772 : 10 : data->ev = test_ctx->ev;
773 : 10 : data->uid = _i;
774 : 10 : data->gid = _i;
775 : 10 : data->groupname = talloc_asprintf(data, "testgroup%d", _i);
776 : 10 : fail_unless(data->groupname != NULL, "Out of memory\n");
777 : :
778 : 10 : data->attrs = sysdb_new_attrs(data);
779 [ + - ]: 10 : if (ret != EOK) {
780 : 0 : fail("Could not create the changeset");
781 : : return;
782 : : }
783 : :
784 [ + + ]: 55 : for (j = MBO_GROUP_BASE; j < _i; j++) {
785 : 45 : membername = talloc_asprintf(data, "testghost%d", j);
786 : 45 : fail_unless(membername != NULL, "Out of memory\n");
787 : 45 : ret = sysdb_attrs_steal_string(data->attrs, SYSDB_GHOST, membername);
788 [ - + ]: 45 : if (ret != EOK) {
789 : 0 : fail_unless(ret == EOK, "Cannot add attr\n");
790 : : }
791 : : }
792 : :
793 : 10 : ret = test_store_group(data);
794 : :
795 : 10 : fail_if(ret != EOK, "Could not add group %s", data->groupname);
796 : 10 : talloc_free(test_ctx);
797 : : }
798 : : END_TEST
799 : :
800 : 10 : START_TEST (test_sysdb_add_incomplete_group)
801 : : {
802 : : struct sysdb_test_ctx *test_ctx;
803 : : struct test_data *data;
804 : : int ret;
805 : :
806 : : /* Setup */
807 : 10 : ret = setup_sysdb_tests(&test_ctx);
808 [ - + ]: 10 : if (ret != EOK) {
809 : 0 : fail("Could not set up the test");
810 : 10 : return;
811 : : }
812 : :
813 : 10 : data = talloc_zero(test_ctx, struct test_data);
814 : 10 : data->ctx = test_ctx;
815 : 10 : data->ev = test_ctx->ev;
816 : 10 : data->uid = _i;
817 : 10 : data->gid = _i;
818 : 10 : data->groupname = talloc_asprintf(data, "testgroup%d", _i);
819 : :
820 : 10 : ret = test_add_incomplete_group(data);
821 : :
822 : 10 : fail_if(ret != EOK, "Could not add incomplete group %s", data->groupname);
823 : 10 : talloc_free(test_ctx);
824 : : }
825 : : END_TEST
826 : :
827 : 20 : START_TEST (test_sysdb_getpwnam)
828 : : {
829 : : struct sysdb_test_ctx *test_ctx;
830 : : struct ldb_result *res;
831 : : const char *username;
832 : : uid_t uid;
833 : : int ret;
834 : :
835 : : /* Setup */
836 : 20 : ret = setup_sysdb_tests(&test_ctx);
837 [ - + ]: 20 : if (ret != EOK) {
838 : 0 : fail("Could not set up the test");
839 : 20 : return;
840 : : }
841 : :
842 : 20 : username = talloc_asprintf(test_ctx, "testuser%d", _i);
843 : :
844 : 20 : ret = sysdb_getpwnam(test_ctx,
845 : 20 : test_ctx->sysdb,
846 : : username, &res);
847 [ - + ]: 20 : if (ret) {
848 : 0 : fail("sysdb_getpwnam failed for username %s (%d: %s)",
849 : : username, ret, strerror(ret));
850 : : goto done;
851 : : }
852 : :
853 [ - + ]: 20 : if (res->count != 1) {
854 : 0 : fail("Invalid number of replies. Expected 1, got %d", res->count);
855 : : goto done;
856 : : }
857 : :
858 : 20 : uid = ldb_msg_find_attr_as_uint(res->msgs[0], SYSDB_UIDNUM, 0);
859 : 20 : fail_unless(uid == _i, "Did not find the expected UID");
860 : :
861 : : /* Search for the user with the wrong case */
862 : 20 : username = talloc_asprintf(test_ctx, "TESTUSER%d", _i);
863 : :
864 : 20 : ret = sysdb_getpwnam(test_ctx,
865 : 20 : test_ctx->sysdb,
866 : : username, &res);
867 [ - + ]: 20 : if (ret) {
868 : 0 : fail("sysdb_getpwnam failed for username %s (%d: %s)",
869 : : username, ret, strerror(ret));
870 : : goto done;
871 : : }
872 : :
873 [ - + ]: 20 : if (res->count != 0) {
874 : 0 : fail("The upper-case username search should fail.");
875 : : }
876 : :
877 : : done:
878 : 20 : talloc_free(test_ctx);
879 : : }
880 : : END_TEST
881 : :
882 : 10 : START_TEST (test_sysdb_getgrnam)
883 : : {
884 : : struct sysdb_test_ctx *test_ctx;
885 : : struct ldb_result *res;
886 : : const char *groupname;
887 : : gid_t gid;
888 : : int ret;
889 : :
890 : : /* Setup */
891 : 10 : ret = setup_sysdb_tests(&test_ctx);
892 [ - + ]: 10 : if (ret != EOK) {
893 : 0 : fail("Could not set up the test");
894 : 10 : return;
895 : : }
896 : :
897 : 10 : groupname = talloc_asprintf(test_ctx, "testgroup%d", _i);
898 : :
899 : 10 : ret = sysdb_getgrnam(test_ctx,
900 : 10 : test_ctx->sysdb,
901 : : groupname, &res);
902 [ - + ]: 10 : if (ret) {
903 : 0 : fail("sysdb_getgrnam failed for groupname %s (%d: %s)",
904 : : groupname, ret, strerror(ret));
905 : : goto done;
906 : : }
907 : :
908 [ - + ]: 10 : if (res->count != 1) {
909 : 0 : fail("Invalid number of replies. Expected 1, got %d", res->count);
910 : : goto done;
911 : : }
912 : :
913 : 10 : gid = ldb_msg_find_attr_as_uint(res->msgs[0], SYSDB_GIDNUM, 0);
914 : 10 : fail_unless(gid == _i,
915 : : "Did not find the expected GID (found %d expected %d)",
916 : : gid, _i);
917 : :
918 : : /* Search for the group with the wrong case */
919 : 10 : groupname = talloc_asprintf(test_ctx, "TESTGROUP%d", _i);
920 : :
921 : 10 : ret = sysdb_getgrnam(test_ctx,
922 : 10 : test_ctx->sysdb,
923 : : groupname, &res);
924 [ - + ]: 10 : if (ret) {
925 : 0 : fail("sysdb_getgrnam failed for groupname %s (%d: %s)",
926 : : groupname, ret, strerror(ret));
927 : : goto done;
928 : : }
929 : :
930 [ - + ]: 10 : if (res->count != 0) {
931 : 0 : fail("The upper-case groupname search should fail.");
932 : : }
933 : :
934 : : done:
935 : 10 : talloc_free(test_ctx);
936 : : }
937 : : END_TEST
938 : :
939 : 10 : START_TEST (test_sysdb_getgrgid)
940 : : {
941 : : struct sysdb_test_ctx *test_ctx;
942 : : struct ldb_result *res;
943 : : const char *e_groupname;
944 : : const char *groupname;
945 : : int ret;
946 : :
947 : : /* Setup */
948 : 10 : ret = setup_sysdb_tests(&test_ctx);
949 [ - + ]: 10 : if (ret != EOK) {
950 : 0 : fail("Could not set up the test");
951 : 10 : return;
952 : : }
953 : :
954 : 10 : ret = sysdb_getgrgid(test_ctx,
955 : 10 : test_ctx->sysdb,
956 : : _i, &res);
957 [ - + ]: 10 : if (ret) {
958 : 0 : fail("sysdb_getgrgid failed for gid %d (%d: %s)",
959 : : _i, ret, strerror(ret));
960 : : goto done;
961 : : }
962 : :
963 : 10 : groupname = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_NAME, 0);
964 : :
965 : 10 : e_groupname = talloc_asprintf(test_ctx, "testgroup%d", _i);
966 [ - + ]: 10 : if (e_groupname == NULL) {
967 : 0 : fail("Cannot allocate memory");
968 : : goto done;
969 : : }
970 : :
971 : 10 : fail_unless(strcmp(groupname, e_groupname) == 0,
972 : : "Did not find the expected groupname (found %s expected %s)",
973 : : groupname, e_groupname);
974 : : done:
975 : 10 : talloc_free(test_ctx);
976 : : }
977 : : END_TEST
978 : :
979 : 10 : START_TEST (test_sysdb_getpwuid)
980 : : {
981 : : struct sysdb_test_ctx *test_ctx;
982 : : struct ldb_result *res;
983 : : const char *e_username;
984 : : const char *username;
985 : : int ret;
986 : :
987 : : /* Setup */
988 : 10 : ret = setup_sysdb_tests(&test_ctx);
989 [ - + ]: 10 : if (ret != EOK) {
990 : 0 : fail("Could not set up the test");
991 : 10 : return;
992 : : }
993 : :
994 : 10 : ret = sysdb_getpwuid(test_ctx,
995 : 10 : test_ctx->sysdb,
996 : : _i, &res);
997 [ - + ]: 10 : if (ret) {
998 : 0 : fail("sysdb_getpwuid failed for uid %d (%d: %s)",
999 : : _i, ret, strerror(ret));
1000 : : goto done;
1001 : : }
1002 : :
1003 : 10 : fail_unless(res->count == 1, "Expected 1 user entry, found %d\n",
1004 : : res->count);
1005 : :
1006 : 10 : username = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_NAME, 0);
1007 : :
1008 : 10 : e_username = talloc_asprintf(test_ctx, "testuser%d", _i);
1009 [ - + ]: 10 : if (username == NULL) {
1010 : 0 : fail("Cannot allocate memory");
1011 : : goto done;
1012 : : }
1013 : :
1014 : 10 : fail_unless(strcmp(username, e_username) == 0,
1015 : : "Did not find the expected username (found %s expected %s)",
1016 : : username, e_username);
1017 : : done:
1018 : 10 : talloc_free(test_ctx);
1019 : : }
1020 : : END_TEST
1021 : :
1022 : 1 : START_TEST (test_sysdb_enumgrent)
1023 : : {
1024 : : struct sysdb_test_ctx *test_ctx;
1025 : : struct ldb_result *res;
1026 : : int ret;
1027 : :
1028 : : /* Setup */
1029 : 1 : ret = setup_sysdb_tests(&test_ctx);
1030 [ - + ]: 1 : if (ret != EOK) {
1031 : 0 : fail("Could not set up the test");
1032 : 1 : return;
1033 : : }
1034 : :
1035 : 1 : ret = sysdb_enumgrent(test_ctx,
1036 : 1 : test_ctx->sysdb,
1037 : : &res);
1038 : 1 : fail_unless(ret == EOK,
1039 : : "sysdb_enumgrent failed (%d: %s)",
1040 : : ret, strerror(ret));
1041 : :
1042 : : /* 10 groups + 10 users (we're MPG) */
1043 : 1 : fail_if(res->count != 20, "Expected 20 users, got %d", res->count);
1044 : :
1045 : 1 : talloc_free(test_ctx);
1046 : : }
1047 : : END_TEST
1048 : :
1049 : 1 : START_TEST (test_sysdb_enumpwent)
1050 : : {
1051 : : struct sysdb_test_ctx *test_ctx;
1052 : : struct ldb_result *res;
1053 : : int ret;
1054 : :
1055 : : /* Setup */
1056 : 1 : ret = setup_sysdb_tests(&test_ctx);
1057 [ - + ]: 1 : if (ret != EOK) {
1058 : 0 : fail("Could not set up the test");
1059 : 1 : return;
1060 : : }
1061 : :
1062 : 1 : ret = sysdb_enumpwent(test_ctx,
1063 : 1 : test_ctx->sysdb,
1064 : : &res);
1065 : 1 : fail_unless(ret == EOK,
1066 : : "sysdb_enumpwent failed (%d: %s)",
1067 : : ret, strerror(ret));
1068 : :
1069 : 1 : fail_if(res->count != 10, "Expected 10 users, got %d", res->count);
1070 : :
1071 : 1 : talloc_free(test_ctx);
1072 : : }
1073 : : END_TEST
1074 : :
1075 : :
1076 : 10 : START_TEST (test_sysdb_set_user_attr)
1077 : : {
1078 : : struct sysdb_test_ctx *test_ctx;
1079 : : struct test_data *data;
1080 : : int ret;
1081 : :
1082 : : /* Setup */
1083 : 10 : ret = setup_sysdb_tests(&test_ctx);
1084 [ - + ]: 10 : if (ret != EOK) {
1085 : 0 : fail("Could not set up the test");
1086 : : return;
1087 : : }
1088 : :
1089 : 10 : data = talloc_zero(test_ctx, struct test_data);
1090 : 10 : data->ctx = test_ctx;
1091 : 10 : data->ev = test_ctx->ev;
1092 : 10 : data->username = talloc_asprintf(data, "testuser%d", _i);
1093 : :
1094 : 10 : data->attrs = sysdb_new_attrs(test_ctx);
1095 [ - + ]: 10 : if (ret != EOK) {
1096 : 0 : fail("Could not create the changeset");
1097 : : return;
1098 : : }
1099 : :
1100 : 10 : ret = sysdb_attrs_add_string(data->attrs,
1101 : : SYSDB_SHELL,
1102 : : "/bin/ksh");
1103 [ - + ]: 10 : if (ret != EOK) {
1104 : 0 : fail("Could not create the changeset");
1105 : : return;
1106 : : }
1107 : :
1108 : 10 : ret = test_set_user_attr(data);
1109 : :
1110 : 10 : fail_if(ret != EOK, "Could not modify user %s", data->username);
1111 : :
1112 : 10 : talloc_free(test_ctx);
1113 : : }
1114 : : END_TEST
1115 : :
1116 : 20 : START_TEST (test_sysdb_get_user_attr)
1117 : : {
1118 : : struct sysdb_test_ctx *test_ctx;
1119 : 20 : const char *attrs[] = { SYSDB_SHELL, NULL };
1120 : : struct ldb_result *res;
1121 : : const char *attrval;
1122 : : char *username;
1123 : : int ret;
1124 : :
1125 : : /* Setup */
1126 : 20 : ret = setup_sysdb_tests(&test_ctx);
1127 [ - + ]: 20 : if (ret != EOK) {
1128 : 0 : fail("Could not set up the test");
1129 : 20 : return;
1130 : : }
1131 : :
1132 : 20 : username = talloc_asprintf(test_ctx, "testuser%d", _i);
1133 : :
1134 : 20 : ret = sysdb_get_user_attr(test_ctx, test_ctx->sysdb,
1135 : : username, attrs, &res);
1136 [ - + ]: 20 : if (ret) {
1137 : 0 : fail("Could not get attributes for user %s", username);
1138 : : goto done;
1139 : : }
1140 : :
1141 : 20 : fail_if(res->count != 1,
1142 : : "Invalid number of entries, expected 1, got %d", res->count);
1143 : :
1144 : 20 : attrval = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_SHELL, 0);
1145 : 20 : fail_if(strcmp(attrval, "/bin/ksh"),
1146 : : "Got bad attribute value for user %s", username);
1147 : : done:
1148 : 20 : talloc_free(test_ctx);
1149 : : }
1150 : : END_TEST
1151 : :
1152 : 10 : START_TEST (test_sysdb_add_group_member)
1153 : : {
1154 : : struct sysdb_test_ctx *test_ctx;
1155 : : struct test_data *data;
1156 : : int ret;
1157 : :
1158 : : /* Setup */
1159 : 10 : ret = setup_sysdb_tests(&test_ctx);
1160 [ - + ]: 10 : if (ret != EOK) {
1161 : 0 : fail("Could not set up the test");
1162 : 10 : return;
1163 : : }
1164 : :
1165 : 10 : data = talloc_zero(test_ctx, struct test_data);
1166 : 10 : data->ctx = test_ctx;
1167 : 10 : data->ev = test_ctx->ev;
1168 : 10 : data->groupname = talloc_asprintf(data, "testgroup%d", _i);
1169 : 10 : data->uid = _i - 1000; /* the UID of user to add */
1170 : :
1171 : 10 : ret = test_add_group_member(data);
1172 : :
1173 : 10 : fail_if(ret != EOK, "Could not modify group %s", data->groupname);
1174 : 10 : talloc_free(test_ctx);
1175 : : }
1176 : : END_TEST
1177 : :
1178 : 10 : START_TEST (test_sysdb_remove_group_member)
1179 : : {
1180 : : struct sysdb_test_ctx *test_ctx;
1181 : : struct test_data *data;
1182 : : int ret;
1183 : :
1184 : : /* Setup */
1185 : 10 : ret = setup_sysdb_tests(&test_ctx);
1186 [ - + ]: 10 : if (ret != EOK) {
1187 : 0 : fail("Could not set up the test");
1188 : 10 : return;
1189 : : }
1190 : :
1191 : 10 : data = talloc_zero(test_ctx, struct test_data);
1192 : 10 : data->ctx = test_ctx;
1193 : 10 : data->ev = test_ctx->ev;
1194 : 10 : data->groupname = talloc_asprintf(data, "testgroup%d", _i);
1195 : 10 : data->uid = _i - 1000; /* the UID of user to add */
1196 : :
1197 : 10 : ret = test_remove_group_member(data);
1198 : :
1199 : 10 : talloc_free(test_ctx);
1200 : : }
1201 : : END_TEST
1202 : :
1203 : 1 : START_TEST (test_sysdb_remove_nonexistent_user)
1204 : : {
1205 : : struct sysdb_test_ctx *test_ctx;
1206 : : struct test_data *data;
1207 : : int ret;
1208 : :
1209 : : /* Setup */
1210 : 1 : ret = setup_sysdb_tests(&test_ctx);
1211 [ - + ]: 1 : if (ret != EOK) {
1212 : 0 : fail("Could not set up the test");
1213 : 1 : return;
1214 : : }
1215 : :
1216 : 1 : data = talloc_zero(test_ctx, struct test_data);
1217 : 1 : data->ctx = test_ctx;
1218 : 1 : data->ev = test_ctx->ev;
1219 : 1 : data->uid = 12345;
1220 : :
1221 : 1 : ret = test_remove_nonexistent_user(data);
1222 : :
1223 : 1 : fail_if(ret != ENOENT, "Unexpected return code %d, expected ENOENT", ret);
1224 : 1 : talloc_free(test_ctx);
1225 : : }
1226 : : END_TEST
1227 : :
1228 : 1 : START_TEST (test_sysdb_remove_nonexistent_group)
1229 : : {
1230 : : struct sysdb_test_ctx *test_ctx;
1231 : : struct test_data *data;
1232 : : int ret;
1233 : :
1234 : : /* Setup */
1235 : 1 : ret = setup_sysdb_tests(&test_ctx);
1236 [ - + ]: 1 : if (ret != EOK) {
1237 : 0 : fail("Could not set up the test");
1238 : 1 : return;
1239 : : }
1240 : :
1241 : 1 : data = talloc_zero(test_ctx, struct test_data);
1242 : 1 : data->ctx = test_ctx;
1243 : 1 : data->ev = test_ctx->ev;
1244 : 1 : data->uid = 12345;
1245 : :
1246 : 1 : ret = test_remove_nonexistent_group(data);
1247 : :
1248 : 1 : fail_if(ret != ENOENT, "Unexpected return code %d, expected ENOENT", ret);
1249 : 1 : talloc_free(test_ctx);
1250 : : }
1251 : : END_TEST
1252 : :
1253 : 10 : START_TEST (test_sysdb_store_custom)
1254 : : {
1255 : : struct sysdb_test_ctx *test_ctx;
1256 : : struct test_data *data;
1257 : : int ret;
1258 : :
1259 : : /* Setup */
1260 : 10 : ret = setup_sysdb_tests(&test_ctx);
1261 [ - + ]: 10 : if (ret != EOK) {
1262 : 0 : fail("Could not set up the test");
1263 : : return;
1264 : : }
1265 : :
1266 : 10 : data = talloc_zero(test_ctx, struct test_data);
1267 : 10 : data->ctx = test_ctx;
1268 : 10 : data->ev = test_ctx->ev;
1269 : 10 : data->uid = _i;
1270 : 10 : data->attrs = sysdb_new_attrs(test_ctx);
1271 [ - + ]: 10 : if (ret != EOK) {
1272 : 0 : fail("Could not create attribute list");
1273 : : return;
1274 : : }
1275 : :
1276 : 10 : ret = sysdb_attrs_add_string(data->attrs,
1277 : : TEST_ATTR_NAME,
1278 : : TEST_ATTR_VALUE);
1279 [ - + ]: 10 : if (ret != EOK) {
1280 : 0 : fail("Could not add attribute");
1281 : : return;
1282 : : }
1283 : :
1284 : 10 : ret = test_store_custom(data);
1285 : :
1286 : 10 : fail_if(ret != EOK, "Could not add custom object");
1287 : 10 : talloc_free(test_ctx);
1288 : : }
1289 : : END_TEST
1290 : :
1291 : 1 : START_TEST (test_sysdb_search_custom_by_name)
1292 : : {
1293 : : struct sysdb_test_ctx *test_ctx;
1294 : : struct test_data *data;
1295 : : int ret;
1296 : : char *object_name;
1297 : :
1298 : : /* Setup */
1299 : 1 : ret = setup_sysdb_tests(&test_ctx);
1300 [ - + ]: 1 : if (ret != EOK) {
1301 : 0 : fail("Could not set up the test");
1302 : 1 : return;
1303 : : }
1304 : :
1305 : 1 : data = talloc_zero(test_ctx, struct test_data);
1306 : 1 : fail_unless(data != NULL, "talloc_zero failed");
1307 : 1 : data->ctx = test_ctx;
1308 : 1 : data->ev = test_ctx->ev;
1309 : 1 : data->attrlist = talloc_array(test_ctx, const char *, 2);
1310 : 1 : fail_unless(data->attrlist != NULL, "talloc_array failed");
1311 : 1 : data->attrlist[0] = TEST_ATTR_NAME;
1312 : 1 : data->attrlist[1] = NULL;
1313 : :
1314 : 1 : object_name = talloc_asprintf(data, "%s_%d", CUSTOM_TEST_OBJECT, 29010);
1315 : 1 : fail_unless(object_name != NULL, "talloc_asprintf failed");
1316 : :
1317 : 1 : ret = sysdb_search_custom_by_name(data, data->ctx->sysdb,
1318 : : object_name,
1319 : : CUSTOM_TEST_CONTAINER,
1320 : : data->attrlist,
1321 : : &data->msgs_count,
1322 : : &data->msgs);
1323 : :
1324 : 1 : fail_if(ret != EOK, "Could not search custom object");
1325 : :
1326 : 1 : fail_unless(data->msgs_count == 1,
1327 : : "Wrong number of objects, exptected [1] got [%d]",
1328 : : data->msgs_count);
1329 : 1 : fail_unless(data->msgs[0]->num_elements == 1,
1330 : : "Wrong number of results, expected [1] got [%d]",
1331 : : data->msgs[0]->num_elements);
1332 : 1 : fail_unless(strcmp(data->msgs[0]->elements[0].name, TEST_ATTR_NAME) == 0,
1333 : : "Wrong attribute name");
1334 : 1 : fail_unless(data->msgs[0]->elements[0].num_values == 1,
1335 : : "Wrong number of attribute values");
1336 [ - + ][ # # ]: 1 : fail_unless(strncmp((const char *)data->msgs[0]->elements[0].values[0].data,
1337 : : TEST_ATTR_VALUE,
1338 : : data->msgs[0]->elements[0].values[0].length) == 0,
1339 : : "Wrong attribute value");
1340 : :
1341 : 1 : talloc_free(test_ctx);
1342 : : }
1343 : : END_TEST
1344 : :
1345 : 1 : START_TEST (test_sysdb_update_custom)
1346 : : {
1347 : : struct sysdb_test_ctx *test_ctx;
1348 : : struct test_data *data;
1349 : : int ret;
1350 : :
1351 : : /* Setup */
1352 : 1 : ret = setup_sysdb_tests(&test_ctx);
1353 [ - + ]: 1 : if (ret != EOK) {
1354 : 0 : fail("Could not set up the test");
1355 : : return;
1356 : : }
1357 : :
1358 : 1 : data = talloc_zero(test_ctx, struct test_data);
1359 : 1 : data->ctx = test_ctx;
1360 : 1 : data->ev = test_ctx->ev;
1361 : 1 : data->uid = 29010;
1362 : 1 : data->attrs = sysdb_new_attrs(test_ctx);
1363 [ - + ]: 1 : if (ret != EOK) {
1364 : 0 : fail("Could not create attribute list");
1365 : : return;
1366 : : }
1367 : :
1368 : 1 : ret = sysdb_attrs_add_string(data->attrs,
1369 : : TEST_ATTR_NAME,
1370 : : TEST_ATTR_UPDATE_VALUE);
1371 [ - + ]: 1 : if (ret != EOK) {
1372 : 0 : fail("Could not add attribute");
1373 : : return;
1374 : : }
1375 : :
1376 : 1 : ret = sysdb_attrs_add_string(data->attrs,
1377 : : TEST_ATTR_ADD_NAME,
1378 : : TEST_ATTR_ADD_VALUE);
1379 [ - + ]: 1 : if (ret != EOK) {
1380 : 0 : fail("Could not add attribute");
1381 : : return;
1382 : : }
1383 : :
1384 : 1 : ret = test_store_custom(data);
1385 : :
1386 : 1 : fail_if(ret != EOK, "Could not add custom object");
1387 : 1 : talloc_free(test_ctx);
1388 : : }
1389 : : END_TEST
1390 : :
1391 : 1 : START_TEST (test_sysdb_search_custom_update)
1392 : : {
1393 : : struct sysdb_test_ctx *test_ctx;
1394 : : struct test_data *data;
1395 : : int ret;
1396 : : char *object_name;
1397 : : struct ldb_message_element *el;
1398 : :
1399 : : /* Setup */
1400 : 1 : ret = setup_sysdb_tests(&test_ctx);
1401 [ - + ]: 1 : if (ret != EOK) {
1402 : 0 : fail("Could not set up the test");
1403 : 1 : return;
1404 : : }
1405 : :
1406 : 1 : data = talloc_zero(test_ctx, struct test_data);
1407 : 1 : fail_unless(data != NULL, "talloc_zero failed");
1408 : 1 : data->ctx = test_ctx;
1409 : 1 : data->ev = test_ctx->ev;
1410 : 1 : data->attrlist = talloc_array(test_ctx, const char *, 3);
1411 : 1 : fail_unless(data->attrlist != NULL, "talloc_array failed");
1412 : 1 : data->attrlist[0] = TEST_ATTR_NAME;
1413 : 1 : data->attrlist[1] = TEST_ATTR_ADD_NAME;
1414 : 1 : data->attrlist[2] = NULL;
1415 : :
1416 : 1 : object_name = talloc_asprintf(data, "%s_%d", CUSTOM_TEST_OBJECT, 29010);
1417 : 1 : fail_unless(object_name != NULL, "talloc_asprintf failed");
1418 : :
1419 : 1 : ret = sysdb_search_custom_by_name(data, data->ctx->sysdb,
1420 : : object_name,
1421 : : CUSTOM_TEST_CONTAINER,
1422 : : data->attrlist,
1423 : : &data->msgs_count,
1424 : : &data->msgs);
1425 : :
1426 : 1 : fail_if(ret != EOK, "Could not search custom object");
1427 : :
1428 : 1 : fail_unless(data->msgs_count == 1,
1429 : : "Wrong number of objects, exptected [1] got [%d]",
1430 : : data->msgs_count);
1431 : 1 : fail_unless(data->msgs[0]->num_elements == 2,
1432 : : "Wrong number of results, expected [2] got [%d]",
1433 : : data->msgs[0]->num_elements);
1434 : :
1435 : 1 : el = ldb_msg_find_element(data->msgs[0], TEST_ATTR_NAME);
1436 : 1 : fail_unless(el != NULL, "Attribute [%s] not found", TEST_ATTR_NAME);
1437 : 1 : fail_unless(el->num_values == 1, "Wrong number ([%d] instead of 1) "
1438 : : "of attribute values for [%s]", el->num_values,
1439 : : TEST_ATTR_NAME);
1440 [ - + ][ # # ]: 1 : fail_unless(strncmp((const char *) el->values[0].data,
1441 : : TEST_ATTR_UPDATE_VALUE,
1442 : : el->values[0].length) == 0,
1443 : : "Wrong attribute value");
1444 : :
1445 : 1 : el = ldb_msg_find_element(data->msgs[0], TEST_ATTR_ADD_NAME);
1446 : 1 : fail_unless(el != NULL, "Attribute [%s] not found", TEST_ATTR_ADD_NAME);
1447 : 1 : fail_unless(el->num_values == 1, "Wrong number ([%d] instead of 1) "
1448 : : "of attribute values for [%s]", el->num_values,
1449 : : TEST_ATTR_ADD_NAME);
1450 [ - + ][ # # ]: 1 : fail_unless(strncmp((const char *) el->values[0].data,
1451 : : TEST_ATTR_ADD_VALUE,
1452 : : el->values[0].length) == 0,
1453 : : "Wrong attribute value");
1454 : :
1455 : :
1456 : 1 : talloc_free(test_ctx);
1457 : : }
1458 : : END_TEST
1459 : :
1460 : 1 : START_TEST (test_sysdb_search_custom)
1461 : : {
1462 : : struct sysdb_test_ctx *test_ctx;
1463 : : struct test_data *data;
1464 : : int ret;
1465 : 1 : const char *filter = "(distinguishedName=*)";
1466 : :
1467 : : /* Setup */
1468 : 1 : ret = setup_sysdb_tests(&test_ctx);
1469 [ - + ]: 1 : if (ret != EOK) {
1470 : 0 : fail("Could not set up the test");
1471 : 1 : return;
1472 : : }
1473 : :
1474 : 1 : data = talloc_zero(test_ctx, struct test_data);
1475 : 1 : fail_unless(data != NULL, "talloc_zero failed");
1476 : 1 : data->ctx = test_ctx;
1477 : 1 : data->ev = test_ctx->ev;
1478 : 1 : data->attrlist = talloc_array(test_ctx, const char *, 3);
1479 : 1 : fail_unless(data->attrlist != NULL, "talloc_array failed");
1480 : 1 : data->attrlist[0] = TEST_ATTR_NAME;
1481 : 1 : data->attrlist[1] = TEST_ATTR_ADD_NAME;
1482 : 1 : data->attrlist[2] = NULL;
1483 : :
1484 : 1 : ret = sysdb_search_custom(data, data->ctx->sysdb,
1485 : : filter,
1486 : : CUSTOM_TEST_CONTAINER,
1487 : : data->attrlist,
1488 : : &data->msgs_count,
1489 : : &data->msgs);
1490 : :
1491 : 1 : fail_if(ret != EOK, "Could not search custom object");
1492 : :
1493 : 1 : fail_unless(data->msgs_count == 10,
1494 : : "Wrong number of objects, exptected [10] got [%d]",
1495 : : data->msgs_count);
1496 : :
1497 : 1 : talloc_free(test_ctx);
1498 : : }
1499 : : END_TEST
1500 : :
1501 : 1 : START_TEST (test_sysdb_delete_custom)
1502 : : {
1503 : : struct sysdb_test_ctx *test_ctx;
1504 : : struct test_data *data;
1505 : : int ret;
1506 : :
1507 : : /* Setup */
1508 : 1 : ret = setup_sysdb_tests(&test_ctx);
1509 [ - + ]: 1 : if (ret != EOK) {
1510 : 0 : fail("Could not set up the test");
1511 : 1 : return;
1512 : : }
1513 : :
1514 : 1 : data = talloc_zero(test_ctx, struct test_data);
1515 : 1 : data->ctx = test_ctx;
1516 : 1 : data->ev = test_ctx->ev;
1517 : :
1518 : 1 : ret = test_delete_custom(data);
1519 : :
1520 : 1 : fail_if(ret != EOK, "Could not delete custom object");
1521 : 1 : talloc_free(test_ctx);
1522 : : }
1523 : : END_TEST
1524 : :
1525 : 1 : START_TEST (test_sysdb_cache_password)
1526 : : {
1527 : : struct sysdb_test_ctx *test_ctx;
1528 : : struct test_data *data;
1529 : : int ret;
1530 : :
1531 : : /* Setup */
1532 : 1 : ret = setup_sysdb_tests(&test_ctx);
1533 : 1 : fail_unless(ret == EOK, "Could not set up the test");
1534 : :
1535 : 1 : data = talloc_zero(test_ctx, struct test_data);
1536 : 1 : data->ctx = test_ctx;
1537 : 1 : data->ev = test_ctx->ev;
1538 : 1 : data->username = talloc_asprintf(data, "testuser%d", _i);
1539 : :
1540 : 1 : ret = sysdb_cache_password(test_ctx->sysdb,
1541 : : data->username, data->username);
1542 : :
1543 : 1 : fail_unless(ret == EOK, "sysdb_cache_password request failed [%d].", ret);
1544 : :
1545 : 1 : talloc_free(test_ctx);
1546 : : }
1547 : 1 : END_TEST
1548 : :
1549 : 3 : static void cached_authentication_without_expiration(const char *username,
1550 : : const char *password,
1551 : : int expected_result)
1552 : : {
1553 : : struct sysdb_test_ctx *test_ctx;
1554 : : struct test_data *data;
1555 : : int ret;
1556 : 3 : time_t expire_date = -1;
1557 : 3 : time_t delayed_until = -1;
1558 : : const char *val[2];
1559 : 3 : val[1] = NULL;
1560 : :
1561 : : /* Setup */
1562 : 3 : ret = setup_sysdb_tests(&test_ctx);
1563 : 3 : fail_unless(ret == EOK, "Could not set up the test");
1564 : :
1565 : 3 : data = talloc_zero(test_ctx, struct test_data);
1566 : 3 : data->ctx = test_ctx;
1567 : 3 : data->ev = test_ctx->ev;
1568 : 3 : data->username = username;
1569 : :
1570 : 3 : val[0] = "0";
1571 : 3 : ret = confdb_add_param(test_ctx->confdb, true, CONFDB_PAM_CONF_ENTRY,
1572 : : CONFDB_PAM_CRED_TIMEOUT, val);
1573 [ - + ]: 3 : if (ret != EOK) {
1574 : 0 : fail("Could not initialize provider");
1575 : 0 : talloc_free(test_ctx);
1576 : 3 : return;
1577 : : }
1578 : :
1579 : 3 : ret = sysdb_cache_auth(test_ctx->sysdb, data->username,
1580 : : (const uint8_t *)password, strlen(password),
1581 : 3 : test_ctx->confdb, false, &expire_date, &delayed_until);
1582 : :
1583 : 3 : fail_unless(ret == expected_result, "sysdb_cache_auth request does not "
1584 : : "return expected result [%d].",
1585 : : expected_result);
1586 : :
1587 : 3 : fail_unless(expire_date == 0, "Wrong expire date, expected [%d], got [%d]",
1588 : : 0, expire_date);
1589 : :
1590 : 3 : fail_unless(delayed_until == -1, "Wrong delay, expected [%d], got [%d]",
1591 : : -1, delayed_until);
1592 : :
1593 : 3 : talloc_free(test_ctx);
1594 : : }
1595 : :
1596 : 3 : static void cached_authentication_with_expiration(const char *username,
1597 : : const char *password,
1598 : : int expected_result)
1599 : : {
1600 : : struct sysdb_test_ctx *test_ctx;
1601 : : struct test_data *data;
1602 : : int ret;
1603 : 3 : time_t expire_date = -1;
1604 : : const char *val[2];
1605 : 3 : val[1] = NULL;
1606 : : time_t now;
1607 : : time_t expected_expire_date;
1608 : 3 : time_t delayed_until = -1;
1609 : :
1610 : : /* Setup */
1611 : 3 : ret = setup_sysdb_tests(&test_ctx);
1612 : 3 : fail_unless(ret == EOK, "Could not set up the test");
1613 : :
1614 : 3 : data = talloc_zero(test_ctx, struct test_data);
1615 : 3 : data->ctx = test_ctx;
1616 : 3 : data->ev = test_ctx->ev;
1617 : 3 : data->username = username;
1618 : :
1619 : 3 : val[0] = "1";
1620 : 3 : ret = confdb_add_param(test_ctx->confdb, true, CONFDB_PAM_CONF_ENTRY,
1621 : : CONFDB_PAM_CRED_TIMEOUT, val);
1622 [ - + ]: 3 : if (ret != EOK) {
1623 : 0 : fail("Could not initialize provider");
1624 : 0 : talloc_free(test_ctx);
1625 : 3 : return;
1626 : : }
1627 : :
1628 : 3 : now = time(NULL);
1629 : 3 : expected_expire_date = now + (24 * 60 * 60);
1630 [ + - ][ + - ]: 3 : DEBUG(9, ("Setting SYSDB_LAST_ONLINE_AUTH to [%lld].\n", (long long) now));
[ - + ][ # # ]
[ # # ]
1631 : :
1632 : 3 : data->attrs = sysdb_new_attrs(data);
1633 : 3 : ret = sysdb_attrs_add_time_t(data->attrs, SYSDB_LAST_ONLINE_AUTH, now);
1634 : :
1635 : 3 : ret = sysdb_set_user_attr(data->ctx->sysdb, data->username,
1636 : : data->attrs, SYSDB_MOD_REP);
1637 : 3 : fail_unless(ret == EOK, "Could not modify user %s", data->username);
1638 : :
1639 : 3 : ret = sysdb_cache_auth(test_ctx->sysdb, data->username,
1640 : : (const uint8_t *) password, strlen(password),
1641 : 3 : test_ctx->confdb, false, &expire_date, &delayed_until);
1642 : :
1643 : 3 : fail_unless(ret == expected_result,
1644 : : "sysdb_cache_auth request does not return expected "
1645 : : "result [%d], got [%d].", expected_result, ret);
1646 : :
1647 : 3 : fail_unless(expire_date == expected_expire_date,
1648 : : "Wrong expire date, expected [%d], got [%d]",
1649 : : expected_expire_date, expire_date);
1650 : :
1651 : 3 : fail_unless(delayed_until == -1, "Wrong delay, expected [%d], got [%d]",
1652 : : -1, delayed_until);
1653 : :
1654 : 3 : talloc_free(test_ctx);
1655 : : }
1656 : :
1657 : 1 : START_TEST (test_sysdb_cached_authentication_missing_password)
1658 : : {
1659 : : TALLOC_CTX *tmp_ctx;
1660 : : char *username;
1661 : :
1662 : 1 : tmp_ctx = talloc_new(NULL);
1663 : 1 : fail_unless(tmp_ctx != NULL, "talloc_new failed.");
1664 : :
1665 : 1 : username = talloc_asprintf(tmp_ctx, "testuser%d", _i);
1666 : 1 : fail_unless(username != NULL, "talloc_asprintf failed.");
1667 : :
1668 : 1 : cached_authentication_without_expiration(username, "abc", ENOENT);
1669 : 1 : cached_authentication_with_expiration(username, "abc", ENOENT);
1670 : :
1671 : 1 : talloc_free(tmp_ctx);
1672 : :
1673 : : }
1674 : 1 : END_TEST
1675 : :
1676 : 1 : START_TEST (test_sysdb_cached_authentication_wrong_password)
1677 : : {
1678 : : TALLOC_CTX *tmp_ctx;
1679 : : char *username;
1680 : :
1681 : 1 : tmp_ctx = talloc_new(NULL);
1682 : 1 : fail_unless(tmp_ctx != NULL, "talloc_new failed.");
1683 : :
1684 : 1 : username = talloc_asprintf(tmp_ctx, "testuser%d", _i);
1685 : 1 : fail_unless(username != NULL, "talloc_asprintf failed.");
1686 : :
1687 : 1 : cached_authentication_without_expiration(username, "abc", EINVAL);
1688 : 1 : cached_authentication_with_expiration(username, "abc", EINVAL);
1689 : :
1690 : 1 : talloc_free(tmp_ctx);
1691 : :
1692 : : }
1693 : 1 : END_TEST
1694 : :
1695 : 1 : START_TEST (test_sysdb_cached_authentication)
1696 : : {
1697 : : TALLOC_CTX *tmp_ctx;
1698 : : char *username;
1699 : :
1700 : 1 : tmp_ctx = talloc_new(NULL);
1701 : 1 : fail_unless(tmp_ctx != NULL, "talloc_new failed.");
1702 : :
1703 : 1 : username = talloc_asprintf(tmp_ctx, "testuser%d", _i);
1704 : 1 : fail_unless(username != NULL, "talloc_asprintf failed.");
1705 : :
1706 : 1 : cached_authentication_without_expiration(username, username, EOK);
1707 : 1 : cached_authentication_with_expiration(username, username, EOK);
1708 : :
1709 : 1 : talloc_free(tmp_ctx);
1710 : :
1711 : : }
1712 : 1 : END_TEST
1713 : :
1714 : 9 : START_TEST (test_sysdb_prepare_asq_test_user)
1715 : : {
1716 : : struct sysdb_test_ctx *test_ctx;
1717 : : struct test_data *data;
1718 : : int ret;
1719 : :
1720 : : /* Setup */
1721 : 9 : ret = setup_sysdb_tests(&test_ctx);
1722 [ - + ]: 9 : if (ret != EOK) {
1723 : 0 : fail("Could not set up the test");
1724 : 9 : return;
1725 : : }
1726 : :
1727 : 9 : data = talloc_zero(test_ctx, struct test_data);
1728 : 9 : data->ctx = test_ctx;
1729 : 9 : data->ev = test_ctx->ev;
1730 : 9 : data->groupname = talloc_asprintf(data, "testgroup%d", _i);
1731 : 9 : data->uid = ASQ_TEST_USER_UID;
1732 : :
1733 : 9 : ret = test_add_group_member(data);
1734 : :
1735 : 9 : fail_if(ret != EOK, "Could not modify group %s", data->groupname);
1736 : 9 : talloc_free(test_ctx);
1737 : : }
1738 : : END_TEST
1739 : :
1740 : 1 : START_TEST (test_sysdb_asq_search)
1741 : : {
1742 : : struct sysdb_test_ctx *test_ctx;
1743 : : struct test_data *data;
1744 : : struct ldb_dn *user_dn;
1745 : : int ret;
1746 : : size_t msgs_count;
1747 : : struct ldb_message **msgs;
1748 : : int i;
1749 : : char *gid_str;
1750 : :
1751 : : /* Setup */
1752 : 1 : ret = setup_sysdb_tests(&test_ctx);
1753 [ - + ]: 1 : if (ret != EOK) {
1754 : 0 : fail("Could not set up the test");
1755 : 1 : return;
1756 : : }
1757 : :
1758 : 1 : data = talloc_zero(test_ctx, struct test_data);
1759 : 1 : data->ctx = test_ctx;
1760 : 1 : data->ev = test_ctx->ev;
1761 : 1 : data->attrlist = talloc_array(data, const char *, 2);
1762 : 1 : fail_unless(data->attrlist != NULL, "talloc_array failed");
1763 : :
1764 : 1 : data->attrlist[0] = "gidNumber";
1765 : 1 : data->attrlist[1] = NULL;
1766 : :
1767 : 1 : user_dn = sysdb_user_dn(data->ctx->sysdb, data, ASQ_TEST_USER);
1768 : 1 : fail_unless(user_dn != NULL, "sysdb_user_dn failed");
1769 : :
1770 : 1 : ret = sysdb_asq_search(data, test_ctx->sysdb,
1771 : : user_dn, NULL, "memberof",
1772 : : data->attrlist, &msgs_count, &msgs);
1773 : :
1774 : 1 : fail_if(ret != EOK, "Failed to send ASQ search request.\n");
1775 : :
1776 : 1 : fail_unless(msgs_count == 10, "wrong number of results, "
1777 : : "found [%d] expected [10]", msgs_count);
1778 : :
1779 [ + + ]: 11 : for (i = 0; i < msgs_count; i++) {
1780 : 10 : fail_unless(msgs[i]->num_elements == 1, "wrong number of elements, "
1781 : : "found [%d] expected [1]",
1782 : : msgs[i]->num_elements);
1783 : :
1784 : 10 : fail_unless(msgs[i]->elements[0].num_values == 1,
1785 : : "wrong number of values, found [%d] expected [1]",
1786 : : msgs[i]->elements[0].num_values);
1787 : :
1788 : 10 : gid_str = talloc_asprintf(data, "%d", 28010 + i);
1789 : 10 : fail_unless(gid_str != NULL, "talloc_asprintf failed.");
1790 : 10 : fail_unless(strncmp(gid_str,
1791 : : (const char *) msgs[i]->elements[0].values[0].data,
1792 : : msgs[i]->elements[0].values[0].length) == 0,
1793 : : "wrong value, found [%.*s] expected [%s]",
1794 : : msgs[i]->elements[0].values[0].length,
1795 : : msgs[i]->elements[0].values[0].data, gid_str);
1796 : : }
1797 : :
1798 : 1 : talloc_free(test_ctx);
1799 : : }
1800 : : END_TEST
1801 : :
1802 : 1 : START_TEST (test_sysdb_search_all_users)
1803 : : {
1804 : : struct sysdb_test_ctx *test_ctx;
1805 : : struct test_data *data;
1806 : : int ret;
1807 : : int i;
1808 : : char *uid_str;
1809 : :
1810 : : /* Setup */
1811 : 1 : ret = setup_sysdb_tests(&test_ctx);
1812 [ - + ]: 1 : if (ret != EOK) {
1813 : 0 : fail("Could not set up the test");
1814 : 1 : return;
1815 : : }
1816 : :
1817 : 1 : data = talloc_zero(test_ctx, struct test_data);
1818 : 1 : data->ctx = test_ctx;
1819 : 1 : data->ev = test_ctx->ev;
1820 : 1 : data->attrlist = talloc_array(data, const char *, 2);
1821 : 1 : fail_unless(data->attrlist != NULL, "talloc_array failed");
1822 : :
1823 : 1 : data->attrlist[0] = "uidNumber";
1824 : 1 : data->attrlist[1] = NULL;
1825 : :
1826 : 1 : ret = test_search_all_users(data);
1827 : :
1828 : 1 : fail_if(ret != EOK, "Search failed");
1829 : :
1830 : 1 : fail_unless(data->msgs_count == 10,
1831 : : "wrong number of results, found [%d] expected [10]",
1832 : : data->msgs_count);
1833 : :
1834 [ + + ]: 11 : for (i = 0; i < data->msgs_count; i++) {
1835 : 10 : fail_unless(data->msgs[i]->num_elements == 1,
1836 : : "wrong number of elements, found [%d] expected [1]",
1837 : : data->msgs[i]->num_elements);
1838 : :
1839 : 10 : fail_unless(data->msgs[i]->elements[0].num_values == 1,
1840 : : "wrong number of values, found [%d] expected [1]",
1841 : : data->msgs[i]->elements[0].num_values);
1842 : :
1843 : 10 : uid_str = talloc_asprintf(data, "%d", 27010 + i);
1844 : 10 : fail_unless(uid_str != NULL, "talloc_asprintf failed.");
1845 : 10 : fail_unless(strncmp(uid_str,
1846 : : (char *) data->msgs[i]->elements[0].values[0].data,
1847 : : data->msgs[i]->elements[0].values[0].length) == 0,
1848 : : "wrong value, found [%.*s] expected [%s]",
1849 : : data->msgs[i]->elements[0].values[0].length,
1850 : : data->msgs[i]->elements[0].values[0].data, uid_str);
1851 : : }
1852 : :
1853 : 1 : talloc_free(test_ctx);
1854 : : }
1855 : : END_TEST
1856 : :
1857 : 1 : START_TEST (test_sysdb_delete_recursive)
1858 : : {
1859 : : struct sysdb_test_ctx *test_ctx;
1860 : : struct test_data *data;
1861 : : int ret;
1862 : :
1863 : : /* Setup */
1864 : 1 : ret = setup_sysdb_tests(&test_ctx);
1865 [ - + ]: 1 : if (ret != EOK) {
1866 : 0 : fail("Could not set up the test");
1867 : 1 : return;
1868 : : }
1869 : :
1870 : 1 : data = talloc_zero(test_ctx, struct test_data);
1871 : 1 : data->ctx = test_ctx;
1872 : 1 : data->ev = test_ctx->ev;
1873 : :
1874 : 1 : ret = test_delete_recursive(data);
1875 : :
1876 : 1 : fail_if(ret != EOK, "Recursive delete failed");
1877 : 1 : talloc_free(test_ctx);
1878 : : }
1879 : : END_TEST
1880 : :
1881 : 1 : START_TEST (test_sysdb_attrs_replace_name)
1882 : : {
1883 : : struct sysdb_attrs *attrs;
1884 : : struct ldb_message_element *el;
1885 : : int ret;
1886 : :
1887 : 1 : attrs = sysdb_new_attrs(NULL);
1888 : 1 : fail_unless(attrs != NULL, "sysdb_new_attrs failed");
1889 : :
1890 : 1 : ret = sysdb_attrs_add_string(attrs, "foo", "bar");
1891 : 1 : fail_unless(ret == EOK, "sysdb_attrs_add_string failed");
1892 : :
1893 : 1 : ret = sysdb_attrs_add_string(attrs, "fool", "bool");
1894 : 1 : fail_unless(ret == EOK, "sysdb_attrs_add_string failed");
1895 : :
1896 : 1 : ret = sysdb_attrs_add_string(attrs, "foot", "boot");
1897 : 1 : fail_unless(ret == EOK, "sysdb_attrs_add_string failed");
1898 : :
1899 : 1 : ret = sysdb_attrs_replace_name(attrs, "foo", "foot");
1900 : 1 : fail_unless(ret == EEXIST,
1901 : : "sysdb_attrs_replace overwrites existing attribute");
1902 : :
1903 : 1 : ret = sysdb_attrs_replace_name(attrs, "foo", "oof");
1904 : 1 : fail_unless(ret == EOK, "sysdb_attrs_replace failed");
1905 : :
1906 : 1 : ret = sysdb_attrs_get_el(attrs, "foo", &el);
1907 : 1 : fail_unless(ret == EOK, "sysdb_attrs_get_el failed");
1908 : 1 : fail_unless(el->num_values == 0, "Attribute foo is not empty.");
1909 : :
1910 : 1 : ret = sysdb_attrs_get_el(attrs, "oof", &el);
1911 : 1 : fail_unless(ret == EOK, "sysdb_attrs_get_el failed");
1912 : 1 : fail_unless(el->num_values == 1,
1913 : : "Wrong number of values for attribute oof, "
1914 : : "expected [1] got [%d].", el->num_values);
1915 [ - + ][ # # ]: 1 : fail_unless(strncmp("bar", (char *) el->values[0].data,
[ # # ][ # # ]
[ # # ]
1916 : : el->values[0].length) == 0,
1917 : : "Wrong value, expected [bar] got [%.*s]", el->values[0].length,
1918 : : el->values[0].data);
1919 : :
1920 : 1 : talloc_free(attrs);
1921 : : }
1922 : 1 : END_TEST
1923 : :
1924 : 20 : START_TEST (test_sysdb_memberof_store_group)
1925 : : {
1926 : : struct sysdb_test_ctx *test_ctx;
1927 : : struct test_data *data;
1928 : : int ret;
1929 : :
1930 : : /* Setup */
1931 : 20 : ret = setup_sysdb_tests(&test_ctx);
1932 [ - + ]: 20 : if (ret != EOK) {
1933 : 0 : fail("Could not set up the test");
1934 : 20 : return;
1935 : : }
1936 : :
1937 : 20 : data = talloc_zero(test_ctx, struct test_data);
1938 : 20 : data->ctx = test_ctx;
1939 : 20 : data->ev = test_ctx->ev;
1940 : 20 : data->gid = MBO_GROUP_BASE + _i;
1941 : 20 : data->groupname = talloc_asprintf(data, "testgroup%d", data->gid);
1942 : :
1943 [ + + ]: 20 : if (_i == 0) {
1944 : 2 : data->attrlist = NULL;
1945 : : } else {
1946 : 18 : data->attrlist = talloc_array(data, const char *, 2);
1947 : 18 : fail_unless(data->attrlist != NULL, "talloc_array failed.");
1948 : 18 : data->attrlist[0] = talloc_asprintf(data, "testgroup%d", data->gid - 1);
1949 : 18 : data->attrlist[1] = NULL;
1950 : : }
1951 : :
1952 : 20 : ret = test_memberof_store_group(data);
1953 : :
1954 : 20 : fail_if(ret != EOK, "Could not store POSIX group #%d", data->gid);
1955 : 20 : talloc_free(test_ctx);
1956 : : }
1957 : : END_TEST
1958 : :
1959 : 10 : START_TEST (test_sysdb_memberof_store_group_with_ghosts)
1960 : : {
1961 : : struct sysdb_test_ctx *test_ctx;
1962 : : struct test_data *data;
1963 : : int ret;
1964 : :
1965 : : /* Setup */
1966 : 10 : ret = setup_sysdb_tests(&test_ctx);
1967 [ - + ]: 10 : if (ret != EOK) {
1968 : 0 : fail("Could not set up the test");
1969 : 10 : return;
1970 : : }
1971 : :
1972 : 10 : data = talloc_zero(test_ctx, struct test_data);
1973 : 10 : data->ctx = test_ctx;
1974 : 10 : data->ev = test_ctx->ev;
1975 : 10 : data->gid = _i;
1976 : 10 : data->groupname = talloc_asprintf(data, "testgroup%d", data->gid);
1977 : :
1978 [ - + ]: 10 : if (_i == 0) {
1979 : 0 : data->attrlist = NULL;
1980 : : } else {
1981 : 10 : data->attrlist = talloc_array(data, const char *, 2);
1982 : 10 : fail_unless(data->attrlist != NULL, "talloc_array failed.");
1983 : 10 : data->attrlist[0] = talloc_asprintf(data, "testgroup%d", data->gid - 1);
1984 : 10 : data->attrlist[1] = NULL;
1985 : : }
1986 : :
1987 : 10 : data->memberlist = talloc_array(data, char *, 2);
1988 : 10 : fail_unless(data->memberlist != NULL, "talloc_array failed.");
1989 : 10 : data->memberlist[0] = talloc_asprintf(data, "testuser%d", data->gid);
1990 : 10 : data->memberlist[1] = NULL;
1991 : :
1992 : 10 : ret = test_memberof_store_group_with_ghosts(data);
1993 : :
1994 : 10 : fail_if(ret != EOK, "Could not store POSIX group #%d", data->gid);
1995 : 10 : talloc_free(test_ctx);
1996 : : }
1997 : : END_TEST
1998 : :
1999 : 1 : START_TEST (test_sysdb_memberof_close_loop)
2000 : : {
2001 : : struct sysdb_test_ctx *test_ctx;
2002 : : struct test_data *data;
2003 : : int ret;
2004 : :
2005 : : /* Setup */
2006 : 1 : ret = setup_sysdb_tests(&test_ctx);
2007 [ - + ]: 1 : if (ret != EOK) {
2008 : 0 : fail("Could not set up the test");
2009 : 1 : return;
2010 : : }
2011 : :
2012 : 1 : data = talloc_zero(test_ctx, struct test_data);
2013 : 1 : data->ctx = test_ctx;
2014 : 1 : data->ev = test_ctx->ev;
2015 : 1 : data->gid = MBO_GROUP_BASE;
2016 : 1 : data->groupname = talloc_asprintf(data, "testgroup%d", data->gid);
2017 : :
2018 : 1 : data->attrlist = talloc_array(data, const char *, 2);
2019 : 1 : fail_unless(data->attrlist != NULL, "talloc_array failed.");
2020 : 1 : data->attrlist[0] = talloc_asprintf(data, "testgroup%d", data->gid + 9);
2021 : 1 : data->attrlist[1] = NULL;
2022 : :
2023 : 1 : ret = test_memberof_store_group(data);
2024 : :
2025 : 1 : fail_if(ret != EOK, "Could not store POSIX group #%d", data->gid);
2026 : 1 : talloc_free(test_ctx);
2027 : : }
2028 : : END_TEST
2029 : :
2030 : 20 : START_TEST (test_sysdb_memberof_store_user)
2031 : : {
2032 : : struct sysdb_test_ctx *test_ctx;
2033 : : struct test_data *data;
2034 : : int ret;
2035 : :
2036 : : /* Setup */
2037 : 20 : ret = setup_sysdb_tests(&test_ctx);
2038 [ - + ]: 20 : if (ret != EOK) {
2039 : 0 : fail("Could not set up the test");
2040 : 20 : return;
2041 : : }
2042 : :
2043 : 20 : data = talloc_zero(test_ctx, struct test_data);
2044 : 20 : data->ctx = test_ctx;
2045 : 20 : data->ev = test_ctx->ev;
2046 : 20 : data->uid = MBO_USER_BASE + _i;
2047 : 20 : data->gid = 0; /* MPG domain */
2048 : 20 : data->username = talloc_asprintf(data, "testuser%d", data->uid);
2049 : :
2050 : 20 : ret = test_store_user(data);
2051 : :
2052 : 20 : fail_if(ret != EOK, "Could not store user %s", data->username);
2053 : 20 : talloc_free(test_ctx);
2054 : : }
2055 : : END_TEST
2056 : :
2057 : 20 : START_TEST (test_sysdb_memberof_add_group_member)
2058 : : {
2059 : : struct sysdb_test_ctx *test_ctx;
2060 : : struct test_data *data;
2061 : : int ret;
2062 : :
2063 : : /* Setup */
2064 : 20 : ret = setup_sysdb_tests(&test_ctx);
2065 [ - + ]: 20 : if (ret != EOK) {
2066 : 0 : fail("Could not set up the test");
2067 : 20 : return;
2068 : : }
2069 : :
2070 : 20 : data = talloc_zero(test_ctx, struct test_data);
2071 : 20 : data->ctx = test_ctx;
2072 : 20 : data->ev = test_ctx->ev;
2073 : 20 : data->groupname = talloc_asprintf(data, "testgroup%d", _i + MBO_GROUP_BASE);
2074 : 20 : data->uid = MBO_USER_BASE + _i;
2075 : :
2076 : 20 : ret = test_add_group_member(data);
2077 : :
2078 : 20 : fail_if(ret != EOK, "Could not modify group %s", data->groupname);
2079 : :
2080 : 20 : talloc_free(test_ctx);
2081 : : }
2082 : : END_TEST
2083 : :
2084 : 10 : START_TEST (test_sysdb_memberof_check_memberuid_without_group_5)
2085 : : {
2086 : : struct sysdb_test_ctx *test_ctx;
2087 : : struct test_data *data;
2088 : : int ret;
2089 : :
2090 : : /* Setup */
2091 : 10 : ret = setup_sysdb_tests(&test_ctx);
2092 [ - + ]: 10 : if (ret != EOK) {
2093 : 0 : fail("Could not set up the test");
2094 : 10 : return;
2095 : : }
2096 : :
2097 : 10 : data = talloc_zero(test_ctx, struct test_data);
2098 : 10 : data->ctx = test_ctx;
2099 : 10 : data->ev = test_ctx->ev;
2100 : 10 : data->gid = _i + MBO_GROUP_BASE;
2101 : :
2102 : 10 : data->attrlist = talloc_array(data, const char *, 2);
2103 : 10 : fail_unless(data->attrlist != NULL, "tallo_array failed.");
2104 : 10 : data->attrlist[0] = "memberuid";
2105 : 10 : data->attrlist[1] = NULL;
2106 : :
2107 : 10 : ret = sysdb_search_group_by_gid(data, test_ctx->sysdb,
2108 : : _i + MBO_GROUP_BASE,
2109 : : data->attrlist, &data->msg);
2110 [ + + ]: 10 : if (_i == 5) {
2111 : 1 : fail_unless(ret == ENOENT,
2112 : : "sysdb_search_group_by_gid found "
2113 : : "already deleted group");
2114 [ + - ]: 1 : if (ret == ENOENT) ret = EOK;
2115 : :
2116 : 1 : fail_if(ret != EOK, "Could not check group %d", data->gid);
2117 : : } else {
2118 : 9 : fail_if(ret != EOK, "Could not check group %d", data->gid);
2119 : :
2120 : 9 : fail_unless(data->msg->num_elements == 1,
2121 : : "Wrong number of results, expected [1] got [%d]",
2122 : : data->msg->num_elements);
2123 : 9 : fail_unless(strcmp(data->msg->elements[0].name, "memberuid") == 0,
2124 : : "Wrong attribute name");
2125 : 9 : fail_unless(data->msg->elements[0].num_values == ((_i + 1) % 6),
2126 : : "Wrong number of attribute values, "
2127 : : "expected [%d] got [%d]", ((_i + 1) % 6),
2128 : : data->msg->elements[0].num_values);
2129 : : }
2130 : :
2131 : 10 : talloc_free(test_ctx);
2132 : : }
2133 : : END_TEST
2134 : :
2135 : 10 : START_TEST (test_sysdb_memberof_check_memberuid)
2136 : : {
2137 : : struct sysdb_test_ctx *test_ctx;
2138 : : struct test_data *data;
2139 : : int ret;
2140 : :
2141 : : /* Setup */
2142 : 10 : ret = setup_sysdb_tests(&test_ctx);
2143 [ - + ]: 10 : if (ret != EOK) {
2144 : 0 : fail("Could not set up the test");
2145 : 10 : return;
2146 : : }
2147 : :
2148 : 10 : data = talloc_zero(test_ctx, struct test_data);
2149 : 10 : data->ctx = test_ctx;
2150 : 10 : data->ev = test_ctx->ev;
2151 : 10 : data->gid = _i + MBO_GROUP_BASE;
2152 : :
2153 : 10 : data->attrlist = talloc_array(data, const char *, 2);
2154 : 10 : fail_unless(data->attrlist != NULL, "tallo_array failed.");
2155 : 10 : data->attrlist[0] = "memberuid";
2156 : 10 : data->attrlist[1] = NULL;
2157 : :
2158 : 10 : ret = sysdb_search_group_by_gid(data, test_ctx->sysdb,
2159 : : _i + MBO_GROUP_BASE,
2160 : : data->attrlist, &data->msg);
2161 : :
2162 : 10 : fail_if(ret != EOK, "Could not check group %d", data->gid);
2163 : :
2164 : 10 : fail_unless(data->msg->num_elements == 1,
2165 : : "Wrong number of results, expected [1] got [%d]",
2166 : : data->msg->num_elements);
2167 : 10 : fail_unless(strcmp(data->msg->elements[0].name, "memberuid") == 0,
2168 : : "Wrong attribute name");
2169 : 10 : fail_unless(data->msg->elements[0].num_values == _i + 1,
2170 : : "Wrong number of attribute values, expected [%d] got [%d]",
2171 : : _i + 1, data->msg->elements[0].num_values);
2172 : :
2173 : 10 : talloc_free(test_ctx);
2174 : : }
2175 : : END_TEST
2176 : :
2177 : 10 : START_TEST (test_sysdb_memberof_check_memberuid_loop)
2178 : : {
2179 : : struct sysdb_test_ctx *test_ctx;
2180 : : struct test_data *data;
2181 : : int ret;
2182 : :
2183 : : /* Setup */
2184 : 10 : ret = setup_sysdb_tests(&test_ctx);
2185 [ - + ]: 10 : if (ret != EOK) {
2186 : 0 : fail("Could not set up the test");
2187 : 10 : return;
2188 : : }
2189 : :
2190 : 10 : data = talloc_zero(test_ctx, struct test_data);
2191 : 10 : data->ctx = test_ctx;
2192 : 10 : data->ev = test_ctx->ev;
2193 : 10 : data->gid = _i + MBO_GROUP_BASE;
2194 : :
2195 : 10 : data->attrlist = talloc_array(data, const char *, 2);
2196 : 10 : fail_unless(data->attrlist != NULL, "tallo_array failed.");
2197 : 10 : data->attrlist[0] = "memberuid";
2198 : 10 : data->attrlist[1] = NULL;
2199 : :
2200 : 10 : ret = sysdb_search_group_by_gid(data, test_ctx->sysdb,
2201 : : _i + MBO_GROUP_BASE,
2202 : : data->attrlist, &data->msg);
2203 : :
2204 : 10 : fail_if(ret != EOK, "Could not check group %d", data->gid);
2205 : :
2206 : 10 : fail_unless(data->msg->num_elements == 1,
2207 : : "Wrong number of results, expected [1] got [%d]",
2208 : : data->msg->num_elements);
2209 : 10 : fail_unless(strcmp(data->msg->elements[0].name, "memberuid") == 0,
2210 : : "Wrong attribute name");
2211 : 10 : fail_unless(data->msg->elements[0].num_values == 10,
2212 : : "Wrong number of attribute values, expected [%d] got [%d]",
2213 : : 10, data->msg->elements[0].num_values);
2214 : :
2215 : 10 : talloc_free(test_ctx);
2216 : : }
2217 : : END_TEST
2218 : :
2219 : 10 : START_TEST (test_sysdb_memberof_check_memberuid_loop_without_group_5)
2220 : : {
2221 : : struct sysdb_test_ctx *test_ctx;
2222 : : struct test_data *data;
2223 : : int ret;
2224 : :
2225 : : /* Setup */
2226 : 10 : ret = setup_sysdb_tests(&test_ctx);
2227 [ - + ]: 10 : if (ret != EOK) {
2228 : 0 : fail("Could not set up the test");
2229 : 10 : return;
2230 : : }
2231 : :
2232 : 10 : data = talloc_zero(test_ctx, struct test_data);
2233 : 10 : data->ctx = test_ctx;
2234 : 10 : data->ev = test_ctx->ev;
2235 : 10 : data->gid = _i + MBO_GROUP_BASE;
2236 : :
2237 : 10 : data->attrlist = talloc_array(data, const char *, 2);
2238 : 10 : fail_unless(data->attrlist != NULL, "tallo_array failed.");
2239 : 10 : data->attrlist[0] = "memberuid";
2240 : 10 : data->attrlist[1] = NULL;
2241 : :
2242 : 10 : ret = sysdb_search_group_by_gid(data, test_ctx->sysdb,
2243 : : _i + MBO_GROUP_BASE,
2244 : : data->attrlist, &data->msg);
2245 : :
2246 [ + + ]: 10 : if (_i == 5) {
2247 : 1 : fail_unless(ret == ENOENT,
2248 : : "sysdb_search_group_by_gid_send found "
2249 : : "already deleted group");
2250 [ + - ]: 1 : if (ret == ENOENT) ret = EOK;
2251 : :
2252 : 1 : fail_if(ret != EOK, "Could not check group %d", data->gid);
2253 : : } else {
2254 : 9 : fail_if(ret != EOK, "Could not check group %d", data->gid);
2255 : :
2256 : 9 : fail_unless(data->msg->num_elements == 1,
2257 : : "Wrong number of results, expected [1] got [%d]",
2258 : : data->msg->num_elements);
2259 : 9 : fail_unless(strcmp(data->msg->elements[0].name, "memberuid") == 0,
2260 : : "Wrong attribute name");
2261 : 9 : fail_unless(data->msg->elements[0].num_values == ((_i + 5) % 10),
2262 : : "Wrong number of attribute values, expected [%d] got [%d]",
2263 : : ((_i + 5) % 10), data->msg->elements[0].num_values);
2264 : : }
2265 : :
2266 : 10 : talloc_free(test_ctx);
2267 : : }
2268 : : END_TEST
2269 : :
2270 : 10 : START_TEST (test_sysdb_memberof_check_ghost)
2271 : : {
2272 : : struct sysdb_test_ctx *test_ctx;
2273 : : struct test_data *data;
2274 : : int ret, j;
2275 : : char *expected;
2276 : :
2277 : : /* Setup */
2278 : 10 : ret = setup_sysdb_tests(&test_ctx);
2279 [ - + ]: 10 : if (ret != EOK) {
2280 : 0 : fail("Could not set up the test");
2281 : : return;
2282 : : }
2283 : :
2284 : 10 : data = talloc_zero(test_ctx, struct test_data);
2285 : 10 : data->ctx = test_ctx;
2286 : 10 : data->ev = test_ctx->ev;
2287 : 10 : data->gid = _i;
2288 : :
2289 : 10 : data->attrlist = talloc_array(data, const char *, 2);
2290 : 10 : fail_unless(data->attrlist != NULL, "talloc_array failed.");
2291 : 10 : data->attrlist[0] = SYSDB_GHOST;
2292 : 10 : data->attrlist[1] = NULL;
2293 : :
2294 : 10 : ret = sysdb_search_group_by_gid(data, test_ctx->sysdb,
2295 : : data->gid,
2296 : : data->attrlist, &data->msg);
2297 : :
2298 : 10 : fail_if(ret != EOK, "Could not check group %d", data->gid);
2299 : :
2300 [ + + ]: 10 : if (_i > MBO_GROUP_BASE) {
2301 : : /* After the previous test, the first group (gid == MBO_GROUP_BASE)
2302 : : * has no ghost users. That's a legitimate test case we need to account
2303 : : * for now.
2304 : : */
2305 : 9 : fail_unless(data->msg->num_elements == 1,
2306 : : "Wrong number of results, expected [1] got [%d] for %d",
2307 : : data->msg->num_elements, data->gid);
2308 : : }
2309 : :
2310 [ + + ]: 10 : if (data->msg->num_elements == 0) {
2311 : 1 : talloc_free(test_ctx);
2312 : : return;
2313 : : }
2314 : :
2315 : 9 : fail_unless(strcmp(data->msg->elements[0].name, SYSDB_GHOST) == 0,
2316 : : "Wrong attribute name");
2317 : 9 : fail_unless(data->msg->elements[0].num_values == _i - MBO_GROUP_BASE,
2318 : : "Wrong number of attribute values, expected [%d] got [%d]",
2319 : : _i + 1, data->msg->elements[0].num_values);
2320 : :
2321 [ + + ]: 54 : for (j = MBO_GROUP_BASE; j < _i; j++) {
2322 : 45 : expected = talloc_asprintf(data, "testghost%d", j);
2323 : 45 : fail_if(expected == NULL, "OOM\n");
2324 : 45 : fail_unless(strcmp(expected,
2325 : : (const char *) data->msg->elements[0].values[j-MBO_GROUP_BASE].data) == 0);
2326 : 45 : talloc_free(expected);
2327 : : }
2328 : :
2329 : 10 : talloc_free(test_ctx);
2330 : : }
2331 : : END_TEST
2332 : :
2333 : 5 : START_TEST (test_sysdb_memberof_convert_to_real_users)
2334 : : {
2335 : : struct sysdb_test_ctx *test_ctx;
2336 : : struct test_data *data;
2337 : : int ret;
2338 : :
2339 : : /* Setup */
2340 : 5 : ret = setup_sysdb_tests(&test_ctx);
2341 [ - + ]: 5 : if (ret != EOK) {
2342 : 0 : fail("Could not set up the test");
2343 : 5 : return;
2344 : : }
2345 : :
2346 : 5 : data = talloc_zero(test_ctx, struct test_data);
2347 : 5 : data->ctx = test_ctx;
2348 : 5 : data->ev = test_ctx->ev;
2349 : 5 : data->uid = _i * 2;
2350 : 5 : data->gid = _i * 2;
2351 : 5 : data->username = talloc_asprintf(data, "testghost%d", _i);
2352 : :
2353 : 5 : ret = test_store_user(data);
2354 : 5 : fail_if(ret != EOK, "Cannot add user %s\n", data->username);
2355 : : }
2356 : : END_TEST
2357 : :
2358 : 10 : START_TEST (test_sysdb_memberof_check_convert)
2359 : : {
2360 : : struct sysdb_test_ctx *test_ctx;
2361 : : struct test_data *data;
2362 : : int ret;
2363 : : struct ldb_message_element *ghosts;
2364 : : struct ldb_message_element *members;
2365 : : int exp_mem, exp_gh;
2366 : :
2367 : : /* Setup */
2368 : 10 : ret = setup_sysdb_tests(&test_ctx);
2369 [ - + ]: 10 : if (ret != EOK) {
2370 : 0 : fail("Could not set up the test");
2371 : : return;
2372 : : }
2373 : :
2374 : 10 : data = talloc_zero(test_ctx, struct test_data);
2375 : 10 : data->ctx = test_ctx;
2376 : 10 : data->ev = test_ctx->ev;
2377 : 10 : data->gid = _i;
2378 : :
2379 : 10 : data->attrlist = talloc_array(data, const char *, 3);
2380 : 10 : fail_unless(data->attrlist != NULL, "talloc_array failed.");
2381 : 10 : data->attrlist[0] = SYSDB_GHOST;
2382 : 10 : data->attrlist[1] = SYSDB_MEMBER;
2383 : 10 : data->attrlist[2] = NULL;
2384 : :
2385 : 10 : ret = sysdb_search_group_by_gid(data, test_ctx->sysdb,
2386 : : data->gid,
2387 : : data->attrlist, &data->msg);
2388 : :
2389 : 10 : fail_if(ret != EOK, "Could not check group %d", data->gid);
2390 : :
2391 : 10 : fail_unless(data->msg->num_elements == (_i == MBO_GROUP_BASE) ? 0 : 1,
2392 : : "Wrong number of results, expected [1] got [%d] for %d",
2393 : : data->msg->num_elements, data->gid);
2394 : :
2395 [ + + ]: 10 : if (data->msg->num_elements == 0) {
2396 : 1 : talloc_free(test_ctx);
2397 : : return;
2398 : : }
2399 : :
2400 : :
2401 : 9 : members = ldb_msg_find_element(data->msg, SYSDB_MEMBER);
2402 : 9 : exp_mem = _i - MBO_GROUP_BASE;
2403 [ + + ]: 9 : if (exp_mem > NUM_GHOSTS/2) {
2404 : 4 : exp_mem = NUM_GHOSTS/2;
2405 : : }
2406 : :
2407 : 9 : ghosts = ldb_msg_find_element(data->msg, SYSDB_GHOST);
2408 : 9 : exp_gh = _i - MBO_GROUP_BASE - 5;
2409 [ + + ]: 9 : if (exp_gh < 0) {
2410 : 4 : exp_gh = 0;
2411 : : }
2412 : :
2413 : 9 : fail_if(exp_mem != members->num_values,
2414 : : "Expected %d members, found %d\n", exp_mem, members->num_values);
2415 [ + + ]: 9 : if (exp_gh) {
2416 : 4 : fail_if(exp_gh != ghosts->num_values,
2417 : : "Expected %d members, found %d\n", exp_gh, ghosts->num_values);
2418 : : }
2419 : :
2420 : 10 : talloc_free(test_ctx);
2421 : : }
2422 : : END_TEST
2423 : :
2424 : 5 : START_TEST (test_sysdb_memberof_user_cleanup)
2425 : : {
2426 : : struct sysdb_test_ctx *test_ctx;
2427 : : struct test_data *data;
2428 : : int ret;
2429 : :
2430 : : /* Setup */
2431 : 5 : ret = setup_sysdb_tests(&test_ctx);
2432 [ - + ]: 5 : if (ret != EOK) {
2433 : 0 : fail("Could not set up the test");
2434 : 5 : return;
2435 : : }
2436 : :
2437 : 5 : data = talloc_zero(test_ctx, struct test_data);
2438 : 5 : data->ctx = test_ctx;
2439 : 5 : data->ev = test_ctx->ev;
2440 : 5 : data->uid = _i * 2;
2441 : :
2442 : 5 : ret = test_remove_user_by_uid(data);
2443 : :
2444 : 5 : fail_if(ret != EOK, "Could not remove user with uid %d", _i);
2445 : 5 : talloc_free(test_ctx);
2446 : : }
2447 : : END_TEST
2448 : :
2449 : 1 : START_TEST (test_sysdb_attrs_to_list)
2450 : : {
2451 : : struct sysdb_attrs *attrs_list[3];
2452 : : char **list;
2453 : : errno_t ret;
2454 : :
2455 : 1 : TALLOC_CTX *test_ctx = talloc_new(NULL);
2456 : :
2457 : 1 : attrs_list[0] = sysdb_new_attrs(test_ctx);
2458 : 1 : ret = sysdb_attrs_add_string(attrs_list[0], "test_attr", "attr1");
2459 : 1 : fail_if(ret, "Add string failed");
2460 : 1 : attrs_list[1] = sysdb_new_attrs(test_ctx);
2461 : 1 : ret = sysdb_attrs_add_string(attrs_list[1], "test_attr", "attr2");
2462 : 1 : fail_if(ret, "Add string failed");
2463 : 1 : attrs_list[2] = sysdb_new_attrs(test_ctx);
2464 : 1 : ret = sysdb_attrs_add_string(attrs_list[2], "nottest_attr", "attr3");
2465 : 1 : fail_if(ret, "Add string failed");
2466 : :
2467 : 1 : ret = sysdb_attrs_to_list(test_ctx, attrs_list, 3,
2468 : : "test_attr", &list);
2469 : 1 : fail_unless(ret == EOK, "sysdb_attrs_to_list failed with code %d", ret);
2470 : :
2471 : 1 : fail_unless(strcmp(list[0],"attr1") == 0, "Expected [attr1], got [%s]",
2472 : : list[0]);
2473 : 1 : fail_unless(strcmp(list[1],"attr2") == 0, "Expected [attr2], got [%s]",
2474 : : list[1]);
2475 : 1 : fail_unless(list[2] == NULL, "List should be NULL-terminated");
2476 : :
2477 : 1 : talloc_free(test_ctx);
2478 : : }
2479 : 1 : END_TEST
2480 : :
2481 : 1 : START_TEST(test_group_rename)
2482 : : {
2483 : : struct sysdb_test_ctx *test_ctx;
2484 : : errno_t ret;
2485 : : gid_t gid;
2486 : 1 : const gid_t grgid = 38001;
2487 : : const char *name;
2488 : 1 : const char *fromname = "fromgroup";
2489 : 1 : const char *toname = "togroup";
2490 : : struct ldb_result *res;
2491 : :
2492 : : /* Setup */
2493 : 1 : ret = setup_sysdb_tests(&test_ctx);
2494 : 1 : fail_unless(ret == EOK, "Could not set up the test");
2495 : :
2496 : : /* Store and verify the first group */
2497 : 1 : ret = sysdb_store_group(test_ctx->sysdb, fromname, grgid, NULL, 0, 0);
2498 : 1 : fail_unless(ret == EOK, "Could not add first group");
2499 : :
2500 : 1 : ret = sysdb_getgrnam(test_ctx, test_ctx->sysdb, fromname, &res);
2501 : 1 : fail_unless(ret == EOK, "Could not retrieve the group from cache\n");
2502 [ - + ]: 1 : if (res->count != 1) {
2503 : 0 : fail("Invalid number of replies. Expected 1, got %d", res->count);
2504 : : goto done;
2505 : : }
2506 : :
2507 : 1 : gid = ldb_msg_find_attr_as_uint(res->msgs[0], SYSDB_GIDNUM, 0);
2508 : 1 : fail_unless(gid == grgid,
2509 : : "Did not find the expected GID (found %llu expected %llu)",
2510 : : (unsigned long long) gid, (unsigned long long) grgid);
2511 : 1 : name = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_NAME, NULL);
2512 : 1 : fail_unless(strcmp(fromname, name) == 0,
2513 : : "Did not find the expected name (found %s expected %s)",
2514 : : name, fromname);
2515 : :
2516 : : /* Perform rename and check that GID is the same, but name changed */
2517 : 1 : ret = sysdb_add_group(test_ctx->sysdb, toname, grgid, NULL, 0, 0);
2518 : 1 : fail_unless(ret == EEXIST, "Group renamed with a low level call?");
2519 : :
2520 : 1 : ret = sysdb_store_group(test_ctx->sysdb, toname, grgid, NULL, 0, 0);
2521 : 1 : fail_unless(ret == EOK, "Could not add first group");
2522 : :
2523 : 1 : ret = sysdb_getgrnam(test_ctx, test_ctx->sysdb, toname, &res);
2524 : 1 : fail_unless(ret == EOK, "Could not retrieve the group from cache\n");
2525 [ - + ]: 1 : if (res->count != 1) {
2526 : 0 : fail("Invalid number of replies. Expected 1, got %d", res->count);
2527 : : goto done;
2528 : : }
2529 : :
2530 : 1 : gid = ldb_msg_find_attr_as_uint(res->msgs[0], SYSDB_GIDNUM, 0);
2531 : 1 : fail_unless(gid == grgid,
2532 : : "Did not find the expected GID (found %llu expected %llu)",
2533 : : (unsigned long long) gid, (unsigned long long) grgid);
2534 : 1 : name = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_NAME, NULL);
2535 : 1 : fail_unless(strcmp(toname, name) == 0,
2536 : : "Did not find the expected GID (found %s expected %s)",
2537 : : name, toname);
2538 : :
2539 : : /* Verify the first name is gone */
2540 : 1 : ret = sysdb_getgrnam(test_ctx, test_ctx->sysdb, fromname, &res);
2541 : 1 : fail_unless(ret == EOK, "Could not retrieve the group from cache\n");
2542 : 1 : fail_unless(res->count == 0, "Unexpectedly found the original user\n");
2543 : :
2544 : : done:
2545 : 1 : talloc_free(test_ctx);
2546 : : }
2547 : 1 : END_TEST
2548 : :
2549 : 1 : START_TEST(test_user_rename)
2550 : : {
2551 : : struct sysdb_test_ctx *test_ctx;
2552 : : errno_t ret;
2553 : : uid_t uid;
2554 : 1 : const uid_t userid = 38002;
2555 : : const char *name;
2556 : 1 : const char *fromname = "fromuser";
2557 : 1 : const char *toname = "touser";
2558 : : struct ldb_result *res;
2559 : :
2560 : : /* Setup */
2561 : 1 : ret = setup_sysdb_tests(&test_ctx);
2562 : 1 : fail_unless(ret == EOK, "Could not set up the test");
2563 : :
2564 : : /* Store and verify the first user */
2565 : 1 : ret = sysdb_store_user(test_ctx->sysdb, fromname, NULL, userid, 0,
2566 : : fromname, "/", "/bin/sh",
2567 : : NULL, NULL, NULL, 0, 0);
2568 : 1 : fail_unless(ret == EOK, "Could not add first user");
2569 : :
2570 : 1 : ret = sysdb_getpwnam(test_ctx, test_ctx->sysdb, fromname, &res);
2571 : 1 : fail_unless(ret == EOK, "Could not retrieve the user from cache\n");
2572 [ - + ]: 1 : if (res->count != 1) {
2573 : 0 : fail("Invalid number of replies. Expected 1, got %d", res->count);
2574 : : goto done;
2575 : : }
2576 : :
2577 : 1 : uid = ldb_msg_find_attr_as_uint(res->msgs[0], SYSDB_UIDNUM, 0);
2578 : 1 : fail_unless(uid == userid,
2579 : : "Did not find the expected UID (found %llu expected %llu)",
2580 : : (unsigned long long) uid, (unsigned long long) userid);
2581 : 1 : name = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_NAME, NULL);
2582 : 1 : fail_unless(strcmp(fromname, name) == 0,
2583 : : "Did not find the expected name (found %s expected %s)",
2584 : : name, fromname);
2585 : :
2586 : : /* Perform rename and check that GID is the same, but name changed */
2587 : 1 : ret = sysdb_add_user(test_ctx->sysdb, toname, userid, 0,
2588 : : fromname, "/", "/bin/sh", NULL, NULL, 0, 0);
2589 : 1 : fail_unless(ret == EEXIST, "A second user added with low level call?");
2590 : :
2591 : 1 : ret = sysdb_store_user(test_ctx->sysdb, toname, NULL, userid, 0,
2592 : : fromname, "/", "/bin/sh", NULL, NULL, NULL, 0, 0);
2593 : 1 : fail_unless(ret == EOK, "Could not add second user");
2594 : :
2595 : 1 : ret = sysdb_getpwnam(test_ctx, test_ctx->sysdb, toname, &res);
2596 : 1 : fail_unless(ret == EOK, "Could not retrieve the user from cache\n");
2597 [ - + ]: 1 : if (res->count != 1) {
2598 : 0 : fail("Invalid number of replies. Expected 1, got %d", res->count);
2599 : : goto done;
2600 : : }
2601 : :
2602 : 1 : uid = ldb_msg_find_attr_as_uint(res->msgs[0], SYSDB_UIDNUM, 0);
2603 : 1 : fail_unless(uid == userid,
2604 : : "Did not find the expected UID (found %llu expected %llu)",
2605 : : (unsigned long long) uid, (unsigned long long) userid);
2606 : 1 : name = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_NAME, NULL);
2607 : 1 : fail_unless(strcmp(toname, name) == 0,
2608 : : "Did not find the expected name (found %s expected %s)",
2609 : : name, fromname);
2610 : :
2611 : : /* Verify the first name is gone */
2612 : 1 : ret = sysdb_getpwnam(test_ctx, test_ctx->sysdb, fromname, &res);
2613 : 1 : fail_unless(ret == EOK, "Could not retrieve the user from cache\n");
2614 : 1 : fail_unless(res->count == 0, "Unexpectedly found the original user\n");
2615 : :
2616 : : done:
2617 : 1 : talloc_free(test_ctx);
2618 : : }
2619 : 1 : END_TEST
2620 : :
2621 : 1 : START_TEST (test_sysdb_update_members)
2622 : : {
2623 : : struct sysdb_test_ctx *test_ctx;
2624 : : char **add_groups;
2625 : : char **del_groups;
2626 : 1 : const char *user = "testuser27000";
2627 : : errno_t ret;
2628 : :
2629 : : /* Setup */
2630 : 1 : ret = setup_sysdb_tests(&test_ctx);
2631 : 1 : fail_unless(ret == EOK, "Could not set up the test");
2632 : :
2633 : : /* Add a user to two groups */
2634 : 1 : add_groups = talloc_array(test_ctx, char *, 3);
2635 : 1 : add_groups[0] = talloc_strdup(add_groups, "testgroup28001");
2636 : 1 : add_groups[1] = talloc_strdup(add_groups, "testgroup28002");
2637 : 1 : add_groups[2] = NULL;
2638 : :
2639 : 1 : ret = sysdb_update_members(test_ctx->sysdb, user, SYSDB_MEMBER_USER,
2640 : : (const char *const *)add_groups, NULL);
2641 : 1 : fail_unless(ret == EOK, "Could not add groups");
2642 : 1 : talloc_zfree(add_groups);
2643 : :
2644 : : /* Remove a user from one group and add to another */
2645 : 1 : del_groups = talloc_array(test_ctx, char *, 2);
2646 : 1 : del_groups[0] = talloc_strdup(del_groups, "testgroup28001");
2647 : 1 : del_groups[1] = NULL;
2648 : 1 : add_groups = talloc_array(test_ctx, char *, 2);
2649 : 1 : add_groups[0] = talloc_strdup(add_groups, "testgroup28003");
2650 : 1 : add_groups[1] = NULL;
2651 : :
2652 : 1 : ret = sysdb_update_members(test_ctx->sysdb, user, SYSDB_MEMBER_USER,
2653 : : (const char *const *)add_groups,
2654 : : (const char *const *)del_groups);
2655 : 1 : fail_unless(ret == EOK, "Group replace failed");
2656 : 1 : talloc_zfree(add_groups);
2657 : 1 : talloc_zfree(del_groups);
2658 : :
2659 : : /* Remove a user from two groups */
2660 : 1 : del_groups = talloc_array(test_ctx, char *, 3);
2661 : 1 : del_groups[0] = talloc_strdup(del_groups, "testgroup28002");
2662 : 1 : del_groups[1] = talloc_strdup(del_groups, "testgroup28003");
2663 : 1 : del_groups[2] = NULL;
2664 : :
2665 : 1 : ret = sysdb_update_members(test_ctx->sysdb, user, SYSDB_MEMBER_USER,
2666 : : NULL, (const char *const *)del_groups);
2667 : 1 : fail_unless(ret == EOK, "Could not remove groups");
2668 : :
2669 : 1 : talloc_zfree(test_ctx);
2670 : : }
2671 : 1 : END_TEST
2672 : :
2673 : :
2674 : 10 : START_TEST (test_sysdb_group_dn_name)
2675 : : {
2676 : : struct sysdb_test_ctx *test_ctx;
2677 : : int ret;
2678 : : struct ldb_dn *group_dn;
2679 : : const char *groupname;
2680 : : char *parsed;
2681 : :
2682 : : /* Setup */
2683 : 10 : ret = setup_sysdb_tests(&test_ctx);
2684 [ - + ]: 10 : if (ret != EOK) {
2685 : 0 : fail("Could not set up the test");
2686 : : return;
2687 : : }
2688 : :
2689 : 10 : groupname = talloc_asprintf(test_ctx, "testgroup%d", _i);
2690 : 10 : group_dn = sysdb_group_dn(test_ctx->sysdb, test_ctx, groupname);
2691 [ - + ]: 10 : if (!group_dn || !groupname) {
2692 : 0 : fail("Out of memory");
2693 : : return;
2694 : : }
2695 : :
2696 : 10 : ret = sysdb_group_dn_name(test_ctx->sysdb, test_ctx,
2697 : : ldb_dn_get_linearized(group_dn), &parsed);
2698 : 10 : fail_if(ret != EOK, "Cannot get the group name from DN");
2699 : :
2700 : 10 : fail_if(strcmp(groupname, parsed) != 0,
2701 : : "Names don't match (got %s)", parsed);
2702 : 10 : talloc_free(test_ctx);
2703 : : }
2704 : : END_TEST
2705 : :
2706 : 10 : START_TEST (test_sysdb_add_basic_netgroup)
2707 : : {
2708 : : struct sysdb_test_ctx *test_ctx;
2709 : : struct test_data *data;
2710 : : int ret;
2711 : :
2712 : : /* Setup */
2713 : 10 : ret = setup_sysdb_tests(&test_ctx);
2714 [ - + ]: 10 : if (ret != EOK) {
2715 : 0 : fail("Could not set up the test");
2716 : 10 : return;
2717 : : }
2718 : :
2719 : 10 : data = talloc_zero(test_ctx, struct test_data);
2720 : 10 : data->ctx = test_ctx;
2721 : 10 : data->ev = test_ctx->ev;
2722 : 10 : data->uid = _i; /* This is kinda abuse of uid, though */
2723 : 10 : data->netgrname = talloc_asprintf(data, "testnetgr%d", _i);
2724 : :
2725 : 10 : ret = test_add_basic_netgroup(data);
2726 : :
2727 : 10 : fail_if(ret != EOK, "Could not add netgroup %s", data->netgrname);
2728 : 10 : talloc_free(test_ctx);
2729 : : }
2730 : : END_TEST
2731 : :
2732 : 10 : START_TEST (test_sysdb_search_netgroup_by_name)
2733 : : {
2734 : : struct sysdb_test_ctx *test_ctx;
2735 : : int ret;
2736 : : const char *netgrname;
2737 : : struct ldb_message *msg;
2738 : : struct ldb_dn *netgroup_dn;
2739 : :
2740 : : /* Setup */
2741 : 10 : ret = setup_sysdb_tests(&test_ctx);
2742 [ - + ]: 10 : if (ret != EOK) {
2743 : 0 : fail("Could not set up the test");
2744 : 10 : return;
2745 : : }
2746 : :
2747 : 10 : netgrname = talloc_asprintf(test_ctx, "testnetgr%d", _i);
2748 : :
2749 : 10 : ret = sysdb_search_netgroup_by_name(test_ctx, test_ctx->sysdb,
2750 : : netgrname, NULL, &msg);
2751 : 10 : fail_if(ret != EOK, "Could not find netgroup with name %s", netgrname);
2752 : :
2753 : 10 : netgroup_dn = sysdb_netgroup_dn(test_ctx->sysdb, test_ctx, netgrname);
2754 : 10 : fail_if(netgroup_dn == NULL);
2755 : 10 : fail_if(ldb_dn_compare(msg->dn, netgroup_dn) != 0, "Found wrong netgroup!\n");
2756 : 10 : talloc_free(test_ctx);
2757 : : }
2758 : : END_TEST
2759 : :
2760 : 5 : START_TEST (test_sysdb_remove_netgroup_entry)
2761 : : {
2762 : : struct sysdb_test_ctx *test_ctx;
2763 : : struct test_data *data;
2764 : : int ret;
2765 : :
2766 : : /* Setup */
2767 : 5 : ret = setup_sysdb_tests(&test_ctx);
2768 [ - + ]: 5 : if (ret != EOK) {
2769 : 0 : fail("Could not set up the test");
2770 : 5 : return;
2771 : : }
2772 : :
2773 : 5 : data = talloc_zero(test_ctx, struct test_data);
2774 : 5 : data->ctx = test_ctx;
2775 : 5 : data->ev = test_ctx->ev;
2776 : 5 : data->netgrname = talloc_asprintf(data, "testnetgr%d", _i);
2777 : :
2778 : 5 : ret = test_remove_netgroup_entry(data);
2779 : :
2780 : 5 : fail_if(ret != EOK, "Could not remove netgroup %s", data->netgrname);
2781 : 5 : talloc_free(test_ctx);
2782 : : }
2783 : : END_TEST
2784 : :
2785 : 5 : START_TEST (test_sysdb_remove_netgroup_by_name)
2786 : : {
2787 : : struct sysdb_test_ctx *test_ctx;
2788 : : struct test_data *data;
2789 : : int ret;
2790 : :
2791 : : /* Setup */
2792 : 5 : ret = setup_sysdb_tests(&test_ctx);
2793 [ - + ]: 5 : if (ret != EOK) {
2794 : 0 : fail("Could not set up the test");
2795 : 5 : return;
2796 : : }
2797 : :
2798 : 5 : data = talloc_zero(test_ctx, struct test_data);
2799 : 5 : data->ctx = test_ctx;
2800 : 5 : data->ev = test_ctx->ev;
2801 : 5 : data->netgrname = talloc_asprintf(data, "testnetgr%d", _i);
2802 : :
2803 : 5 : ret = test_remove_netgroup_by_name(data);
2804 : :
2805 : 5 : fail_if(ret != EOK, "Could not remove netgroup with name %s", data->netgrname);
2806 : 5 : talloc_free(test_ctx);
2807 : : }
2808 : : END_TEST
2809 : :
2810 : 10 : START_TEST (test_sysdb_set_netgroup_attr)
2811 : : {
2812 : : struct sysdb_test_ctx *test_ctx;
2813 : : struct test_data *data;
2814 : : int ret;
2815 : :
2816 : : /* Setup */
2817 : 10 : ret = setup_sysdb_tests(&test_ctx);
2818 [ - + ]: 10 : if (ret != EOK) {
2819 : 0 : fail("Could not set up the test");
2820 : 10 : return;
2821 : : }
2822 : :
2823 : 10 : data = talloc_zero(test_ctx, struct test_data);
2824 : 10 : data->ctx = test_ctx;
2825 : 10 : data->ev = test_ctx->ev;
2826 : 10 : data->uid = _i; /* This is kinda abuse of uid, though */
2827 : 10 : data->netgrname = talloc_asprintf(data, "testnetgr%d", _i);
2828 : :
2829 : 10 : ret = test_set_netgroup_attr(data);
2830 : :
2831 : 10 : fail_if(ret != EOK, "Could not set netgroup attribute %s", data->netgrname);
2832 : 10 : talloc_free(test_ctx);
2833 : : }
2834 : : END_TEST
2835 : :
2836 : 10 : START_TEST (test_sysdb_get_netgroup_attr)
2837 : : {
2838 : : struct sysdb_test_ctx *test_ctx;
2839 : : int ret;
2840 : : const char *description;
2841 : : const char *netgrname;
2842 : : struct ldb_result *res;
2843 : 10 : const char *attrs[] = { SYSDB_DESCRIPTION, NULL };
2844 : : const char *attrval;
2845 : :
2846 : : /* Setup */
2847 : 10 : ret = setup_sysdb_tests(&test_ctx);
2848 [ - + ]: 10 : if (ret != EOK) {
2849 : 0 : fail("Could not set up the test");
2850 : 10 : return;
2851 : : }
2852 : :
2853 : 10 : description = talloc_asprintf(test_ctx, "Sysdb Netgroup %d", _i);
2854 : 10 : netgrname = talloc_asprintf(test_ctx, "testnetgr%d", _i);
2855 : :
2856 : 10 : ret = sysdb_get_netgroup_attr(test_ctx, test_ctx->sysdb,
2857 : : netgrname, attrs, &res);
2858 : :
2859 : 10 : fail_if(ret != EOK, "Could not get netgroup attributes");
2860 : 10 : fail_if(res->count != 1,
2861 : : "Invalid number of entries, expected 1, got %d", res->count);
2862 : :
2863 : 10 : attrval = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_DESCRIPTION, 0);
2864 : 10 : fail_if(strcmp(attrval, description),
2865 : : "Got bad attribute value for netgroup %s", netgrname);
2866 : 10 : talloc_free(test_ctx);
2867 : : }
2868 : : END_TEST
2869 : :
2870 : 10 : START_TEST(test_sysdb_add_netgroup_tuple)
2871 : : {
2872 : : errno_t ret;
2873 : : struct sysdb_test_ctx *test_ctx;
2874 : : const char *netgrname;
2875 : : const char *hostname;
2876 : : const char *username;
2877 : : const char *domainname;
2878 : : struct ldb_result *res;
2879 : : struct sysdb_netgroup_ctx **entries;
2880 : :
2881 : : /* Setup */
2882 : 10 : ret = setup_sysdb_tests(&test_ctx);
2883 [ - + ]: 10 : if (ret != EOK) {
2884 : 0 : fail("Could not set up the test");
2885 : 10 : return;
2886 : : }
2887 : :
2888 : 10 : netgrname = talloc_asprintf(test_ctx, "testnetgr%d", _i);
2889 : 10 : fail_if(netgrname == NULL, "Out of memory");
2890 : :
2891 : 10 : hostname = talloc_asprintf(test_ctx, "hostname%d", _i);
2892 : 10 : fail_if(hostname == NULL, "Out of memory");
2893 : :
2894 : 10 : username = talloc_asprintf(test_ctx, "username%d", _i);
2895 : 10 : fail_if(username == NULL, "Out of memory");
2896 : :
2897 : 10 : domainname = talloc_asprintf(test_ctx, "domainname%d", _i);
2898 : 10 : fail_if(domainname == NULL, "Out of memory");
2899 : :
2900 : 10 : ret = sysdb_add_netgroup_tuple(test_ctx->sysdb,
2901 : : netgrname, hostname,
2902 : : username, domainname);
2903 : 10 : fail_unless(ret == EOK, "Failed to add netgr tuple");
2904 : :
2905 : 10 : ret = sysdb_getnetgr(test_ctx, test_ctx->sysdb,
2906 : : netgrname, &res);
2907 : 10 : fail_unless(ret == EOK, "Failed to retrieve netgr information");
2908 : :
2909 : 10 : ret = sysdb_netgr_to_entries(test_ctx, res, &entries);
2910 : 10 : fail_unless(ret == EOK, "Failed to convert entries");
2911 : :
2912 [ + - ][ + - ]: 10 : fail_unless(entries && entries[0] && !entries[1],
[ - + ]
2913 : : "Got more than one triple back");
2914 : :
2915 : 10 : fail_unless(strcmp(entries[0]->value.triple.hostname, hostname) == 0,
2916 : : "Got [%s], expected [%s] for hostname",
2917 : : entries[0]->value.triple.hostname, hostname);
2918 : :
2919 : 10 : fail_unless(strcmp(entries[0]->value.triple.username, username) == 0,
2920 : : "Got [%s], expected [%s] for username",
2921 : : entries[0]->value.triple.username, username);
2922 : :
2923 : 10 : fail_unless(strcmp(entries[0]->value.triple.domainname, domainname) == 0,
2924 : : "Got [%s], expected [%s] for domainname",
2925 : : entries[0]->value.triple.domainname, domainname);
2926 : :
2927 : 10 : talloc_free(test_ctx);
2928 : : }
2929 : : END_TEST
2930 : :
2931 : 10 : START_TEST(test_sysdb_remove_netgroup_tuple)
2932 : : {
2933 : : errno_t ret;
2934 : : struct sysdb_test_ctx *test_ctx;
2935 : : const char *netgrname;
2936 : : const char *hostname;
2937 : : const char *username;
2938 : : const char *domainname;
2939 : : struct ldb_result *res;
2940 : : struct sysdb_netgroup_ctx **entries;
2941 : :
2942 : : /* Setup */
2943 : 10 : ret = setup_sysdb_tests(&test_ctx);
2944 [ - + ]: 10 : if (ret != EOK) {
2945 : 0 : fail("Could not set up the test");
2946 : 10 : return;
2947 : : }
2948 : :
2949 : 10 : netgrname = talloc_asprintf(test_ctx, "testnetgr%d", _i);
2950 : 10 : fail_if(netgrname == NULL, "Out of memory");
2951 : :
2952 : 10 : hostname = talloc_asprintf(test_ctx, "hostname%d", _i);
2953 : 10 : fail_if(hostname == NULL, "Out of memory");
2954 : :
2955 : 10 : username = talloc_asprintf(test_ctx, "username%d", _i);
2956 : 10 : fail_if(username == NULL, "Out of memory");
2957 : :
2958 : 10 : domainname = talloc_asprintf(test_ctx, "domainname%d", _i);
2959 : 10 : fail_if(domainname == NULL, "Out of memory");
2960 : :
2961 : 10 : ret = sysdb_remove_netgroup_tuple(test_ctx->sysdb,
2962 : : netgrname, hostname,
2963 : : username, domainname);
2964 : 10 : fail_unless(ret == EOK, "Failed to remove netgr tuple");
2965 : :
2966 : 10 : ret = sysdb_getnetgr(test_ctx, test_ctx->sysdb,
2967 : : netgrname, &res);
2968 : 10 : fail_unless(ret == EOK, "Failed to retrieve netgr information");
2969 : :
2970 : 10 : ret = sysdb_netgr_to_entries(test_ctx, res, &entries);
2971 : 10 : fail_unless(ret == EOK, "Failed to convert entries");
2972 : :
2973 [ + - ][ - + ]: 10 : fail_unless(entries && !entries[0],"Found entries unexpectedly");
2974 : :
2975 : 10 : talloc_free(test_ctx);
2976 : : }
2977 : : END_TEST
2978 : :
2979 : 9 : START_TEST(test_sysdb_add_netgroup_member)
2980 : : {
2981 : : errno_t ret;
2982 : : struct sysdb_test_ctx *test_ctx;
2983 : : const char *netgrname;
2984 : : const char *membername;
2985 : : struct ldb_result *res;
2986 : : struct sysdb_netgroup_ctx **entries;
2987 : :
2988 : : char *hostname1;
2989 : : char *username1;
2990 : : char *domainname1;
2991 : :
2992 : : char *hostname2;
2993 : : char *username2;
2994 : : char *domainname2;
2995 : :
2996 : : /* Setup */
2997 : 9 : ret = setup_sysdb_tests(&test_ctx);
2998 [ - + ]: 9 : if (ret != EOK) {
2999 : 0 : fail("Could not set up the test");
3000 : 9 : return;
3001 : : }
3002 : :
3003 : 9 : netgrname = talloc_asprintf(test_ctx, "testnetgr%d", _i);
3004 : 9 : fail_if(netgrname == NULL, "Out of memory");
3005 : :
3006 : 9 : membername = talloc_asprintf(test_ctx, "testnetgr%d", _i+1);
3007 : 9 : fail_if(membername == NULL, "Out of memory");
3008 : :
3009 : 9 : hostname1 = talloc_asprintf(test_ctx, "hostname%d", _i);
3010 : 9 : hostname2 = talloc_asprintf(test_ctx, "hostname%d", _i+1);
3011 : :
3012 : 9 : username1 = talloc_asprintf(test_ctx, "username%d", _i);
3013 : 9 : username2 = talloc_asprintf(test_ctx, "username%d", _i+1);
3014 : :
3015 : 9 : domainname1 = talloc_asprintf(test_ctx, "domainname%d", _i);
3016 : 9 : domainname2 = talloc_asprintf(test_ctx, "domainname%d", _i+1);
3017 : :
3018 : 9 : ret = sysdb_add_netgroup_member(test_ctx->sysdb, netgrname, membername);
3019 : 9 : fail_unless(ret == EOK, "Failed to add netgr member");
3020 : :
3021 : 9 : ret = sysdb_getnetgr(test_ctx, test_ctx->sysdb,
3022 : : netgrname, &res);
3023 : 9 : fail_unless(ret == EOK, "Failed to retrieve netgr information");
3024 : :
3025 : 9 : ret = sysdb_netgr_to_entries(test_ctx, res, &entries);
3026 : 9 : fail_unless(ret == EOK, "Failed to convert entries");
3027 : :
3028 : 9 : fail_if(!entries, "Received a NULL triple");
3029 : 9 : fail_if(!entries[0], "Did not get any responses");
3030 [ + - ][ + - ]: 9 : fail_unless(entries[0] && entries[1] && !entries[2],
[ - + ]
3031 : : "Did not get exactly two responses");
3032 : :
3033 : 9 : fail_unless(strcmp(entries[0]->value.triple.hostname, hostname1) == 0,
3034 : : "Got [%s], expected [%s] for hostname",
3035 : : entries[0]->value.triple.hostname, hostname1);
3036 : :
3037 : 9 : fail_unless(strcmp(entries[0]->value.triple.username, username1) == 0,
3038 : : "Got [%s], expected [%s] for username",
3039 : : entries[0]->value.triple.username, username1);
3040 : :
3041 : 9 : fail_unless(strcmp(entries[0]->value.triple.domainname, domainname1) == 0,
3042 : : "Got [%s], expected [%s] for domainname",
3043 : : entries[0]->value.triple.domainname, domainname1);
3044 : :
3045 : 9 : fail_unless(strcmp(entries[1]->value.triple.hostname, hostname2) == 0,
3046 : : "Got [%s], expected [%s] for hostname",
3047 : : entries[0]->value.triple.hostname, hostname2);
3048 : :
3049 : 9 : fail_unless(strcmp(entries[1]->value.triple.username, username2) == 0,
3050 : : "Got [%s], expected [%s] for username",
3051 : : entries[0]->value.triple.username, username2);
3052 : :
3053 : 9 : fail_unless(strcmp(entries[1]->value.triple.domainname, domainname2) == 0,
3054 : : "Got [%s], expected [%s] for domainname",
3055 : : entries[0]->value.triple.domainname, domainname2);
3056 : :
3057 : 9 : talloc_free(test_ctx);
3058 : : }
3059 : : END_TEST
3060 : :
3061 : 9 : START_TEST(test_sysdb_remove_netgroup_member)
3062 : : {
3063 : : errno_t ret;
3064 : : struct sysdb_test_ctx *test_ctx;
3065 : : const char *netgrname;
3066 : : const char *membername;
3067 : : struct ldb_result *res;
3068 : : struct sysdb_netgroup_ctx **entries;
3069 : :
3070 : : char *hostname;
3071 : : char *username;
3072 : : char *domainname;
3073 : :
3074 : : /* Setup */
3075 : 9 : ret = setup_sysdb_tests(&test_ctx);
3076 [ - + ]: 9 : if (ret != EOK) {
3077 : 0 : fail("Could not set up the test");
3078 : 9 : return;
3079 : : }
3080 : :
3081 : 9 : netgrname = talloc_asprintf(test_ctx, "testnetgr%d", _i);
3082 : 9 : fail_if(netgrname == NULL, "Out of memory");
3083 : :
3084 : 9 : membername = talloc_asprintf(test_ctx, "testnetgr%d", _i+1);
3085 : 9 : fail_if(membername == NULL, "Out of memory");
3086 : :
3087 : 9 : hostname = talloc_asprintf(test_ctx, "hostname%d", _i);
3088 : 9 : username = talloc_asprintf(test_ctx, "username%d", _i);
3089 : 9 : domainname = talloc_asprintf(test_ctx, "domainname%d", _i);
3090 : :
3091 : 9 : ret = sysdb_remove_netgroup_member(test_ctx->sysdb, netgrname, membername);
3092 : 9 : fail_unless(ret == EOK, "Failed to add netgr member");
3093 : :
3094 : 9 : ret = sysdb_getnetgr(test_ctx, test_ctx->sysdb,
3095 : : netgrname, &res);
3096 : 9 : fail_unless(ret == EOK, "Failed to retrieve netgr information");
3097 : :
3098 : 9 : ret = sysdb_netgr_to_entries(test_ctx, res, &entries);
3099 : 9 : fail_unless(ret == EOK, "Failed to convert entries");
3100 : :
3101 : 9 : fail_if(!entries, "Received a NULL triple");
3102 : 9 : fail_if(!entries[0], "Did not get any responses");
3103 [ + - ][ - + ]: 9 : fail_unless(entries[0] && !entries[1],
3104 : : "Did not get exactly one response");
3105 : :
3106 : 9 : fail_unless(strcmp(entries[0]->value.triple.hostname, hostname) == 0,
3107 : : "Got [%s], expected [%s] for hostname",
3108 : : entries[0]->value.triple.hostname, hostname);
3109 : :
3110 : 9 : fail_unless(strcmp(entries[0]->value.triple.username, username) == 0,
3111 : : "Got [%s], expected [%s] for username",
3112 : : entries[0]->value.triple.username, username);
3113 : :
3114 : 9 : fail_unless(strcmp(entries[0]->value.triple.domainname, domainname) == 0,
3115 : : "Got [%s], expected [%s] for domainname",
3116 : : entries[0]->value.triple.domainname, domainname);
3117 : :
3118 : 9 : talloc_free(test_ctx);
3119 : : }
3120 : : END_TEST
3121 : :
3122 : 1 : START_TEST(test_odd_characters)
3123 : : {
3124 : : errno_t ret;
3125 : : struct sysdb_test_ctx *test_ctx;
3126 : : struct ldb_result *res;
3127 : : struct ldb_message *msg;
3128 : : const struct ldb_val *val;
3129 : 1 : const char odd_username[] = "*(odd)\\user,name";
3130 : 1 : const char odd_groupname[] = "*(odd\\*)\\group,name";
3131 : 1 : const char odd_netgroupname[] = "*(odd\\*)\\netgroup,name";
3132 : : const char *received_user;
3133 : : const char *received_group;
3134 : : static const char *user_attrs[] = SYSDB_PW_ATTRS;
3135 : : static const char *netgr_attrs[] = SYSDB_NETGR_ATTRS;
3136 : :
3137 : : /* Setup */
3138 : 1 : ret = setup_sysdb_tests(&test_ctx);
3139 [ - + ]: 1 : if (ret != EOK) {
3140 : 0 : fail("Could not set up the test");
3141 : 1 : return;
3142 : : }
3143 : :
3144 : : /* ===== Groups ===== */
3145 : :
3146 : : /* Add */
3147 : 1 : ret = sysdb_add_incomplete_group(test_ctx->sysdb,
3148 : : odd_groupname, 20000, NULL, true, 0);
3149 : 1 : fail_unless(ret == EOK, "sysdb_add_incomplete_group error [%d][%s]",
3150 : : ret, strerror(ret));
3151 : :
3152 : : /* Retrieve */
3153 : 1 : ret = sysdb_search_group_by_name(test_ctx, test_ctx->sysdb,
3154 : : odd_groupname, NULL, &msg);
3155 : 1 : fail_unless(ret == EOK, "sysdb_search_group_by_name error [%d][%s]",
3156 : : ret, strerror(ret));
3157 : 1 : talloc_zfree(msg);
3158 : :
3159 : 1 : ret = sysdb_getgrnam(test_ctx, test_ctx->sysdb, odd_groupname, &res);
3160 : 1 : fail_unless(ret == EOK, "sysdb_getgrnam error [%d][%s]",
3161 : : ret, strerror(ret));
3162 : 1 : fail_unless(res->count == 1, "Received [%d] responses",
3163 : : res->count);
3164 : 1 : received_group = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_NAME, NULL);
3165 : 1 : fail_unless(strcmp(received_group, odd_groupname) == 0,
3166 : : "Expected [%s], got [%s]",
3167 : : odd_groupname, received_group);
3168 : 1 : talloc_free(res);
3169 : :
3170 : :
3171 : : /* ===== Users ===== */
3172 : :
3173 : : /* Add */
3174 : 1 : ret = sysdb_add_basic_user(test_ctx->sysdb,
3175 : : odd_username,
3176 : : 10000, 10000,
3177 : : "","","");
3178 : 1 : fail_unless(ret == EOK, "sysdb_add_basic_user error [%d][%s]",
3179 : : ret, strerror(ret));
3180 : :
3181 : : /* Retrieve */
3182 : 1 : ret = sysdb_search_user_by_name(test_ctx, test_ctx->sysdb,
3183 : : odd_username, NULL, &msg);
3184 : 1 : fail_unless(ret == EOK, "sysdb_search_user_by_name error [%d][%s]",
3185 : : ret, strerror(ret));
3186 : 1 : val = ldb_dn_get_component_val(msg->dn, 0);
3187 : 1 : fail_unless(strcmp((char *)val->data, odd_username)==0,
3188 : : "Expected [%s] got [%s]\n",
3189 : : odd_username, (char *)val->data);
3190 : 1 : talloc_zfree(msg);
3191 : :
3192 : : /* Add to the group */
3193 : 1 : ret = sysdb_add_group_member(test_ctx->sysdb, odd_groupname, odd_username,
3194 : : SYSDB_MEMBER_USER);
3195 : 1 : fail_unless(ret == EOK, "sysdb_add_group_member error [%d][%s]",
3196 : : ret, strerror(ret));
3197 : :
3198 : 1 : ret = sysdb_getpwnam(test_ctx, test_ctx->sysdb, odd_username, &res);
3199 : 1 : fail_unless(ret == EOK, "sysdb_getpwnam error [%d][%s]",
3200 : : ret, strerror(ret));
3201 : 1 : fail_unless(res->count == 1, "Received [%d] responses",
3202 : : res->count);
3203 : 1 : received_user = ldb_msg_find_attr_as_string(res->msgs[0], SYSDB_NAME, NULL);
3204 : 1 : fail_unless(strcmp(received_user, odd_username) == 0,
3205 : : "Expected [%s], got [%s]",
3206 : : odd_username, received_user);
3207 : 1 : talloc_zfree(res);
3208 : :
3209 : : /* Attributes */
3210 : 1 : ret = sysdb_get_user_attr(test_ctx, test_ctx->sysdb,
3211 : : odd_username, user_attrs, &res);
3212 : 1 : fail_unless(ret == EOK, "sysdb_get_user_attr error [%d][%s]",
3213 : : ret, strerror(ret));
3214 : 1 : talloc_free(res);
3215 : :
3216 : : /* Delete User */
3217 : 1 : ret = sysdb_delete_user(test_ctx->sysdb, odd_username, 10000);
3218 : 1 : fail_unless(ret == EOK, "sysdb_delete_user error [%d][%s]",
3219 : : ret, strerror(ret));
3220 : :
3221 : :
3222 : : /* Delete Group */
3223 : 1 : ret = sysdb_delete_group(test_ctx->sysdb, odd_groupname, 20000);
3224 : 1 : fail_unless(ret == EOK, "sysdb_delete_group error [%d][%s]",
3225 : : ret, strerror(ret));
3226 : :
3227 : : /* ===== Netgroups ===== */
3228 : : /* Add */
3229 : 1 : ret = sysdb_add_netgroup(test_ctx->sysdb,
3230 : : odd_netgroupname, "No description",
3231 : : NULL, NULL, 30, 0);
3232 : 1 : fail_unless(ret == EOK, "sysdb_add_netgroup error [%d][%s]",
3233 : : ret, strerror(ret));
3234 : :
3235 : : /* Retrieve */
3236 : 1 : ret = sysdb_getnetgr(test_ctx, test_ctx->sysdb,
3237 : : odd_netgroupname, &res);
3238 : 1 : fail_unless(ret == EOK, "sysdb_getnetgr error [%d][%s]",
3239 : : ret, strerror(ret));
3240 : 1 : fail_unless(res->count == 1, "Received [%d] responses",
3241 : : res->count);
3242 : 1 : talloc_zfree(res);
3243 : :
3244 : 1 : ret = sysdb_get_netgroup_attr(test_ctx, test_ctx->sysdb,
3245 : : odd_netgroupname, netgr_attrs, &res);
3246 : 1 : fail_unless(ret == EOK, "sysdb_get_netgroup_attr error [%d][%s]",
3247 : : ret, strerror(ret));
3248 : 1 : fail_unless(res->count == 1, "Received [%d] responses",
3249 : : res->count);
3250 : 1 : talloc_zfree(res);
3251 : :
3252 : : /* ===== Arbitrary Entries ===== */
3253 : :
3254 : 1 : talloc_free(test_ctx);
3255 : : }
3256 : : END_TEST
3257 : :
3258 : : /* == SERVICE TESTS == */
3259 : 12 : void services_check_match(struct sysdb_test_ctx *test_ctx,
3260 : : bool by_name,
3261 : : const char *primary_name,
3262 : : int port,
3263 : : const char **aliases,
3264 : : const char **protocols)
3265 : : {
3266 : : errno_t ret;
3267 : : unsigned int i, j;
3268 : : bool matched;
3269 : : const char *ret_name;
3270 : : int ret_port;
3271 : : struct ldb_result *res;
3272 : : struct ldb_message *msg;
3273 : : struct ldb_message_element *el;
3274 : :
3275 [ + + ]: 12 : if (by_name) {
3276 : : /* Look up the service by name */
3277 : 6 : ret = sysdb_getservbyname(test_ctx, test_ctx->sysdb, primary_name,
3278 : : NULL, &res);
3279 : 6 : fail_if(ret != EOK, "sysdb_getservbyname error [%s]\n",
3280 : : strerror(ret));
3281 : : } else {
3282 : : /* Look up the newly-added service by port */
3283 : 6 : ret = sysdb_getservbyport(test_ctx, test_ctx->sysdb,
3284 : : port, NULL, &res);
3285 : 6 : fail_if(ret != EOK, "sysdb_getservbyport error [%s]\n",
3286 : : strerror(ret));
3287 : : }
3288 : 12 : fail_if(res == NULL, "ENOMEM");
3289 : 12 : fail_if(res->count != 1);
3290 : :
3291 : : /* Make sure the returned entry matches */
3292 : 12 : msg = res->msgs[0];
3293 : 12 : ret_name = ldb_msg_find_attr_as_string(msg, SYSDB_NAME, NULL);
3294 : 12 : fail_if(ret_name == NULL);
3295 : 12 : fail_unless(strcmp(ret_name, primary_name) == 0);
3296 : :
3297 : 12 : ret_port = ldb_msg_find_attr_as_int(msg, SYSDB_SVC_PORT, 0);
3298 : 12 : fail_if (ret_port != port);
3299 : :
3300 : 12 : el = ldb_msg_find_element(msg, SYSDB_NAME_ALIAS);
3301 [ + + ]: 34 : for (i = 0; i < el->num_values; i++) {
3302 : : matched = false;
3303 [ + + ]: 64 : for (j = 0; aliases[j]; j++) {
3304 [ + + ]: 42 : if (strcmp(aliases[j], (const char *)el->values[i].data) == 0) {
3305 : 22 : matched = true;
3306 : : }
3307 : : }
3308 : 22 : fail_if(!matched, "Unexpected value in LDB entry: [%s]",
3309 : : (const char *)el->values[i].data);
3310 : : }
3311 : :
3312 : 12 : el = ldb_msg_find_element(msg, SYSDB_SVC_PROTO);
3313 [ + + ]: 36 : for (i = 0; i < el->num_values; i++) {
3314 : : matched = false;
3315 [ + + ]: 72 : for (j = 0; protocols[j]; j++) {
3316 [ + + ]: 48 : if (strcmp(protocols[j], (const char *)el->values[i].data) == 0) {
3317 : 24 : matched = true;
3318 : : }
3319 : : }
3320 : 24 : fail_if(!matched, "Unexpected value in LDB entry: [%s]",
3321 : : (const char *)el->values[i].data);
3322 : : }
3323 : 12 : }
3324 : :
3325 : : #define services_check_match_name(test_ctx, primary_name, port, aliases, protocols) \
3326 : : do { \
3327 : : services_check_match(test_ctx, true, primary_name, port, aliases, protocols); \
3328 : : } while(0);
3329 : :
3330 : : #define services_check_match_port(test_ctx, primary_name, port, aliases, protocols) \
3331 : : do { \
3332 : : services_check_match(test_ctx, false, primary_name, port, aliases, protocols); \
3333 : : } while(0);
3334 : :
3335 : : errno_t
3336 : : sysdb_svc_add(TALLOC_CTX *mem_ctx,
3337 : : struct sysdb_ctx *sysdb,
3338 : : const char *primary_name,
3339 : : int port,
3340 : : const char **aliases,
3341 : : const char **protocols,
3342 : : struct ldb_dn **dn);
3343 : :
3344 : 1 : START_TEST(test_sysdb_add_services)
3345 : : {
3346 : : errno_t ret;
3347 : : struct sysdb_test_ctx *test_ctx;
3348 : : char *primary_name;
3349 : : const char **aliases;
3350 : : const char **protocols;
3351 : 1 : int port = 3890;
3352 : :
3353 : : /* Setup */
3354 : 1 : ret = setup_sysdb_tests(&test_ctx);
3355 : 1 : fail_if(ret != EOK, "Could not set up the test");
3356 : :
3357 : 1 : primary_name = talloc_asprintf(test_ctx, "test_service");
3358 : 1 : fail_if(primary_name == NULL);
3359 : :
3360 : 1 : aliases = talloc_array(test_ctx, const char *, 3);
3361 : 1 : fail_if(aliases == NULL);
3362 : :
3363 : 1 : aliases[0] = talloc_asprintf(aliases, "test_service_alias1");
3364 : 1 : fail_if(aliases[0] == NULL);
3365 : :
3366 : 1 : aliases[1] = talloc_asprintf(aliases, "test_service_alias2");
3367 : 1 : fail_if(aliases[1] == NULL);
3368 : :
3369 : 1 : aliases[2] = NULL;
3370 : :
3371 : 1 : protocols = talloc_array(test_ctx, const char *, 3);
3372 : 1 : fail_if(protocols == NULL);
3373 : :
3374 : 1 : protocols[0] = talloc_asprintf(protocols, "tcp");
3375 : 1 : fail_if(protocols[0] == NULL);
3376 : :
3377 : 1 : protocols[1] = talloc_asprintf(protocols, "udp");
3378 : 1 : fail_if(protocols[1] == NULL);
3379 : :
3380 : 1 : protocols[2] = NULL;
3381 : :
3382 : 1 : ret = sysdb_transaction_start(test_ctx->sysdb);
3383 : 1 : fail_if(ret != EOK);
3384 : :
3385 : 1 : ret = sysdb_svc_add(NULL, test_ctx->sysdb,
3386 : : primary_name, port,
3387 : : aliases, protocols,
3388 : : NULL);
3389 : 1 : fail_unless(ret == EOK, "sysdb_svc_add error [%s]\n", strerror(ret));
3390 : :
3391 : : /* Search by name and make sure the results match */
3392 : 1 : services_check_match_name(test_ctx,
3393 : : primary_name, port,
3394 : : aliases, protocols);
3395 : :
3396 : : /* Search by port and make sure the results match */
3397 : 1 : services_check_match_port(test_ctx,
3398 : : primary_name, port,
3399 : : aliases, protocols);
3400 : :
3401 : 1 : ret = sysdb_transaction_commit(test_ctx->sysdb);
3402 : 1 : fail_if (ret != EOK);
3403 : :
3404 : : /* Clean up after ourselves (and test deleting by name)
3405 : : *
3406 : : * We have to do this after the transaction, because LDB
3407 : : * doesn't like adding and deleting the same entry in a
3408 : : * single transaction.
3409 : : */
3410 : 1 : ret = sysdb_svc_delete(test_ctx->sysdb, primary_name, 0, NULL);
3411 : 1 : fail_if(ret != EOK);
3412 : :
3413 : 1 : talloc_free(test_ctx);
3414 : : }
3415 : 1 : END_TEST
3416 : :
3417 : 1 : START_TEST(test_sysdb_store_services)
3418 : : {
3419 : : errno_t ret;
3420 : : struct sysdb_test_ctx *test_ctx;
3421 : 1 : const char *primary_name = "test_store_service";
3422 : 1 : const char *alt_primary_name = "alt_test_store_service";
3423 : : const char **aliases;
3424 : : const char **protocols;
3425 : 1 : int port = 3890;
3426 : 1 : int altport = 3891;
3427 : :
3428 : : /* Setup */
3429 : 1 : ret = setup_sysdb_tests(&test_ctx);
3430 : 1 : fail_if(ret != EOK, "Could not set up the test");
3431 : :
3432 : 1 : aliases = talloc_array(test_ctx, const char *, 3);
3433 : 1 : fail_if(aliases == NULL);
3434 : :
3435 : 1 : aliases[0] = talloc_asprintf(aliases, "test_service_alias1");
3436 : 1 : fail_if(aliases[0] == NULL);
3437 : :
3438 : 1 : aliases[1] = talloc_asprintf(aliases, "test_service_alias2");
3439 : 1 : fail_if(aliases[1] == NULL);
3440 : :
3441 : 1 : aliases[2] = NULL;
3442 : :
3443 : 1 : protocols = talloc_array(test_ctx, const char *, 3);
3444 : 1 : fail_if(protocols == NULL);
3445 : :
3446 : 1 : protocols[0] = talloc_asprintf(protocols, "tcp");
3447 : 1 : fail_if(protocols[0] == NULL);
3448 : :
3449 : 1 : protocols[1] = talloc_asprintf(protocols, "udp");
3450 : 1 : fail_if(protocols[1] == NULL);
3451 : :
3452 : 1 : protocols[2] = NULL;
3453 : :
3454 : 1 : ret = sysdb_transaction_start(test_ctx->sysdb);
3455 : 1 : fail_if(ret != EOK);
3456 : :
3457 : : /* Store this group (which will add it) */
3458 : 1 : ret = sysdb_store_service(test_ctx->sysdb,
3459 : : primary_name, port,
3460 : : aliases, protocols,
3461 : : NULL, NULL, 1, 1);
3462 : 1 : fail_if (ret != EOK);
3463 : :
3464 : : /* Search by name and make sure the results match */
3465 : 1 : services_check_match_name(test_ctx,
3466 : : primary_name, port,
3467 : : aliases, protocols);
3468 : :
3469 : : /* Search by port and make sure the results match */
3470 : 1 : services_check_match_port(test_ctx,
3471 : : primary_name, port,
3472 : : aliases, protocols);
3473 : :
3474 : : /* Change the service name */
3475 : 1 : ret = sysdb_store_service(test_ctx->sysdb,
3476 : : alt_primary_name, port,
3477 : : aliases, protocols,
3478 : : NULL, NULL, 1, 1);
3479 : 1 : fail_if (ret != EOK, "[%s]", strerror(ret));
3480 : :
3481 : 1 : services_check_match_name(test_ctx,
3482 : : alt_primary_name, port,
3483 : : aliases, protocols);
3484 : :
3485 : : /* Search by port and make sure the results match */
3486 : 1 : services_check_match_port(test_ctx,
3487 : : alt_primary_name, port,
3488 : : aliases, protocols);
3489 : :
3490 : :
3491 : : /* Change it back */
3492 : 1 : ret = sysdb_store_service(test_ctx->sysdb,
3493 : : primary_name, port,
3494 : : aliases, protocols,
3495 : : NULL, NULL, 1, 1);
3496 : 1 : fail_if (ret != EOK, "[%s]", strerror(ret));
3497 : :
3498 : : /* Change the port number */
3499 : 1 : ret = sysdb_store_service(test_ctx->sysdb,
3500 : : primary_name, altport,
3501 : : aliases, protocols,
3502 : : NULL, NULL, 1, 1);
3503 : 1 : fail_if (ret != EOK, "[%s]", strerror(ret));
3504 : :
3505 : : /* Search by name and make sure the results match */
3506 : 1 : services_check_match_name(test_ctx,
3507 : : primary_name, altport,
3508 : : aliases, protocols);
3509 : :
3510 : : /* Search by port and make sure the results match */
3511 : 1 : services_check_match_port(test_ctx,
3512 : : primary_name, altport,
3513 : : aliases, protocols);
3514 : :
3515 : : /* TODO: Test changing aliases and protocols */
3516 : :
3517 : 1 : ret = sysdb_transaction_commit(test_ctx->sysdb);
3518 : 1 : fail_if(ret != EOK, "[%s]", strerror(ret));
3519 : :
3520 : : /* Clean up after ourselves (and test deleting by port)
3521 : : *
3522 : : * We have to do this after the transaction, because LDB
3523 : : * doesn't like adding and deleting the same entry in a
3524 : : * single transaction.
3525 : : */
3526 : 1 : ret = sysdb_svc_delete(test_ctx->sysdb, NULL, altport, NULL);
3527 : 1 : fail_if(ret != EOK);
3528 : :
3529 : 1 : talloc_free(test_ctx);
3530 : : }
3531 : 1 : END_TEST
3532 : :
3533 : : errno_t
3534 : : sysdb_svc_remove_alias(struct sysdb_ctx *sysdb,
3535 : : struct ldb_dn *dn,
3536 : : const char *alias);
3537 : :
3538 : 1 : START_TEST(test_sysdb_svc_remove_alias)
3539 : : {
3540 : : errno_t ret;
3541 : : struct sysdb_test_ctx *test_ctx;
3542 : 1 : const char *primary_name = "remove_alias_test";
3543 : : const char **aliases;
3544 : : const char **protocols;
3545 : 1 : int port = 3990;
3546 : : struct ldb_dn *dn;
3547 : :
3548 : : /* Setup */
3549 : 1 : ret = setup_sysdb_tests(&test_ctx);
3550 : 1 : fail_if(ret != EOK, "Could not set up the test");
3551 : :
3552 : 1 : aliases = talloc_array(test_ctx, const char *, 3);
3553 : 1 : fail_if(aliases == NULL);
3554 : :
3555 : 1 : aliases[0] = talloc_asprintf(aliases, "remove_alias_alias1");
3556 : 1 : fail_if(aliases[0] == NULL);
3557 : :
3558 : 1 : aliases[1] = talloc_asprintf(aliases, "remove_alias_alias2");
3559 : 1 : fail_if(aliases[1] == NULL);
3560 : :
3561 : 1 : aliases[2] = NULL;
3562 : :
3563 : 1 : protocols = talloc_array(test_ctx, const char *, 3);
3564 : 1 : fail_if(protocols == NULL);
3565 : :
3566 : 1 : protocols[0] = talloc_asprintf(protocols, "tcp");
3567 : 1 : fail_if(protocols[0] == NULL);
3568 : :
3569 : 1 : protocols[1] = talloc_asprintf(protocols, "udp");
3570 : 1 : fail_if(protocols[1] == NULL);
3571 : :
3572 : 1 : protocols[2] = NULL;
3573 : :
3574 : 1 : ret = sysdb_transaction_start(test_ctx->sysdb);
3575 : 1 : fail_if(ret != EOK);
3576 : :
3577 : 1 : ret = sysdb_svc_add(NULL, test_ctx->sysdb,
3578 : : primary_name, port,
3579 : : aliases, protocols,
3580 : : NULL);
3581 : 1 : fail_unless(ret == EOK, "sysdb_svc_add error [%s]\n", strerror(ret));
3582 : :
3583 : : /* Search by name and make sure the results match */
3584 : 1 : services_check_match_name(test_ctx,
3585 : : primary_name, port,
3586 : : aliases, protocols);
3587 : :
3588 : : /* Search by port and make sure the results match */
3589 : 1 : services_check_match_port(test_ctx,
3590 : : primary_name, port,
3591 : : aliases, protocols);
3592 : :
3593 : : /* Now remove an alias */
3594 : 1 : dn = sysdb_svc_dn(test_ctx->sysdb, test_ctx, test_ctx->domain->name, primary_name);
3595 : 1 : fail_if (dn == NULL);
3596 : :
3597 : 1 : ret = sysdb_svc_remove_alias(test_ctx->sysdb, dn, aliases[1]);
3598 : 1 : fail_if (ret != EOK, "[%s]", strerror(ret));
3599 : 1 : sysdb_transaction_commit(test_ctx->sysdb);
3600 : 1 : sysdb_transaction_start(test_ctx->sysdb);
3601 : :
3602 : : /* Set aliases[1] to NULL to perform validation checks */
3603 : 1 : aliases[1] = NULL;
3604 : :
3605 : : /* Search by name and make sure the results match */
3606 : 1 : services_check_match_name(test_ctx,
3607 : : primary_name, port,
3608 : : aliases, protocols);
3609 : :
3610 : : /* Search by port and make sure the results match */
3611 : 1 : services_check_match_port(test_ctx,
3612 : : primary_name, port,
3613 : : aliases, protocols);
3614 : :
3615 : 1 : ret = sysdb_transaction_commit(test_ctx->sysdb);
3616 : 1 : fail_if(ret != EOK);
3617 : :
3618 : 1 : talloc_free(test_ctx);
3619 : : }
3620 : 1 : END_TEST
3621 : :
3622 : 1 : START_TEST(test_sysdb_has_enumerated)
3623 : : {
3624 : : errno_t ret;
3625 : : struct sysdb_test_ctx *test_ctx;
3626 : : bool enumerated;
3627 : :
3628 : : /* Setup */
3629 : 1 : ret = setup_sysdb_tests(&test_ctx);
3630 : 1 : fail_if(ret != EOK, "Could not set up the test");
3631 : :
3632 : 1 : ret = sysdb_has_enumerated(test_ctx->sysdb, &enumerated);
3633 : 1 : fail_if(ret != EOK, "Error [%d][%s] checking enumeration",
3634 : : ret, strerror(ret));
3635 : :
3636 : 1 : fail_if(enumerated, "Enumeration should default to false");
3637 : :
3638 : 1 : ret = sysdb_set_enumerated(test_ctx->sysdb,
3639 : : true);
3640 : 1 : fail_if(ret != EOK, "Error [%d][%s] setting enumeration",
3641 : : ret, strerror(ret));
3642 : :
3643 : : /* Recheck enumeration status */
3644 : 1 : ret = sysdb_has_enumerated(test_ctx->sysdb,
3645 : : &enumerated);
3646 : 1 : fail_if(ret != EOK, "Error [%d][%s] checking enumeration",
3647 : : ret, strerror(ret));
3648 : :
3649 : 1 : fail_unless(enumerated, "Enumeration should have been set to true");
3650 : :
3651 : 1 : talloc_free(test_ctx);
3652 : : }
3653 : 1 : END_TEST
3654 : :
3655 : 1 : START_TEST(test_sysdb_original_dn_case_insensitive)
3656 : : {
3657 : : errno_t ret;
3658 : : struct sysdb_test_ctx *test_ctx;
3659 : : const char *filter;
3660 : : struct ldb_dn *base_dn;
3661 : 1 : const char *no_attrs[] = { NULL };
3662 : : struct ldb_message **msgs;
3663 : : size_t num_msgs;
3664 : :
3665 : : /* Setup */
3666 : 1 : ret = setup_sysdb_tests(&test_ctx);
3667 : 1 : fail_if(ret != EOK, "Could not set up the test");
3668 : :
3669 : 1 : ret = sysdb_add_incomplete_group(test_ctx->sysdb,
3670 : : "case_sensitive_group1", 29000,
3671 : : "cn=case_sensitive_group1,cn=example,cn=com",
3672 : : true, 0);
3673 : 1 : fail_unless(ret == EOK, "sysdb_add_incomplete_group error [%d][%s]",
3674 : : ret, strerror(ret));
3675 : :
3676 : 1 : ret = sysdb_add_incomplete_group(test_ctx->sysdb,
3677 : : "case_sensitive_group2", 29001,
3678 : : "cn=CASE_SENSITIVE_GROUP1,cn=EXAMPLE,cn=COM",
3679 : : true, 0);
3680 : 1 : fail_unless(ret == EOK, "sysdb_add_incomplete_group error [%d][%s]",
3681 : : ret, strerror(ret));
3682 : :
3683 : : /* Search by originalDN should yield 2 entries */
3684 : 1 : filter = talloc_asprintf(test_ctx, "%s=%s", SYSDB_ORIG_DN,
3685 : : "cn=case_sensitive_group1,cn=example,cn=com");
3686 : 1 : fail_if(filter == NULL, "Cannot construct filter\n");
3687 : :
3688 : 1 : base_dn = sysdb_domain_dn(test_ctx->sysdb, test_ctx);
3689 : 1 : fail_if(base_dn == NULL, "Cannot construct basedn\n");
3690 : :
3691 : 1 : ret = sysdb_search_entry(test_ctx, test_ctx->sysdb,
3692 : : base_dn, LDB_SCOPE_SUBTREE, filter, no_attrs,
3693 : : &num_msgs, &msgs);
3694 : 1 : fail_unless(ret == EOK, "cache search error [%d][%s]",
3695 : : ret, strerror(ret));
3696 : 1 : fail_unless(num_msgs == 2, "Did not find the expected number of entries using "
3697 : : "case insensitive originalDN search");
3698 : : }
3699 : 1 : END_TEST
3700 : :
3701 : : struct sysdb_subdom dom1 = { "DOM1.SUB", "dom1.sub", "dom1", "S-1" };
3702 : : struct sysdb_subdom dom2 = { "DOM2.SUB", "dom2.sub", "dom2", "S-2" };
3703 : : struct sysdb_subdom dom_t = { "TEST.SUB", "test.sub", "test", "S-3" };
3704 : :
3705 : 1 : START_TEST(test_sysdb_subdomain_create)
3706 : : {
3707 : : struct sysdb_test_ctx *test_ctx;
3708 : : errno_t ret;
3709 : 1 : struct sysdb_subdom **cur_subdomains = NULL;
3710 : : size_t cur_subdomains_count;
3711 : 1 : struct sysdb_subdom *new_subdom1 = &dom1;
3712 : 1 : struct sysdb_subdom *new_subdom2 = &dom2;
3713 : 1 : int num_subdom1 = 1;
3714 : 1 : int num_subdom2 = 1;
3715 : :
3716 : 1 : ret = setup_sysdb_tests(&test_ctx);
3717 : 1 : fail_if(ret != EOK, "Could not set up the test");
3718 : :
3719 : 1 : ret = sysdb_get_subdomains(test_ctx, test_ctx->sysdb,
3720 : : &cur_subdomains_count, &cur_subdomains);
3721 : 1 : fail_unless(ret == EOK, "sysdb_get_subdomains failed with [%d][%s]",
3722 : : ret, strerror(ret));
3723 : 1 : fail_unless(cur_subdomains != NULL, "No sub-domains returned.");
3724 : 1 : fail_unless(cur_subdomains[0] == NULL, "No empty sub-domain list returned.");
3725 : :
3726 : 1 : ret = sysdb_update_subdomains(test_ctx->sysdb, num_subdom1, new_subdom1);
3727 : 1 : fail_unless(ret == EOK, "sysdb_update_subdomains failed with [%d][%s]",
3728 : : ret, strerror(ret));
3729 : :
3730 : 1 : ret = sysdb_get_subdomains(test_ctx, test_ctx->sysdb,
3731 : : &cur_subdomains_count, &cur_subdomains);
3732 : 1 : fail_unless(ret == EOK, "sysdb_get_subdomains failed with [%d][%s]",
3733 : : ret, strerror(ret));
3734 : 1 : fail_unless(cur_subdomains != NULL, "No sub-domains returned.");
3735 : 1 : fail_unless(cur_subdomains[0] != NULL, "Empyt sub-domain list returned.");
3736 : 1 : fail_unless(strcmp(cur_subdomains[0]->name, new_subdom1[0].name) == 0,
3737 : : "Unexpected sub-domain found, expected [%s], got [%s]",
3738 : : new_subdom1[0].name, cur_subdomains[0]->name);
3739 : :
3740 : 1 : ret = sysdb_update_subdomains(test_ctx->sysdb, num_subdom2, new_subdom2);
3741 : 1 : fail_unless(ret == EOK, "sysdb_update_subdomains failed with [%d][%s]",
3742 : : ret, strerror(ret));
3743 : :
3744 : 1 : ret = sysdb_get_subdomains(test_ctx, test_ctx->sysdb,
3745 : : &cur_subdomains_count, &cur_subdomains);
3746 : 1 : fail_unless(ret == EOK, "sysdb_get_subdomains failed with [%d][%s]",
3747 : : ret, strerror(ret));
3748 : 1 : fail_unless(cur_subdomains != NULL, "No sub-domains returned.");
3749 : 1 : fail_unless(cur_subdomains[0] != NULL, "Empyt sub-domain list returned.");
3750 : 1 : fail_unless(strcmp(cur_subdomains[0]->name, new_subdom2[0].name) == 0,
3751 : : "Unexpected sub-domain found, expected [%s], got [%s]",
3752 : : new_subdom2[0].name, cur_subdomains[0]->name);
3753 : :
3754 : 1 : ret = sysdb_update_subdomains(test_ctx->sysdb, 0, NULL);
3755 : 1 : fail_unless(ret == EOK, "sysdb_update_subdomains failed with [%d][%s]",
3756 : : ret, strerror(ret));
3757 : :
3758 : 1 : ret = sysdb_get_subdomains(test_ctx, test_ctx->sysdb,
3759 : : &cur_subdomains_count, &cur_subdomains);
3760 : 1 : fail_unless(ret == EOK, "sysdb_get_subdomains failed with [%d][%s]",
3761 : : ret, strerror(ret));
3762 : 1 : fail_unless(cur_subdomains != NULL, "No sub-domains returned.");
3763 : 1 : fail_unless(cur_subdomains[0] == NULL, "No empty sub-domain list returned.");
3764 : : }
3765 : 1 : END_TEST
3766 : :
3767 : 1 : START_TEST(test_sysdb_subdomain_store_user)
3768 : : {
3769 : : struct sysdb_test_ctx *test_ctx;
3770 : : errno_t ret;
3771 : 1 : struct sysdb_subdom *test_subdom = &dom_t;
3772 : 1 : int num_subdom = 1;
3773 : 1 : struct sss_domain_info *subdomain = NULL;
3774 : 1 : struct ldb_result *results = NULL;
3775 : 1 : struct ldb_dn *base_dn = NULL;
3776 : 1 : struct ldb_dn *check_dn = NULL;
3777 : :
3778 : 1 : ret = setup_sysdb_tests(&test_ctx);
3779 : 1 : fail_if(ret != EOK, "Could not set up the test");
3780 : :
3781 : 1 : ret = sysdb_update_subdomains(test_ctx->sysdb, num_subdom, test_subdom);
3782 : 1 : fail_unless(ret == EOK, "sysdb_update_subdomains failed with [%d][%s]",
3783 : : ret, strerror(ret));
3784 : :
3785 : 1 : subdomain = new_subdomain(test_ctx, test_ctx->domain, "test.sub",
3786 : : NULL, NULL);
3787 : 1 : fail_unless(subdomain != NULL, "new_subdomain failed.");
3788 : :
3789 : 1 : ret = sysdb_store_user(subdomain->sysdb, "subdomuser", NULL, 12345, 0,
3790 : : "Sub Domain User", "/home/subdomuser", "/bin/bash",
3791 : : NULL, NULL, NULL, -1, 0);
3792 : 1 : fail_unless(ret == EOK, "sysdb_store_user failed.");
3793 : :
3794 : 1 : base_dn =ldb_dn_new(test_ctx, test_ctx->sysdb->ldb, "cn=sysdb");
3795 : 1 : fail_unless(base_dn != NULL);
3796 : :
3797 : 1 : check_dn = ldb_dn_new(test_ctx, test_ctx->sysdb->ldb,
3798 : : "name=subdomuser,cn=users,cn=test.sub,cn=sysdb");
3799 : 1 : fail_unless(check_dn != NULL);
3800 : :
3801 : 1 : ret = ldb_search(test_ctx->sysdb->ldb, test_ctx, &results, base_dn,
3802 : : LDB_SCOPE_SUBTREE, NULL, "name=subdomuser");
3803 : 1 : fail_unless(ret == EOK, "ldb_search failed.");
3804 : 1 : fail_unless(results->count == 1, "Unexpected number of results, "
3805 : : "expected [%d], got [%d]",
3806 : : 1, results->count);
3807 : 1 : fail_unless(ldb_dn_compare(results->msgs[0]->dn, check_dn) == 0,
3808 : : "Unexpedted DN returned");
3809 : :
3810 : 1 : ret = sysdb_delete_user(subdomain->sysdb, "subdomuser", 0);
3811 : 1 : fail_unless(ret == EOK, "sysdb_delete_user failed [%d][%s].",
3812 : : ret, strerror(ret));
3813 : :
3814 : 1 : ret = ldb_search(test_ctx->sysdb->ldb, test_ctx, &results, base_dn,
3815 : : LDB_SCOPE_SUBTREE, NULL, "name=subdomuser");
3816 : 1 : fail_unless(ret == EOK, "ldb_search failed.");
3817 : 1 : fail_unless(results->count == 0, "Unexpected number of results, "
3818 : : "expected [%d], got [%d]",
3819 : : 0, results->count);
3820 : : }
3821 : 1 : END_TEST
3822 : :
3823 : 1 : START_TEST(test_sysdb_subdomain_user_ops)
3824 : : {
3825 : : struct sysdb_test_ctx *test_ctx;
3826 : : errno_t ret;
3827 : 1 : struct sysdb_subdom *test_subdom = &dom_t;
3828 : 1 : int num_subdom = 1;
3829 : 1 : struct sss_domain_info *subdomain = NULL;
3830 : 1 : struct ldb_message *msg = NULL;
3831 : 1 : struct ldb_dn *check_dn = NULL;
3832 : :
3833 : 1 : ret = setup_sysdb_tests(&test_ctx);
3834 : 1 : fail_if(ret != EOK, "Could not set up the test");
3835 : :
3836 : 1 : ret = sysdb_update_subdomains(test_ctx->sysdb, num_subdom, test_subdom);
3837 : 1 : fail_unless(ret == EOK, "sysdb_update_subdomains failed with [%d][%s]",
3838 : : ret, strerror(ret));
3839 : :
3840 : 1 : subdomain = new_subdomain(test_ctx, test_ctx->domain, "test.sub",
3841 : : NULL, NULL);
3842 : 1 : fail_unless(subdomain != NULL, "new_subdomain failed.");
3843 : :
3844 : 1 : ret = sysdb_store_domuser(subdomain, "subdomuser", NULL, 12345, 0,
3845 : : "Sub Domain User", "/home/subdomuser", "/bin/bash",
3846 : : NULL, NULL, -1, 0);
3847 : 1 : fail_unless(ret == EOK, "sysdb_store_domuser failed.");
3848 : :
3849 : 1 : check_dn = ldb_dn_new(test_ctx, test_ctx->sysdb->ldb,
3850 : : "name=subdomuser,cn=users,cn=test.sub,cn=sysdb");
3851 : 1 : fail_unless(check_dn != NULL);
3852 : :
3853 : 1 : ret = sysdb_search_domuser_by_name(test_ctx, subdomain, "subdomuser", NULL,
3854 : : &msg);
3855 : 1 : fail_unless(ret == EOK, "sysdb_search_domuser_by_name failed with [%d][%s].",
3856 : : ret, strerror(ret));
3857 : 1 : fail_unless(ldb_dn_compare(msg->dn, check_dn) == 0,
3858 : : "Unexpedted DN returned");
3859 : :
3860 : 1 : ret = sysdb_search_domuser_by_uid(test_ctx, subdomain, 12345, NULL, &msg);
3861 : 1 : fail_unless(ret == EOK, "sysdb_search_domuser_by_uid failed with [%d][%s].",
3862 : : ret, strerror(ret));
3863 : 1 : fail_unless(ldb_dn_compare(msg->dn, check_dn) == 0,
3864 : : "Unexpedted DN returned");
3865 : :
3866 : 1 : ret = sysdb_delete_domuser(subdomain, "subdomuser", 12345);
3867 : 1 : fail_unless(ret == EOK, "sysdb_delete_domuser failed with [%d][%s].",
3868 : : ret, strerror(ret));
3869 : :
3870 : : }
3871 : 1 : END_TEST
3872 : :
3873 : 1 : START_TEST(test_sysdb_subdomain_group_ops)
3874 : : {
3875 : : struct sysdb_test_ctx *test_ctx;
3876 : : errno_t ret;
3877 : 1 : struct sysdb_subdom *test_subdom = &dom_t;
3878 : 1 : int num_subdom = 1;
3879 : 1 : struct sss_domain_info *subdomain = NULL;
3880 : 1 : struct ldb_message *msg = NULL;
3881 : 1 : struct ldb_dn *check_dn = NULL;
3882 : :
3883 : 1 : ret = setup_sysdb_tests(&test_ctx);
3884 : 1 : fail_if(ret != EOK, "Could not set up the test");
3885 : :
3886 : 1 : ret = sysdb_update_subdomains(test_ctx->sysdb, num_subdom, test_subdom);
3887 : 1 : fail_unless(ret == EOK, "sysdb_update_subdomains failed with [%d][%s]",
3888 : : ret, strerror(ret));
3889 : :
3890 : 1 : subdomain = new_subdomain(test_ctx, test_ctx->domain, "test.sub",
3891 : : NULL, NULL);
3892 : 1 : fail_unless(subdomain != NULL, "new_subdomain failed.");
3893 : :
3894 : 1 : ret = sysdb_store_domgroup(subdomain, "subdomgroup", 12345, NULL, -1, 0);
3895 : 1 : fail_unless(ret == EOK, "sysdb_store_domgroup failed.");
3896 : :
3897 : 1 : check_dn = ldb_dn_new(test_ctx, test_ctx->sysdb->ldb,
3898 : : "name=subdomgroup,cn=groups,cn=test.sub,cn=sysdb");
3899 : 1 : fail_unless(check_dn != NULL);
3900 : :
3901 : 1 : ret = sysdb_search_domgroup_by_name(test_ctx, subdomain, "subdomgroup", NULL,
3902 : : &msg);
3903 : 1 : fail_unless(ret == EOK, "sysdb_search_domgroup_by_name failed with [%d][%s].",
3904 : : ret, strerror(ret));
3905 : 1 : fail_unless(ldb_dn_compare(msg->dn, check_dn) == 0,
3906 : : "Unexpedted DN returned");
3907 : :
3908 : 1 : ret = sysdb_search_domgroup_by_gid(test_ctx, subdomain, 12345, NULL, &msg);
3909 : 1 : fail_unless(ret == EOK, "sysdb_search_domgroup_by_gid failed with [%d][%s].",
3910 : : ret, strerror(ret));
3911 : 1 : fail_unless(ldb_dn_compare(msg->dn, check_dn) == 0,
3912 : : "Unexpedted DN returned");
3913 : :
3914 : 1 : ret = sysdb_delete_domgroup(subdomain, "subdomgroup", 12345);
3915 : 1 : fail_unless(ret == EOK, "sysdb_delete_domgroup failed with [%d][%s].",
3916 : : ret, strerror(ret));
3917 : :
3918 : : }
3919 : 1 : END_TEST
3920 : :
3921 : : #ifdef BUILD_AUTOFS
3922 : 10 : START_TEST(test_autofs_create_map)
3923 : : {
3924 : : struct sysdb_test_ctx *test_ctx;
3925 : : const char *autofsmapname;
3926 : : errno_t ret;
3927 : :
3928 : 10 : ret = setup_sysdb_tests(&test_ctx);
3929 : 10 : fail_if(ret != EOK, "Could not set up the test");
3930 : :
3931 : 10 : autofsmapname = talloc_asprintf(test_ctx, "testmap%d", _i);
3932 : 10 : fail_if(autofsmapname == NULL, "Out of memory\n");
3933 : :
3934 : 10 : ret = sysdb_save_autofsmap(test_ctx->sysdb, autofsmapname,
3935 : : autofsmapname, NULL, 0, 0);
3936 : 10 : fail_if(ret != EOK, "Could not store autofs map %s", autofsmapname);
3937 : 10 : talloc_free(test_ctx);
3938 : : }
3939 : 10 : END_TEST
3940 : :
3941 : 10 : START_TEST(test_autofs_retrieve_map)
3942 : : {
3943 : : struct sysdb_test_ctx *test_ctx;
3944 : : const char *autofsmapname;
3945 : : errno_t ret;
3946 : 10 : struct ldb_message *map = NULL;
3947 : :
3948 : 10 : ret = setup_sysdb_tests(&test_ctx);
3949 : 10 : fail_if(ret != EOK, "Could not set up the test");
3950 : :
3951 : 10 : autofsmapname = talloc_asprintf(test_ctx, "testmap%d", _i);
3952 : 10 : fail_if(autofsmapname == NULL, "Out of memory\n");
3953 : :
3954 : 10 : ret = sysdb_get_map_byname(test_ctx, test_ctx->sysdb,
3955 : : autofsmapname, &map);
3956 : 10 : fail_if(ret != EOK, "Could not retrieve autofs map %s", autofsmapname);
3957 : 10 : fail_if(map == NULL, "No map retrieved?\n");
3958 : 10 : talloc_free(test_ctx);
3959 : : }
3960 : 10 : END_TEST
3961 : :
3962 : 10 : START_TEST(test_autofs_delete_map)
3963 : : {
3964 : : struct sysdb_test_ctx *test_ctx;
3965 : : const char *autofsmapname;
3966 : : errno_t ret;
3967 : :
3968 : 10 : ret = setup_sysdb_tests(&test_ctx);
3969 : 10 : fail_if(ret != EOK, "Could not set up the test");
3970 : :
3971 : 10 : autofsmapname = talloc_asprintf(test_ctx, "testmap%d", _i);
3972 : 10 : fail_if(autofsmapname == NULL, "Out of memory\n");
3973 : :
3974 : 10 : ret = sysdb_delete_autofsmap(test_ctx->sysdb, autofsmapname);
3975 : 10 : fail_if(ret != EOK, "Could not retrieve autofs map %s", autofsmapname);
3976 : 10 : talloc_free(test_ctx);
3977 : : }
3978 : 10 : END_TEST
3979 : :
3980 : 10 : START_TEST(test_autofs_retrieve_map_neg)
3981 : : {
3982 : : struct sysdb_test_ctx *test_ctx;
3983 : : const char *autofsmapname;
3984 : : errno_t ret;
3985 : 10 : struct ldb_message *map = NULL;
3986 : :
3987 : 10 : ret = setup_sysdb_tests(&test_ctx);
3988 : 10 : fail_if(ret != EOK, "Could not set up the test");
3989 : :
3990 : 10 : autofsmapname = talloc_asprintf(test_ctx, "testmap%d", _i);
3991 : 10 : fail_if(autofsmapname == NULL, "Out of memory\n");
3992 : :
3993 : 10 : ret = sysdb_get_map_byname(test_ctx, test_ctx->sysdb,
3994 : : autofsmapname, &map);
3995 : 10 : fail_if(ret != ENOENT, "Expected ENOENT, got %d instead\n", ret);
3996 : 10 : fail_if(map != NULL, "Unexpected map found\n");
3997 : 10 : talloc_free(test_ctx);
3998 : : }
3999 : 10 : END_TEST
4000 : :
4001 : 10 : START_TEST(test_autofs_store_entry_in_map)
4002 : : {
4003 : : struct sysdb_test_ctx *test_ctx;
4004 : : const char *autofsmapname;
4005 : : const char *autofskey;
4006 : : const char *autofsval;
4007 : : errno_t ret;
4008 : : int ii;
4009 : 10 : const int limit = 10;
4010 : :
4011 : 10 : ret = setup_sysdb_tests(&test_ctx);
4012 : 10 : fail_if(ret != EOK, "Could not set up the test");
4013 : :
4014 : 10 : autofsmapname = talloc_asprintf(test_ctx, "testmap%d", _i);
4015 : 10 : fail_if(autofsmapname == NULL, "Out of memory\n");
4016 : :
4017 [ + + ]: 110 : for (ii=0; ii < limit; ii++) {
4018 : 100 : autofskey = talloc_asprintf(test_ctx, "%s_testkey%d",
4019 : : autofsmapname, ii);
4020 : 100 : fail_if(autofskey == NULL, "Out of memory\n");
4021 : :
4022 : 100 : autofsval = talloc_asprintf(test_ctx, "testserver:/testval%d", ii);
4023 : 100 : fail_if(autofsval == NULL, "Out of memory\n");
4024 : :
4025 : 100 : ret = sysdb_save_autofsentry(test_ctx->sysdb, autofsmapname, autofskey,
4026 : : autofsval, NULL);
4027 : 100 : fail_if(ret != EOK, "Could not save autofs entry %s", autofskey);
4028 : : }
4029 : :
4030 : 10 : talloc_free(test_ctx);
4031 : : }
4032 : 10 : END_TEST
4033 : :
4034 : 10 : START_TEST(test_autofs_retrieve_keys_by_map)
4035 : : {
4036 : : struct sysdb_test_ctx *test_ctx;
4037 : : const char *autofsmapname;
4038 : : errno_t ret;
4039 : : size_t count;
4040 : : struct ldb_message **entries;
4041 : 10 : const int expected = 10;
4042 : :
4043 : 10 : ret = setup_sysdb_tests(&test_ctx);
4044 : 10 : fail_if(ret != EOK, "Could not set up the test");
4045 : :
4046 : 10 : autofsmapname = talloc_asprintf(test_ctx, "testmap%d", _i);
4047 : 10 : fail_if(autofsmapname == NULL, "Out of memory\n");
4048 : :
4049 : 10 : ret = sysdb_autofs_entries_by_map(test_ctx, test_ctx->sysdb,
4050 : : autofsmapname, &count, &entries);
4051 : 10 : fail_if(ret != EOK, "Cannot get autofs entries for map %s\n",
4052 : : autofsmapname);
4053 : 10 : fail_if(count != expected, "Expected to find %d entries, got %d\n",
4054 : : expected, count);
4055 : 10 : talloc_free(test_ctx);
4056 : : }
4057 : 10 : END_TEST
4058 : :
4059 : 10 : START_TEST(test_autofs_key_duplicate)
4060 : : {
4061 : : struct sysdb_test_ctx *test_ctx;
4062 : : const char *autofsmapname;
4063 : : const char *autofskey;
4064 : : const char *autofsval;
4065 : : errno_t ret;
4066 : :
4067 : 10 : ret = setup_sysdb_tests(&test_ctx);
4068 : 10 : fail_if(ret != EOK, "Could not set up the test");
4069 : :
4070 : 10 : autofsmapname = talloc_asprintf(test_ctx, "testmap%d", _i);
4071 : 10 : fail_if(autofsmapname == NULL, "Out of memory\n");
4072 : :
4073 : 10 : autofskey = talloc_asprintf(test_ctx, "testkey");
4074 : 10 : fail_if(autofskey == NULL, "Out of memory\n");
4075 : :
4076 : 10 : autofsval = talloc_asprintf(test_ctx, "testserver:/testval%d", _i);
4077 : 10 : fail_if(autofsval == NULL, "Out of memory\n");
4078 : :
4079 : 10 : ret = sysdb_save_autofsentry(test_ctx->sysdb, autofsmapname, autofskey,
4080 : : autofsval, NULL);
4081 : 10 : fail_if(ret != EOK, "Could not save autofs entry %s", autofskey);
4082 : 10 : talloc_free(test_ctx);
4083 : : }
4084 : 10 : END_TEST
4085 : :
4086 : 1 : START_TEST(test_autofs_get_duplicate_keys)
4087 : : {
4088 : : struct sysdb_test_ctx *test_ctx;
4089 : : const char *autofskey;
4090 : : errno_t ret;
4091 : 1 : const char *attrs[] = { SYSDB_AUTOFS_ENTRY_KEY,
4092 : : SYSDB_AUTOFS_ENTRY_VALUE,
4093 : : NULL };
4094 : : size_t count;
4095 : : struct ldb_message **msgs;
4096 : : struct ldb_dn *dn;
4097 : : const char *filter;
4098 : 1 : const int expected = 10;
4099 : :
4100 : 1 : ret = setup_sysdb_tests(&test_ctx);
4101 : 1 : fail_if(ret != EOK, "Could not set up the test");
4102 : :
4103 : 1 : autofskey = talloc_asprintf(test_ctx, "testkey");
4104 : 1 : fail_if(autofskey == NULL, "Out of memory\n");
4105 : :
4106 : 1 : filter = talloc_asprintf(test_ctx, "(&(objectclass=%s)(%s=%s))",
4107 : : SYSDB_AUTOFS_ENTRY_OC, SYSDB_AUTOFS_ENTRY_KEY, autofskey);
4108 : 1 : fail_if(filter == NULL, "Out of memory\n");
4109 : :
4110 : 1 : dn = ldb_dn_new_fmt(test_ctx, test_ctx->sysdb->ldb, SYSDB_TMPL_CUSTOM_SUBTREE,
4111 : 1 : AUTOFS_MAP_SUBDIR, test_ctx->sysdb->domain->name);
4112 : 1 : fail_if(dn == NULL, "Out of memory\n");
4113 : :
4114 : 1 : ret = sysdb_search_entry(test_ctx, test_ctx->sysdb, dn, LDB_SCOPE_SUBTREE,
4115 : : filter, attrs, &count, &msgs);
4116 : 1 : fail_if(count != expected, "Found %d entries with name %s, expected %d\n",
4117 : : count, autofskey, expected);
4118 : 1 : talloc_free(test_ctx);
4119 : : }
4120 : 1 : END_TEST
4121 : :
4122 : : #endif /* BUILD_AUTOFS */
4123 : :
4124 : 623 : Suite *create_sysdb_suite(void)
4125 : : {
4126 : 623 : Suite *s = suite_create("sysdb");
4127 : :
4128 : 623 : TCase *tc_sysdb = tcase_create("SYSDB Tests");
4129 : :
4130 : : /* Create a new user */
4131 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_add_user,27000,27010);
4132 : :
4133 : : /* Verify the users were added */
4134 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_getpwnam, 27000, 27010);
4135 : :
4136 : : /* Create a new group */
4137 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_add_group, 28000, 28010);
4138 : :
4139 : : /* Verify the groups were added */
4140 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_getgrnam, 28000, 28010);
4141 : :
4142 : : /* sysdb_group_dn_name returns the name of the group in question */
4143 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_group_dn_name, 28000, 28010);
4144 : :
4145 : : /* sysdb_store_user allows setting attributes for existing users */
4146 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_store_user_existing, 27000, 27010);
4147 : :
4148 : : /* test the change */
4149 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_get_user_attr, 27000, 27010);
4150 : :
4151 : : /* Add and remove users in a group with sysdb_update_members */
4152 : 623 : tcase_add_test(tc_sysdb, test_sysdb_update_members);
4153 : :
4154 : : /* Remove the other half by gid */
4155 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_local_group_by_gid, 28000, 28010);
4156 : :
4157 : : /* Remove the other half by uid */
4158 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_local_user_by_uid, 27000, 27010);
4159 : :
4160 : : /* Create a new user */
4161 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_store_user, 27010, 27020);
4162 : :
4163 : : /* Verify the users were added */
4164 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_getpwnam, 27010, 27020);
4165 : :
4166 : : /* Verify the users can be queried by UID */
4167 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_getpwuid, 27010, 27020);
4168 : :
4169 : : /* Enumerate the users */
4170 : 623 : tcase_add_test(tc_sysdb, test_sysdb_enumpwent);
4171 : :
4172 : : /* Change their attribute */
4173 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_set_user_attr, 27010, 27020);
4174 : :
4175 : : /* Verify the change */
4176 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_get_user_attr, 27010, 27020);
4177 : :
4178 : : /* Create a new group */
4179 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_store_group, 28010, 28020);
4180 : :
4181 : : /* Verify the groups were added */
4182 : :
4183 : : /* Verify the groups can be queried by GID */
4184 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_getgrgid, 28010, 28020);
4185 : :
4186 : : /* Enumerate the groups */
4187 : 623 : tcase_add_test(tc_sysdb, test_sysdb_enumgrent);
4188 : :
4189 : : /* Add some members to the groups */
4190 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_add_group_member, 28010, 28020);
4191 : :
4192 : : /* Authenticate with missing cached password */
4193 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_cached_authentication_missing_password,
4194 : : 27010, 27011);
4195 : :
4196 : : /* Add a cached password */
4197 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_cache_password, 27010, 27011);
4198 : :
4199 : : /* Authenticate against cached password */
4200 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_cached_authentication_wrong_password,
4201 : : 27010, 27011);
4202 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_cached_authentication, 27010, 27011);
4203 : :
4204 : : /* ASQ search test */
4205 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_prepare_asq_test_user, 28011, 28020);
4206 : 623 : tcase_add_test(tc_sysdb, test_sysdb_asq_search);
4207 : :
4208 : : /* Test search with more than one result */
4209 : 623 : tcase_add_test(tc_sysdb, test_sysdb_search_all_users);
4210 : :
4211 : : /* Remove the members from the groups */
4212 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_group_member, 28010, 28020);
4213 : :
4214 : : /* Remove the users by name */
4215 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_local_user, 27010, 27020);
4216 : :
4217 : : /* Remove the groups by name */
4218 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_local_group, 28010, 28020);
4219 : :
4220 : : /* test the ignore_not_found parameter for users */
4221 : 623 : tcase_add_test(tc_sysdb, test_sysdb_remove_nonexistent_user);
4222 : :
4223 : : /* test the ignore_not_found parameter for groups */
4224 : 623 : tcase_add_test(tc_sysdb, test_sysdb_remove_nonexistent_group);
4225 : :
4226 : : /* Create incomplete groups - remove will fail if the LDB objects don't exist */
4227 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_add_incomplete_group, 28000, 28010);
4228 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_local_group_by_gid, 28000, 28010);
4229 : :
4230 : : /* test custom operations */
4231 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_store_custom, 29010, 29020);
4232 : 623 : tcase_add_test(tc_sysdb, test_sysdb_search_custom_by_name);
4233 : 623 : tcase_add_test(tc_sysdb, test_sysdb_update_custom);
4234 : 623 : tcase_add_test(tc_sysdb, test_sysdb_search_custom_update);
4235 : 623 : tcase_add_test(tc_sysdb, test_sysdb_search_custom);
4236 : 623 : tcase_add_test(tc_sysdb, test_sysdb_delete_custom);
4237 : :
4238 : : /* test recursive delete */
4239 : 623 : tcase_add_test(tc_sysdb, test_sysdb_delete_recursive);
4240 : :
4241 : 623 : tcase_add_test(tc_sysdb, test_sysdb_attrs_replace_name);
4242 : :
4243 : 623 : tcase_add_test(tc_sysdb, test_sysdb_attrs_to_list);
4244 : :
4245 : : /* Test unusual characters */
4246 : 623 : tcase_add_test(tc_sysdb, test_odd_characters);
4247 : :
4248 : : /* Test sysdb enumerated flag */
4249 : 623 : tcase_add_test(tc_sysdb, test_sysdb_has_enumerated);
4250 : :
4251 : : /* Test originalDN searches */
4252 : 623 : tcase_add_test(tc_sysdb, test_sysdb_original_dn_case_insensitive);
4253 : :
4254 : : /* Test user and group renames */
4255 : 623 : tcase_add_test(tc_sysdb, test_group_rename);
4256 : 623 : tcase_add_test(tc_sysdb, test_user_rename);
4257 : :
4258 : : /* ===== NETGROUP TESTS ===== */
4259 : :
4260 : : /* Create a new netgroup */
4261 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_add_basic_netgroup, 27000, 27010);
4262 : :
4263 : : /* Verify the netgroups were added */
4264 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_search_netgroup_by_name, 27000, 27010);
4265 : :
4266 : : /* Test setting attributes */
4267 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_set_netgroup_attr, 27000, 27010);
4268 : :
4269 : : /* Verify they have been changed */
4270 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_get_netgroup_attr, 27000, 27010);
4271 : :
4272 : : /* Add some tuples */
4273 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_add_netgroup_tuple, 27000, 27010);
4274 : :
4275 : : /* Add a nested netgroup */
4276 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_add_netgroup_member, 27000, 27009);
4277 : :
4278 : : /* Remove the nested netgroup */
4279 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_netgroup_member, 27000, 27009);
4280 : :
4281 : : /* Remove the tuples */
4282 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_netgroup_tuple, 27000, 27010);
4283 : :
4284 : : /* Remove half of them by name */
4285 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_netgroup_by_name, 27000, 27005);
4286 : :
4287 : : /* Remove the other half by DN */
4288 : 623 : tcase_add_loop_test(tc_sysdb, test_sysdb_remove_netgroup_entry, 27005, 27010);
4289 : :
4290 : : /* ===== SERVICE TESTS ===== */
4291 : :
4292 : : /* Create a new service */
4293 : 623 : tcase_add_test(tc_sysdb, test_sysdb_add_services);
4294 : 623 : tcase_add_test(tc_sysdb, test_sysdb_store_services);
4295 : 623 : tcase_add_test(tc_sysdb, test_sysdb_svc_remove_alias);
4296 : :
4297 : : /* Add all test cases to the test suite */
4298 : 623 : suite_add_tcase(s, tc_sysdb);
4299 : :
4300 : 623 : TCase *tc_memberof = tcase_create("SYSDB member/memberof/memberuid Tests");
4301 : :
4302 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_store_group, 0, 10);
4303 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_store_user, 0, 10);
4304 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_add_group_member,
4305 : : 0, 10);
4306 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_check_memberuid,
4307 : : 0, 10);
4308 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_remove_local_group_by_gid,
4309 : : MBO_GROUP_BASE + 5, MBO_GROUP_BASE + 6);
4310 : 623 : tcase_add_loop_test(tc_memberof,
4311 : : test_sysdb_memberof_check_memberuid_without_group_5,
4312 : : 0, 10);
4313 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_remove_local_group_by_gid,
4314 : : MBO_GROUP_BASE , MBO_GROUP_BASE + 10);
4315 : :
4316 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_store_group, 0, 10);
4317 : 623 : tcase_add_test(tc_memberof, test_sysdb_memberof_close_loop);
4318 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_store_user, 0, 10);
4319 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_add_group_member,
4320 : : 0, 10);
4321 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_check_memberuid_loop,
4322 : : 0, 10);
4323 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_remove_local_group_by_gid,
4324 : : MBO_GROUP_BASE + 5, MBO_GROUP_BASE + 6);
4325 : 623 : tcase_add_loop_test(tc_memberof,
4326 : : test_sysdb_memberof_check_memberuid_loop_without_group_5,
4327 : : 0, 10);
4328 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_remove_local_group_by_gid,
4329 : : MBO_GROUP_BASE , MBO_GROUP_BASE + 10);
4330 : :
4331 : : /* Ghost users tests */
4332 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_store_group_with_ghosts,
4333 : : MBO_GROUP_BASE , MBO_GROUP_BASE + 10);
4334 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_remove_local_group_by_gid,
4335 : : MBO_GROUP_BASE , MBO_GROUP_BASE + 10);
4336 : :
4337 : : /* ghost users - RFC2307 */
4338 : : /* Add groups with ghost users */
4339 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_add_group_with_ghosts,
4340 : : MBO_GROUP_BASE , MBO_GROUP_BASE + 10);
4341 : : /* Check the ghost user attribute */
4342 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_check_ghost,
4343 : : MBO_GROUP_BASE , MBO_GROUP_BASE + 10);
4344 : : /* Add user entries, converting the ghost attributes to member attributes */
4345 : : /* We only convert half of the users and keep the ghost attributes for the
4346 : : * other half as we also want to test if we don't delete any ghost users
4347 : : * by accident
4348 : : */
4349 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_convert_to_real_users,
4350 : : MBO_GROUP_BASE , MBO_GROUP_BASE + NUM_GHOSTS/2);
4351 : : /* Check the members and ghosts are there as appropriate */
4352 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_check_convert,
4353 : : MBO_GROUP_BASE , MBO_GROUP_BASE + NUM_GHOSTS);
4354 : : /* Remove the real users */
4355 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_memberof_user_cleanup,
4356 : : MBO_GROUP_BASE , MBO_GROUP_BASE + NUM_GHOSTS/2);
4357 : 623 : tcase_add_loop_test(tc_memberof, test_sysdb_remove_local_group_by_gid,
4358 : : MBO_GROUP_BASE , MBO_GROUP_BASE + NUM_GHOSTS);
4359 : :
4360 : 623 : suite_add_tcase(s, tc_memberof);
4361 : :
4362 : 623 : TCase *tc_subdomain = tcase_create("SYSDB sub-domain Tests");
4363 : :
4364 : 623 : tcase_add_test(tc_subdomain, test_sysdb_subdomain_create);
4365 : 623 : tcase_add_test(tc_subdomain, test_sysdb_subdomain_store_user);
4366 : 623 : tcase_add_test(tc_subdomain, test_sysdb_subdomain_user_ops);
4367 : 623 : tcase_add_test(tc_subdomain, test_sysdb_subdomain_group_ops);
4368 : :
4369 : 623 : suite_add_tcase(s, tc_subdomain);
4370 : :
4371 : : #ifdef BUILD_AUTOFS
4372 : 623 : TCase *tc_autofs = tcase_create("SYSDB autofs Tests");
4373 : :
4374 : 623 : tcase_add_loop_test(tc_subdomain, test_autofs_create_map,
4375 : : TEST_AUTOFS_MAP_BASE, TEST_AUTOFS_MAP_BASE+10);
4376 : :
4377 : 623 : tcase_add_loop_test(tc_subdomain, test_autofs_retrieve_map,
4378 : : TEST_AUTOFS_MAP_BASE, TEST_AUTOFS_MAP_BASE+10);
4379 : :
4380 : 623 : tcase_add_loop_test(tc_subdomain, test_autofs_store_entry_in_map,
4381 : : TEST_AUTOFS_MAP_BASE, TEST_AUTOFS_MAP_BASE+10);
4382 : :
4383 : 623 : tcase_add_loop_test(tc_subdomain, test_autofs_retrieve_keys_by_map,
4384 : : TEST_AUTOFS_MAP_BASE, TEST_AUTOFS_MAP_BASE+10);
4385 : :
4386 : 623 : tcase_add_loop_test(tc_subdomain, test_autofs_delete_map,
4387 : : TEST_AUTOFS_MAP_BASE, TEST_AUTOFS_MAP_BASE+10);
4388 : :
4389 : 623 : tcase_add_loop_test(tc_subdomain, test_autofs_retrieve_map_neg,
4390 : : TEST_AUTOFS_MAP_BASE, TEST_AUTOFS_MAP_BASE+10);
4391 : :
4392 : 623 : tcase_add_loop_test(tc_subdomain, test_autofs_key_duplicate,
4393 : : TEST_AUTOFS_MAP_BASE, TEST_AUTOFS_MAP_BASE+10);
4394 : :
4395 : 623 : tcase_add_test(tc_subdomain, test_autofs_get_duplicate_keys);
4396 : :
4397 : 623 : suite_add_tcase(s, tc_autofs);
4398 : : #endif
4399 : :
4400 : 623 : return s;
4401 : : }
4402 : :
4403 : 623 : int main(int argc, const char *argv[]) {
4404 : : int opt;
4405 : : int ret;
4406 : : poptContext pc;
4407 : : int failure_count;
4408 : 623 : int no_cleanup = 0;
4409 : : Suite *sysdb_suite;
4410 : : SRunner *sr;
4411 : :
4412 : 3738 : struct poptOption long_options[] = {
4413 : : POPT_AUTOHELP
4414 : 2492 : SSSD_MAIN_OPTS
4415 : : {"no-cleanup", 'n', POPT_ARG_NONE, &no_cleanup, 0,
4416 : 623 : _("Do not delete the test database after a test run"), NULL },
4417 : : POPT_TABLEEND
4418 : : };
4419 : :
4420 : : /* Set debug level to invalid value so we can deside if -d 0 was used. */
4421 : 623 : debug_level = SSSDBG_INVALID;
4422 : :
4423 : 623 : pc = poptGetContext(argv[0], argc, argv, long_options, 0);
4424 [ - + ]: 623 : while((opt = poptGetNextOpt(pc)) != -1) {
4425 : : switch(opt) {
4426 : : default:
4427 : 0 : fprintf(stderr, "\nInvalid option %s: %s\n\n",
4428 : : poptBadOption(pc, 0), poptStrerror(opt));
4429 : 0 : poptPrintUsage(pc, stderr, 0);
4430 : : return 1;
4431 : : }
4432 : : }
4433 : 623 : poptFreeContext(pc);
4434 : :
4435 [ - + ]: 623 : DEBUG_INIT(debug_level);
4436 : :
4437 : 623 : tests_set_cwd();
4438 : :
4439 : 623 : ret = unlink(TESTS_PATH"/"LOCAL_SYSDB_FILE);
4440 [ + - ][ - + ]: 623 : if (ret != EOK && errno != ENOENT) {
4441 : 0 : fprintf(stderr, "Could not delete the test ldb file (%d) (%s)\n",
4442 : : errno, strerror(errno));
4443 : : return EXIT_FAILURE;
4444 : : }
4445 : :
4446 : 623 : sysdb_suite = create_sysdb_suite();
4447 : 623 : sr = srunner_create(sysdb_suite);
4448 : : /* If CK_VERBOSITY is set, use that, otherwise it defaults to CK_NORMAL */
4449 : 623 : srunner_run_all(sr, CK_ENV);
4450 : 1 : failure_count = srunner_ntests_failed(sr);
4451 : 1 : srunner_free(sr);
4452 [ + - ][ + - ]: 1 : if (failure_count == 0 && !no_cleanup) {
4453 : 1 : ret = unlink(TESTS_PATH"/"TEST_CONF_FILE);
4454 [ - + ]: 1 : if (ret != EOK) {
4455 : 0 : fprintf(stderr, "Could not delete the test config ldb file (%d) (%s)\n",
4456 : 0 : errno, strerror(errno));
4457 : : return EXIT_FAILURE;
4458 : : }
4459 : 1 : ret = unlink(TESTS_PATH"/"LOCAL_SYSDB_FILE);
4460 [ - + ]: 1 : if (ret != EOK) {
4461 : 1 : fprintf(stderr, "Could not delete the test config ldb file (%d) (%s)\n",
4462 : 0 : errno, strerror(errno));
4463 : : return EXIT_FAILURE;
4464 : : }
4465 : :
4466 : : return EXIT_SUCCESS;
4467 : : }
4468 : : return EXIT_FAILURE;
4469 : 5 : }
|
