Mercurial > sci

comparison tests/test-db.c @ 5:566bc028cdcb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
tests: initial tests coming - Add tests for database access. - While here transform common code into libsci.a
author David Demelier <markand@malikania.fr>
date Wed, 16 Jun 2021 13:25:42 +0200
parents
children 3ef8128e244f
comparison
equal deleted inserted replaced
4:9c4fea43803c 5:566bc028cdcb
1 /*
2 * test-db.c -- test database access
3 *
4 * Copyright (c) 2021 David Demelier <markand@malikania.fr>
5 *
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include <stdio.h>
20 #include <string.h>
21 #include <err.h>
22
23 #define GREATEST_USE_ABBREVS 0
24 #include <greatest.h>
25
26 #include "db.h"
27 #include "types.h"
28 #include "util.h"
29
30 #define DB "test.db"
31
32 static void
33 setup(void *data)
34 {
35 (void)data;
36
37 remove(DB);
38
39 if (db_open(DB) < 0)
40 err(1, "unable to create database");
41 }
42
43 static void
44 teardown(void *data)
45 {
46 (void)data;
47
48 db_finish();
49 remove(DB);
50 }
51
52 GREATEST_TEST
53 test_projects_add(void)
54 {
55 struct project proj = {0};
56
57 proj.name = "test";
58 proj.desc = "Test project";
59 proj.url = "example.org";
60 proj.script = "#!/bin/sh exit 0";
61
62 GREATEST_ASSERT_EQ(db_project_add(&proj), 0);
63 GREATEST_ASSERT(proj.id > 0);
64
65 GREATEST_PASS();
66 }
67
68 GREATEST_TEST
69 test_projects_list(void)
70 {
71 struct project projs[] = {
72 {
73 .name = "example 1",
74 .desc = "Example project 1",
75 .url = "example.org",
76 .script = "#!/bin/sh exit 0"
77 },
78 {
79 .name = "example 2",
80 .desc = "Example project 2",
81 .url = "example.org",
82 .script = "#!/bin/sh exit 0"
83 }
84 };
85 struct db_ctx ctx;
86
87 for (size_t i = 0; i < UTIL_SIZE(projs); ++i) {
88 GREATEST_ASSERT_EQ(db_project_add(&projs[i]), 0);
89 GREATEST_ASSERT(projs[i].id > 0);
90 }
91
92 memset(projs, 0, sizeof (projs));
93
94 GREATEST_ASSERT_EQ(db_project_list(&ctx, projs, UTIL_SIZE(projs)), 2LL);
95 GREATEST_ASSERT(projs[0].id > 0);
96 GREATEST_ASSERT_STR_EQ(projs[0].name, "example 1");
97 GREATEST_ASSERT_STR_EQ(projs[0].desc, "Example project 1");
98 GREATEST_ASSERT_STR_EQ(projs[0].url, "example.org");
99 GREATEST_ASSERT_STR_EQ(projs[0].script, "#!/bin/sh exit 0");
100 GREATEST_ASSERT(projs[1].id > 0);
101 GREATEST_ASSERT_STR_EQ(projs[1].name, "example 2");
102 GREATEST_ASSERT_STR_EQ(projs[1].desc, "Example project 2");
103 GREATEST_ASSERT_STR_EQ(projs[1].url, "example.org");
104 GREATEST_ASSERT_STR_EQ(projs[1].script, "#!/bin/sh exit 0");
105
106 db_ctx_finish(&ctx);
107
108 GREATEST_PASS();
109 }
110
111 GREATEST_TEST
112 test_projects_find(void)
113 {
114 struct project projs[] = {
115 {
116 .name = "example 1",
117 .desc = "Example project 1",
118 .url = "example.org",
119 .script = "#!/bin/sh exit 0"
120 },
121 {
122 .name = "example 2",
123 .desc = "Example project 2",
124 .url = "example.org",
125 .script = "#!/bin/sh exit 0"
126 }
127 };
128 struct project find = { .name = "example 2" };
129 struct db_ctx ctx;
130
131 for (size_t i = 0; i < UTIL_SIZE(projs); ++i) {
132 GREATEST_ASSERT_EQ(db_project_add(&projs[i]), 0);
133 GREATEST_ASSERT(projs[i].id > 0);
134 }
135
136 GREATEST_ASSERT_EQ(db_project_find(&ctx, &find), 0);
137 GREATEST_ASSERT_EQ(find.id, 2);
138 GREATEST_ASSERT_STR_EQ(find.name, "example 2");
139 GREATEST_ASSERT_STR_EQ(find.desc, "Example project 2");
140 GREATEST_ASSERT_STR_EQ(find.url, "example.org");
141 GREATEST_ASSERT_STR_EQ(find.script, "#!/bin/sh exit 0");
142
143 db_ctx_finish(&ctx);
144
145 GREATEST_PASS();
146 }
147
148 GREATEST_TEST
149 test_projects_find_id(void)
150 {
151 struct project projs[] = {
152 {
153 .name = "example 1",
154 .desc = "Example project 1",
155 .url = "example.org",
156 .script = "#!/bin/sh exit 0"
157 },
158 {
159 .name = "example 2",
160 .desc = "Example project 2",
161 .url = "example.org",
162 .script = "#!/bin/sh exit 0"
163 }
164 };
165 struct project find = { .id = 2 };
166 struct db_ctx ctx;
167
168 for (size_t i = 0; i < UTIL_SIZE(projs); ++i) {
169 GREATEST_ASSERT_EQ(db_project_add(&projs[i]), 0);
170 GREATEST_ASSERT(projs[i].id > 0);
171 }
172
173 /* First generated id should start at 1. */
174 GREATEST_ASSERT_EQ(db_project_find_id(&ctx, &find), 0);
175 GREATEST_ASSERT_EQ(find.id, 2);
176 GREATEST_ASSERT_STR_EQ(find.name, "example 2");
177 GREATEST_ASSERT_STR_EQ(find.desc, "Example project 2");
178 GREATEST_ASSERT_STR_EQ(find.url, "example.org");
179 GREATEST_ASSERT_STR_EQ(find.script, "#!/bin/sh exit 0");
180
181 db_ctx_finish(&ctx);
182
183 GREATEST_PASS();
184 }
185
186 GREATEST_SUITE(suite_projects)
187 {
188 GREATEST_SET_SETUP_CB(setup, NULL);
189 GREATEST_SET_TEARDOWN_CB(teardown, NULL);
190 GREATEST_RUN_TEST(test_projects_add);
191 GREATEST_RUN_TEST(test_projects_list);
192 GREATEST_RUN_TEST(test_projects_find);
193 GREATEST_RUN_TEST(test_projects_find_id);
194 }
195
196 GREATEST_TEST
197 test_workers_add(void)
198 {
199 struct worker wk = {0};
200
201 wk.name = "test";
202 wk.desc = "Test worker";
203
204 GREATEST_ASSERT_EQ(db_worker_add(&wk), 0);
205 GREATEST_ASSERT(wk.id > 0);
206
207 GREATEST_PASS();
208 }
209
210 GREATEST_TEST
211 test_workers_list(void)
212 {
213 struct worker wks[] = {
214 {
215 .name = "example 1",
216 .desc = "Example worker 1",
217 },
218 {
219 .name = "example 2",
220 .desc = "Example worker 2",
221 }
222 };
223 struct db_ctx ctx;
224
225 for (size_t i = 0; i < UTIL_SIZE(wks); ++i) {
226 GREATEST_ASSERT_EQ(db_worker_add(&wks[i]), 0);
227 GREATEST_ASSERT(wks[i].id > 0);
228 }
229
230 memset(wks, 0, sizeof (wks));
231
232 GREATEST_ASSERT_EQ(db_worker_list(&ctx, wks, UTIL_SIZE(wks)), 2LL);
233 GREATEST_ASSERT(wks[0].id > 0);
234 GREATEST_ASSERT_STR_EQ(wks[0].name, "example 1");
235 GREATEST_ASSERT_STR_EQ(wks[0].desc, "Example worker 1");
236 GREATEST_ASSERT(wks[1].id > 0);
237 GREATEST_ASSERT_STR_EQ(wks[1].name, "example 2");
238 GREATEST_ASSERT_STR_EQ(wks[1].desc, "Example worker 2");
239
240 db_ctx_finish(&ctx);
241
242 GREATEST_PASS();
243 }
244
245 GREATEST_TEST
246 test_workers_find(void)
247 {
248 struct worker wks[] = {
249 {
250 .name = "example 1",
251 .desc = "Example worker 1",
252 },
253 {
254 .name = "example 2",
255 .desc = "Example worker 2",
256 }
257 };
258 struct worker find = { .name = "example 1" };
259 struct db_ctx ctx;
260
261 for (size_t i = 0; i < UTIL_SIZE(wks); ++i) {
262 GREATEST_ASSERT_EQ(db_worker_add(&wks[i]), 0);
263 GREATEST_ASSERT(wks[i].id > 0);
264 }
265
266 GREATEST_ASSERT_EQ(db_worker_find(&ctx, &find), 0);
267 GREATEST_ASSERT_EQ(find.id, 1);
268 GREATEST_ASSERT_STR_EQ(find.name, "example 1");
269 GREATEST_ASSERT_STR_EQ(find.desc, "Example worker 1");
270
271 db_ctx_finish(&ctx);
272
273 GREATEST_PASS();
274 }
275
276 GREATEST_TEST
277 test_workers_find_id(void)
278 {
279 struct worker wks[] = {
280 {
281 .name = "example 1",
282 .desc = "Example worker 1",
283 },
284 {
285 .name = "example 2",
286 .desc = "Example worker 2",
287 }
288 };
289 struct worker find = { .id = 1 };
290 struct db_ctx ctx;
291
292 for (size_t i = 0; i < UTIL_SIZE(wks); ++i) {
293 GREATEST_ASSERT_EQ(db_worker_add(&wks[i]), 0);
294 GREATEST_ASSERT(wks[i].id > 0);
295 }
296
297 /* First generated id should start at 1. */
298 GREATEST_ASSERT_EQ(db_worker_find_id(&ctx, &find), 0);
299 GREATEST_ASSERT_EQ(find.id, 1);
300 GREATEST_ASSERT_STR_EQ(find.name, "example 1");
301 GREATEST_ASSERT_STR_EQ(find.desc, "Example worker 1");
302
303 db_ctx_finish(&ctx);
304
305 GREATEST_PASS();
306 }
307
308 GREATEST_SUITE(suite_workers)
309 {
310 GREATEST_SET_SETUP_CB(setup, NULL);
311 GREATEST_SET_TEARDOWN_CB(teardown, NULL);
312 GREATEST_RUN_TEST(test_workers_add);
313 GREATEST_RUN_TEST(test_workers_list);
314 GREATEST_RUN_TEST(test_workers_find);
315 GREATEST_RUN_TEST(test_workers_find_id);
316 }
317
318 GREATEST_TEST
319 test_jobs_add(void)
320 {
321 struct project proj = {0};
322 struct job job = {0};
323
324 proj.name = "test";
325 proj.desc = "Test project";
326 proj.url = "example.org";
327 proj.script = "#!/bin/sh exit 0";
328
329 GREATEST_ASSERT_EQ(db_project_add(&proj), 0);
330 GREATEST_ASSERT(proj.id > 0);
331
332 job.project_id = proj.id;
333 job.tag = "123456";
334
335 GREATEST_ASSERT_EQ(db_job_add(&job), 0);
336 GREATEST_ASSERT(job.id > 0);
337
338 GREATEST_PASS();
339 }
340
341 GREATEST_TEST
342 test_jobs_todo(void)
343 {
344 struct project proj = {0};
345 struct job job = {0};
346 struct worker wk = {0};
347 struct job todo[16] = {0};
348 struct db_ctx ctx;
349
350 proj.name = "test";
351 proj.desc = "Test project";
352 proj.url = "example.org";
353 proj.script = "#!/bin/sh exit 0";
354
355 GREATEST_ASSERT_EQ(db_project_add(&proj), 0);
356 GREATEST_ASSERT(proj.id > 0);
357
358 job.project_id = proj.id;
359 job.tag = "123456";
360
361 GREATEST_ASSERT_EQ(db_job_add(&job), 0);
362 GREATEST_ASSERT(job.id > 0);
363
364 wk.name = "test";
365 wk.desc = "Test worker";
366
367 GREATEST_ASSERT_EQ(db_worker_add(&wk), 0);
368 GREATEST_ASSERT(wk.id > 0);
369
370 GREATEST_ASSERT_EQ(db_job_todo(&ctx, todo, UTIL_SIZE(todo), wk.id), 1);
371 GREATEST_ASSERT(todo[0].id > 0);
372 GREATEST_ASSERT_STR_EQ(todo[0].tag, "123456");
373 GREATEST_ASSERT_EQ(todo[0].project_id, proj.id);
374
375 db_ctx_finish(&ctx);
376
377 GREATEST_PASS();
378 }
379
380 GREATEST_SUITE(suite_jobs)
381 {
382 GREATEST_SET_SETUP_CB(setup, NULL);
383 GREATEST_SET_TEARDOWN_CB(teardown, NULL);
384 GREATEST_RUN_TEST(test_jobs_add);
385 GREATEST_RUN_TEST(test_jobs_todo);
386 }
387
388
389 GREATEST_TEST
390 test_jobresults_add(void)
391 {
392 struct project projs[] = {
393 {
394 .name = "example 1",
395 .desc = "Example project 1",
396 .url = "example.org",
397 .script = "#!/bin/sh exit 0"
398 },
399 {
400 .name = "example 2",
401 .desc = "Example project 2",
402 .url = "example.org",
403 .script = "#!/bin/sh exit 0"
404 }
405 };
406 struct job jobs[] = {
407 {
408 .project_id = 0, /* will be project 1 */
409 .tag = "123456"
410 },
411 {
412 .project_id = 0, /* will be project 2 */
413 .tag = "abcdef"
414 },
415 };
416 struct worker wks[] = {
417 {
418 .name = "alpine-aarch64",
419 .desc = "alpine-aarch64"
420 },
421 {
422 .name = "alpine-armhf",
423 .desc = "alpine-armhf"
424 },
425 };
426 struct job todo[16] = {0};
427 struct jobresult res = {0};
428 struct db_ctx ctx;
429
430 for (size_t i = 0; i < UTIL_SIZE(projs); ++i) {
431 GREATEST_ASSERT_EQ(db_project_add(&projs[i]), 0);
432 GREATEST_ASSERT(projs[i].id > 0);
433 }
434
435 /* Update jobs with newly created projects. */
436 jobs[0].project_id = projs[0].id;
437 jobs[1].project_id = projs[1].id;
438
439 for (size_t i = 0; i < UTIL_SIZE(jobs); ++i) {
440 GREATEST_ASSERT_EQ(db_job_add(&jobs[i]), 0);
441 GREATEST_ASSERT(jobs[i].id > 0);
442 }
443
444 for (size_t i = 0; i < UTIL_SIZE(wks); ++i) {
445 GREATEST_ASSERT_EQ(db_worker_add(&wks[i]), 0);
446 GREATEST_ASSERT(wks[i].id > 0);
447 }
448
449 /*
450 * Now add a jobresult for worker alpine-aarch64 and the job "abcdef",
451 * this means that this worker will only have the job "123456" to do
452 * while the other worker will have all to do.
453 */
454 res.job_id = jobs[1].id;
455 res.worker_id = wks[0].id;
456 res.exitcode = 0;
457 res.log = "Success";
458
459 GREATEST_ASSERT_EQ(db_jobresult_add(&res), 0);
460 GREATEST_ASSERT(res.id > 0);
461
462 /* 1 job left for alpine-aarch64 -> [123456]. */
463 GREATEST_ASSERT_EQ(db_job_todo(&ctx, todo, UTIL_SIZE(todo), wks[0].id), 1);
464 GREATEST_ASSERT(todo[0].id > 0);
465 GREATEST_ASSERT_STR_EQ(todo[0].tag, "123456");
466 GREATEST_ASSERT_EQ(todo[0].project_id, projs[0].id);
467
468 db_ctx_finish(&ctx);
469
470 /* 2 jobs left for alpine-armhf -> [123456, abcdef]. */
471 GREATEST_ASSERT_EQ(db_job_todo(&ctx, todo, UTIL_SIZE(todo), wks[1].id), 2);
472 GREATEST_ASSERT(todo[0].id > 0);
473 GREATEST_ASSERT_STR_EQ(todo[0].tag, "123456");
474 GREATEST_ASSERT_EQ(todo[0].project_id, projs[0].id);
475 GREATEST_ASSERT(todo[1].id > 0);
476 GREATEST_ASSERT_STR_EQ(todo[1].tag, "abcdef");
477 GREATEST_ASSERT_EQ(todo[1].project_id, projs[1].id);
478
479 db_ctx_finish(&ctx);
480
481 GREATEST_PASS();
482 }
483
484 GREATEST_SUITE(suite_jobresults)
485 {
486 GREATEST_SET_SETUP_CB(setup, NULL);
487 GREATEST_SET_TEARDOWN_CB(teardown, NULL);
488 GREATEST_RUN_TEST(test_jobresults_add);
489 }
490
491 GREATEST_MAIN_DEFS();
492
493 int
494 main(int argc, char **argv)
495 {
496 GREATEST_MAIN_BEGIN();
497 GREATEST_RUN_SUITE(suite_projects);
498 GREATEST_RUN_SUITE(suite_workers);
499 GREATEST_RUN_SUITE(suite_jobs);
500 GREATEST_RUN_SUITE(suite_jobresults);
501 GREATEST_MAIN_END();
502 }