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.*;
  48
  49 @RunWith(MockitoJUnitRunner.class)
  50 public class CommonImportManagerTest {
  51     private CommonImportManager commonImportManager;
  52     @Mock
  53     private ComponentsUtils componentsUtils;
  54     @Mock
  55     PropertyOperation propertyOperation;
  56     @Mock
  57     private JanusGraphGenericDao janusGraphGenericDao;
  58
  59     @Mock
  60     private Function<Object, Either<ActionStatus, ResponseFormat>> validator;
  61     @Mock
  62     private Function<Object, ImmutablePair<ElementTypeEnum, String>> elementInfoGetter;
  63     @Mock
  64     private Function<String, Either<Object, StorageOperationStatus>> elementFetcher;
  65     @Mock
  66     private Function<Object, Either<Object, StorageOperationStatus>> elementAdder;
  67     @Mock
  68     private BiFunction<Object, Object, Either<Object, StorageOperationStatus>> elementUpgrader;
  69
  70     @Before
  71     public void startUp() {
  72         commonImportManager = new CommonImportManager(componentsUtils, propertyOperation);
  73
  74         when(propertyOperation.getJanusGraphGenericDao()).thenReturn(janusGraphGenericDao);
  75     }
  76
  77     @Test
  78     public void testCreateElementTypesByDao_validationFailed() {
  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
  85         ResponseFormat responseFormat = new ResponseFormat();
  86         responseFormat.setServiceException(new ServiceException());
  87         when(validator.apply(type1)).thenReturn(Either.right(responseFormat));
  88
  89
  90         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
  91
  92         verify(elementAdder, never()).apply(Mockito.any());
  93         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
  94         verify(janusGraphGenericDao).rollback();
  95     }
  96
  97     @Test
  98     public void testCreateElementTypesByDao_RuntTimeExceptionInValidation() {
  99         Object type1 = new Object();
 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         when(validator.apply(type1)).thenThrow(new RuntimeException("Test Exception"));
 105
 106         try {
 107             commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 108         }
 109         catch(Exception skip) {
 110         }
 111
 112         verify(elementAdder, never()).apply(Mockito.any());
 113         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 114         verify(janusGraphGenericDao).rollback();
 115     }
 116
 117     @Test
 118     public void testCreateElementTypesByDao_capabilityTypeFetcherFailed() {
 119         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 120         List<Object> elementTypesToCreate = Arrays.asList(type1);
 121
 122         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 123         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 124
 125         when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
 126         when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 127         ResponseFormat responseFormat = new ResponseFormat();
 128         responseFormat.setServiceException(new ServiceException());
 129         when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
 130         when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.INVALID_CONTENT, type1)).thenReturn(responseFormat);
 131
 132
 133         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 134
 135         verify(elementAdder, never()).apply(Mockito.any());
 136         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 137         verify(janusGraphGenericDao).rollback();
 138     }
 139
 140     @Test
 141     public void testCreateElementTypesByDao_capabilityTypeNotFound_AddFailed() {
 142         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 143         List<Object> elementTypesToCreate = Arrays.asList(type1);
 144
 145         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 146         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 147
 148         when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
 149         when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 150         when(elementAdder.apply(type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION));
 151
 152         ResponseFormat responseFormat = new ResponseFormat();
 153         responseFormat.setServiceException(new ServiceException());
 154         when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
 155         when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1)).thenReturn(responseFormat);
 156
 157
 158         commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 159
 160         verify(elementAdder).apply(type1);
 161         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 162         verify(janusGraphGenericDao).rollback();
 163     }
 164
 165
 166     @Test
 167     public void testCreateElementTypesByDao_capabilityTypeNotFound_AddSucceeded() {
 168         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 169         List<Object> elementTypesToCreate = Arrays.asList(type1);
 170
 171         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 172         when(elementInfoGetter.apply(type1)).thenReturn(elementInfo);
 173
 174         when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK));
 175         when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 176         when(elementAdder.apply(type1)).thenReturn(Either.left(type1));
 177
 178
 179         Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 180
 181         verify(elementAdder).apply(type1);
 182         verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any());
 183         verify(janusGraphGenericDao).commit();
 184
 185         assertEquals(type1, result.left().value().get(0).getLeft());
 186         assertEquals(true, result.left().value().get(0).getRight());
 187     }
 188
 189     @Test
 190     public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeFailed() {
 191         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 192         CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
 193         List<Object> elementTypesToCreate = Arrays.asList(type1_1);
 194
 195         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 196         when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
 197
 198         when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
 199         when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
 200         when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION));
 201
 202         ResponseFormat responseFormat = new ResponseFormat();
 203         responseFormat.setServiceException(new ServiceException());
 204         when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod();
 205         when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1_1)).thenReturn(responseFormat);
 206
 207
 208         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(janusGraphGenericDao).rollback();
 213     }
 214
 215     @Test
 216     public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeSucceeded() {
 217         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 218         CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
 219         List<Object> elementTypesToCreate = Arrays.asList(type1_1);
 220
 221         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 222         when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
 223
 224         when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
 225         when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
 226         when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.left(type1_1));
 227
 228         Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 229
 230         verify(elementAdder, never()).apply(Mockito.any());
 231         verify(elementUpgrader).apply(type1_1, type1);
 232         verify(janusGraphGenericDao).commit();
 233
 234         assertEquals(type1_1, result.left().value().get(0).getLeft());
 235         assertEquals(true, result.left().value().get(0).getRight());
 236     }
 237
 238     @Test
 239     public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeAlreadyExists() {
 240         CapabilityTypeDefinition type1 = new CapabilityTypeDefinition();
 241         CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition();
 242         List<Object> elementTypesToCreate = Arrays.asList(type1_1);
 243
 244         ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability");
 245         when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo);
 246
 247         when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK));
 248         when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1));
 249         when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.OK));
 250
 251         Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader);
 252
 253         verify(elementAdder, never()).apply(Mockito.any());
 254         verify(elementUpgrader).apply(type1_1, type1);
 255         verify(janusGraphGenericDao).commit();
 256
 257         assertEquals(type1_1, result.left().value().get(0).getLeft());
 258         assertEquals(false, result.left().value().get(0).getRight());
 259     }
 260
 261
 262 }