storage: test full device write

With most test now writing only a small amount of data to the devices,
we need this new test to validate that we can write on the whole
device.

Signed-off-by: Gaëtan Lehmann <gaetan.lehmann@vates.tech>

Author: glehmann

tests/storage/__init__.py

@@ -4,6 +4,7 @@
     XVACompression,
     coalesce_integrity,
     cold_migration_then_come_back,
+    full_vdi_write,
     install_randstream,
     live_storage_migration_then_come_back,
     randstream,

tests/storage/ext/test_ext_sr.py

@@ -16,6 +16,7 @@
     ImageFormat,
     XVACompression,
     coalesce_integrity,
+    full_vdi_write,
     try_to_create_sr_with_missing_device,
     vdi_export_import,
     vdi_is_open,
@@ -101,6 +102,10 @@ def test_vdi_export_import(self, storage_test_vm: VM, ext_sr: SR, image_format:
                                defer: Defer) -> None:
         vdi_export_import(storage_test_vm, ext_sr, image_format, temp_large_dir, defer)
 
+    @pytest.mark.small_vm
+    def test_full_vdi_write(self, storage_test_vm: VM, vdi_on_ext_sr: VDI, defer: Defer):
+        full_vdi_write(storage_test_vm, vdi_on_ext_sr, defer)
+
     # *** tests with reboots (longer tests).
 
     @pytest.mark.small_vm

tests/storage/lvm/test_lvm_sr.py

@@ -16,6 +16,7 @@
     ImageFormat,
     XVACompression,
     coalesce_integrity,
+    full_vdi_write,
     try_to_create_sr_with_missing_device,
     vdi_export_import,
     vdi_is_open,
@@ -147,6 +148,10 @@ def test_failing_resize_on_inflate_after_setSizePhys(
     def test_coalesce(self, storage_test_vm: VM, vdi_on_lvm_sr: VDI, vdi_op: CoalesceOperation, defer: Defer) -> None:
         coalesce_integrity(storage_test_vm, vdi_on_lvm_sr, vdi_op, defer)
 
+    @pytest.mark.small_vm
+    def test_full_vdi_write(self, storage_test_vm: VM, vdi_on_lvm_sr: VDI, defer: Defer):
+        full_vdi_write(storage_test_vm, vdi_on_lvm_sr, defer)
+
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
     def test_xva_export_import(self, vm_on_lvm_sr: VM, compression: XVACompression, temp_large_dir: str, defer: Defer) \

tests/storage/lvmoiscsi/test_lvmoiscsi_sr.py

@@ -10,6 +10,7 @@
     ImageFormat,
     XVACompression,
     coalesce_integrity,
+    full_vdi_write,
     vdi_export_import,
     vdi_is_open,
     xva_export_import,
@@ -73,6 +74,10 @@ def test_coalesce(self, storage_test_vm: 'VM', vdi_on_lvmoiscsi_sr: 'VDI', vdi_o
                       defer: Defer) -> None:
         coalesce_integrity(storage_test_vm, vdi_on_lvmoiscsi_sr, vdi_op, defer)
 
+    @pytest.mark.small_vm
+    def test_full_vdi_write(self, storage_test_vm: VM, vdi_on_lvmoiscsi_sr: VDI, defer: Defer):
+        full_vdi_write(storage_test_vm, vdi_on_lvmoiscsi_sr, defer)
+
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
     def test_xva_export_import(self, vm_on_lvmoiscsi_sr: VM, compression: XVACompression, temp_large_dir: str,

tests/storage/nfs/test_nfs_sr.py

@@ -13,6 +13,7 @@
     ImageFormat,
     XVACompression,
     coalesce_integrity,
+    full_vdi_write,
     vdi_export_import,
     vdi_is_open,
     xva_export_import,
@@ -119,6 +120,10 @@ def test_snapshot(self, dispatch_nfs: VM) -> None:
     def test_coalesce(self, storage_test_vm: VM, dispatch_nfs: VDI, vdi_op: CoalesceOperation, defer: Defer) -> None:
         coalesce_integrity(storage_test_vm, dispatch_nfs, vdi_op, defer)
 
+    @pytest.mark.small_vm
+    def test_full_vdi_write(self, storage_test_vm: VM, vdi_on_nfs_sr: VDI, defer: Defer):
+        full_vdi_write(storage_test_vm, vdi_on_nfs_sr, defer)
+
     @pytest.mark.small_vm
     # Make sure this fixture is called before the parametrized one
     @pytest.mark.usefixtures('vm_ref')

tests/storage/storage.py

@@ -335,3 +335,14 @@ def vdi_export_import(vm: VM, sr: SR, image_format: ImageFormat, temp_large_dir:
     dev = f'/dev/{vbd.param_get("device")}'
 
     validate_partially_populated_device(vm, dev, config.volume_size, checksums)
+
+def full_vdi_write(vm: VM, vdi: VDI, defer: Defer):
+    vdi.get_virtual_size()
+    vbd = vm.connect_vdi(vdi)
+    defer(lambda: vm.disconnect_vdi(vdi))
+
+    dev = f'/dev/{vbd.param_get("device")}'
+    install_randstream(vm)
+
+    checksum = randstream(vm, f'generate {dev}')
+    randstream(vm, f'validate --expected-checksum {checksum} {dev}')

tests/storage/xfs/test_xfs_sr.py

@@ -16,6 +16,7 @@
     ImageFormat,
     XVACompression,
     coalesce_integrity,
+    full_vdi_write,
     vdi_export_import,
     vdi_is_open,
     xva_export_import,
@@ -107,6 +108,10 @@ def test_snapshot(self, vm_on_xfs_sr: VM) -> None:
     def test_coalesce(self, storage_test_vm: VM, vdi_on_xfs_sr: VDI, vdi_op: CoalesceOperation, defer: Defer) -> None:
         coalesce_integrity(storage_test_vm, vdi_on_xfs_sr, vdi_op, defer)
 
+    @pytest.mark.small_vm
+    def test_full_vdi_write(self, storage_test_vm: VM, vdi_on_xfs_sr: VDI, defer: Defer):
+        full_vdi_write(storage_test_vm, vdi_on_xfs_sr, defer)
+
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
     def test_xva_export_import(self, vm_on_xfs_sr: VM, compression: XVACompression, temp_large_dir: str, defer: Defer) \

tests/storage/zfs/test_zfs_sr.py

@@ -16,6 +16,7 @@
     ImageFormat,
     XVACompression,
     coalesce_integrity,
+    full_vdi_write,
     vdi_export_import,
     vdi_is_open,
     xva_export_import,
@@ -104,6 +105,10 @@ def test_snapshot(self, vm_on_zfs_sr: VM) -> None:
     def test_coalesce(self, storage_test_vm: VM, vdi_on_zfs_sr: VDI, vdi_op: CoalesceOperation, defer: Defer) -> None:
         coalesce_integrity(storage_test_vm, vdi_on_zfs_sr, vdi_op, defer)
 
+    @pytest.mark.small_vm
+    def test_full_vdi_write(self, storage_test_vm: VM, vdi_on_zfs_sr: VDI, defer: Defer):
+        full_vdi_write(storage_test_vm, vdi_on_zfs_sr, defer)
+
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
     def test_xva_export_import(self, vm_on_zfs_sr: VM, compression: XVACompression, temp_large_dir: str, defer: Defer) \

tests/storage/zfsvol/test_zfsvol_sr.py

@@ -15,6 +15,7 @@
     ImageFormat,
     XVACompression,
     coalesce_integrity,
+    full_vdi_write,
     vdi_export_import,
     xva_export_import,
 )
@@ -78,6 +79,10 @@ def test_coalesce(self, storage_test_vm: VM, vdi_on_zfsvol_sr: VDI, vdi_op: Coal
             -> None:
         coalesce_integrity(storage_test_vm, vdi_on_zfsvol_sr, vdi_op, defer)
 
+    @pytest.mark.small_vm
+    def test_full_vdi_write(self, storage_test_vm: VM, vdi_on_zfsvol_sr: VDI, defer: Defer):
+        full_vdi_write(storage_test_vm, vdi_on_zfsvol_sr, defer)
+
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
     def test_xva_export_import(self, vm_on_zfsvol_sr: VM, compression: XVACompression, temp_large_dir: str,