asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/tasks/mig1710/UpgradeMigration1710Test.java

   1 package org.openecomp.sdc.asdctool.migration.tasks.mig1710;
   2
   3
   4 import static org.junit.Assert.assertEquals;
   5 import static org.mockito.ArgumentMatchers.any;
   6 import static org.mockito.ArgumentMatchers.anyString;
   7 import static org.mockito.ArgumentMatchers.eq;
   8 import static org.mockito.Mockito.doReturn;
   9 import static org.mockito.Mockito.times;
  10 import static org.mockito.Mockito.verify;
  11 import static org.mockito.Mockito.when;
  12
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.stream.Collectors;
  17 import java.util.stream.Stream;
  18
  19 import org.junit.Before;
  20 import org.junit.BeforeClass;
  21 import org.junit.Test;
  22 import org.junit.runner.RunWith;
  23 import org.mockito.InjectMocks;
  24 import org.mockito.Mock;
  25 import org.mockito.junit.MockitoJUnitRunner;
  26 import org.openecomp.sdc.asdctool.migration.core.task.MigrationResult;
  27 import org.openecomp.sdc.asdctool.migration.tasks.handlers.XlsOutputHandler;
  28 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  29 import org.openecomp.sdc.be.config.Configuration;
  30 import org.openecomp.sdc.be.config.ConfigurationManager;
  31 import org.openecomp.sdc.be.dao.api.ActionStatus;
  32 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  33 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  34 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  35 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  36 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  37 import org.openecomp.sdc.be.impl.ComponentsUtils;
  38 import org.openecomp.sdc.be.model.Component;
  39 import org.openecomp.sdc.be.model.ComponentInstance;
  40 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  41 import org.openecomp.sdc.be.model.Resource;
  42 import org.openecomp.sdc.be.model.User;
  43 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  44 import org.openecomp.sdc.be.model.operations.api.IUserAdminOperation;
  45 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  46 import org.openecomp.sdc.common.api.ConfigurationSource;
  47 import org.openecomp.sdc.exception.ResponseFormat;
  48
  49 import com.google.common.collect.Lists;
  50
  51 import fj.data.Either;
  52 @RunWith(MockitoJUnitRunner.class)
  53 public class UpgradeMigration1710Test {
  54
  55     private final static String USER = "jh0003";
  56     private final static String CONF_LEVEL =  "5.0";
  57
  58     private final User user = new User();
  59
  60     @InjectMocks
  61     private UpgradeMigration1710 migration = new UpgradeMigration1710();
  62     @Mock
  63     private IUserAdminOperation userAdminOperation;
  64     @Mock
  65     private ToscaOperationFacade toscaOperationFacade;
  66     @Mock
  67     private LifecycleBusinessLogic lifecycleBusinessLogic;
  68     @Mock
  69     private TitanDao titanDao;
  70     @Mock
  71     private ComponentsUtils componentUtils;
  72     @Mock
  73     private ConfigurationSource configurationSource;
  74     @Mock
  75     private XlsOutputHandler outputHandler;
  76
  77     private static ConfigurationManager configurationManager;
  78     private static List<String> resources = Stream.of("org.openecomp.resource.cp.extCP").collect(Collectors.toList());
  79     private static Map<String, List<String>> resourcesForUpgrade;
  80
  81     @BeforeClass
  82     public static void setUpClass() {
  83         resourcesForUpgrade = new HashMap<>();
  84         resourcesForUpgrade.put(CONF_LEVEL, resources);
  85     }
  86
  87     @Before
  88     public void setUp() {
  89         user.setUserId(USER);
  90         configurationManager = new ConfigurationManager(configurationSource);
  91         configurationManager.setConfiguration(new Configuration());
  92         configurationManager.getConfiguration().setSkipUpgradeVSPs(true);
  93         configurationManager.getConfiguration().setSkipUpgradeFailedVfs(true);
  94         configurationManager.getConfiguration().setAutoHealingOwner(USER);
  95
  96     }
  97
  98     @Test
  99     public void nodeTypesUpgradeFailed() {
 100         resolveUserAndDefineUpgradeLevel();
 101         when(titanDao.getByCriteria(any(), any(), any(), any()))
 102                                                 .thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
 103         assertEquals(MigrationResult.MigrationStatus.FAILED, migration.migrate().getMigrationStatus());
 104     }
 105
 106     @Test
 107     public void nodeTypesUpgradePassedAndVFsUpgradeFailedWhenSkipFailedVFsIsNotSupported() {
 108         final boolean failOnVfUpgrade = true;
 109         final boolean upgradeServices = false;
 110         final boolean exceptionOnVfUpgrade = false;
 111         final boolean upgradeVFC = false;
 112         configurationManager.getConfiguration().setSkipUpgradeFailedVfs(false);
 113         resolveUserAndDefineUpgradeLevel();
 114         upgradeRules(failOnVfUpgrade, exceptionOnVfUpgrade, upgradeServices, upgradeVFC);
 115         assertEquals(MigrationResult.MigrationStatus.FAILED, migration.migrate().getMigrationStatus());
 116         verify(titanDao, times(1)).commit();
 117         verify(titanDao, times(2)).rollback();
 118     }
 119
 120     @Test
 121     public void upgradeAllVFsUpgradeFailedOnExceptionWhenSkipFailedVFsIsNotSupported() {
 122         final boolean failOnVfUpgrade = false;
 123         final boolean upgradeServices = false;
 124         final boolean exceptionOnVfUpgrade = true;
 125         final boolean upgradeVFC = false;
 126         configurationManager.getConfiguration().setSkipUpgradeFailedVfs(false);
 127         resolveUserAndDefineUpgradeLevel();
 128         upgradeRules(failOnVfUpgrade, exceptionOnVfUpgrade, upgradeServices, upgradeVFC);
 129         assertEquals(MigrationResult.MigrationStatus.FAILED, migration.migrate().getMigrationStatus());
 130         verify(titanDao, times(1)).commit();
 131         verify(titanDao, times(2)).rollback();
 132     }
 133
 134     @Test
 135     public void upgradeAllIfVFsUpgradeFailedOnExceptionWhenSkipFailedVFsIsSupported() {
 136         final boolean failOnVfUpgrade = false;
 137         final boolean upgradeServices = true;
 138         final boolean exceptionOnFvUpgrade = true;
 139         final boolean upgradeVFC = false;
 140         configurationManager.getConfiguration().setSkipUpgradeFailedVfs(true);
 141         resolveUserAndDefineUpgradeLevel();
 142         upgradeRules(failOnVfUpgrade, exceptionOnFvUpgrade, upgradeServices, upgradeVFC);
 143         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 144         verify(titanDao, times(2)).commit();
 145         verify(titanDao, times(3)).rollback();
 146     }
 147
 148
 149     @Test
 150     public void upgradeAll() {
 151         final boolean failOnVfUpgrade = false;
 152         final boolean upgradeServices = true;
 153         final boolean exceptionOnFvUpgrade = false;
 154         final boolean upgradeVFC = false;
 155         resolveUserAndDefineUpgradeLevel();
 156         upgradeRules(failOnVfUpgrade, exceptionOnFvUpgrade, upgradeServices, upgradeVFC);
 157         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 158         verify(titanDao, times(2)).commit();
 159         verify(titanDao, times(3)).rollback();
 160     }
 161
 162     @Test
 163     public void upgradeAllWhenVspUpgradeIsRequired() {
 164         final boolean failOnVfUpgrade = false;
 165         final boolean upgradeServices = true;
 166         final boolean exceptionOnFvUpgrade = false;
 167         final boolean upgradeVFC = true;
 168         resolveUserAndDefineUpgradeLevel();
 169         upgradeRules(failOnVfUpgrade, exceptionOnFvUpgrade, upgradeServices, upgradeVFC);
 170         configurationManager.getConfiguration().setSkipUpgradeVSPs(false);
 171 //        migration.setComponentsUtils(componentUtils);
 172         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 173     }
 174
 175     @Test
 176     public void migrationFailedWhenUserNotResolved() {
 177         when(userAdminOperation.getUserData(anyString(), eq(false))).thenReturn(Either.right(ActionStatus.MISSING_INFORMATION));
 178         when(titanDao.rollback()).thenReturn(TitanOperationStatus.OK);
 179         assertEquals(MigrationResult.MigrationStatus.FAILED, migration.migrate().getMigrationStatus());
 180     }
 181
 182     private void resolveUserAndDefineUpgradeLevel() {
 183         when(userAdminOperation.getUserData(anyString(), eq(false))).thenReturn(Either.left(user));
 184         configurationManager.getConfiguration().setToscaConformanceLevel(CONF_LEVEL);
 185         configurationManager.getConfiguration().setResourcesForUpgrade(resourcesForUpgrade);
 186     }
 187
 188     private void upgradeRules(boolean failedVfUpgrade, boolean exceptionOnVfUpgrade, boolean upgradeService, boolean upgradeVFCs) {
 189         GraphVertex component = new GraphVertex();
 190         component.setJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE, LifecycleStateEnum.CERTIFIED.name());
 191         component.setJsonMetadataField(JsonPresentationFields.UNIQUE_ID, "12345");
 192         List<GraphVertex> components = Lists.newArrayList();
 193         components.add(component);
 194
 195         Resource resource = new Resource();
 196         Either<Component, StorageOperationStatus> foundResource = Either.left(resource);
 197
 198         when(titanDao.getByCriteria(any(), any(), any(), any()))
 199                                                         .thenReturn(Either.left(components));
 200         when(titanDao.getParentVertecies(any(GraphVertex.class), any(), any()))
 201                                                         //1th node to upgrade
 202                                                         .thenReturn(Either.left(components))
 203                                                         //parent of the 1th node - stop recursion
 204                                                         .thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
 205         if (failedVfUpgrade) {
 206             Either<Component, StorageOperationStatus> getToscaForVF = Either.right(StorageOperationStatus.NOT_FOUND);
 207             when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(foundResource)
 208                                                                     .thenReturn(foundResource)
 209                                                                     .thenReturn(getToscaForVF);
 210         }
 211         else {
 212             if (exceptionOnVfUpgrade) {
 213                 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(foundResource)
 214                         .thenReturn(foundResource)
 215                         .thenThrow(new RuntimeException());
 216             }
 217             else {
 218                 when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(foundResource);
 219                 //happy flow
 220                 if (upgradeService) {
 221                     Either<Resource, StorageOperationStatus> service = Either.left(resource);
 222                     if (upgradeVFCs) {
 223                         when(componentUtils.convertFromStorageResponse(any(), any())).thenCallRealMethod();
 224                         when(componentUtils.getResponseFormat(any(ActionStatus.class),any())).thenCallRealMethod();
 225                         when(toscaOperationFacade.getLatestCertifiedByToscaResourceName(any(), any(), any()))
 226                                 .thenReturn(service)
 227                                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND))
 228                                 .thenReturn(service)
 229                                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 230                     }
 231                     else {
 232                         when(toscaOperationFacade.getLatestCertifiedByToscaResourceName(any(), any(), any()))
 233                                 .thenReturn(service);
 234                     }
 235                 }
 236             }
 237         }
 238         List<ComponentInstance> instances = Lists.newArrayList();
 239         instances.add(createComponentInstance());
 240         resource.setComponentInstances(instances);
 241         Either<Resource, ResponseFormat> fromLifeCycle = Either.left(resource);
 242         doReturn(fromLifeCycle).when(lifecycleBusinessLogic)
 243                 .changeComponentState(any(), any(), any(), any(), any(),eq(true), eq(false));
 244
 245      }
 246
 247     private ComponentInstance createComponentInstance() {
 248         ComponentInstance instance = new ComponentInstance();
 249         instance.setIcon("");
 250         instance.setUniqueId("");
 251         instance.setName("");
 252         instance.setComponentUid("");
 253         instance.setCreationTime(1L);
 254         instance.setModificationTime(2L);
 255         instance.setDescription("");
 256         instance.setPosX("");
 257         instance.setPosY("");
 258         instance.setPropertyValueCounter(1);
 259         instance.setNormalizedName("");
 260         instance.setOriginType(OriginTypeEnum.CVFC);
 261         instance.setCustomizationUUID("");
 262         instance.setComponentName("");
 263         instance.setComponentVersion("");
 264         instance.setToscaComponentName("");
 265         instance.setInvariantName("");
 266         instance.setSourceModelInvariant("");
 267         instance.setSourceModelName("");
 268         instance.setSourceModelUuid("");
 269         instance.setSourceModelUid("");
 270         instance.setIsProxy(false);
 271         return instance;
 272      }
 273
 274
 275 }