1 files changed, 242 insertions, 0 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CommonImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CommonImportManagerTest.java
new file mode 100644
index 0000000000..15eeb31f48
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CommonImportManagerTest.java
@@ -0,0 +1,242 @@
+package org.openecomp.sdc.be.components.impl;
+
+import fj.data.Either;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.openecomp.sdc.be.components.impl.CommonImportManager.ElementTypeEnum;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.openecomp.sdc.exception.ResponseFormat;
+import org.openecomp.sdc.exception.ServiceException;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class CommonImportManagerTest {
+    private CommonImportManager commonImportManager;
+    @Mock
+    private ComponentsUtils componentsUtils;
+    @Mock
+    PropertyOperation propertyOperation;
+    @Mock
+    private TitanGenericDao titanGenericDao;
+    
+    @Mock
+    private Function<Object, Either<ActionStatus, ResponseFormat>> validator;
+    @Mock
+    private Function<Object, ImmutablePair<ElementTypeEnum, String>> elementInfoGetter;
+    @Mock
+    private Function<String, Either<Object, StorageOperationStatus>> elementFetcher;
+    @Mock
+    private Function<Object, Either<Object, StorageOperationStatus>> elementAdder;
+    @Mock
+    private BiFunction<Object, Object, Either<Object, StorageOperationStatus>> elementUpgrader;
+    
+    @Before
+    public void startUp() {
+        commonImportManager = new CommonImportManager(componentsUtils, propertyOperation);
+        
+        when(propertyOperation.getTitanGenericDao()).thenReturn(titanGenericDao);
+    }
+    
+    @Test
+    public void testCreateElementTypesByDao_validationFailed() {
+        Object type1 = new Object();
+        List<Object> elementTypesToCreate = Arrays.asList(type1);
+        
+        ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); 
+        when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
+        
+        ResponseFormat responseFormat = new ResponseFormat();
+        responseFormat.setServiceException(new ServiceException());
+        when(validator.apply(type1)).thenReturn(Either.right(responseFormat));
+        
+        
+        commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
+        
+        verify(elementAdder, never()).apply(Mockito.any());
+        verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
+        verify(titanGenericDao).rollback();
+    }
+    
+    @Test
+    public void testCreateElementTypesByDao_RuntTimeExceptionInValidation() {
+        Object type1 = new Object();
+        List<Object> elementTypesToCreate = Arrays.asList(type1);
+        
+        ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); 
+        when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
+        when(validator.apply(type1)).thenThrow(new RuntimeException("Test Exception"));
+        
+        try {
+            commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
+        }
+        catch(Exception skip) {
+        }
+        
+        verify(elementAdder, never()).apply(Mockito.any());
+        verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
+        verify(titanGenericDao).rollback();
+    }
+    
+    @Test
+    public void testCreateElementTypesByDao_capabilityTypeFetcherFailed() {
+        CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
+        List<Object> elementTypesToCreate = Arrays.asList(type1);
+        
+        ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); 
+        when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
+        
+        when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
+        when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+        ResponseFormat responseFormat = new ResponseFormat();
+        responseFormat.setServiceException(new ServiceException());
+        when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
+        when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.INVALID_CONTENT, type1)).thenReturn(responseFormat);
+        
+        
+        commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
+        
+        verify(elementAdder, never()).apply(Mockito.any());
+        verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
+        verify(titanGenericDao).rollback();
+    }
+    
+    @Test
+    public void testCreateElementTypesByDao_capabilityTypeNotFound_AddFailed() {
+        CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
+        List<Object> elementTypesToCreate = Arrays.asList(type1);
+        
+        ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); 
+        when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
+        
+        when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
+        when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+        when(elementAdder.apply(type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION));
+        
+        ResponseFormat responseFormat = new ResponseFormat();
+        responseFormat.setServiceException(new ServiceException());
+        when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
+        when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1)).thenReturn(responseFormat);
+
+        
+        commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
+
+        verify(elementAdder).apply(type1);
+        verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
+        verify(titanGenericDao).rollback();
+    }
+
+    
+    @Test
+    public void testCreateElementTypesByDao_capabilityTypeNotFound_AddSucceeded() {
+        CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
+        List<Object> elementTypesToCreate = Arrays.asList(type1);
+        
+        ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); 
+        when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
+        
+        when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
+        when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+        when(elementAdder.apply(type1)).thenReturn(Either.left(type1));
+        
+        
+        Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
+
+        verify(elementAdder).apply(type1);
+        verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
+        verify(titanGenericDao).commit();
+        
+        assertEquals(type1, result.left().value().get(0).getLeft());
+        assertEquals(true, result.left().value().get(0).getRight());
+    }
+    
+    @Test
+    public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeFailed() {
+        CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
+        CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
+        List<Object> elementTypesToCreate = Arrays.asList(type1_1);
+        
+        ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); 
+        when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
+        
+        when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
+        when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
+        when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION));
+        
+        ResponseFormat responseFormat = new ResponseFormat();
+        responseFormat.setServiceException(new ServiceException());
+        when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
+        when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1_1)).thenReturn(responseFormat);
+
+        
+        commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
+
+        verify(elementAdder, never()).apply(Mockito.any());
+        verify(elementUpgrader).apply(type1_1, type1);
+        verify(titanGenericDao).rollback();
+    }
+    
+    @Test
+    public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeSucceeded() {
+        CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
+        CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
+        List<Object> elementTypesToCreate = Arrays.asList(type1_1);
+        
+        ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); 
+        when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
+        
+        when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
+        when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
+        when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.left(type1_1));
+        
+        Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
+
+        verify(elementAdder, never()).apply(Mockito.any());
+        verify(elementUpgrader).apply(type1_1, type1);
+        verify(titanGenericDao).commit();
+        
+        assertEquals(type1_1, result.left().value().get(0).getLeft());
+        assertEquals(true, result.left().value().get(0).getRight());
+    }
+    
+    @Test
+    public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeAlreadyExists() {
+        CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
+        CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
+        List<Object> elementTypesToCreate = Arrays.asList(type1_1);
+        
+        ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); 
+        when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
+        
+        when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
+        when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
+        when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.OK));
+        
+        Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
+
+        verify(elementAdder, never()).apply(Mockito.any());
+        verify(elementUpgrader).apply(type1_1, type1);
+        verify(titanGenericDao).commit();
+        
+        assertEquals(type1_1, result.left().value().get(0).getLeft());
+        assertEquals(false, result.left().value().get(0).getRight());
+    }
+
+
+}