Debian Codegraph @

ansible_collections/containers/podman/tests/integration/targets/podman_quadlet/tasks/main.yml

raw
1 - name: Test podman_quadlet
2 block:
3 - name: Discover podman version
4 shell: podman version | grep "^Version:" | awk {'print $2'}
5 register: podman_v
6
7 - name: Set podman version fact
8 set_fact:
9 podman_version: "{{ podman_v.stdout | string }}"
10
11 - name: Print podman version
12 debug: var=podman_v.stdout
13
14 - name: Define quadlet user dir
15 set_fact:
16 quadlet_user_dir: "{{ ansible_env.HOME }}/.config/containers/systemd"
17
18 - name: Create temporary directory for single-file quadlet
19 ansible.builtin.tempfile:
20 state: directory
21 prefix: quadlet_single_
22 register: quadlet_single_dir
23
24 - name: Write a simple container quadlet file
25 copy:
26 dest: "{{ quadlet_single_dir.path }}/test-single.container"
27 mode: "0644"
28 content: |
29 [Container]
30 Image=docker.io/library/alpine:latest
31 Exec=/bin/sh -c 'sleep 600'
32
33 - name: Install quadlet from a single file
34 containers.podman.podman_quadlet:
35 state: present
36 src: "{{ quadlet_single_dir.path }}/test-single.container"
37 reload_systemd: true
38 register: install_single
39
40 - name: Assert install_single changed
41 assert:
42 that:
43 - install_single.changed
44
45 - name: Verify quadlet file exists in user dir
46 stat:
47 path: "{{ quadlet_user_dir }}/test-single.container"
48 register: single_stat
49
50 - name: Assert quadlet file present
51 assert:
52 that:
53 - single_stat.stat.exists
54
55 - name: Reinstall quadlet single file should be idempotent
56 containers.podman.podman_quadlet:
57 state: present
58 src: "{{ quadlet_single_dir.path }}/test-single.container"
59 reload_systemd: false
60 register: reinstall_single
61
62 - name: Assert reinstall_single not changed
63 assert:
64 that:
65 - not reinstall_single.changed
66
67 - name: Remove quadlet without suffix (module should resolve)
68 containers.podman.podman_quadlet:
69 state: absent
70 name:
71 - test-single
72 register: rm_no_suffix
73
74 - name: Assert rm_no_suffix changed
75 assert:
76 that:
77 - rm_no_suffix.changed
78
79 - name: Create temporary directory for quadlet application
80 ansible.builtin.tempfile:
81 state: directory
82 prefix: quadlet_app_
83 register: quadlet_app_dir
84
85 - name: Write two quadlet files into application dir
86 copy:
87 dest: "{{ item.dest }}"
88 mode: "0644"
89 content: "{{ item.content }}"
90 loop:
91 - {
92 dest: "{{ quadlet_app_dir.path }}/app-a.container",
93 content: "[Container]\nImage=docker.io/library/alpine:latest\nExec=/bin/sh -c 'sleep 600'\n",
94 }
95 - {
96 dest: "{{ quadlet_app_dir.path }}/app-b.container",
97 content: "[Container]\nImage=docker.io/library/alpine:latest\nExec=/bin/sh -c 'sleep 600'\n",
98 }
99
100 - name: Install quadlet application (directory)
101 containers.podman.podman_quadlet:
102 state: present
103 src: "{{ quadlet_app_dir.path }}"
104 register: install_app
105
106 - name: Verify both app quadlets installed
107 stat:
108 path: "{{ item }}"
109 loop:
110 - "{{ quadlet_user_dir }}/app-a.container"
111 - "{{ quadlet_user_dir }}/app-b.container"
112 register: app_stats
113
114 - name: Assert app files present
115 assert:
116 that:
117 - app_stats.results | map(attribute='stat.exists') | list | min
118
119 - name: Remove one quadlet from the application (should remove whole app)
120 containers.podman.podman_quadlet:
121 state: absent
122 name:
123 - app-a.container
124 register: rm_app_one
125
126 - name: Recreate two standalone quadlets and remove by names list
127 block:
128 - name: Write two standalone quadlets
129 copy:
130 dest: "{{ item.dest }}"
131 mode: "0644"
132 content: "{{ item.content }}"
133 loop:
134 - {
135 dest: "{{ quadlet_single_dir.path }}/standalone-a.container",
136 content: "[Container]\nImage=docker.io/library/alpine:latest\nExec=/bin/sh -c 'sleep 600'\n",
137 }
138 - {
139 dest: "{{ quadlet_single_dir.path }}/standalone-b.container",
140 content: "[Container]\nImage=docker.io/library/alpine:latest\nExec=/bin/sh -c 'sleep 600'\n",
141 }
142
143 - name: Install two standalone quadlets
144 containers.podman.podman_quadlet:
145 state: present
146 src: "{{ item }}"
147 loop:
148 - "{{ quadlet_single_dir.path }}/standalone-a.container"
149 - "{{ quadlet_single_dir.path }}/standalone-b.container"
150
151 - name: Remove both via names list
152 containers.podman.podman_quadlet:
153 state: absent
154 name:
155 - standalone-a.container
156 - standalone-b.container
157 register: rm_both
158
159 - name: Assert removal succeeded and return value structure is correct
160 assert:
161 that:
162 - rm_both.changed
163 - rm_both.quadlets is defined
164 - rm_both.quadlets | length == 2
165 - rm_both.quadlets[0].name in ['standalone-a.container', 'standalone-b.container']
166 - rm_both.quadlets[1].name in ['standalone-a.container', 'standalone-b.container']
167
168 - name: Verify both app quadlets are removed
169 stat:
170 path: "{{ item }}"
171 loop:
172 - "{{ quadlet_user_dir }}/app-a.container"
173 - "{{ quadlet_user_dir }}/app-b.container"
174 register: app_rm_stats
175
176 - name: Assert app files absent
177 assert:
178 that:
179 - (app_rm_stats.results | map(attribute='stat.exists') | list) | select('equalto', true) | list | length == 0
180
181 - name: Remove non-existent quadlet (should be idempotent)
182 containers.podman.podman_quadlet:
183 state: absent
184 name:
185 - does-not-exist.container
186 register: rm_non_existent
187
188 - name: Assert rm_non_existent succeeded but not changed
189 assert:
190 that:
191 - not rm_non_existent.changed
192
193 # Edge case and negative tests
194 - name: Test invalid src parameter (missing file)
195 containers.podman.podman_quadlet:
196 state: present
197 src: /nonexistent/path/file.container
198 register: invalid_src
199 ignore_errors: true
200
201 - name: Assert invalid src fails appropriately
202 assert:
203 that:
204 - invalid_src is failed
205
206 - name: Test absent state without name or all (should fail)
207 containers.podman.podman_quadlet:
208 state: absent
209 register: absent_missing_args
210 ignore_errors: true
211
212 - name: Assert absent missing args fails
213 assert:
214 that:
215 - absent_missing_args is failed
216 - absent_missing_args.msg is search("must be specified")
217
218 - name: Test force parameter
219 block:
220 - name: Create a quadlet file for force test
221 copy:
222 dest: "{{ quadlet_single_dir.path }}/force-test.container"
223 mode: "0644"
224 content: |
225 [Container]
226 Image=docker.io/library/alpine:latest
227 Exec=/bin/sh -c 'sleep 600'
228
229 - name: Install quadlet for force test
230 containers.podman.podman_quadlet:
231 state: present
232 src: "{{ quadlet_single_dir.path }}/force-test.container"
233 register: force_install
234
235 - name: Assert install succeeded
236 assert:
237 that:
238 - force_install.changed
239
240 - name: Remove quadlet with force=false (testing non-default)
241 containers.podman.podman_quadlet:
242 state: absent
243 name:
244 - force-test.container
245 force: false
246 register: rm_no_force
247
248 - name: Assert removal succeeded even without force
249 assert:
250 that:
251 - rm_no_force.changed
252
253 - name: Test files parameter (additional files)
254 block:
255 - name: Create main quadlet and additional config file
256 copy:
257 dest: "{{ item.dest }}"
258 mode: "0644"
259 content: "{{ item.content }}"
260 loop:
261 - {
262 dest: "{{ quadlet_single_dir.path }}/app-with-config.container",
263 content: "[Container]\nImage=docker.io/library/alpine:latest\nExec=/bin/sh -c 'sleep 600'\n",
264 }
265 - {
266 dest: "{{ quadlet_single_dir.path }}/app.conf",
267 content: "# Configuration file\nkey=value\n",
268 }
269
270 - name: Install quadlet with additional files
271 containers.podman.podman_quadlet:
272 state: present
273 src: "{{ quadlet_single_dir.path }}/app-with-config.container"
274 files:
275 - "{{ quadlet_single_dir.path }}/app.conf"
276 register: install_with_files
277
278 - name: Assert install with files succeeded
279 assert:
280 that:
281 - install_with_files.changed
282
283 - name: Verify both files are installed
284 stat:
285 path: "{{ item }}"
286 loop:
287 - "{{ quadlet_user_dir }}/app-with-config.container"
288 - "{{ quadlet_user_dir }}/app.conf"
289 register: files_stats
290
291 - name: Assert both files present
292 assert:
293 that:
294 - files_stats.results | map(attribute='stat.exists') | list | min
295
296 - name: Remove quadlet with files
297 containers.podman.podman_quadlet:
298 state: absent
299 name:
300 - app-with-config.container
301
302 - name: Test malformed quadlet file handling
303 block:
304 - name: Create malformed quadlet file
305 copy:
306 dest: "{{ quadlet_single_dir.path }}/malformed.container"
307 mode: "0644"
308 content: |
309 [Container
310 Image=docker.io/library/alpine:latest
311 # Missing closing bracket
312
313 - name: Try to install malformed quadlet
314 containers.podman.podman_quadlet:
315 state: present
316 src: "{{ quadlet_single_dir.path }}/malformed.container"
317 register: malformed_install
318 ignore_errors: true
319
320 # Note: Podman may accept malformed files, so we don't assert failure
321 - name: Cleanup malformed quadlet if installed
322 containers.podman.podman_quadlet:
323 state: absent
324 name:
325 - malformed.container
326 ignore_errors: true
327
328 - name: Test update scenario (content change triggers remove+install)
329 block:
330 - name: Create quadlet for update test
331 copy:
332 dest: "{{ quadlet_single_dir.path }}/update-test.container"
333 mode: "0644"
334 content: |
335 [Container]
336 Image=docker.io/library/alpine:latest
337 Exec=/bin/sh -c 'sleep 100'
338
339 - name: Install quadlet for update test
340 containers.podman.podman_quadlet:
341 state: present
342 src: "{{ quadlet_single_dir.path }}/update-test.container"
343 register: update_install_first
344
345 - name: Assert first install changed
346 assert:
347 that:
348 - update_install_first.changed
349
350 - name: Modify the quadlet file content
351 copy:
352 dest: "{{ quadlet_single_dir.path }}/update-test.container"
353 mode: "0644"
354 content: |
355 [Container]
356 Image=docker.io/library/alpine:latest
357 Exec=/bin/sh -c 'sleep 200'
358
359 - name: Reinstall modified quadlet (should trigger update)
360 containers.podman.podman_quadlet:
361 state: present
362 src: "{{ quadlet_single_dir.path }}/update-test.container"
363 register: update_install_second
364
365 - name: Assert update changed
366 assert:
367 that:
368 - update_install_second.changed
369
370 - name: Read installed file content
371 slurp:
372 src: "{{ quadlet_user_dir }}/update-test.container"
373 register: installed_content
374
375 - name: Assert installed file has updated content
376 assert:
377 that:
378 - "'sleep 200' in (installed_content.content | b64decode)"
379
380 - name: Reinstall same content again (should be idempotent)
381 containers.podman.podman_quadlet:
382 state: present
383 src: "{{ quadlet_single_dir.path }}/update-test.container"
384 register: update_install_third
385
386 - name: Assert idempotent after update
387 assert:
388 that:
389 - not update_install_third.changed
390
391 - name: Cleanup update test quadlet
392 containers.podman.podman_quadlet:
393 state: absent
394 name:
395 - update-test.container
396
397 - name: Test update with files parameter
398 block:
399 - name: Create quadlet and config for files update test
400 copy:
401 dest: "{{ item.dest }}"
402 mode: "0644"
403 content: "{{ item.content }}"
404 loop:
405 - {
406 dest: "{{ quadlet_single_dir.path }}/files-update.container",
407 content: "[Container]\nImage=docker.io/library/alpine:latest\nExec=/bin/sh -c 'sleep 600'\n",
408 }
409 - {
410 dest: "{{ quadlet_single_dir.path }}/files-update.conf",
411 content: "# Config v1\nkey=value1\n",
412 }
413
414 - name: Install quadlet with config file
415 containers.podman.podman_quadlet:
416 state: present
417 src: "{{ quadlet_single_dir.path }}/files-update.container"
418 files:
419 - "{{ quadlet_single_dir.path }}/files-update.conf"
420 register: files_update_first
421
422 - name: Assert first install changed
423 assert:
424 that:
425 - files_update_first.changed
426
427 - name: Modify the config file only
428 copy:
429 dest: "{{ quadlet_single_dir.path }}/files-update.conf"
430 mode: "0644"
431 content: |
432 # Config v2
433 key=value2
434
435 - name: Reinstall with modified config file
436 containers.podman.podman_quadlet:
437 state: present
438 src: "{{ quadlet_single_dir.path }}/files-update.container"
439 files:
440 - "{{ quadlet_single_dir.path }}/files-update.conf"
441 register: files_update_second
442
443 - name: Assert config change triggered update
444 assert:
445 that:
446 - files_update_second.changed
447
448 - name: Read installed config file content
449 slurp:
450 src: "{{ quadlet_user_dir }}/files-update.conf"
451 register: installed_conf_content
452
453 - name: Assert installed config has updated content
454 assert:
455 that:
456 - "'value2' in (installed_conf_content.content | b64decode)"
457
458 - name: Cleanup files update test
459 containers.podman.podman_quadlet:
460 state: absent
461 name:
462 - files-update.container
463
464 - name: Test check mode
465 block:
466 - name: Create quadlet for check mode test
467 copy:
468 dest: "{{ quadlet_single_dir.path }}/check-mode.container"
469 mode: "0644"
470 content: |
471 [Container]
472 Image=docker.io/library/alpine:latest
473 Exec=/bin/sh -c 'sleep 600'
474
475 - name: Install quadlet in check mode
476 containers.podman.podman_quadlet:
477 state: present
478 src: "{{ quadlet_single_dir.path }}/check-mode.container"
479 check_mode: true
480 register: check_mode_install
481
482 - name: Assert check mode shows change but doesn't install
483 assert:
484 that:
485 - check_mode_install.changed
486
487 - name: Verify file not actually installed in check mode
488 stat:
489 path: "{{ quadlet_user_dir }}/check-mode.container"
490 register: check_mode_stat
491
492 - name: Assert file not present after check mode
493 assert:
494 that:
495 - not check_mode_stat.stat.exists
496
497 - name: Remove in check mode (should show change)
498 containers.podman.podman_quadlet:
499 state: absent
500 name:
501 - check-mode.container
502 check_mode: true
503 register: check_mode_remove
504
505 - name: Assert check mode remove shows no change (idempotent)
506 assert:
507 that:
508 - not check_mode_remove.changed
509
510 - name: Install quadlet for real to test check mode removal
511 containers.podman.podman_quadlet:
512 state: present
513 src: "{{ quadlet_single_dir.path }}/check-mode.container"
514
515 - name: Remove in check mode (should show change now)
516 containers.podman.podman_quadlet:
517 state: absent
518 name:
519 - check-mode.container
520 check_mode: true
521 register: check_mode_remove_existing
522
523 - name: Assert check mode remove existing shows change
524 assert:
525 that:
526 - check_mode_remove_existing.changed
527
528 - name: Verify file still exists after check mode remove
529 stat:
530 path: "{{ quadlet_user_dir }}/check-mode.container"
531 register: check_mode_stat_existing
532
533 - name: Assert file present
534 assert:
535 that:
536 - check_mode_stat_existing.stat.exists
537
538 - name: Test asset removal detection (files removed from install)
539 block:
540 - name: Create quadlet and config for asset removal test
541 copy:
542 dest: "{{ item.dest }}"
543 mode: "0644"
544 content: "{{ item.content }}"
545 loop:
546 - {
547 dest: "{{ quadlet_single_dir.path }}/asset-removal.container",
548 content: "[Container]\nImage=docker.io/library/alpine:latest\nExec=/bin/sh -c 'sleep 600'\n",
549 }
550 - {
551 dest: "{{ quadlet_single_dir.path }}/asset-removal.conf",
552 content: "# Asset config\nkey=value\n",
553 }
554
555 - name: Install quadlet with config file
556 containers.podman.podman_quadlet:
557 state: present
558 src: "{{ quadlet_single_dir.path }}/asset-removal.container"
559 files:
560 - "{{ quadlet_single_dir.path }}/asset-removal.conf"
561 register: asset_removal_first
562
563 - name: Assert first install changed
564 assert:
565 that:
566 - asset_removal_first.changed
567
568 - name: Verify both files are installed
569 stat:
570 path: "{{ item }}"
571 loop:
572 - "{{ quadlet_user_dir }}/asset-removal.container"
573 - "{{ quadlet_user_dir }}/asset-removal.conf"
574 register: asset_files_stats
575
576 - name: Assert both files present
577 assert:
578 that:
579 - asset_files_stats.results | map(attribute='stat.exists') | list | min
580
581 - name: Reinstall without the config file (should detect asset removal)
582 containers.podman.podman_quadlet:
583 state: present
584 src: "{{ quadlet_single_dir.path }}/asset-removal.container"
585 register: asset_removal_second
586
587 - name: Assert reinstall detected change due to asset removal
588 assert:
589 that:
590 - asset_removal_second.changed
591
592 - name: Verify config file is removed
593 stat:
594 path: "{{ quadlet_user_dir }}/asset-removal.conf"
595 register: asset_conf_stat
596
597 - name: Assert config file removed
598 assert:
599 that:
600 - not asset_conf_stat.stat.exists
601
602 - name: Cleanup asset removal test
603 containers.podman.podman_quadlet:
604 state: absent
605 name:
606 - asset-removal.container
607 ignore_errors: true
608
609 - name: Test .quadlets file install (Podman 6.0+)
610 when: podman_version is version('6.0', '>=')
611 block:
612 - name: Create a .quadlets file with multiple sections
613 copy:
614 dest: "{{ quadlet_single_dir.path }}/webapp.quadlets"
615 mode: "0644"
616 content: |
617 # FileName=web-server
618 [Container]
619 Image=docker.io/library/alpine:latest
620 Exec=/bin/sh -c 'sleep 600'
621 ---
622 # FileName=app-storage
623 [Volume]
624 Label=app=webapp
625
626 - name: Install .quadlets file
627 containers.podman.podman_quadlet:
628 state: present
629 src: "{{ quadlet_single_dir.path }}/webapp.quadlets"
630 register: quadlets_install
631
632 - name: Assert .quadlets install changed
633 assert:
634 that:
635 - quadlets_install.changed
636
637 - name: Verify generated quadlet files exist
638 stat:
639 path: "{{ item }}"
640 loop:
641 - "{{ quadlet_user_dir }}/web-server.container"
642 - "{{ quadlet_user_dir }}/app-storage.volume"
643 register: quadlets_stats
644
645 - name: Assert generated files present
646 assert:
647 that:
648 - quadlets_stats.results | map(attribute='stat.exists') | list | min
649
650 - name: Reinstall same .quadlets file (should be idempotent)
651 containers.podman.podman_quadlet:
652 state: present
653 src: "{{ quadlet_single_dir.path }}/webapp.quadlets"
654 register: quadlets_reinstall
655
656 - name: Assert .quadlets reinstall idempotent
657 assert:
658 that:
659 - not quadlets_reinstall.changed
660
661 - name: Modify .quadlets file content
662 copy:
663 dest: "{{ quadlet_single_dir.path }}/webapp.quadlets"
664 mode: "0644"
665 content: |
666 # FileName=web-server
667 [Container]
668 Image=docker.io/library/alpine:latest
669 Exec=/bin/sh -c 'sleep 999'
670 ---
671 # FileName=app-storage
672 [Volume]
673 Label=app=webapp
674
675 - name: Reinstall modified .quadlets file
676 containers.podman.podman_quadlet:
677 state: present
678 src: "{{ quadlet_single_dir.path }}/webapp.quadlets"
679 register: quadlets_update
680
681 - name: Assert .quadlets update detected change
682 assert:
683 that:
684 - quadlets_update.changed
685
686 - name: Read installed container file content
687 slurp:
688 src: "{{ quadlet_user_dir }}/web-server.container"
689 register: quadlets_container_content
690
691 - name: Assert container file has updated content
692 assert:
693 that:
694 - "'sleep 999' in (quadlets_container_content.content | b64decode)"
695
696 - name: Cleanup .quadlets test (remove via app marker)
697 containers.podman.podman_quadlet:
698 state: absent
699 name:
700 - web-server.container
701 ignore_errors: true
702
703 - name: Skip .quadlets test notice
704 debug:
705 msg: "Skipping .quadlets test - requires Podman 6.0+ (current: {{ podman_version }})"
706 when: podman_version is version('6.0', '<')
707
708 - name: Test nested subdirectory validation
709 block:
710 - name: Create temporary directory for subdir test
711 ansible.builtin.tempfile:
712 state: directory
713 prefix: quadlet_subdir_
714 register: quadlet_subdir_test_dir
715
716 - name: Create a subdirectory inside the app directory
717 file:
718 path: "{{ quadlet_subdir_test_dir.path }}/nested_subdir"
719 state: directory
720
721 - name: Create a quadlet file in the parent directory
722 copy:
723 dest: "{{ quadlet_subdir_test_dir.path }}/test.container"
724 mode: "0644"
725 content: |
726 [Container]
727 Image=docker.io/library/alpine:latest
728 Exec=/bin/sh -c 'sleep 600'
729
730 - name: Create a file in the nested subdirectory
731 copy:
732 dest: "{{ quadlet_subdir_test_dir.path }}/nested_subdir/nested.conf"
733 mode: "0644"
734 content: "# Nested config\n"
735
736 - name: Try to install directory with subdirectory (should fail)
737 containers.podman.podman_quadlet:
738 state: present
739 src: "{{ quadlet_subdir_test_dir.path }}"
740 register: subdir_install
741 ignore_errors: true
742
743 - name: Assert subdir install fails with expected message
744 assert:
745 that:
746 - subdir_install is failed
747 - subdir_install.msg is search("nested") or subdir_install.msg is search("subdirector")
748
749 always:
750 # clean the test quadlets
751 - name: Cleanup installed quadlets
752 containers.podman.podman_quadlet:
753 state: absent
754 name:
755 - test-single.container
756 - app-a.container
757 - app-b.container
758 - force-test.container
759 - app-with-config.container
760 - malformed.container
761 - check-mode.container
762 - update-test.container
763 - files-update.container
764 - asset-removal.container
765 - web-server.container
766 - app-storage.volume
767 ignore_errors: true
768
769 - name: Verify cleanup - files should be removed from filesystem
770 stat:
771 path: "{{ item }}"
772 loop:
773 - "{{ quadlet_user_dir }}/test-single.container"
774 - "{{ quadlet_user_dir }}/app-a.container"
775 - "{{ quadlet_user_dir }}/app-b.container"
776 - "{{ quadlet_user_dir }}/force-test.container"
777 - "{{ quadlet_user_dir }}/app-with-config.container"
778 - "{{ quadlet_user_dir }}/app.conf"
779 - "{{ quadlet_user_dir }}/update-test.container"
780 - "{{ quadlet_user_dir }}/files-update.container"
781 - "{{ quadlet_user_dir }}/files-update.conf"
782 - "{{ quadlet_user_dir }}/asset-removal.container"
783 - "{{ quadlet_user_dir }}/asset-removal.conf"
784 - "{{ quadlet_user_dir }}/web-server.container"
785 - "{{ quadlet_user_dir }}/app-storage.volume"
786 register: cleanup_stats
787 ignore_errors: true
788
789 - name: Assert all test files removed from filesystem
790 assert:
791 that:
792 - (cleanup_stats.results | map(attribute='stat.exists') | list) | select('equalto', true) | list | length == 0
793 quiet: true
794 ignore_errors: true