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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import fj.data.Either;
  24 import org.apache.commons.lang3.tuple.ImmutablePair;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.junit.runner.RunWith;
  28 import org.mockito.Mock;
  29 import org.mockito.Mockito;
  30 import org.mockito.junit.MockitoJUnitRunner;
  31 import org.openecomp.sdc.be.components.impl.CommonImportManager.ElementTypeEnum;
  32 import org.openecomp.sdc.be.dao.api.ActionStatus;
  33 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  34 import org.openecomp.sdc.be.impl.ComponentsUtils;
  35 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  36 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  37 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  38 import org.openecomp.sdc.exception.ResponseFormat;
  39 import org.openecomp.sdc.exception.ServiceException;
  40
  41 import java.util.Arrays;
  42 import java.util.List;
  43 import java.util.function.BiFunction;
  44 import java.util.function.Function;
  45
  46 import static org.junit.Assert.assertEquals;
  47 import static org.mockito.Mockito.never;
  48 import static org.mockito.Mockito.verify;
  49 import static org.mockito.Mockito.when;
  50
  51 @RunWith(MockitoJUnitRunner.class)
  52 public class CommonImportManagerTest {
  53     private CommonImportManager commonImportManager;
  54     @Mock
  55     private ComponentsUtils componentsUtils;
  56     @Mock
  57     PropertyOperation propertyOperation;
  58     @Mock
  59     private JanusGraphGenericDao janusGraphGenericDao;
  60
  61     @Mock
  62     private Function<Object, Either<ActionStatus, ResponseFormat>> validator;
  63     @Mock
  64     private Function<Object, ImmutablePair<ElementTypeEnum, String>> elementInfoGetter;
  65     @Mock
  66     private Function<String, Either<Object, StorageOperationStatus>> elementFetcher;
  67     @Mock
  68     private Function<Object, Either<Object, StorageOperationStatus>> elementAdder;
  69     @Mock
  70     private BiFunction<Object, Object, Either<Object, StorageOperationStatus>> elementUpgrader;
  71
  72     @Before
  73     public void startUp() {
  74         commonImportManager = new CommonImportManager(componentsUtils, propertyOperation);
  75
  76         when(propertyOperation.getJanusGraphGenericDao()).thenReturn(janusGraphGenericDao);
  77     }
  78
  79     @Test
  80     public void testCreateElementTypesByDao_validationFailed() {
  81         Object type1 = new Object();
  82         List<Object> elementTypesToCreate = Arrays.asList(type1);
  83
  84         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
  85         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
  86
  87         ResponseFormat responseFormat = new ResponseFormat();
  88         responseFormat.setServiceException(new ServiceException());
  89         when(validator.apply(type1)).thenReturn(Either.right(responseFormat));
  90
  91
  92         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
  93
  94         verify(elementAdder, never()).apply(Mockito.any());
  95         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
  96         verify(janusGraphGenericDao).rollback();
  97     }
  98
  99     @Test
 100     public void testCreateElementTypesByDao_RuntTimeExceptionInValidation() {
 101         Object type1 = new Object();
 102         List<Object> elementTypesToCreate = Arrays.asList(type1);
 103
 104         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 105         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 106         when(validator.apply(type1)).thenThrow(new RuntimeException("Test Exception"));
 107
 108         try {
 109             commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 110         }
 111         catch(Exception skip) {
 112         }
 113
 114         verify(elementAdder, never()).apply(Mockito.any());
 115         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 116         verify(janusGraphGenericDao).rollback();
 117     }
 118
 119     @Test
 120     public void testCreateElementTypesByDao_capabilityTypeFetcherFailed() {
 121         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 122         List<Object> elementTypesToCreate = Arrays.asList(type1);
 123
 124         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 125         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 126
 127         when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
 128         when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 129         ResponseFormat responseFormat = new ResponseFormat();
 130         responseFormat.setServiceException(new ServiceException());
 131         when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
 132         when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.INVALID_CONTENT, type1)).thenReturn(responseFormat);
 133
 134
 135         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 136
 137         verify(elementAdder, never()).apply(Mockito.any());
 138         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 139         verify(janusGraphGenericDao).rollback();
 140     }
 141
 142     @Test
 143     public void testCreateElementTypesByDao_capabilityTypeNotFound_AddFailed() {
 144         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 145         List<Object> elementTypesToCreate = Arrays.asList(type1);
 146
 147         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 148         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 149
 150         when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
 151         when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 152         when(elementAdder.apply(type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION));
 153
 154         ResponseFormat responseFormat = new ResponseFormat();
 155         responseFormat.setServiceException(new ServiceException());
 156         when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
 157         when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1)).thenReturn(responseFormat);
 158
 159
 160         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 161
 162         verify(elementAdder).apply(type1);
 163         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 164         verify(janusGraphGenericDao).rollback();
 165     }
 166
 167
 168     @Test
 169     public void testCreateElementTypesByDao_capabilityTypeNotFound_AddSucceeded() {
 170         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 171         List<Object> elementTypesToCreate = Arrays.asList(type1);
 172
 173         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 174         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 175
 176         when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
 177         when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 178         when(elementAdder.apply(type1)).thenReturn(Either.left(type1));
 179
 180
 181         Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 182
 183         verify(elementAdder).apply(type1);
 184         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 185         verify(janusGraphGenericDao).commit();
 186
 187         assertEquals(type1, result.left().value().get(0).getLeft());
 188         assertEquals(true, result.left().value().get(0).getRight());
 189     }
 190
 191     @Test
 192     public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeFailed() {
 193         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 194         CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
 195         List<Object> elementTypesToCreate = Arrays.asList(type1_1);
 196
 197         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 198         when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
 199
 200         when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
 201         when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
 202         when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION));
 203
 204         ResponseFormat responseFormat = new ResponseFormat();
 205         responseFormat.setServiceException(new ServiceException());
 206         when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
 207         when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1_1)).thenReturn(responseFormat);
 208
 209
 210         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 211
 212         verify(elementAdder, never()).apply(Mockito.any());
 213         verify(elementUpgrader).apply(type1_1, type1);
 214         verify(janusGraphGenericDao).rollback();
 215     }
 216
 217     @Test
 218     public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeSucceeded() {
 219         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 220         CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
 221         List<Object> elementTypesToCreate = Arrays.asList(type1_1);
 222
 223         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 224         when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
 225
 226         when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
 227         when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
 228         when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.left(type1_1));
 229
 230         Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 231
 232         verify(elementAdder, never()).apply(Mockito.any());
 233         verify(elementUpgrader).apply(type1_1, type1);
 234         verify(janusGraphGenericDao).commit();
 235
 236         assertEquals(type1_1, result.left().value().get(0).getLeft());
 237         assertEquals(true, result.left().value().get(0).getRight());
 238     }
 239
 240     @Test
 241     public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeAlreadyExists() {
 242         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 243         CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
 244         List<Object> elementTypesToCreate = Arrays.asList(type1_1);
 245
 246         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 247         when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
 248
 249         when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
 250         when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
 251         when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.OK));
 252
 253         Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 254
 255         verify(elementAdder, never()).apply(Mockito.any());
 256         verify(elementUpgrader).apply(type1_1, type1);
 257         verify(janusGraphGenericDao).commit();
 258
 259         assertEquals(type1_1, result.left().value().get(0).getLeft());
 260         assertEquals(false, result.left().value().get(0).getRight());
 261     }
 262
 263
 264 }