carroarmato0/ansible.posix
1
0
Fork 0
mirror of https://github.com/ansible-collections/ansible.posix.git synced 2026-01-11 23:25:28 +01:00
Code Issues Projects Releases Packages Wiki Activity

refactor tests

Browse source 
* Add a stat task for almost every filesize tasks and check results
  (size) consistency.
* Check that cmd result is always the same, in check mode or not.
* Check consistency of other returned results (size_diff & filesize.bytes).

add DOCUMENTATION.seealso section
fix docstrings coding style (tenses, typos...)
add changelog fragment (placeholder)
This commit is contained in:
quidame 2021-03-17 09:34:25 +01:00
parent 10d2e489b1
commit 6ce2f02fe5
6 changed files with 447 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
changelogs/fragments/148_new_module_filesize.yml Normal file
View file

@ -0,0 +1,3 @@
---
trivial:
- filesize - new module to create or resize a file (https://github.com/ansible-collections/ansible.posix/pull/148).

52
plugins/modules/filesize.py
View file

@ -41,13 +41,13 @@ options:
(= 1024KiB); C(G), C(g), C(GiB) or C(giB) (= 1024MiB); and so on.
- If the multiplicative suffix is not provided, the value is treated as
an integer number of blocks of I(blocksize) bytes each (float values
will be rounded to the closest integer).
are rounded to the closest integer).
- When the I(size) value is equal to the current file size, does nothing.
- When the I(size) value is bigger than the current file size, bytes will
be appended to the file without truncating it, i.e. without modifying
the existing bytes of the file.
- When the I(size) value is smaller than the current file size, it will
be truncated to the requested value without modifying bytes before this
- When the I(size) value is bigger than the current file size, bytes are
appended to the file without truncating it, in other words, without
modifying the existing bytes of the file.
- When the I(size) value is smaller than the current file size, it is
truncated to the requested value without modifying bytes before this
value.
- That means that a file of any arbitrary size can be grown to any other
arbitrary size, and then resized down to its initial size without
@ -59,8 +59,8 @@ options:
- Size of blocks, in bytes if not followed by a multiplicative suffix.
- The numeric value (before the unit) C(MUST) be an integer (or a C(float)
if it equals an integer).
- If not set, the size of blocks will be guessed from the OS and commonly
result in C(512) or C(4096) bytes, that will be used internally by the
- If not set, the size of blocks is guessed from the OS and commonly
results in C(512) or C(4096) bytes, that is used internally by the
module or when I(size) has no unit.
type: str
source:
@ -71,8 +71,9 @@ options:
default: /dev/zero
force:
description:
- Whether or not to overwrite the file if it exists, i.e. to truncate it
from 0. When C(true), the module is not idempotent.
- Whether or not to overwrite the file if it exists, in other words, to
truncate it from 0. When C(true), the module is not idempotent, that
means it always reports I(changed=true).
- I(force=yes) and I(sparse=yes) are mutually exclusive.
type: bool
default: no
@ -81,7 +82,7 @@ options:
- Whether or not the file to create should be a sparse file.
- This option is effective only on newly created files, or when growing a
file, only for the bytes to append.
- This option is not supported on OpenBSD and Solaris.
- This option is not supported on OpenBSD, Solaris and AIX.
- I(force=yes) and I(sparse=yes) are mutually exclusive.
type: bool
default: no
@ -92,6 +93,35 @@ notes:
requirements:
- dd
seealso:
- name: dd(1) manpage for Linux
description: Manual page of the GNU/Linux's dd implementation (from GNU coreutils).
link: https://man7.org/linux/man-pages/man1/dd.1.html
- name: dd(1) manpage for IBM AIX
description: Manual page of the IBM AIX's dd implementation.
link: https://www.ibm.com/support/knowledgecenter/ssw_aix_72/d_commands/dd.html
- name: dd(1) manpage for Mac OSX
description: Manual page of the Mac OSX's dd implementation.
link: https://www.unix.com/man-page/osx/1/dd/
- name: dd(1M) manpage for Solaris
description: Manual page of the Oracle Solaris's dd implementation.
link: https://docs.oracle.com/cd/E36784_01/html/E36871/dd-1m.html
- name: dd(1) manpage for FreeBSD
description: Manual page of the FreeBSD's dd implementation.
link: https://www.freebsd.org/cgi/man.cgi?dd(1)
- name: dd(1) manpage for OpenBSD
description: Manual page of the OpenBSD's dd implementation.
link: https://man.openbsd.org/dd
- name: dd(1) manpage for NetBSD
description: Manual page of the NetBSD's dd implementation.
link: https://man.netbsd.org/dd.1
extends_documentation_fragment: files
'''

184
tests/integration/targets/filesize/tasks/basics.yml
View file

@ -12,12 +12,24 @@
register: filesize_test_basic_01
check_mode: yes
- name: Stat the file (should not exist)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_01
- name: Create an empty file
filesize:
path: "{{ filesize_testfile }}"
size: "0"
register: filesize_test_basic_02
- name: Stat the file (should exist now)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_02
- name: Create an empty file (check mode, idempotency)
filesize:
path: "{{ filesize_testfile }}"
@ -31,14 +43,40 @@
size: "0G"
register: filesize_test_basic_04
- name: Stat the file (should still exist, unchanged)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_04
- name: Assert that results are as expected
assert:
that:
# check_mode & idempotency are in good shape.
- filesize_test_basic_01 is changed
- filesize_test_basic_02 is changed
- filesize_test_basic_03 is not changed
- filesize_test_basic_04 is not changed
# check_mode returns the same command than actual mode.
- filesize_test_basic_02.cmd == filesize_test_basic_01.cmd
- filesize_test_basic_03.cmd is undefined
- filesize_test_basic_04.cmd is undefined
# Module's specific return results are consistent with user input, that
# means: with *expected* results.
- filesize_test_basic_01.filesize.bytes == 0
- filesize_test_basic_02.filesize.bytes == 0
- filesize_test_basic_03.filesize.bytes == 0
- filesize_test_basic_04.filesize.bytes == 0
- filesize_test_basic_01.size_diff == 0
- filesize_test_basic_02.size_diff == 0
- filesize_test_basic_03.size_diff == 0
- filesize_test_basic_04.size_diff == 0
# Results populated by module.set_fs_attributes_if_different() are still
# consistent with current state of the file.
- filesize_test_basic_01.state is undefined
- filesize_test_basic_02.state in ["file"]
- filesize_test_basic_01.size is undefined
@ -46,6 +84,12 @@
- filesize_test_basic_03.size == 0
- filesize_test_basic_04.size == 0
# Cross results with those retrieved by another module.
- not filesize_stat_basic_01.stat.exists
- filesize_stat_basic_02.stat.exists
- filesize_stat_basic_02.stat.isreg
- filesize_stat_basic_02.stat.size == 0
- filesize_stat_basic_04.stat.size == 0
- name: Fill the file up to 57kB (57000B) with random data (check mode)
@ -56,6 +100,12 @@
register: filesize_test_basic_11
check_mode: yes
- name: Stat the file (should still be unchanged)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_11
- name: Fill the file up to 57kB (57000B) with random data
filesize:
path: "{{ filesize_testfile }}"
@ -63,14 +113,15 @@
source: /dev/urandom
register: filesize_test_basic_12
- name: Get checksum of the resulting file
- name: Stat the resulting file (and get its checksum)
stat:
path: "{{ filesize_testfile }}"
register: filesize_test_basic_stat_00
register: filesize_stat_basic_12
- name: Store checksum as fact
set_fact:
filesize_test_checksum: "{{ filesize_test_basic_stat_00.stat.checksum }}"
filesize_test_checksum: "{{ filesize_stat_basic_12.stat.checksum }}"
- name: Fill the file up to 57000B (57kB) with random data (check mode, idempotency)
filesize:
@ -87,10 +138,11 @@
source: /dev/urandom
register: filesize_test_basic_14
- name: Get checksum of the resulting file
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_test_basic_stat_01
register: filesize_stat_basic_14
- name: Assert that results are as expected
assert:
@ -100,17 +152,25 @@
- filesize_test_basic_13 is not changed
- filesize_test_basic_14 is not changed
- filesize_test_basic_12.cmd == filesize_test_basic_11.cmd
- filesize_test_basic_13.cmd is undefined
- filesize_test_basic_14.cmd is undefined
- filesize_test_basic_11.filesize.bytes == 57000
- filesize_test_basic_12.filesize.bytes == 57000
- filesize_test_basic_13.filesize.bytes == 57000
- filesize_test_basic_14.filesize.bytes == 57000
- filesize_test_basic_11.size == 0
- filesize_test_basic_12.size == 57000
- filesize_test_basic_13.size == 57000
- filesize_test_basic_14.size == 57000
- filesize_test_basic_11.size_diff == 57000
- filesize_test_basic_12.size_diff == 57000
- filesize_test_basic_13.size_diff == 0
- filesize_test_basic_14.size_diff == 0
- filesize_test_basic_stat_01.stat.checksum == filesize_test_checksum
- filesize_stat_basic_11.stat.size == 0
- filesize_stat_basic_12.stat.size == 57000
- filesize_stat_basic_14.stat.size == 57000
- filesize_stat_basic_14.stat.checksum == filesize_test_checksum
@ -121,16 +181,23 @@
register: filesize_test_basic_21
check_mode: yes
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_21
- name: Expand the file with 1 byte (57001B)
filesize:
path: "{{ filesize_testfile }}"
size: "57001B"
register: filesize_test_basic_22
- name: Get checksum of the resulting file
- name: Stat the file (should have grown of 1 byte)
stat:
path: "{{ filesize_testfile }}"
register: filesize_test_basic_stat_02
register: filesize_stat_basic_22
- name: Expand the file with 1 byte (57.001kB) (check mode, idempotency)
filesize:
@ -145,6 +212,12 @@
size: "57.001 kB"
register: filesize_test_basic_24
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_24
- name: Assert that results are as expected
assert:
that:
@ -153,20 +226,28 @@
- filesize_test_basic_23 is not changed
- filesize_test_basic_24 is not changed
- filesize_test_basic_22.cmd == filesize_test_basic_21.cmd
- filesize_test_basic_23.cmd is undefined
- filesize_test_basic_24.cmd is undefined
- filesize_test_basic_21.filesize.bytes == 57001
- filesize_test_basic_22.filesize.bytes == 57001
- filesize_test_basic_23.filesize.bytes == 57001
- filesize_test_basic_24.filesize.bytes == 57001
- filesize_test_basic_21.size == 57000
- filesize_test_basic_22.size == 57001
- filesize_test_basic_23.size == 57001
- filesize_test_basic_24.size == 57001
- filesize_test_basic_21.size_diff == 1
- filesize_test_basic_22.size_diff == 1
- filesize_test_basic_23.size_diff == 0
- filesize_test_basic_24.size_diff == 0
- filesize_test_basic_stat_02.stat.checksum != filesize_test_checksum
- filesize_stat_basic_21.stat.size == 57000
- filesize_stat_basic_22.stat.size == 57001
- filesize_stat_basic_24.stat.size == 57001
- filesize_stat_basic_21.stat.checksum == filesize_test_checksum
- filesize_stat_basic_22.stat.checksum != filesize_test_checksum
- filesize_stat_basic_24.stat.checksum != filesize_test_checksum
- name: Expand the file up to 2 MiB (2*1024*1024 bytes) (check mode)
@ -176,12 +257,24 @@
register: filesize_test_basic_31
check_mode: yes
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_31
- name: Expand the file up to 2 MiB (2*1024*1024 bytes)
filesize:
path: "{{ filesize_testfile }}"
size: "2 MiB"
register: filesize_test_basic_32
- name: Stat the file again (should have grown to 2MiB)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_32
- name: Expand the file up to 2×1M (2*1024*1024 bytes) (check mode, idempotency)
filesize:
path: "{{ filesize_testfile }}"
@ -197,6 +290,12 @@
blocksize: "1M"
register: filesize_test_basic_34
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_34
- name: Assert that results are as expected
assert:
that:
@ -205,19 +304,24 @@
- filesize_test_basic_33 is not changed
- filesize_test_basic_34 is not changed
- filesize_test_basic_32.cmd == filesize_test_basic_31.cmd
- filesize_test_basic_33.cmd is undefined
- filesize_test_basic_34.cmd is undefined
- filesize_test_basic_31.filesize.bytes == 2*1024**2
- filesize_test_basic_32.filesize.bytes == 2*1024**2
- filesize_test_basic_33.filesize.bytes == 2*1024**2
- filesize_test_basic_34.filesize.bytes == 2*1024**2
- filesize_test_basic_31.size == 57001
- filesize_test_basic_32.size == 2*1024**2
- filesize_test_basic_33.size == 2*1024**2
- filesize_test_basic_34.size == 2*1024**2
- filesize_test_basic_31.size_diff == 2*1024**2 - 57001
- filesize_test_basic_32.size_diff == 2*1024**2 - 57001
- filesize_test_basic_33.size_diff == 0
- filesize_test_basic_34.size_diff == 0
- filesize_stat_basic_31.stat.size == 57001
- filesize_stat_basic_32.stat.size == 2*1024**2
- filesize_stat_basic_34.stat.size == 2*1024**2
- name: Truncate the file to 57kB (57000B) (check mode)
@ -227,16 +331,23 @@
register: filesize_test_basic_41
check_mode: yes
- name: Stat the resulting file (should be unchanged)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_basic_41
- name: Truncate the file to 57kB (57000B)
filesize:
path: "{{ filesize_testfile }}"
size: "57kB"
register: filesize_test_basic_42
- name: Get checksum of the resulting file
- name: Stat the resulting file (and get its checksum)
stat:
path: "{{ filesize_testfile }}"
register: filesize_test_basic_stat_03
register: filesize_stat_basic_42
- name: Truncate the file to 57000B (57kB) (check mode, idempotency)
filesize:
@ -251,10 +362,11 @@
size: "57000 B"
register: filesize_test_basic_44
- name: Get checksum of the resulting file
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_test_basic_stat_04
register: filesize_stat_basic_44
- name: Assert that results are as expected
assert:
@ -264,18 +376,28 @@
- filesize_test_basic_43 is not changed
- filesize_test_basic_44 is not changed
- filesize_test_basic_42.cmd == filesize_test_basic_41.cmd
- filesize_test_basic_43.cmd is undefined
- filesize_test_basic_44.cmd is undefined
- filesize_test_basic_41.filesize.bytes == 57000
- filesize_test_basic_42.filesize.bytes == 57000
- filesize_test_basic_43.filesize.bytes == 57000
- filesize_test_basic_44.filesize.bytes == 57000
- filesize_test_basic_41.size == filesize_test_basic_31.filesize.bytes
- filesize_test_basic_42.size == 57000
- filesize_test_basic_43.size == 57000
- filesize_test_basic_44.size == 57000
- filesize_test_basic_41.size_diff == 57000 - 2*1024**2
- filesize_test_basic_42.size_diff == 57000 - 2*1024**2
- filesize_test_basic_43.size_diff == 0
- filesize_test_basic_44.size_diff == 0
- filesize_test_basic_stat_03.stat.checksum == filesize_test_checksum
- filesize_test_basic_stat_04.stat.checksum == filesize_test_checksum
- filesize_stat_basic_41.stat.size == 2*1024**2
- filesize_stat_basic_42.stat.size == 57000
- filesize_stat_basic_44.stat.size == 57000
# The original random file is back.
- filesize_stat_basic_41.stat.checksum != filesize_test_checksum
- filesize_stat_basic_42.stat.checksum == filesize_test_checksum
- filesize_stat_basic_44.stat.checksum == filesize_test_checksum

109
tests/integration/targets/filesize/tasks/floats.yml
View file

@ -12,12 +12,24 @@
register: filesize_test_float_01
check_mode: yes
- name: Stat the file (should not exist)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_float_01
- name: Create a file with a size of 512.512kB
filesize:
path: "{{ filesize_testfile }}"
size: 512.512kB
register: filesize_test_float_02
- name: Stat the file (should exist now)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_float_02
- name: Create a file with a size of 0.512512MB (check mode, idempotency)
filesize:
path: "{{ filesize_testfile }}"
@ -31,6 +43,12 @@
size: 0.512512MB
register: filesize_test_float_04
- name: Stat the file (should still exist, unchanged)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_float_04
- name: Assert that results are as expected
assert:
that:
@ -39,6 +57,20 @@
- filesize_test_float_03 is not changed
- filesize_test_float_04 is not changed
- filesize_test_float_02.cmd == filesize_test_float_01.cmd
- filesize_test_float_03.cmd is undefined
- filesize_test_float_04.cmd is undefined
- filesize_test_float_01.filesize.bytes == 512512
- filesize_test_float_02.filesize.bytes == 512512
- filesize_test_float_03.filesize.bytes == 512512
- filesize_test_float_04.filesize.bytes == 512512
- filesize_test_float_01.size_diff == 512512
- filesize_test_float_02.size_diff == 512512
- filesize_test_float_03.size_diff == 0
- filesize_test_float_04.size_diff == 0
- filesize_test_float_01.state is undefined
- filesize_test_float_02.state in ["file"]
- filesize_test_float_01.size is undefined
@ -46,6 +78,12 @@
- filesize_test_float_03.size == 512512
- filesize_test_float_04.size == 512512
- not filesize_stat_float_01.stat.exists
- filesize_stat_float_02.stat.exists
- filesize_stat_float_02.stat.isreg
- filesize_stat_float_02.stat.size == 512512
- filesize_stat_float_04.stat.size == 512512
- name: Create a file with a size of 512.513kB (check mode)
@ -55,12 +93,24 @@
register: filesize_test_float_11
check_mode: yes
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_float_11
- name: Create a file with a size of 512.513kB
filesize:
path: "{{ filesize_testfile }}"
size: 512.513kB
register: filesize_test_float_12
- name: Stat the file (should have grown of 1 byte)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_float_12
- name: Create a file with a size of 0.512513MB (check mode, idempotency)
filesize:
path: "{{ filesize_testfile }}"
@ -74,6 +124,12 @@
size: 0.512513MB
register: filesize_test_float_14
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_float_14
- name: Assert that results are as expected
assert:
that:
@ -82,13 +138,29 @@
- filesize_test_float_13 is not changed
- filesize_test_float_14 is not changed
- filesize_test_float_11.size == 512512
- filesize_test_float_12.cmd == filesize_test_float_11.cmd
- filesize_test_float_13.cmd is undefined
- filesize_test_float_14.cmd is undefined
- filesize_test_float_11.filesize.bytes == 512513
- filesize_test_float_12.filesize.bytes == 512513
- filesize_test_float_13.filesize.bytes == 512513
- filesize_test_float_14.filesize.bytes == 512513
- filesize_test_float_11.size_diff == 1
- filesize_test_float_12.size_diff == 1
- filesize_test_float_13.size_diff == 0
- filesize_test_float_14.size_diff == 0
- filesize_test_float_11.size == 512512
- filesize_test_float_12.size == 512513
- filesize_test_float_13.size == 512513
- filesize_test_float_14.size == 512513
- filesize_stat_float_11.stat.size == 512512
- filesize_stat_float_12.stat.size == 512513
- filesize_stat_float_14.stat.size == 512513
- name: Create a file with a size of 4.004MB (check mode)
@ -98,12 +170,24 @@
register: filesize_test_float_21
check_mode: yes
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_float_21
- name: Create a file with a size of 4.004MB
filesize:
path: "{{ filesize_testfile }}"
size: 4.004MB
register: filesize_test_float_22
- name: Stat the file (should have grown to 4.004MB)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_float_22
- name: Create a file with a size of 4.004MB (check mode, idempotency)
filesize:
path: "{{ filesize_testfile }}"
@ -117,6 +201,12 @@
size: 4.004MB
register: filesize_test_float_24
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
register: filesize_stat_float_24
- name: Assert that results are as expected
assert:
that:
@ -125,11 +215,28 @@
- filesize_test_float_23 is not changed
- filesize_test_float_24 is not changed
- filesize_test_float_22.cmd == filesize_test_float_21.cmd
- filesize_test_float_23.cmd is undefined
- filesize_test_float_24.cmd is undefined
- filesize_test_float_21.filesize.bytes == 4004000
- filesize_test_float_22.filesize.bytes == 4004000
- filesize_test_float_23.filesize.bytes == 4004000
- filesize_test_float_24.filesize.bytes == 4004000
- filesize_test_float_21.size_diff == 4004000 - 512513
- filesize_test_float_22.size_diff == 4004000 - 512513
- filesize_test_float_23.size_diff == 0
- filesize_test_float_24.size_diff == 0
- filesize_test_float_21.size == 512513
- filesize_test_float_22.size == 4004000
- filesize_test_float_23.size == 4004000
- filesize_test_float_24.size == 4004000
- filesize_stat_float_21.stat.size == 512513
- filesize_stat_float_22.stat.size == 4004000
- filesize_stat_float_24.stat.size == 4004000
- name: Remove test file

125
tests/integration/targets/filesize/tasks/sparse.yml
View file

@ -9,6 +9,13 @@
register: filesize_test_sparse_01
check_mode: yes
- name: Stat the file (should not exist)
stat:
path: "{{ filesize_testfile }}"
get_checksum: no
register: filesize_stat_sparse_01
- name: Create a huge sparse file of 4TB
filesize:
path: "{{ filesize_testfile }}"
@ -16,6 +23,13 @@
sparse: yes
register: filesize_test_sparse_02
- name: Stat the resulting file (should exist now)
stat:
path: "{{ filesize_testfile }}"
get_checksum: no
register: filesize_stat_sparse_02
- name: Create a huge sparse file of 4TB (4000GB) (check mode, idempotency)
filesize:
path: "{{ filesize_testfile }}"
@ -48,6 +62,13 @@
sparse: yes
register: filesize_test_sparse_06
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
get_checksum: no
register: filesize_stat_sparse_06
- name: Assert that results are as expected
assert:
that:
@ -58,14 +79,40 @@
- filesize_test_sparse_05 is not changed
- filesize_test_sparse_06 is not changed
- filesize_test_sparse_02.cmd == filesize_test_sparse_01.cmd
- filesize_test_sparse_03.cmd is undefined
- filesize_test_sparse_04.cmd is undefined
- filesize_test_sparse_05.cmd is undefined
- filesize_test_sparse_06.cmd is undefined
- filesize_test_sparse_01.filesize.bytes == 4*1000**4
- filesize_test_sparse_02.filesize.bytes == 4*1000**4
- filesize_test_sparse_03.filesize.bytes == 4*1000**4
- filesize_test_sparse_04.filesize.bytes == 4*1000**4
- filesize_test_sparse_05.filesize.bytes == 4*1000**4
- filesize_test_sparse_06.filesize.bytes == 4*1000**4
- filesize_test_sparse_01.size_diff == 4*1000**4
- filesize_test_sparse_02.size_diff == 4*1000**4
- filesize_test_sparse_03.size_diff == 0
- filesize_test_sparse_04.size_diff == 0
- filesize_test_sparse_05.size_diff == 0
- filesize_test_sparse_06.size_diff == 0
- filesize_test_sparse_01.state is undefined
- filesize_test_sparse_02.state in ["file"]
- filesize_test_sparse_01.size is undefined
- filesize_test_sparse_02.size == 4000000000000
- filesize_test_sparse_03.size == 4000000000000
- filesize_test_sparse_04.size == 4000000000000
- filesize_test_sparse_05.size == 4000000000000
- filesize_test_sparse_06.size == 4000000000000
- filesize_test_sparse_02.size == 4*1000**4
- filesize_test_sparse_03.size == 4*1000**4
- filesize_test_sparse_04.size == 4*1000**4
- filesize_test_sparse_05.size == 4*1000**4
- filesize_test_sparse_06.size == 4*1000**4
- not filesize_stat_sparse_01.stat.exists
- filesize_stat_sparse_02.stat.exists
- filesize_stat_sparse_02.stat.isreg
- filesize_stat_sparse_02.stat.size == 4*1000**4
- filesize_stat_sparse_06.stat.size == 4*1000**4
@ -77,6 +124,13 @@
register: filesize_test_sparse_11
check_mode: yes
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
get_checksum: no
register: filesize_stat_sparse_11
- name: Change sparse file size to 4TiB
filesize:
path: "{{ filesize_testfile }}"
@ -84,6 +138,13 @@
sparse: yes
register: filesize_test_sparse_12
- name: Stat the file again (should have grown)
stat:
path: "{{ filesize_testfile }}"
get_checksum: no
register: filesize_stat_sparse_12
- name: Change sparse file size to 4TiB (4096GiB) (check mode, idempotency)
filesize:
path: "{{ filesize_testfile }}"
@ -99,6 +160,13 @@
sparse: yes
register: filesize_test_sparse_14
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
get_checksum: no
register: filesize_stat_sparse_14
- name: Assert that results are as expected
assert:
that:
@ -107,11 +175,24 @@
- filesize_test_sparse_13 is not changed
- filesize_test_sparse_14 is not changed
- filesize_test_sparse_12.cmd == filesize_test_sparse_11.cmd
- filesize_test_sparse_13.cmd is undefined
- filesize_test_sparse_14.cmd is undefined
- filesize_test_sparse_11.size_diff == 398046511104
- filesize_test_sparse_12.size_diff == 398046511104
- filesize_test_sparse_13.size_diff == 0
- filesize_test_sparse_14.size_diff == 0
- filesize_test_sparse_11.size == 4000000000000
- filesize_test_sparse_12.size == 4398046511104
- filesize_test_sparse_13.size == 4398046511104
- filesize_test_sparse_14.size == 4398046511104
- filesize_stat_sparse_11.stat.size == 4000000000000
- filesize_stat_sparse_12.stat.size == 4398046511104
- filesize_stat_sparse_14.stat.size == 4398046511104
- name: Change sparse file size to 4.321TB (check mode)
@ -122,6 +203,13 @@
register: filesize_test_sparse_21
check_mode: yes
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
get_checksum: no
register: filesize_stat_sparse_21
- name: Change sparse file size to 4.321TB
filesize:
path: "{{ filesize_testfile }}"
@ -129,6 +217,13 @@
sparse: yes
register: filesize_test_sparse_22
- name: Stat the file again (should have been reduced)
stat:
path: "{{ filesize_testfile }}"
get_checksum: no
register: filesize_stat_sparse_22
- name: Change sparse file size to 4321×1GB (check mode, idempotency)
filesize:
path: "{{ filesize_testfile }}"
@ -146,6 +241,13 @@
sparse: yes
register: filesize_test_sparse_24
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_testfile }}"
get_checksum: no
register: filesize_stat_sparse_24
- name: Assert that results are as expected
assert:
that:
@ -154,11 +256,24 @@
- filesize_test_sparse_23 is not changed
- filesize_test_sparse_24 is not changed
- filesize_test_sparse_22.cmd == filesize_test_sparse_21.cmd
- filesize_test_sparse_23.cmd is undefined
- filesize_test_sparse_24.cmd is undefined
- filesize_test_sparse_21.size_diff == 4321*1000**3 - 4*1024**4
- filesize_test_sparse_22.size_diff == 4321*1000**3 - 4*1024**4
- filesize_test_sparse_23.size_diff == 0
- filesize_test_sparse_24.size_diff == 0
- filesize_test_sparse_21.size == 4398046511104
- filesize_test_sparse_22.size == 4321000000000
- filesize_test_sparse_23.size == 4321000000000
- filesize_test_sparse_24.size == 4321000000000
- filesize_stat_sparse_21.stat.size == 4398046511104
- filesize_stat_sparse_22.stat.size == 4321000000000
- filesize_stat_sparse_24.stat.size == 4321000000000
- name: Remove test file

22
tests/integration/targets/filesize/tasks/symlinks.yml
View file

@ -15,6 +15,8 @@
force: yes
follow: no
- name: Create a file with a size of 512 kB (512000 bytes) (check mode)
filesize:
path: "{{ filesize_testlink }}"
@ -28,6 +30,12 @@
size: "512 kB"
register: filesize_test_symlink_02
- name: Stat the resulting file (not the symlink)
stat:
path: "{{ filesize_test_symlink_02.path }}"
register: filesize_stat_symlink_02
- name: Create a file with a size of 500 KiB (512000 bytes) (check mode, idempotency)
filesize:
path: "{{ filesize_testlink }}"
@ -41,6 +49,12 @@
size: "500 KiB"
register: filesize_test_symlink_04
- name: Stat the file again (should remain the same)
stat:
path: "{{ filesize_test_symlink_04.path }}"
register: filesize_stat_symlink_04
- name: Assert that results are as expected
assert:
that:
@ -49,6 +63,10 @@
- filesize_test_symlink_03 is not changed
- filesize_test_symlink_04 is not changed
- filesize_test_symlink_02.cmd == filesize_test_symlink_01.cmd
- filesize_test_symlink_03.cmd is undefined
- filesize_test_symlink_04.cmd is undefined
- filesize_test_symlink_01.state is undefined
- filesize_test_symlink_02.state in ["file"]
- filesize_test_symlink_01.size is undefined
@ -56,6 +74,10 @@
- filesize_test_symlink_03.size == 512000
- filesize_test_symlink_04.size == 512000
- filesize_stat_symlink_02.stat.size == 512000
- filesize_stat_symlink_04.stat.size == 512000
- filesize_test_symlink_04.path == filesize_test_symlink_02.path
- filesize_test_symlink_04.path != filesize_testlink