Skip to content

Commit ad217ed

Browse files
sureshanapartisureshanaparti
committed
unit tests
1 parent caeb499 commit ad217ed

File tree

1 file changed

+200
-0
lines changed

1 file changed

+200
-0
lines changed

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

Lines changed: 200 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,20 +21,34 @@
2121
import static org.mockito.Mockito.when;
2222

2323
import java.lang.reflect.Field;
24+
import java.lang.reflect.InvocationTargetException;
25+
import java.lang.reflect.Method;
2426

2527
import static org.mockito.Mockito.verify;
2628
import static org.mockito.Mockito.never;
2729
import static org.mockito.Mockito.any;
2830

31+
import com.cloud.storage.Storage;
2932
import com.cloud.storage.StorageManager;
3033
import com.cloud.storage.StoragePool;
34+
import org.apache.cloudstack.engine.subsystem.api.storage.DataObject;
35+
import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
36+
import org.apache.cloudstack.engine.subsystem.api.storage.ClusterScope;
37+
import org.apache.cloudstack.engine.subsystem.api.storage.HostScope;
38+
import org.apache.cloudstack.engine.subsystem.api.storage.StorageCacheManager;
39+
import org.apache.cloudstack.engine.subsystem.api.storage.ZoneScope;
3140
import org.apache.cloudstack.framework.config.ConfigKey;
41+
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
42+
import org.apache.cloudstack.storage.image.store.TemplateObject;
3243
import org.apache.cloudstack.storage.to.PrimaryDataStoreTO;
44+
import org.apache.cloudstack.storage.volume.VolumeObject;
45+
import org.junit.Assert;
3346
import org.junit.Before;
3447
import org.junit.Test;
3548
import org.junit.runner.RunWith;
3649
import org.mockito.InjectMocks;
3750
import org.mockito.Mock;
51+
import org.mockito.Mockito;
3852
import org.mockito.Spy;
3953
import org.mockito.junit.MockitoJUnitRunner;
4054

@@ -57,6 +71,10 @@ public class AncientDataMotionStrategyTest {
5771
StorageManager storageManager;
5872
@Mock
5973
StoragePool storagePool;
74+
@Mock
75+
StorageCacheManager cacheMgr;
76+
@Mock
77+
ConfigurationDao configDao;
6078

6179
private static final long POOL_ID = 1l;
6280
private static final Boolean FULL_CLONE_FLAG = true;
@@ -88,4 +106,186 @@ public void testAddFullCloneFlagOnNotVmwareDest(){
88106
verify(dataStoreTO, never()).setFullCloneFlag(any(Boolean.class));
89107
}
90108

109+
@Test
110+
public void testCanBypassSecondaryStorageForDirectDownload() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
111+
VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
112+
Mockito.doReturn(true).when(srcVolumeInfo).isDirectDownload();
113+
114+
VolumeObject destVolumeInfo = Mockito.spy(new VolumeObject());
115+
116+
Method method;
117+
method = AncientDataMotionStrategy.class.getDeclaredMethod("canBypassSecondaryStorage", DataObject.class, DataObject.class);
118+
method.setAccessible(true);
119+
boolean canBypassSecondaryStorage = (boolean) method.invoke(strategy, srcVolumeInfo, destVolumeInfo);
120+
Assert.assertTrue(canBypassSecondaryStorage);
121+
}
122+
123+
@Test
124+
public void testCanBypassSecondaryStorageForUnsupportedDataObject() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
125+
VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
126+
127+
TemplateObject destTemplateInfo = Mockito.spy(new TemplateObject());
128+
129+
Method method;
130+
method = AncientDataMotionStrategy.class.getDeclaredMethod("canBypassSecondaryStorage", DataObject.class, DataObject.class);
131+
method.setAccessible(true);
132+
boolean canBypassSecondaryStorage = (boolean) method.invoke(strategy, srcVolumeInfo, destTemplateInfo);
133+
Assert.assertFalse(canBypassSecondaryStorage);
134+
}
135+
136+
@Test
137+
public void testCanBypassSecondaryStorageForUnsupportedSrcPoolType() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
138+
VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
139+
DataStore srcDataStore = Mockito.mock(DataStore.class);
140+
Mockito.doReturn(new ZoneScope(1L)).when(srcDataStore).getScope();
141+
Mockito.doReturn(srcDataStore).when(srcVolumeInfo).getDataStore();
142+
Mockito.doReturn(Storage.StoragePoolType.PowerFlex).when(srcVolumeInfo).getStoragePoolType();
143+
144+
VolumeObject destVolumeInfo = Mockito.spy(new VolumeObject());
145+
DataStore destDataStore = Mockito.mock(DataStore.class);
146+
Mockito.doReturn(new ZoneScope(1L)).when(destDataStore).getScope();
147+
Mockito.doReturn(destDataStore).when(destVolumeInfo).getDataStore();
148+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(destVolumeInfo).getStoragePoolType();
149+
150+
Method method;
151+
method = AncientDataMotionStrategy.class.getDeclaredMethod("canBypassSecondaryStorage", DataObject.class, DataObject.class);
152+
method.setAccessible(true);
153+
boolean canBypassSecondaryStorage = (boolean) method.invoke(strategy, srcVolumeInfo, destVolumeInfo);
154+
Assert.assertFalse(canBypassSecondaryStorage);
155+
}
156+
157+
@Test
158+
public void testCanBypassSecondaryStorageForUnsupportedDestPoolType() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
159+
VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
160+
DataStore srcDataStore = Mockito.mock(DataStore.class);
161+
Mockito.doReturn(new ZoneScope(1L)).when(srcDataStore).getScope();
162+
Mockito.doReturn(srcDataStore).when(srcVolumeInfo).getDataStore();
163+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(srcVolumeInfo).getStoragePoolType();
164+
165+
VolumeObject destVolumeInfo = Mockito.spy(new VolumeObject());
166+
DataStore destDataStore = Mockito.mock(DataStore.class);
167+
Mockito.doReturn(new ZoneScope(1L)).when(destDataStore).getScope();
168+
Mockito.doReturn(destDataStore).when(destVolumeInfo).getDataStore();
169+
Mockito.doReturn(Storage.StoragePoolType.Iscsi).when(destVolumeInfo).getStoragePoolType();
170+
171+
Method method;
172+
method = AncientDataMotionStrategy.class.getDeclaredMethod("canBypassSecondaryStorage", DataObject.class, DataObject.class);
173+
method.setAccessible(true);
174+
boolean canBypassSecondaryStorage = (boolean) method.invoke(strategy, srcVolumeInfo, destVolumeInfo);
175+
Assert.assertFalse(canBypassSecondaryStorage);
176+
}
177+
178+
@Test
179+
public void testCanBypassSecondaryStorageWithZoneWideNFSPoolsInSameZone() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
180+
VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
181+
DataStore srcDataStore = Mockito.mock(DataStore.class);
182+
Mockito.doReturn(new ZoneScope(1L)).when(srcDataStore).getScope();
183+
Mockito.doReturn(srcDataStore).when(srcVolumeInfo).getDataStore();
184+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(srcVolumeInfo).getStoragePoolType();
185+
186+
VolumeObject destVolumeInfo = Mockito.spy(new VolumeObject());
187+
DataStore destDataStore = Mockito.mock(DataStore.class);
188+
Mockito.doReturn(new ZoneScope(1L)).when(destDataStore).getScope();
189+
Mockito.doReturn(destDataStore).when(destVolumeInfo).getDataStore();
190+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(destVolumeInfo).getStoragePoolType();
191+
192+
Method method;
193+
method = AncientDataMotionStrategy.class.getDeclaredMethod("canBypassSecondaryStorage", DataObject.class, DataObject.class);
194+
method.setAccessible(true);
195+
boolean canBypassSecondaryStorage = (boolean) method.invoke(strategy, srcVolumeInfo, destVolumeInfo);
196+
Assert.assertTrue(canBypassSecondaryStorage);
197+
}
198+
199+
@Test
200+
public void testCanBypassSecondaryStorageWithClusterWideNFSPoolsInSameCluster() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
201+
VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
202+
DataStore srcDataStore = Mockito.mock(DataStore.class);
203+
Mockito.doReturn(new ClusterScope(5L, 2L, 1L)).when(srcDataStore).getScope();
204+
Mockito.doReturn(srcDataStore).when(srcVolumeInfo).getDataStore();
205+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(srcVolumeInfo).getStoragePoolType();
206+
207+
VolumeObject destVolumeInfo = Mockito.spy(new VolumeObject());
208+
DataStore destDataStore = Mockito.mock(DataStore.class);
209+
Mockito.doReturn(new ClusterScope(5L, 2L, 1L)).when(destDataStore).getScope();
210+
Mockito.doReturn(destDataStore).when(destVolumeInfo).getDataStore();
211+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(destVolumeInfo).getStoragePoolType();
212+
213+
Method method;
214+
method = AncientDataMotionStrategy.class.getDeclaredMethod("canBypassSecondaryStorage", DataObject.class, DataObject.class);
215+
method.setAccessible(true);
216+
boolean canBypassSecondaryStorage = (boolean) method.invoke(strategy, srcVolumeInfo, destVolumeInfo);
217+
Assert.assertTrue(canBypassSecondaryStorage);
218+
}
219+
220+
@Test
221+
public void testCanBypassSecondaryStorageWithLocalAndClusterWideNFSPoolsInSameCluster() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
222+
VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
223+
DataStore srcDataStore = Mockito.mock(DataStore.class);
224+
Mockito.doReturn(new HostScope(1L, 1L, 1L)).when(srcDataStore).getScope();
225+
Mockito.doReturn(srcDataStore).when(srcVolumeInfo).getDataStore();
226+
Mockito.doReturn(Storage.StoragePoolType.Filesystem).when(srcVolumeInfo).getStoragePoolType();
227+
228+
VolumeObject destVolumeInfo = Mockito.spy(new VolumeObject());
229+
DataStore destDataStore = Mockito.mock(DataStore.class);
230+
Mockito.doReturn(new ClusterScope(1L, 1L, 1L)).when(destDataStore).getScope();
231+
Mockito.doReturn(destDataStore).when(destVolumeInfo).getDataStore();
232+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(destVolumeInfo).getStoragePoolType();
233+
234+
Method method;
235+
method = AncientDataMotionStrategy.class.getDeclaredMethod("canBypassSecondaryStorage", DataObject.class, DataObject.class);
236+
method.setAccessible(true);
237+
boolean canBypassSecondaryStorage = (boolean) method.invoke(strategy, srcVolumeInfo, destVolumeInfo);
238+
Assert.assertTrue(canBypassSecondaryStorage);
239+
240+
canBypassSecondaryStorage = (boolean) method.invoke(strategy, destVolumeInfo, srcVolumeInfo);
241+
Assert.assertTrue(canBypassSecondaryStorage);
242+
}
243+
244+
@Test
245+
public void testCanBypassSecondaryStorageWithLocalAndZoneWideNFSPoolsInSameZone() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
246+
VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
247+
DataStore srcDataStore = Mockito.mock(DataStore.class);
248+
Mockito.doReturn(new HostScope(1L, 1L, 1L)).when(srcDataStore).getScope();
249+
Mockito.doReturn(srcDataStore).when(srcVolumeInfo).getDataStore();
250+
Mockito.doReturn(Storage.StoragePoolType.Filesystem).when(srcVolumeInfo).getStoragePoolType();
251+
252+
VolumeObject destVolumeInfo = Mockito.spy(new VolumeObject());
253+
DataStore destDataStore = Mockito.mock(DataStore.class);
254+
Mockito.doReturn(new ZoneScope(1L)).when(destDataStore).getScope();
255+
Mockito.doReturn(destDataStore).when(destVolumeInfo).getDataStore();
256+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(destVolumeInfo).getStoragePoolType();
257+
258+
Method method;
259+
method = AncientDataMotionStrategy.class.getDeclaredMethod("canBypassSecondaryStorage", DataObject.class, DataObject.class);
260+
method.setAccessible(true);
261+
boolean canBypassSecondaryStorage = (boolean) method.invoke(strategy, srcVolumeInfo, destVolumeInfo);
262+
Assert.assertTrue(canBypassSecondaryStorage);
263+
264+
canBypassSecondaryStorage = (boolean) method.invoke(strategy, destVolumeInfo, srcVolumeInfo);
265+
Assert.assertTrue(canBypassSecondaryStorage);
266+
}
267+
268+
@Test
269+
public void testCanBypassSecondaryStorageWithClusterWideNFSAndZoneWideNFSPoolsInSameZone() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
270+
VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
271+
DataStore srcDataStore = Mockito.mock(DataStore.class);
272+
Mockito.doReturn(new ClusterScope(5L, 2L, 1L)).when(srcDataStore).getScope();
273+
Mockito.doReturn(srcDataStore).when(srcVolumeInfo).getDataStore();
274+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(srcVolumeInfo).getStoragePoolType();
275+
276+
VolumeObject destVolumeInfo = Mockito.spy(new VolumeObject());
277+
DataStore destDataStore = Mockito.mock(DataStore.class);
278+
Mockito.doReturn(new ZoneScope(1L)).when(destDataStore).getScope();
279+
Mockito.doReturn(destDataStore).when(destVolumeInfo).getDataStore();
280+
Mockito.doReturn(Storage.StoragePoolType.NetworkFilesystem).when(destVolumeInfo).getStoragePoolType();
281+
282+
Method method;
283+
method = AncientDataMotionStrategy.class.getDeclaredMethod("canBypassSecondaryStorage", DataObject.class, DataObject.class);
284+
method.setAccessible(true);
285+
boolean canBypassSecondaryStorage = (boolean) method.invoke(strategy, srcVolumeInfo, destVolumeInfo);
286+
Assert.assertTrue(canBypassSecondaryStorage);
287+
288+
canBypassSecondaryStorage = (boolean) method.invoke(strategy, destVolumeInfo, srcVolumeInfo);
289+
Assert.assertTrue(canBypassSecondaryStorage);
290+
}
91291
}

0 commit comments

Comments
 (0)