Initial commit.
[qa-tools:testrunner-lite.git] / tests / unit / ut_testexecutor.c
1 /*
2  * This file is part of testrunner-lite
3  *
4  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
5  *
6  * Contact: Sami Lahtinen <ext-sami.t.lahtinen@nokia.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public License
10  * version 2.1 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  *
22  */
23
24 /* ------------------------------------------------------------------------- */
25 /* INCLUDE FILES */
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <check.h>
29 #include <string.h>
30 #include <signal.h>
31 #include <unistd.h>
32
33 #include "testdefinitionparser.h"
34 #include "testdefinitiondatatypes.h"
35 #include "testrunnerlite.h"
36 #include "testrunnerlitetestscommon.h"
37 #include "remote_executor.h"
38 #include "executor.h"
39
40 /* ------------------------------------------------------------------------- */
41 /* EXTERNAL DATA STRUCTURES */
42 /* None */
43
44 /* ------------------------------------------------------------------------- */
45 /* EXTERNAL GLOBAL VARIABLES */
46 /* None */
47
48 /* ------------------------------------------------------------------------- */
49 /* EXTERNAL FUNCTION PROTOTYPES */
50 /* None */
51
52 /* ------------------------------------------------------------------------- */
53 /* GLOBAL VARIABLES */
54 /* None */
55
56 /* ------------------------------------------------------------------------- */
57 /* CONSTANTS */
58 /* None */
59
60 /* ------------------------------------------------------------------------- */
61 /* MACROS */
62 /* None */
63
64 /* ------------------------------------------------------------------------- */
65 /* LOCAL GLOBAL VARIABLES */
66 td_suite *suite;
67 td_set   *set;
68 char  *suite_description;
69 /* ------------------------------------------------------------------------- */
70 /* LOCAL CONSTANTS AND MACROS */
71 /* None */
72
73 /* ------------------------------------------------------------------------- */
74 /* MODULE DATA STRUCTURES */
75 /* None */
76
77 /* ------------------------------------------------------------------------- */
78 /* LOCAL FUNCTION PROTOTYPES */
79 /* ------------------------------------------------------------------------- */
80 /* None */
81
82 /* ------------------------------------------------------------------------- */
83 /* FORWARD DECLARATIONS */
84 /* None */
85
86 /* ------------------------------------------------------------------------- */
87 /* ==================== LOCAL FUNCTIONS ==================================== */
88 /* ------------------------------------------------------------------------- */
89 static int set_env_for_remote_tests() 
90 {
91         int ret;
92
93         ret = system ("stat ~/.ssh/myrsakey.pub");
94         if (ret) { 
95                 ret = system ("ssh-keygen -N \"\" -f ~/.ssh/myrsakey");
96                 if (ret)
97                         goto err_out;
98         }
99         ret = system ("grep -f ~/.ssh/myrsakey.pub "
100                       "~/.ssh/authorized_keys");
101         if (ret) {
102                 ret = system ("cat ~/.ssh/myrsakey.pub "
103                               ">> ~/.ssh/authorized_keys");
104                 if (ret)
105                         goto err_out;
106         }
107             
108         ret = system ("grep myrsakey ~/.ssh/config");
109         if (ret) {
110                 ret = system ("echo \"IdentityFile=%d/.ssh/myrsakey\" >> "
111                               "~/.ssh/config");
112                 if (ret)
113                         goto err_out;
114         }
115
116         return 0;
117  err_out:
118         fprintf (stderr, "failed to set env for remote testsing\n");
119         return 1;
120  }      
121
122 START_TEST (test_executor_null_command)
123         exec_data edata;
124         testrunner_lite_options opts;
125
126         memset (&opts, 0x0, sizeof (opts));
127         executor_init (&opts);
128
129         init_exec_data(&edata);
130         edata.soft_timeout = 10;
131         edata.hard_timeout = COMMON_HARD_TIMEOUT;
132         fail_if (execute(NULL, &edata));
133
134 END_TEST
135 /* ------------------------------------------------------------------------- */
136 START_TEST (test_executor_0_timeout)
137         exec_data edata;
138         testrunner_lite_options opts;
139
140         memset (&opts, 0x0, sizeof (opts));
141         executor_init (&opts);
142
143         init_exec_data(&edata);
144         edata.soft_timeout = 0;
145         edata.hard_timeout = 0;
146         fail_if (execute(NULL, &edata));
147
148 END_TEST
149 /* ------------------------------------------------------------------------- */
150 START_TEST (test_executor_stdout)
151         exec_data edata;
152         testrunner_lite_options opts;
153
154         memset (&opts, 0x0, sizeof (opts));
155         executor_init (&opts);
156         
157         init_exec_data(&edata);
158         edata.soft_timeout = 0;
159         edata.hard_timeout = 0;
160         fail_if (execute("pwd", &edata));
161         fail_if (strlen ((char *)edata.stdout_data.buffer) == 0);
162         fail_unless (strlen ((char *)edata.stderr_data.buffer) == 0);
163
164 END_TEST
165 /* ------------------------------------------------------------------------- */
166 START_TEST (test_executor_stderr)
167         exec_data edata;
168         testrunner_lite_options opts;
169
170         memset (&opts, 0x0, sizeof (opts));
171         executor_init (&opts);
172         
173         init_exec_data(&edata);
174         edata.soft_timeout = 0;
175         edata.hard_timeout = 0;
176         fail_if (execute("cat can_of_food", &edata));
177         fail_if (strlen ((char *)edata.stderr_data.buffer) == 0);
178         fail_unless (strlen ((char *)edata.stdout_data.buffer) == 0);
179         
180 END_TEST
181 /* ------------------------------------------------------------------------- */
182 START_TEST (test_executor_long_input_streams)
183         exec_data edata;
184         testrunner_lite_options opts;
185
186         memset (&opts, 0x0, sizeof (opts));
187         executor_init (&opts);
188         
189         init_exec_data(&edata);
190         edata.soft_timeout = 2;
191         edata.hard_timeout = 1;
192         fail_if (execute("/usr/share/testrunner-lite-tests/long_output.sh", 
193                          &edata));
194         fail_unless (edata.result == 0);
195         fail_if (edata.stdout_data.buffer == NULL);
196         fail_if (edata.stderr_data.buffer == NULL);
197         fail_unless (edata.stdout_data.length == 4380);
198         fail_unless (edata.stderr_data.length == 2190);
199         fail_unless (strlen ((char *)edata.stdout_data.buffer) == 4380);
200         fail_unless (strlen ((char *)edata.stderr_data.buffer) == 2190);
201 END_TEST
202 /* ------------------------------------------------------------------------- */
203 START_TEST (test_executor_terminating_process)
204         exec_data edata;
205         testrunner_lite_options opts;
206
207         memset (&opts, 0x0, sizeof (opts));
208         executor_init (&opts);
209         
210         init_exec_data(&edata);
211         edata.soft_timeout = 1;
212         edata.hard_timeout = 1;
213         fail_if (execute("/usr/lib/testrunner-lite-tests/terminating " 
214                          "stdouttest stderrtest", &edata));
215         fail_unless (edata.result == SIGTERM);
216         fail_if (edata.stdout_data.buffer == NULL);
217         fail_if (edata.stderr_data.buffer == NULL);
218         fail_unless (strncmp((char*)edata.stdout_data.buffer, 
219                              "stdouttest", strlen("stdouttest")) == 0);
220         fail_unless (strncmp((char*)edata.stderr_data.buffer, 
221                              "stderrtest", strlen("stderrtest")) == 0);
222         fail_if(edata.failure_info.buffer == NULL);
223         fail_unless (strcmp((char*)edata.failure_info.buffer, 
224                             FAILURE_INFO_TIMEOUT) == 0);
225 END_TEST
226 /* ------------------------------------------------------------------------- */
227 START_TEST (test_executor_killing_process)
228         exec_data edata;
229         testrunner_lite_options opts;
230
231         memset (&opts, 0x0, sizeof (opts));
232         executor_init (&opts);
233         
234         init_exec_data(&edata);
235         edata.soft_timeout = 1;
236         edata.hard_timeout = 1;
237         fail_if (execute("/usr/lib/testrunner-lite-tests/unterminating "
238                          "stdouttest stderrtest", &edata));
239         fail_unless (edata.result == SIGTERM || edata.result == SIGKILL);
240         fail_if (edata.stdout_data.buffer == NULL);
241         fail_if (edata.stderr_data.buffer == NULL);
242         fail_unless (strncmp((char*)edata.stdout_data.buffer, 
243                              "stdouttest", strlen("stdouttest")) == 0);
244         fail_unless (strncmp((char*)edata.stderr_data.buffer, 
245                              "stderrtest", strlen("stderrtest")) == 0);
246         fail_if(edata.failure_info.buffer == NULL);
247         fail_unless (strcmp((char*)edata.failure_info.buffer, 
248                             FAILURE_INFO_TIMEOUT) == 0);
249 END_TEST
250 /* ------------------------------------------------------------------------- */
251 START_TEST (test_executor_piped_command)
252         exec_data edata;
253         testrunner_lite_options opts;
254
255         memset (&opts, 0x0, sizeof (opts));
256         executor_init (&opts);
257
258         init_exec_data(&edata);
259         edata.soft_timeout = 1;
260         edata.hard_timeout = 1;
261         fail_if (execute("echo h world | sed -e 's/h/hello/g' | grep hello", 
262                          &edata));
263         fail_unless (edata.result == 0);
264         fail_if (edata.stdout_data.buffer == NULL);
265         fail_unless (edata.stdout_data.length == strlen("hello world\n"));
266         fail_unless (strcmp((char*)edata.stdout_data.buffer, 
267                             "hello world\n") == 0);
268 END_TEST
269 /* ------------------------------------------------------------------------- */
270 START_TEST (test_executor_without_output_redirection)
271         exec_data edata;
272         testrunner_lite_options opts;
273
274         memset (&opts, 0x0, sizeof (opts));
275         executor_init (&opts);
276
277         init_exec_data(&edata);
278         edata.soft_timeout = 1;
279         edata.hard_timeout = 1;
280         edata.redirect_output = DONT_REDIRECT_OUTPUT;
281         fail_if (execute("echo testing", &edata));
282         fail_unless (edata.result == 0);
283         fail_unless (edata.stdout_data.length == 0);
284         fail_unless (edata.stderr_data.length == 0);
285 END_TEST
286 /* ------------------------------------------------------------------------- */
287 START_TEST (test_executor_exec_data_handling)
288         exec_data edata;
289         testrunner_lite_options opts;
290
291         memset (&opts, 0x0, sizeof (opts));
292         executor_init (&opts);
293
294         init_exec_data(&edata);
295         fail_if (execute("echo testing", &edata));
296         fail_unless (edata.result == 0);
297         fail_unless (edata.stdout_data.length == strlen("testing\n"));
298         fail_unless (strcmp((char*)edata.stdout_data.buffer, "testing\n") == 0);
299
300         clean_exec_data(&edata);
301         fail_unless (edata.stdout_data.buffer == NULL);
302         fail_unless (edata.stderr_data.buffer == NULL);
303
304         init_exec_data(&edata);
305         fail_if (execute("cat unexisting_foobar_file", &edata));
306         fail_if (edata.result == 0);
307         fail_if (edata.stderr_data.length == 0);
308         fail_unless (strlen((char*)edata.stderr_data.buffer) > 0);
309
310         clean_exec_data(&edata);
311         fail_unless (edata.stdout_data.buffer == NULL);
312         fail_unless (edata.stderr_data.buffer == NULL);
313 END_TEST
314 /* ------------------------------------------------------------------------- */
315 START_TEST (test_executor_remote_command)
316         exec_data edata;
317         testrunner_lite_options opts;
318
319         opts.target_address = "localhost";
320         executor_init (&opts);
321         init_exec_data (&edata);
322         
323         fail_if (execute("echo testing", &edata));
324         fail_unless (edata.result == 0);
325         fail_unless (edata.stdout_data.length == strlen("testing\n"));
326         fail_unless (strcmp((char*)edata.stdout_data.buffer, "testing\n") == 0);
327
328         clean_exec_data(&edata);
329         fail_unless (edata.stdout_data.buffer == NULL);
330         fail_unless (edata.stderr_data.buffer == NULL);
331
332         init_exec_data(&edata);
333         fail_if (execute("cat unexisting_foobar_file", &edata));
334         fail_if (edata.result == 0);
335         fail_if (edata.stderr_data.length == 0);
336         fail_unless (strlen((char*)edata.stderr_data.buffer) > 0);
337
338         clean_exec_data(&edata);
339         fail_unless (edata.stdout_data.buffer == NULL);
340         fail_unless (edata.stderr_data.buffer == NULL);
341
342         /* Give time for either ssh_clean or ssh_kill called by execute.
343            They have forked new ssh process to do cleanup */
344         sleep(1);
345 END_TEST
346 /* ------------------------------------------------------------------------- */
347 START_TEST (test_executor_remote_terminating_process)
348         exec_data edata;
349         testrunner_lite_options opts;
350
351         opts.target_address = "localhost";
352         executor_init (&opts);
353         
354         init_exec_data(&edata);
355         edata.soft_timeout = 2;
356         edata.hard_timeout = 1;
357         fail_if (execute("/usr/lib/testrunner-lite-tests/terminating " 
358                          "stdouttest stderrtest", &edata));
359         fail_unless (edata.result == 143); /* 128 + SIGKILL */
360         fail_if (edata.stdout_data.buffer == NULL);
361         fail_if (edata.stderr_data.buffer == NULL);
362         fail_unless (strcmp((char*)edata.stdout_data.buffer, 
363                             "stdouttest") == 0);
364         fail_unless (strncmp((char*)edata.stderr_data.buffer, 
365                              "stderrtest", strlen ("stderrtest")) == 0);
366         /* sleep for a while such that remote killing has done its job */
367         sleep(2);
368         /* check that killing was succesfull */
369         fail_if (execute("pidof terminating", &edata));
370         fail_unless (edata.result == 1);
371
372         /* Give time for either ssh_clean or ssh_kill called by execute.
373            They have forked new ssh process to do cleanup */
374         sleep(1);
375 END_TEST
376 /* ------------------------------------------------------------------------- */
377 START_TEST (test_executor_remote_killing_process)
378         exec_data edata;
379         testrunner_lite_options opts;
380
381         opts.target_address = "localhost";
382         executor_init (&opts);
383
384         init_exec_data(&edata);
385         edata.soft_timeout = 2;
386         edata.hard_timeout = 1;
387         fail_if (execute("/usr/lib/testrunner-lite-tests/unterminating "
388                          "stdouttest stderrtest", &edata));
389         fail_unless (edata.result == 143); /* 128 + SIGKILL */
390         fail_if (edata.stdout_data.buffer == NULL);
391         fail_if (edata.stderr_data.buffer == NULL);
392         fail_unless (strncmp((char*)edata.stdout_data.buffer, 
393                              "stdouttest", strlen("stderrtest")) == 0);
394         fail_unless (strncmp((char*)edata.stderr_data.buffer, 
395                              "stderrtest", strlen("stderrtest")) == 0);
396         /* sleep for a while such that remote killing has done its job */
397         sleep(2);
398         fail_if (execute("pidof unterminating", &edata));
399         fail_unless (edata.result == 1);
400
401         /* Give time for either ssh_clean or ssh_kill called by execute.
402            They have forked new ssh process to do cleanup */
403         sleep(1);
404 END_TEST
405 /* ------------------------------------------------------------------------- */
406 START_TEST(test_executor_remote_test_bg_process_cleanup)
407      int ret;
408      char cmd[1024];
409      char *out_file = "/tmp/testrunner-lite-tests/testrunner-lite.out.xml";
410      
411      sprintf (cmd, "%s -v -f %s -o %s -tlocalhost", TESTRUNNERLITE_BIN, 
412               TESTDATA_BG_XML,  out_file);
413      ret = system (cmd);
414      fail_if (ret != 0, cmd);
415
416      ret = system("pidof unterminating");
417      fail_unless (ret);
418      
419 END_TEST
420 /* ------------------------------------------------------------------------- */
421 START_TEST (test_executor_ssh_conn_check)
422         int ret = ssh_check_conn ("localhost");
423         fail_if (ret, "ret=%d", ret);
424 END_TEST
425 /* ------------------------------------------------------------------------- */
426 START_TEST (test_remote_get)
427
428      int ret;
429      char cmd[1024];
430      
431      sprintf (cmd, "%s -f %s -o /tmp/testrunnerlitetestdir2/res.xml "
432               "-t localhost", 
433               TESTRUNNERLITE_BIN, 
434               TESTDATA_GET_XML_1);
435      ret = system (cmd);
436      fail_if (ret, cmd);
437      
438      sprintf (cmd, "stat /tmp/testrunnerlitetestdir2/");
439      ret = system (cmd);
440      fail_if (ret, cmd);
441      
442      sprintf (cmd, "stat /tmp/testrunnerlitetestdir2/gettest.txt");
443      ret = system (cmd);
444      fail_if (ret, cmd);
445     
446      sprintf (cmd, "stat /tmp/testrunnerlitetestdir2/gettest2.txt");
447      ret = system (cmd);
448      fail_if (ret, cmd);
449      
450      sprintf (cmd, "stat /tmp/testrunnerlitetestdir2/gettest3.txt");
451      ret = system (cmd);
452      fail_if (ret, cmd);
453
454      sprintf (cmd, "stat /tmp/testrunnerlitetestdir2/gettest4.txt");
455      ret = system (cmd);
456      fail_if (ret, cmd);
457
458      sprintf (cmd, "stat /tmp/testrunnerlitetestdir2/get\\ test5.txt");
459      ret = system (cmd);
460      fail_if (ret, cmd);
461 END_TEST
462
463 /* ------------------------------------------------------------------------- */
464 /* ======================== FUNCTIONS ====================================== */
465 /* ------------------------------------------------------------------------- */
466 Suite *make_testexecutor_suite (void)
467 {
468     /* Create suite. */
469     Suite *s = suite_create ("testexecuter");
470
471     /* Create test cases and add to suite. */
472     TCase *tc;
473
474     tc = tcase_create ("Test executor with null command.");
475     tcase_add_test (tc, test_executor_null_command);
476     suite_add_tcase (s, tc);
477
478     tc = tcase_create ("Test executor with 0 timeout.");
479     tcase_add_test (tc, test_executor_0_timeout);
480     suite_add_tcase (s, tc);
481
482     tc = tcase_create ("Test executor stdout output.");
483     tcase_add_test (tc, test_executor_stdout);
484     suite_add_tcase (s, tc);
485
486     tc = tcase_create ("Test executor stderr output.");
487     tcase_add_test (tc, test_executor_stderr);
488     suite_add_tcase (s, tc);
489
490     tc = tcase_create ("Test executor long input streams.");
491     tcase_set_timeout (tc, 5);
492     tcase_add_test (tc, test_executor_long_input_streams);
493     suite_add_tcase (s, tc);
494
495     tc = tcase_create ("Test executor terminating process.");
496     tcase_set_timeout (tc, 5);
497     tcase_add_test (tc, test_executor_terminating_process);
498     suite_add_tcase (s, tc);
499
500     tc = tcase_create ("Test executor killing process.");
501     tcase_set_timeout (tc, 5);
502     tcase_add_test (tc, test_executor_killing_process);
503     suite_add_tcase (s, tc);
504
505     tc = tcase_create ("Test executor piped command.");
506     tcase_add_test (tc, test_executor_piped_command);
507     suite_add_tcase (s, tc);
508
509     tc = tcase_create ("Test executor without output redirection.");
510     tcase_add_test (tc, test_executor_without_output_redirection);
511     suite_add_tcase (s, tc);
512
513     tc = tcase_create ("Test executor execution data handling.");
514     tcase_add_test (tc, test_executor_exec_data_handling);
515     suite_add_tcase (s, tc);
516
517
518     if (set_env_for_remote_tests()) {
519             fprintf (stderr, "skipping remote tests\n");
520             return s;
521     }
522     tc = tcase_create ("Test executor remote command.");
523     tcase_add_test (tc, test_executor_remote_command);
524     suite_add_tcase (s, tc);
525
526     tc = tcase_create ("Test executor remote terminating process.");
527     tcase_set_timeout (tc, 10);
528     tcase_add_test (tc, test_executor_remote_terminating_process);
529     suite_add_tcase (s, tc);
530
531     tc = tcase_create ("Test executor remote killing process.");
532     tcase_set_timeout (tc, 10);
533     tcase_add_test (tc, test_executor_remote_killing_process);
534     suite_add_tcase (s, tc);
535
536     tc = tcase_create ("Test executor remote bg process cleanup.");
537     tcase_set_timeout (tc, 10);
538     tcase_add_test (tc, test_executor_remote_test_bg_process_cleanup);
539     suite_add_tcase (s, tc);
540
541     tc = tcase_create ("Test get feature with remote host.");
542     tcase_set_timeout (tc, 25);
543     tcase_add_test (tc, test_remote_get);
544     suite_add_tcase (s, tc);
545     
546     tc = tcase_create ("Test ssh connection check routine.");
547     tcase_set_timeout (tc, 20);
548     tcase_add_test (tc, test_executor_ssh_conn_check);
549     suite_add_tcase (s, tc);
550     
551     
552     return s;
553 }
554
555 /* ================= OTHER EXPORTED FUNCTIONS ============================== */
556 /* None */
557
558 /* ------------------------------------------------------------------------- */
559 /* End of file */