catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CommonImportManagerTest.java

   1 package org.openecomp.sdc.be.components.impl;
   2
   3 import fj.data.Either;
   4 import org.apache.commons.lang3.tuple.ImmutablePair;
   5 import org.junit.Before;
   6 import org.junit.Test;
   7 import org.junit.runner.RunWith;
   8 import org.mockito.Mock;
   9 import org.mockito.Mockito;
  10 import org.mockito.junit.MockitoJUnitRunner;
  11 import org.openecomp.sdc.be.components.impl.CommonImportManager.ElementTypeEnum;
  12 import org.openecomp.sdc.be.dao.api.ActionStatus;
  13 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  14 import org.openecomp.sdc.be.impl.ComponentsUtils;
  15 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  16 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  17 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  18 import org.openecomp.sdc.exception.ResponseFormat;
  19 import org.openecomp.sdc.exception.ServiceException;
  20
  21 import java.util.Arrays;
  22 import java.util.List;
  23 import java.util.function.BiFunction;
  24 import java.util.function.Function;
  25
  26 import static org.junit.Assert.assertEquals;
  27 import static org.mockito.Mockito.*;
  28
  29 @RunWith(MockitoJUnitRunner.class)
  30 public class CommonImportManagerTest {
  31     private CommonImportManager commonImportManager;
  32     @Mock
  33     private ComponentsUtils componentsUtils;
  34     @Mock
  35     PropertyOperation propertyOperation;
  36     @Mock
  37     private TitanGenericDao titanGenericDao;
  38
  39     @Mock
  40     private Function<Object, Either<ActionStatus, ResponseFormat>> validator;
  41     @Mock
  42     private Function<Object, ImmutablePair<ElementTypeEnum, String>> elementInfoGetter;
  43     @Mock
  44     private Function<String, Either<Object, StorageOperationStatus>> elementFetcher;
  45     @Mock
  46     private Function<Object, Either<Object, StorageOperationStatus>> elementAdder;
  47     @Mock
  48     private BiFunction<Object, Object, Either<Object, StorageOperationStatus>> elementUpgrader;
  49
  50     @Before
  51     public void startUp() {
  52         commonImportManager = new CommonImportManager(componentsUtils, propertyOperation);
  53
  54         when(propertyOperation.getTitanGenericDao()).thenReturn(titanGenericDao);
  55     }
  56
  57     @Test
  58     public void testCreateElementTypesByDao_validationFailed() {
  59         Object type1 = new Object();
  60         List<Object> elementTypesToCreate = Arrays.asList(type1);
  61
  62         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
  63         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
  64
  65         ResponseFormat responseFormat = new ResponseFormat();
  66         responseFormat.setServiceException(new ServiceException());
  67         when(validator.apply(type1)).thenReturn(Either.right(responseFormat));
  68
  69
  70         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
  71
  72         verify(elementAdder, never()).apply(Mockito.any());
  73         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
  74         verify(titanGenericDao).rollback();
  75     }
  76
  77     @Test
  78     public void testCreateElementTypesByDao_RuntTimeExceptionInValidation() {
  79         Object type1 = new Object();
  80         List<Object> elementTypesToCreate = Arrays.asList(type1);
  81
  82         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
  83         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
  84         when(validator.apply(type1)).thenThrow(new RuntimeException("Test Exception"));
  85
  86         try {
  87             commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
  88         }
  89         catch(Exception skip) {
  90         }
  91
  92         verify(elementAdder, never()).apply(Mockito.any());
  93         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
  94         verify(titanGenericDao).rollback();
  95     }
  96
  97     @Test
  98     public void testCreateElementTypesByDao_capabilityTypeFetcherFailed() {
  99         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 100         List<Object> elementTypesToCreate = Arrays.asList(type1);
 101
 102         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 103         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 104
 105         when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
 106         when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 107         ResponseFormat responseFormat = new ResponseFormat();
 108         responseFormat.setServiceException(new ServiceException());
 109         when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
 110         when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.INVALID_CONTENT, type1)).thenReturn(responseFormat);
 111
 112
 113         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 114
 115         verify(elementAdder, never()).apply(Mockito.any());
 116         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 117         verify(titanGenericDao).rollback();
 118     }
 119
 120     @Test
 121     public void testCreateElementTypesByDao_capabilityTypeNotFound_AddFailed() {
 122         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 123         List<Object> elementTypesToCreate = Arrays.asList(type1);
 124
 125         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 126         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 127
 128         when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
 129         when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 130         when(elementAdder.apply(type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION));
 131
 132         ResponseFormat responseFormat = new ResponseFormat();
 133         responseFormat.setServiceException(new ServiceException());
 134         when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
 135         when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1)).thenReturn(responseFormat);
 136
 137
 138         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 139
 140         verify(elementAdder).apply(type1);
 141         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 142         verify(titanGenericDao).rollback();
 143     }
 144
 145
 146     @Test
 147     public void testCreateElementTypesByDao_capabilityTypeNotFound_AddSucceeded() {
 148         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 149         List<Object> elementTypesToCreate = Arrays.asList(type1);
 150
 151         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 152         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 153
 154         when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
 155         when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 156         when(elementAdder.apply(type1)).thenReturn(Either.left(type1));
 157
 158
 159         Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 160
 161         verify(elementAdder).apply(type1);
 162         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 163         verify(titanGenericDao).commit();
 164
 165         assertEquals(type1, result.left().value().get(0).getLeft());
 166         assertEquals(true, result.left().value().get(0).getRight());
 167     }
 168
 169     @Test
 170     public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeFailed() {
 171         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 172         CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
 173         List<Object> elementTypesToCreate = Arrays.asList(type1_1);
 174
 175         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 176         when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
 177
 178         when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
 179         when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
 180         when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION));
 181
 182         ResponseFormat responseFormat = new ResponseFormat();
 183         responseFormat.setServiceException(new ServiceException());
 184         when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
 185         when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1_1)).thenReturn(responseFormat);
 186
 187
 188         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 189
 190         verify(elementAdder, never()).apply(Mockito.any());
 191         verify(elementUpgrader).apply(type1_1, type1);
 192         verify(titanGenericDao).rollback();
 193     }
 194
 195     @Test
 196     public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeSucceeded() {
 197         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 198         CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
 199         List<Object> elementTypesToCreate = Arrays.asList(type1_1);
 200
 201         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 202         when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
 203
 204         when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
 205         when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
 206         when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.left(type1_1));
 207
 208         Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 209
 210         verify(elementAdder, never()).apply(Mockito.any());
 211         verify(elementUpgrader).apply(type1_1, type1);
 212         verify(titanGenericDao).commit();
 213
 214         assertEquals(type1_1, result.left().value().get(0).getLeft());
 215         assertEquals(true, result.left().value().get(0).getRight());
 216     }
 217
 218     @Test
 219     public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeAlreadyExists() {
 220         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 221         CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
 222         List<Object> elementTypesToCreate = Arrays.asList(type1_1);
 223
 224         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 225         when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
 226
 227         when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
 228         when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
 229         when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.OK));
 230
 231         Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 232
 233         verify(elementAdder, never()).apply(Mockito.any());
 234         verify(elementUpgrader).apply(type1_1, type1);
 235         verify(titanGenericDao).commit();
 236
 237         assertEquals(type1_1, result.left().value().get(0).getLeft());
 238         assertEquals(false, result.left().value().get(0).getRight());
 239     }
 240
 241
 242 }