| 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 |