refactor tests

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

changelogs/fragments/148_new_module_filesize.yml

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

plugins/modules/filesize.py

@@ -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
+      - When the I(size) value is bigger than the current file size, bytes are
-        be appended to the file without truncating it, i.e. without modifying
+        appended to the file without truncating it, in other words, without
-        the existing bytes of the file.
+        modifying the existing bytes of the file.
-      - When the I(size) value is smaller than the current file size, it will
+      - When the I(size) value is smaller than the current file size, it is
-        be truncated to the requested value without modifying bytes before this
+        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
+      - If not set, the size of blocks is guessed from the OS and commonly
-        result in C(512) or C(4096) bytes, that will be used internally by the
+        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
+      - Whether or not to overwrite the file if it exists, in other words, to
-        from 0. When C(true), the module is not idempotent.
+        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
 '''
 

tests/integration/targets/filesize/tasks/basics.yml

@@ -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_11.size_diff == 57000
-      - filesize_test_basic_12.size == 57000
+      - filesize_test_basic_12.size_diff == 57000
-      - filesize_test_basic_13.size == 57000
+      - filesize_test_basic_13.size_diff == 0
-      - filesize_test_basic_14.size == 57000
+      - 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_41.size_diff == 57000 - 2*1024**2
-      - filesize_test_basic_42.size == 57000
+      - filesize_test_basic_42.size_diff == 57000 - 2*1024**2
-      - filesize_test_basic_43.size == 57000
+      - filesize_test_basic_43.size_diff == 0
-      - filesize_test_basic_44.size == 57000
+      - filesize_test_basic_44.size_diff == 0
 
-      - filesize_test_basic_stat_03.stat.checksum == filesize_test_checksum
+      - filesize_stat_basic_41.stat.size == 2*1024**2
-      - filesize_test_basic_stat_04.stat.checksum == filesize_test_checksum
+      - 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
 
 
 

tests/integration/targets/filesize/tasks/floats.yml

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

tests/integration/targets/filesize/tasks/sparse.yml

@@ -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_02.size == 4*1000**4
-      - filesize_test_sparse_03.size == 4000000000000
+      - filesize_test_sparse_03.size == 4*1000**4
-      - filesize_test_sparse_04.size == 4000000000000
+      - filesize_test_sparse_04.size == 4*1000**4
-      - filesize_test_sparse_05.size == 4000000000000
+      - filesize_test_sparse_05.size == 4*1000**4
-      - filesize_test_sparse_06.size == 4000000000000
+      - 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

tests/integration/targets/filesize/tasks/symlinks.yml

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