Branch data Line data Source code
1 : : /*
2 : : Authors:
3 : : Michal Zidek <mzidek@redhat.com>
4 : : Stephen Gallagher <sgallagh@redhat.com>
5 : :
6 : : This program is free software; you can redistribute it and/or modify
7 : : it under the terms of the GNU General Public License as published by
8 : : the Free Software Foundation; either version 3 of the License, or
9 : : (at your option) any later version.
10 : :
11 : : This program is distributed in the hope that it will be useful,
12 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : GNU General Public License for more details.
15 : :
16 : : You should have received a copy of the GNU General Public License
17 : : along with this program. If not, see <http://www.gnu.org/licenses/>.
18 : : */
19 : :
20 : : #include <stdlib.h>
21 : : #include <check.h>
22 : : #include <popt.h>
23 : : #include <talloc.h>
24 : : #include <sys/stat.h>
25 : : #include <sys/types.h>
26 : :
27 : :
28 : : #include "config.h"
29 : : #include "tests/common.h"
30 : : #include "util/util.h"
31 : : #include "confdb/confdb.h"
32 : : #include "confdb/confdb_setup.h"
33 : : #include "db/sysdb.h"
34 : : #include "db/sysdb_private.h"
35 : : #include "db/sysdb_services.h"
36 : : #include "db/sysdb_ssh.h"
37 : :
38 : : #define TESTS_PATH "tests_sysdb_ssh"
39 : : #define TEST_CONF_FILE "tests_conf.ldb"
40 : : #define TEST_HOSTNAME "testhost"
41 : :
42 : : struct sysdb_test_ctx {
43 : : struct sysdb_ctx *sysdb;
44 : : struct confdb_ctx *confdb;
45 : : struct tevent_context *ev;
46 : : struct sss_domain_info *domain;
47 : : };
48 : :
49 : 4 : static int setup_sysdb_tests(struct sysdb_test_ctx **ctx)
50 : : {
51 : : struct sysdb_test_ctx *test_ctx;
52 : : char *conf_db;
53 : : int ret;
54 : :
55 : : const char *val[2];
56 : 4 : val[1] = NULL;
57 : :
58 : : /* Create tests directory if it doesn't exist */
59 : : /* (relative to current dir) */
60 : 4 : ret = mkdir(TESTS_PATH, 0775);
61 [ + + ][ - + ]: 4 : if (ret == -1 && errno != EEXIST) {
62 : 0 : fail("Could not create %s directory", TESTS_PATH);
63 : : return EFAULT;
64 : : }
65 : :
66 : 4 : test_ctx = talloc_zero(NULL, struct sysdb_test_ctx);
67 [ - + ]: 4 : if (test_ctx == NULL) {
68 : 0 : fail("Could not allocate memory for test context");
69 : : return ENOMEM;
70 : : }
71 : :
72 : : /* Create an event context
73 : : * It will not be used except in confdb_init and sysdb_init
74 : : */
75 : 4 : test_ctx->ev = tevent_context_init(test_ctx);
76 [ - + ]: 4 : if (test_ctx->ev == NULL) {
77 : 0 : fail("Could not create event context");
78 : 0 : talloc_free(test_ctx);
79 : : return EIO;
80 : : }
81 : :
82 : 4 : conf_db = talloc_asprintf(test_ctx, "%s/%s", TESTS_PATH, TEST_CONF_FILE);
83 [ - + ]: 4 : if (conf_db == NULL) {
84 : 0 : fail("Out of memory, aborting!");
85 : 0 : talloc_free(test_ctx);
86 : : return ENOMEM;
87 : : }
88 [ + - ][ + - ]: 4 : DEBUG(3, ("CONFDB: %s\n", conf_db));
[ - + ][ # # ]
[ # # ]
89 : :
90 : : /* Connect to the conf db */
91 : 4 : ret = confdb_init(test_ctx, &test_ctx->confdb, conf_db);
92 [ - + ]: 4 : if (ret != EOK) {
93 : 0 : fail("Could not initialize connection to the confdb");
94 : 0 : talloc_free(test_ctx);
95 : : return ret;
96 : : }
97 : :
98 : 4 : val[0] = "LOCAL";
99 : 4 : ret = confdb_add_param(test_ctx->confdb, true,
100 : : "config/sssd", "domains", val);
101 [ - + ]: 4 : if (ret != EOK) {
102 : 0 : fail("Could not initialize domains placeholder");
103 : 0 : talloc_free(test_ctx);
104 : : return ret;
105 : : }
106 : :
107 : 4 : val[0] = "local";
108 : 4 : ret = confdb_add_param(test_ctx->confdb, true,
109 : : "config/domain/LOCAL", "id_provider", val);
110 [ - + ]: 4 : if (ret != EOK) {
111 : 0 : fail("Could not initialize provider");
112 : 0 : talloc_free(test_ctx);
113 : : return ret;
114 : : }
115 : :
116 : 4 : val[0] = "TRUE";
117 : 4 : ret = confdb_add_param(test_ctx->confdb, true,
118 : : "config/domain/LOCAL", "enumerate", val);
119 [ - + ]: 4 : if (ret != EOK) {
120 : 0 : fail("Could not initialize LOCAL domain");
121 : 0 : talloc_free(test_ctx);
122 : : return ret;
123 : : }
124 : :
125 : 4 : val[0] = "TRUE";
126 : 4 : ret = confdb_add_param(test_ctx->confdb, true,
127 : : "config/domain/LOCAL", "cache_credentials", val);
128 [ - + ]: 4 : if (ret != EOK) {
129 : 0 : fail("Could not initialize LOCAL domain");
130 : 0 : talloc_free(test_ctx);
131 : : return ret;
132 : : }
133 : :
134 : 4 : ret = sysdb_init_domain_and_sysdb(test_ctx, test_ctx->confdb, "local",
135 : : TESTS_PATH,
136 : : &test_ctx->domain, &test_ctx->sysdb);
137 [ - + ]: 4 : if (ret != EOK) {
138 : 0 : fail("Could not initialize connection to the sysdb (%d)", ret);
139 : 0 : talloc_free(test_ctx);
140 : : return ret;
141 : : }
142 : :
143 : 4 : *ctx = test_ctx;
144 : : return EOK;
145 : : }
146 : :
147 : 1 : static void clean_up(void)
148 : : {
149 : 1 : int ret = 0;
150 : :
151 : 1 : ret += unlink(TESTS_PATH"/"TEST_CONF_FILE);
152 : 1 : ret += unlink(TESTS_PATH"/sssd.ldb");
153 : 1 : ret += rmdir(TESTS_PATH);
154 : :
155 [ - + ]: 1 : if (ret != 0) {
156 : 0 : fprintf(stderr, "Unable to remove all test files from %s\n",TESTS_PATH);
157 : : }
158 : 1 : }
159 : :
160 : : struct test_data {
161 : : struct tevent_context *ev;
162 : : struct sysdb_test_ctx *ctx;
163 : :
164 : : const char *hostname;
165 : : const char *alias;
166 : :
167 : : struct ldb_message *host;
168 : : struct sysdb_attrs *attrs;
169 : : };
170 : :
171 : 2 : static int test_sysdb_store_ssh_host(struct test_data *data)
172 : : {
173 : : int ret;
174 : 2 : time_t now = time(NULL);
175 : :
176 : 2 : ret = sysdb_store_ssh_host(data->ctx->sysdb,
177 : : data->hostname,
178 : : data->alias,
179 : : now,
180 : : data->attrs);
181 : 2 : return ret;
182 : : }
183 : :
184 : 2 : static int test_sysdb_delete_ssh_host(struct test_data *data)
185 : : {
186 : : int ret;
187 : :
188 : 2 : ret = sysdb_delete_ssh_host(data->ctx->sysdb, data->hostname);
189 : 2 : return ret;
190 : : }
191 : :
192 : 1 : static int test_sysdb_get_ssh_host(struct test_data *data)
193 : : {
194 : : int ret;
195 : 1 : const char *attrs[] = { SYSDB_NAME, NULL };
196 : :
197 : 1 : ret = sysdb_get_ssh_host(data->ctx, data->ctx->sysdb,
198 : : data->hostname, attrs,
199 : : &data->host);
200 : :
201 : 1 : return ret;
202 : : }
203 : :
204 : 1 : START_TEST (store_one_host_test)
205 : : {
206 : : struct sysdb_test_ctx *test_ctx;
207 : : struct test_data *data;
208 : : int ret;
209 : :
210 : 1 : ret = setup_sysdb_tests(&test_ctx);
211 [ - + ]: 1 : if (ret != EOK) {
212 : 0 : fail("Could not set up the test");
213 : : return;
214 : : }
215 : :
216 : 1 : data = talloc_zero(test_ctx, struct test_data);
217 [ - + ]: 1 : if (data == NULL) {
218 : 0 : fail("Out of memory!");
219 : 0 : talloc_free(test_ctx);
220 : : return;
221 : : }
222 : :
223 : 1 : data->ctx = test_ctx;
224 : 1 : data->ev = test_ctx->ev;
225 : 1 : data->hostname = talloc_strdup(test_ctx, TEST_HOSTNAME);
226 [ - + ]: 1 : if (data->hostname == NULL) {
227 : 0 : fail("Out of memory!");
228 : 0 : talloc_free(test_ctx);
229 : : return;
230 : : }
231 : :
232 : 1 : data->attrs = sysdb_new_attrs(test_ctx);
233 [ - + ]: 1 : if (data->attrs == NULL) {
234 : 0 : fail("Out of memory!");
235 : 0 : talloc_free(test_ctx);
236 : : return;
237 : : }
238 : :
239 : 1 : ret = test_sysdb_store_ssh_host(data);
240 : :
241 : 1 : fail_if(ret != EOK, "Could not store host into database");
242 : 1 : talloc_free(test_ctx);
243 : : }
244 : : END_TEST
245 : :
246 : 1 : START_TEST (delete_existing_host_test)
247 : : {
248 : : struct sysdb_test_ctx *test_ctx;
249 : : struct test_data *data;
250 : : int ret;
251 : :
252 : 1 : ret = setup_sysdb_tests(&test_ctx);
253 [ - + ]: 1 : if (ret != EOK) {
254 : 0 : fail("Could not set up the test");
255 : : return;
256 : : }
257 : :
258 : 1 : data = talloc_zero(test_ctx, struct test_data);
259 [ - + ]: 1 : if (data == NULL) {
260 : 0 : fail("Out of memory!");
261 : : return;
262 : : }
263 : :
264 : 1 : data->ctx = test_ctx;
265 : 1 : data->ev = test_ctx->ev;
266 : 1 : data->hostname = talloc_strdup(test_ctx, TEST_HOSTNAME);
267 [ - + ]: 1 : if (data->hostname == NULL) {
268 : 0 : fail("Out of memory!");
269 : 0 : talloc_free(test_ctx);
270 : : return;
271 : : }
272 : :
273 : 1 : ret = test_sysdb_delete_ssh_host(data);
274 : :
275 : 1 : fail_if(ret != EOK, "Could not delete host from database");
276 : 1 : talloc_free(test_ctx);
277 : : }
278 : : END_TEST
279 : :
280 : 1 : START_TEST (delete_nonexistent_host_test)
281 : : {
282 : : struct sysdb_test_ctx *test_ctx;
283 : : struct test_data *data;
284 : : int ret;
285 : :
286 : 1 : ret = setup_sysdb_tests(&test_ctx);
287 [ - + ]: 1 : if (ret != EOK) {
288 : 0 : fail("Could not set up the test");
289 : : return;
290 : : }
291 : :
292 : 1 : data = talloc_zero(test_ctx, struct test_data);
293 [ - + ]: 1 : if (data == NULL) {
294 : 0 : fail("Out of memory!");
295 : 0 : talloc_free(test_ctx);
296 : : return;
297 : : }
298 : :
299 : 1 : data->ctx = test_ctx;
300 : 1 : data->ev = test_ctx->ev;
301 : 1 : data->hostname = talloc_strdup(test_ctx, "nonexistent_host");
302 [ - + ]: 1 : if (data->hostname == NULL) {
303 : 0 : fail("Out of memory!");
304 : 0 : talloc_free(test_ctx);
305 : : return;
306 : : }
307 : :
308 : 1 : ret = test_sysdb_delete_ssh_host(data);
309 : :
310 : 1 : fail_if(ret != EOK, "Deletion of nonexistent host returned code %d", ret);
311 : 1 : talloc_free(test_ctx);
312 : :
313 : : }
314 : : END_TEST
315 : :
316 : 1 : START_TEST (sysdb_get_ssh_host_test)
317 : : {
318 : : struct sysdb_test_ctx *test_ctx;
319 : : struct test_data *data;
320 : : int ret;
321 : :
322 : 1 : ret = setup_sysdb_tests(&test_ctx);
323 [ - + ]: 1 : if (ret != EOK) {
324 : 0 : fail("Could not set up test");
325 : : return;
326 : : }
327 : :
328 : 1 : data = talloc_zero(test_ctx, struct test_data);
329 [ - + ]: 1 : if (data == NULL) {
330 : 0 : fail("Out of memory!");
331 : 0 : talloc_free(test_ctx);
332 : : return;
333 : : }
334 : :
335 : 1 : data->ctx = test_ctx;
336 : 1 : data->ev = test_ctx->ev;
337 : 1 : data->hostname = talloc_strdup(test_ctx, TEST_HOSTNAME);
338 [ - + ]: 1 : if (data->hostname == NULL) {
339 : 0 : fail("Out of memory!");
340 : 0 : talloc_free(test_ctx);
341 : : return;
342 : : }
343 : :
344 : 1 : data->attrs = sysdb_new_attrs(test_ctx);
345 [ - + ]: 1 : if (data->attrs == NULL) {
346 : 0 : fail("Out of memory!");
347 : 0 : talloc_free(test_ctx);
348 : : return;
349 : : }
350 : :
351 : 1 : ret = test_sysdb_store_ssh_host(data);
352 [ - + ]: 1 : if (ret != EOK) {
353 : 0 : fail("Could not store host '%s' to database", TEST_HOSTNAME);
354 : 0 : talloc_free(test_ctx);
355 : : return;
356 : : }
357 : :
358 : 1 : ret = test_sysdb_get_ssh_host(data);
359 : :
360 : 1 : fail_if(ret != EOK, "Could not find host '%s'",TEST_HOSTNAME);
361 : 1 : talloc_free(test_ctx);
362 : : }
363 : : END_TEST
364 : :
365 : :
366 : 5 : Suite *create_sysdb_ssh_suite(void)
367 : : {
368 : 5 : Suite *s = suite_create("sysdb_ssh");
369 : 5 : TCase *tc_sysdb_ssh = tcase_create("SYSDB_SSH Tests");
370 : :
371 : 5 : tcase_add_test(tc_sysdb_ssh, store_one_host_test);
372 : 5 : tcase_add_test(tc_sysdb_ssh, delete_existing_host_test);
373 : 5 : tcase_add_test(tc_sysdb_ssh, delete_nonexistent_host_test);
374 : 5 : tcase_add_test(tc_sysdb_ssh, sysdb_get_ssh_host_test);
375 : 5 : suite_add_tcase(s, tc_sysdb_ssh);
376 : 5 : return s;
377 : : }
378 : :
379 : 5 : int main(int argc, const char *argv[])
380 : : {
381 : : int failcount;
382 : : int opt;
383 : : poptContext pc;
384 : : Suite* s;
385 : : SRunner *sr;
386 : :
387 : 25 : struct poptOption long_options[] = {
388 : : POPT_AUTOHELP
389 : 20 : SSSD_MAIN_OPTS
390 : : POPT_TABLEEND
391 : : };
392 : :
393 : : /* Set debug level to invalid value so we can deside if -d 0 was used. */
394 : 5 : debug_level = SSSDBG_INVALID;
395 : :
396 : 5 : pc = poptGetContext(argv[0], argc, (const char **) argv, long_options, 0);
397 [ - + ]: 5 : while ((opt = poptGetNextOpt(pc)) != -1) {
398 : 0 : fprintf(stderr, "\nInvalid option %s: %s\n\n",
399 : : poptBadOption(pc, 0), poptStrerror(opt));
400 : 0 : poptPrintUsage(pc, stderr, 0);
401 : : return 1;
402 : : }
403 : 5 : poptFreeContext(pc);
404 : :
405 [ - + ]: 5 : DEBUG_INIT(debug_level);
406 : :
407 : 5 : tests_set_cwd();
408 : :
409 : 5 : s = create_sysdb_ssh_suite();
410 : :
411 : 5 : sr = srunner_create(s);
412 : 5 : srunner_run_all(sr, CK_ENV);
413 : 1 : failcount = srunner_ntests_failed(sr);
414 : 1 : srunner_free(sr);
415 : :
416 : 1 : clean_up();
417 [ + - ]: 1 : if (failcount != 0) {
418 : : return EXIT_FAILURE;
419 : : }
420 : :
421 : : return EXIT_SUCCESS;
422 : 2 : }
|
