add more tests

Author: Pearl1594

engine/storage/datamotion/src/test/java/org/apache/cloudstack/storage/motion/StorageSystemDataMotionStrategyTest.java

@@ -369,4 +369,286 @@ public void validateIsStoragePoolTypeInListReturnsFalse() {
 
         assertFalse(strategy.isStoragePoolTypeInList(StoragePoolType.SharedMountPoint, listTypes));
     }
+
+    /**
+     * Test updateMigrateDiskInfoForBlockDevice with CLVM destination pool
+     * Should set driver type to RAW for CLVM
+     */
+    @Test
+    public void testUpdateMigrateDiskInfoForBlockDevice_ClvmDestination() {
+        MigrateCommand.MigrateDiskInfo originalDiskInfo = new MigrateCommand.MigrateDiskInfo(
+                "serial123",
+                MigrateCommand.MigrateDiskInfo.DiskType.FILE,
+                MigrateCommand.MigrateDiskInfo.DriverType.QCOW2,
+                MigrateCommand.MigrateDiskInfo.Source.FILE,
+                "/source/path",
+                null
+        );
+
+        StoragePoolVO destStoragePool = new StoragePoolVO();
+        destStoragePool.setPoolType(StoragePoolType.CLVM);
+
+        MigrateCommand.MigrateDiskInfo updatedDiskInfo = strategy.updateMigrateDiskInfoForBlockDevice(
+                originalDiskInfo, destStoragePool);
+
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.BLOCK, updatedDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.RAW, updatedDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.DEV, updatedDiskInfo.getSource());
+        Assert.assertEquals("serial123", updatedDiskInfo.getSerialNumber());
+        Assert.assertEquals("/source/path", updatedDiskInfo.getSourceText());
+    }
+
+    /**
+     * Test updateMigrateDiskInfoForBlockDevice with CLVM_NG destination pool
+     * Should set driver type to QCOW2 for CLVM_NG
+     */
+    @Test
+    public void testUpdateMigrateDiskInfoForBlockDevice_ClvmNgDestination() {
+        MigrateCommand.MigrateDiskInfo originalDiskInfo = new MigrateCommand.MigrateDiskInfo(
+                "serial456",
+                MigrateCommand.MigrateDiskInfo.DiskType.FILE,
+                MigrateCommand.MigrateDiskInfo.DriverType.RAW,
+                MigrateCommand.MigrateDiskInfo.Source.FILE,
+                "/source/path",
+                "/backing/path"
+        );
+
+        StoragePoolVO destStoragePool = new StoragePoolVO();
+        destStoragePool.setPoolType(StoragePoolType.CLVM_NG);
+
+        MigrateCommand.MigrateDiskInfo updatedDiskInfo = strategy.updateMigrateDiskInfoForBlockDevice(
+                originalDiskInfo, destStoragePool);
+
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.BLOCK, updatedDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.QCOW2, updatedDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.DEV, updatedDiskInfo.getSource());
+        Assert.assertEquals("serial456", updatedDiskInfo.getSerialNumber());
+        Assert.assertEquals("/source/path", updatedDiskInfo.getSourceText());
+        Assert.assertEquals("/backing/path", updatedDiskInfo.getBackingStoreText());
+    }
+
+    /**
+     * Test updateMigrateDiskInfoForBlockDevice with non-CLVM destination pool
+     * Should return original DiskInfo unchanged
+     */
+    @Test
+    public void testUpdateMigrateDiskInfoForBlockDevice_NonClvmDestination() {
+        MigrateCommand.MigrateDiskInfo originalDiskInfo = new MigrateCommand.MigrateDiskInfo(
+                "serial789",
+                MigrateCommand.MigrateDiskInfo.DiskType.FILE,
+                MigrateCommand.MigrateDiskInfo.DriverType.QCOW2,
+                MigrateCommand.MigrateDiskInfo.Source.FILE,
+                "/source/path",
+                null
+        );
+
+        StoragePoolVO destStoragePool = new StoragePoolVO();
+        destStoragePool.setPoolType(StoragePoolType.NetworkFilesystem);
+
+        MigrateCommand.MigrateDiskInfo updatedDiskInfo = strategy.updateMigrateDiskInfoForBlockDevice(
+                originalDiskInfo, destStoragePool);
+
+        Assert.assertSame(originalDiskInfo, updatedDiskInfo);
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.FILE, updatedDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.QCOW2, updatedDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.FILE, updatedDiskInfo.getSource());
+    }
+
+    /**
+     * Test supportStoragePoolType with CLVM and CLVM_NG types
+     */
+    @Test
+    public void testSupportStoragePoolType_ClvmTypes() {
+        assertTrue(strategy.supportStoragePoolType(StoragePoolType.CLVM, StoragePoolType.CLVM, StoragePoolType.CLVM_NG));
+        assertTrue(strategy.supportStoragePoolType(StoragePoolType.CLVM_NG, StoragePoolType.CLVM, StoragePoolType.CLVM_NG));
+
+        assertFalse(strategy.supportStoragePoolType(StoragePoolType.CLVM));
+        assertFalse(strategy.supportStoragePoolType(StoragePoolType.CLVM_NG));
+    }
+
+    /**
+     * Test configureMigrateDiskInfo with CLVM destination
+     */
+    @Test
+    public void testConfigureMigrateDiskInfo_ForClvm() {
+        VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn("/dev/vg/volume-path").when(srcVolumeInfo).getPath();
+
+        MigrateCommand.MigrateDiskInfo migrateDiskInfo = strategy.configureMigrateDiskInfo(
+                srcVolumeInfo, "/dev/vg/dest-path", null);
+
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.BLOCK, migrateDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.RAW, migrateDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.DEV, migrateDiskInfo.getSource());
+        Assert.assertEquals("/dev/vg/dest-path", migrateDiskInfo.getSourceText());
+        Assert.assertEquals("/dev/vg/volume-path", migrateDiskInfo.getSerialNumber());
+    }
+
+    /**
+     * Test configureMigrateDiskInfo with CLVM_NG destination and backing file
+     */
+    @Test
+    public void testConfigureMigrateDiskInfo_ForClvmNgWithBacking() {
+        VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn("/dev/vg/volume-path").when(srcVolumeInfo).getPath();
+
+        MigrateCommand.MigrateDiskInfo migrateDiskInfo = strategy.configureMigrateDiskInfo(
+                srcVolumeInfo, "/dev/vg/dest-path", "/dev/vg/backing-template");
+
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.BLOCK, migrateDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.RAW, migrateDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.DEV, migrateDiskInfo.getSource());
+        Assert.assertEquals("/dev/vg/dest-path", migrateDiskInfo.getSourceText());
+        Assert.assertEquals("/dev/vg/backing-template", migrateDiskInfo.getBackingStoreText());
+        Assert.assertEquals("/dev/vg/volume-path", migrateDiskInfo.getSerialNumber());
+    }
+
+    /**
+     * Test isStoragePoolTypeInList with CLVM types
+     */
+    @Test
+    public void testIsStoragePoolTypeInList_WithClvmTypes() {
+        StoragePoolType[] clvmTypes = new StoragePoolType[] {
+            StoragePoolType.CLVM,
+            StoragePoolType.CLVM_NG,
+            StoragePoolType.Filesystem
+        };
+
+        assertTrue(strategy.isStoragePoolTypeInList(StoragePoolType.CLVM, clvmTypes));
+        assertTrue(strategy.isStoragePoolTypeInList(StoragePoolType.CLVM_NG, clvmTypes));
+        assertTrue(strategy.isStoragePoolTypeInList(StoragePoolType.Filesystem, clvmTypes));
+        assertFalse(strategy.isStoragePoolTypeInList(StoragePoolType.NetworkFilesystem, clvmTypes));
+    }
+
+    /**
+     * Test supportStoragePoolType with mixed CLVM and NFS types
+     */
+    @Test
+    public void testSupportStoragePoolType_MixedClvmAndNfs() {
+        assertTrue(strategy.supportStoragePoolType(
+                StoragePoolType.CLVM,
+                StoragePoolType.CLVM,
+                StoragePoolType.CLVM_NG,
+                StoragePoolType.NetworkFilesystem
+        ));
+
+        assertTrue(strategy.supportStoragePoolType(
+                StoragePoolType.CLVM_NG,
+                StoragePoolType.CLVM,
+                StoragePoolType.CLVM_NG,
+                StoragePoolType.NetworkFilesystem
+        ));
+
+        assertTrue(strategy.supportStoragePoolType(
+                StoragePoolType.NetworkFilesystem,
+                StoragePoolType.CLVM,
+                StoragePoolType.CLVM_NG
+        ));
+    }
+
+    /**
+     * Test internalCanHandle with CLVM source and managed destination
+     */
+    @Test
+    public void testInternalCanHandle_ClvmSourceManagedDestination() {
+        VolumeObject volumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn(0L).when(volumeInfo).getPoolId();
+
+        DataStore ds = Mockito.spy(new PrimaryDataStoreImpl());
+
+        Map<VolumeInfo, DataStore> volumeMap = new HashMap<>();
+        volumeMap.put(volumeInfo, ds);
+
+        StoragePoolVO sourcePool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM).when(sourcePool).getPoolType();
+        Mockito.doReturn(true).when(sourcePool).isManaged();
+
+        Mockito.doReturn(sourcePool).when(primaryDataStoreDao).findById(0L);
+
+        StrategyPriority result = strategy.internalCanHandle(
+                volumeMap, new HostVO("srcHostUuid"), new HostVO("destHostUuid"));
+
+        Assert.assertEquals(StrategyPriority.HIGHEST, result);
+    }
+
+    /**
+     * Test internalCanHandle with CLVM_NG source and managed destination
+     */
+    @Test
+    public void testInternalCanHandle_ClvmNgSourceManagedDestination() {
+        VolumeObject volumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn(0L).when(volumeInfo).getPoolId();
+
+        DataStore ds = Mockito.spy(new PrimaryDataStoreImpl());
+
+        Map<VolumeInfo, DataStore> volumeMap = new HashMap<>();
+        volumeMap.put(volumeInfo, ds);
+
+        StoragePoolVO sourcePool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM_NG).when(sourcePool).getPoolType();
+        Mockito.doReturn(true).when(sourcePool).isManaged();
+
+        Mockito.doReturn(sourcePool).when(primaryDataStoreDao).findById(0L);
+
+        StrategyPriority result = strategy.internalCanHandle(
+                volumeMap, new HostVO("srcHostUuid"), new HostVO("destHostUuid"));
+
+        Assert.assertEquals(StrategyPriority.HIGHEST, result);
+    }
+
+    /**
+     * Test internalCanHandle with both CLVM source and CLVM_NG destination
+     */
+    @Test
+    public void testInternalCanHandle_ClvmToClvmNg() {
+        VolumeObject volumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn(0L).when(volumeInfo).getPoolId();
+
+        DataStore ds = Mockito.spy(new PrimaryDataStoreImpl());
+
+        Map<VolumeInfo, DataStore> volumeMap = new HashMap<>();
+        volumeMap.put(volumeInfo, ds);
+
+        StoragePoolVO sourcePool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM).when(sourcePool).getPoolType();
+        Mockito.doReturn(true).when(sourcePool).isManaged();
+
+        StoragePoolVO destPool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM_NG).when(destPool).getPoolType();
+
+        Mockito.doReturn(sourcePool).when(primaryDataStoreDao).findById(0L);
+
+        StrategyPriority result = strategy.internalCanHandle(
+                volumeMap, new HostVO("srcHostUuid"), new HostVO("destHostUuid"));
+
+        Assert.assertEquals(StrategyPriority.HIGHEST, result);
+    }
+
+    /**
+     * Test internalCanHandle with CLVM_NG to CLVM migration
+     */
+    @Test
+    public void testInternalCanHandle_ClvmNgToClvm() {
+        VolumeObject volumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn(0L).when(volumeInfo).getPoolId();
+
+        DataStore ds = Mockito.spy(new PrimaryDataStoreImpl());
+
+        Map<VolumeInfo, DataStore> volumeMap = new HashMap<>();
+        volumeMap.put(volumeInfo, ds);
+
+        StoragePoolVO sourcePool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM_NG).when(sourcePool).getPoolType();
+        Mockito.doReturn(true).when(sourcePool).isManaged();
+
+        StoragePoolVO destPool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM).when(destPool).getPoolType();
+
+        Mockito.doReturn(sourcePool).when(primaryDataStoreDao).findById(0L);
+
+        StrategyPriority result = strategy.internalCanHandle(
+                volumeMap, new HostVO("srcHostUuid"), new HostVO("destHostUuid"));
+
+        Assert.assertEquals(StrategyPriority.HIGHEST, result);
+    }
 }