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 com.google.common.collect.Lists;
   5 import fj.data.Either;
   6 import org.junit.AfterClass;
   7 import org.junit.Before;
   8 import org.junit.BeforeClass;
   9 import org.junit.Test;
  10 import org.junit.runner.RunWith;
  11 import org.mockito.InjectMocks;
  12 import org.mockito.Mock;
  13 import org.mockito.junit.MockitoJUnitRunner;
  14 import org.openecomp.sdc.asdctool.migration.core.task.MigrationResult;
  15 import org.openecomp.sdc.asdctool.migration.tasks.handlers.XlsOutputHandler;
  16 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  17 import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
  18 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  19 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  20 import org.openecomp.sdc.be.components.scheduledtasks.ComponentsCleanBusinessLogic;
  21 import org.openecomp.sdc.be.config.Configuration;
  22 import org.openecomp.sdc.be.config.ConfigurationManager;
  23 import org.openecomp.sdc.be.dao.api.ActionStatus;
  24 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  25 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  26 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  27 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  28 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  29 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  30 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  31 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  32 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  33 import org.openecomp.sdc.be.impl.ComponentsUtils;
  34 import org.openecomp.sdc.be.model.*;
  35 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  36 import org.openecomp.sdc.be.model.operations.api.IUserAdminOperation;
  37 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  38 import org.openecomp.sdc.be.model.operations.impl.CsarOperation;
  39 import org.openecomp.sdc.common.api.ConfigurationSource;
  40 import org.openecomp.sdc.common.http.client.api.HttpRequestHandler;
  41 import org.openecomp.sdc.exception.ResponseFormat;
  42
  43 import java.util.ArrayList;
  44 import java.util.HashMap;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.stream.Collectors;
  48 import java.util.stream.Stream;
  49
  50 import static org.junit.Assert.assertEquals;
  51 import static org.mockito.ArgumentMatchers.any;
  52 import static org.mockito.ArgumentMatchers.anyString;
  53 import static org.mockito.ArgumentMatchers.eq;
  54 import static org.mockito.Mockito.*;
  55
  56 @RunWith(MockitoJUnitRunner.class)
  57 public class UpgradeMigration1710Test {
  58
  59     private static final String USER = "jh0003";
  60     private static final String CONF_LEVEL = "5.0";
  61     private static final String COMPONENT_UNIQUE_ID = "12345";
  62     private static final String OLD_VERSION = "1.0";
  63     private static final String UPDATED_VERSION = "2.0";
  64     private static final String CSAR_UUID = "1234578";
  65     private static HttpRequestHandler originHandler;
  66
  67     private final User user = new User();
  68
  69     @InjectMocks
  70     private UpgradeMigration1710 migration = new UpgradeMigration1710();
  71     @Mock
  72     private IUserAdminOperation userAdminOperation;
  73     @Mock
  74     private ToscaOperationFacade toscaOperationFacade;
  75     @Mock
  76     private LifecycleBusinessLogic lifecycleBusinessLogic;
  77     @Mock
  78     private TitanDao titanDao;
  79     @Mock
  80     private ComponentsUtils componentUtils;
  81     @Mock
  82     private CsarOperation csarOperation;
  83     @Mock
  84     private ConfigurationSource configurationSource;
  85     //don't remove - it is intended to avoid the xls file generating
  86     @Mock
  87     private XlsOutputHandler outputHandler;
  88     @Mock
  89     private ResourceBusinessLogic resourceBusinessLogic;
  90     @Mock
  91     private ServiceBusinessLogic serviceBusinessLogic;
  92     @Mock
  93     private ResponseFormat responseFormat;
  94     @Mock
  95     private ComponentsCleanBusinessLogic componentsCleanBusinessLogic;
  96
  97     private static ConfigurationManager configurationManager;
  98     private static List<String> resources = Stream.of("org.openecomp.resource.cp.extCP").collect(Collectors.toList());
  99     private static Map<String, List<String>> resourcesForUpgrade;
 100
 101     private Resource resource;
 102     private Service service;
 103     private List<String> vfList = new ArrayList<>();
 104
 105     @BeforeClass
 106     public static void setUpClass() {
 107         resourcesForUpgrade = new HashMap<>();
 108         resourcesForUpgrade.put(CONF_LEVEL, resources);
 109         originHandler = HttpRequestHandler.get();
 110     }
 111
 112     @AfterClass
 113     public static void tearDownClass() {
 114         //put the origin handler back
 115         HttpRequestHandler.setTestInstance(originHandler);
 116     }
 117
 118     @Before
 119     public void setUp() {
 120         user.setUserId(USER);
 121         configurationManager = new ConfigurationManager(configurationSource);
 122         configurationManager.setConfiguration(new Configuration());
 123         configurationManager.getConfiguration().setSkipUpgradeVSPs(true);
 124         configurationManager.getConfiguration().setSkipUpgradeFailedVfs(true);
 125         configurationManager.getConfiguration().setAutoHealingOwner(USER);
 126         configurationManager.getConfiguration().setSupportAllottedResourcesAndProxy(true);
 127         configurationManager.getConfiguration().setDeleteLockTimeoutInSeconds(10);
 128         configurationManager.getConfiguration().setMaxDeleteComponents(5);
 129         configurationManager.getConfiguration().setEnableAutoHealing(true);
 130         configurationManager.getConfiguration().setToscaConformanceLevel("5.0");
 131         HashMap<String, List<String>> resourcesForUpgrade = new HashMap();
 132         resourcesForUpgrade.put("5.0", Lists.newArrayList("port"));
 133         configurationManager.getConfiguration().setResourcesForUpgrade(resourcesForUpgrade);
 134
 135         migration.init();
 136         migration.setNodeTypesSupportOnly(false);
 137         when(componentsCleanBusinessLogic.lockDeleteOperation()).thenReturn(StorageOperationStatus.OK);
 138
 139         resource = new Resource();
 140         resource.setCsarUUID(CSAR_UUID);
 141         resource.setVersion(OLD_VERSION);
 142         resource.setUniqueId(COMPONENT_UNIQUE_ID);
 143
 144         service = new Service();
 145         service.setVersion(OLD_VERSION);
 146         service.setUniqueId(COMPONENT_UNIQUE_ID);
 147
 148         vfList.add(COMPONENT_UNIQUE_ID);
 149
 150         when(responseFormat.getFormattedMessage())
 151                 .thenReturn("");
 152         when(componentUtils.getResponseFormat(any(ActionStatus.class), any()))
 153                 .thenReturn(responseFormat);
 154         when(componentUtils.convertFromStorageResponse(any(), any())).thenCallRealMethod();
 155         mockChangeComponentState();
 156     }
 157
 158     @Test
 159     public void nodeTypesUpgradeFailed() {
 160         migration.setNodeTypesSupportOnly(true);
 161         resolveUserAndDefineUpgradeLevel();
 162         when(titanDao.getByCriteria(any(), any(), any(), any()))
 163                 .thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
 164         assertEquals(MigrationResult.MigrationStatus.FAILED, migration.migrate().getMigrationStatus());
 165     }
 166
 167     @Test
 168     public void migrationDisabled() {
 169         configurationManager.getConfiguration().setEnableAutoHealing(false);
 170         migration.init();
 171         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 172         verify(titanDao, times(0)).commit();
 173         verify(titanDao, times(0)).rollback();
 174     }
 175
 176     @Test
 177     public void migrationFailedIfDeleteNodeLockFailed() {
 178         when(componentsCleanBusinessLogic.lockDeleteOperation())
 179                 .thenReturn(StorageOperationStatus.BAD_REQUEST);
 180         assertEquals(MigrationResult.MigrationStatus.FAILED, migration.migrate().getMigrationStatus());
 181     }
 182
 183     @Test
 184     public void migrationFailedIfDeleteNodeLockRetryFailed() {
 185         when(componentsCleanBusinessLogic.lockDeleteOperation())
 186                 .thenReturn(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT)
 187                 .thenReturn(StorageOperationStatus.BAD_REQUEST);
 188         assertEquals(MigrationResult.MigrationStatus.FAILED, migration.migrate().getMigrationStatus());
 189     }
 190
 191     @Test
 192     public void nodeTypesOnlyUpgradePassed() {
 193         migration.setNodeTypesSupportOnly(true);
 194         upgradeAllScenario(false);
 195         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 196         verify(titanDao, times(2)).commit();
 197         verify(titanDao, times(0)).rollback();
 198     }
 199
 200     @Test
 201     public void nodeTypesUpgradePassedAndVFsUpgradeFailedWhenSkipFailedVFsIsNotSupported() {
 202         final boolean failOnVfUpgrade = true;
 203         final boolean upgradeServices = false;
 204         final boolean exceptionOnVfUpgrade = false;
 205         final boolean upgradeVFC = false;
 206         final boolean isFailed = true;
 207         configurationManager.getConfiguration().setSkipUpgradeFailedVfs(false);
 208         migration.init();
 209         migration.setNodeTypesSupportOnly(false);
 210         resolveUserAndDefineUpgradeLevel();
 211         upgradeRules(failOnVfUpgrade, exceptionOnVfUpgrade, upgradeServices, upgradeVFC, isFailed);
 212         assertEquals(MigrationResult.MigrationStatus.FAILED, migration.migrate().getMigrationStatus());
 213         verify(titanDao, times(1)).commit();
 214         verify(titanDao, times(2)).rollback();
 215     }
 216
 217
 218     @Test
 219     public void upgradeAllVFsUpgradeFailedOnExceptionWhenSkipFailedVFsIsNotSupported() {
 220         final boolean failOnVfUpgrade = false;
 221         final boolean upgradeServices = false;
 222         final boolean exceptionOnVfUpgrade = true;
 223         final boolean upgradeVFC = false;
 224         final boolean isFailed = true;
 225         configurationManager.getConfiguration().setSkipUpgradeFailedVfs(false);
 226         resolveUserAndDefineUpgradeLevel();
 227         upgradeRules(failOnVfUpgrade, exceptionOnVfUpgrade, upgradeServices, upgradeVFC, isFailed);
 228         migration.init();
 229         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 230         verify(titanDao, times(2)).commit();
 231         verify(titanDao, times(0)).rollback();
 232     }
 233
 234     @Test
 235     public void upgradeAllIfVFsUpgradeFailedOnExceptionWhenSkipFailedVFsIsSupported() {
 236         final boolean failOnVfUpgrade = false;
 237         final boolean upgradeServices = true;
 238         final boolean exceptionOnFvUpgrade = true;
 239         final boolean upgradeVFC = false;
 240         final boolean isFailed = false;
 241         configurationManager.getConfiguration().setSkipUpgradeFailedVfs(true);
 242         resolveUserAndDefineUpgradeLevel();
 243         upgradeRules(failOnVfUpgrade, exceptionOnFvUpgrade, upgradeServices, upgradeVFC, isFailed);
 244         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 245         verify(titanDao, times(3)).commit();
 246         verify(titanDao, times(1)).rollback();
 247     }
 248
 249
 250     @Test
 251     public void upgradeAll() {
 252         upgradeAllScenario(true);
 253         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 254         verify(titanDao, times(4)).commit();
 255         verify(titanDao, times(0)).rollback();
 256     }
 257
 258     @Test
 259     public void upgradeAllWhenDeleteLockRetrySucceeded() {
 260         when(componentsCleanBusinessLogic.lockDeleteOperation())
 261                 .thenReturn(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT)
 262                 .thenReturn(StorageOperationStatus.OK);
 263         upgradeAllScenario(true);
 264         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 265         verify(titanDao, times(4)).commit();
 266         verify(titanDao, times(0)).rollback();
 267     }
 268
 269     @Test
 270     public void upgradeAllWhenVspUpgradeIsRequired() {
 271         final boolean failOnVfUpgrade = false;
 272         final boolean upgradeServices = true;
 273         final boolean exceptionOnFvUpgrade = false;
 274         final boolean upgradeVFC = true;
 275         final boolean isFailed = true;
 276         resolveUserAndDefineUpgradeLevel();
 277         upgradeRules(failOnVfUpgrade, exceptionOnFvUpgrade, upgradeServices, upgradeVFC, isFailed);
 278         configurationManager.getConfiguration().setSkipUpgradeVSPs(false);
 279         assertEquals(MigrationResult.MigrationStatus.COMPLETED, migration.migrate().getMigrationStatus());
 280     }
 281
 282     @Test
 283     public void migrationFailedWhenUserNotResolved() {
 284         when(userAdminOperation.getUserData(anyString(), eq(false))).thenReturn(Either.right(ActionStatus.MISSING_INFORMATION));
 285         when(titanDao.rollback()).thenReturn(TitanOperationStatus.OK);
 286         assertEquals(MigrationResult.MigrationStatus.FAILED, migration.migrate().getMigrationStatus());
 287     }
 288
 289     @Test
 290     public void verifyThatCheckedOutResourcesMarkedAsDeletedIfUpgradeFailed() {
 291         mockCheckoutFlow();
 292         when(resourceBusinessLogic.validateAndUpdateResourceFromCsar(any(Resource.class), any(), any(), any(),
 293                 any()))
 294                 .thenThrow(new ComponentException(responseFormat));
 295         when(resourceBusinessLogic.deleteResource(anyString(), any()))
 296                 .thenReturn(responseFormat);
 297         mockChangeComponentState();
 298         migration.upgradeVFs(vfList, false);
 299         verify(resourceBusinessLogic).deleteResource(anyString(), any());
 300     }
 301
 302     @Test
 303     public void verifyThatCheckedOutAllottedResourcesMarkedAsDeletedIfUpgradeFailed() {
 304         mockCheckoutFlow();
 305         when(resourceBusinessLogic.validateAndUpdateResourceFromCsar(any(Resource.class), any(), any(), any(),
 306                 any()))
 307                 .thenThrow(new ComponentException(responseFormat));
 308         when(resourceBusinessLogic.deleteResource(anyString(), any()))
 309                 .thenReturn(responseFormat);
 310         mockChangeComponentState();
 311         migration.upgradeVFs(vfList, true);
 312         verify(resourceBusinessLogic).deleteResource(anyString(), any());
 313     }
 314
 315     @Test
 316     public void verifyThatCheckedOutResourceIsNotMarkedAsDeletedIfUpgradeSucceeded() {
 317         mockCheckoutFlow();
 318         resource.setVersion(UPDATED_VERSION);
 319         when(resourceBusinessLogic.validateAndUpdateResourceFromCsar(any(Resource.class), any(), any(), any(),
 320                 any()))
 321                 .thenReturn(resource);
 322         mockChangeComponentState();
 323         migration.upgradeVFs(vfList, true);
 324         verify(resourceBusinessLogic, times(0)).deleteResource(anyString(), any());
 325     }
 326
 327     @Test
 328     public void verifyThatCheckedOutServicesMarkedAsDeletedIfUpgradeFailed() {
 329         List<String> servicesForUpgrade = new ArrayList<>();
 330         servicesForUpgrade.add(COMPONENT_UNIQUE_ID);
 331
 332         Either<Resource, StorageOperationStatus> foundServices = Either.left(resource);
 333         mockCheckoutFlow();
 334         when(toscaOperationFacade.getToscaElement(any(), any(ComponentParametersView.class)))
 335                 .thenReturn(Either.left(service));
 336         when(toscaOperationFacade.getLatestCertifiedByToscaResourceName(any(), any(), any()))
 337                 .thenReturn(foundServices);
 338         migration.upgradeServices(servicesForUpgrade, component -> true, "services");
 339         verify(serviceBusinessLogic, times(0)).deleteService(anyString(), any());
 340     }
 341
 342     @Test
 343     public void verifyThatCheckedOutServicesIsNotMarkedAsDeletedIfUpgradeSucceeded() {
 344         List<String> servicesForUpgrade = new ArrayList<>();
 345         servicesForUpgrade.add(COMPONENT_UNIQUE_ID);
 346
 347         mockCheckoutFlow();
 348         when(toscaOperationFacade.getLatestCertifiedByToscaResourceName(anyString(), any(VertexTypeEnum.class), any(JsonParseFlagEnum.class)))
 349                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 350         when(serviceBusinessLogic.deleteService(anyString(), any()))
 351                 .thenReturn(responseFormat);
 352         migration.upgradeServices(servicesForUpgrade, component -> true, "services");
 353         verify(serviceBusinessLogic).deleteService(anyString(), any());
 354     }
 355
 356
 357     @Test
 358     public void unlockDeleteOperationIsPerformedIfItWasLocked() {
 359         migration.isLockDeleteOperationSucceeded();
 360         migration.unlockDeleteOperation();
 361         verify(componentsCleanBusinessLogic).unlockDeleteOperation();
 362     }
 363
 364     @Test
 365     public void unlockDeleteOperationIsNotPerformedIfItWasNotLocked() {
 366         when(componentsCleanBusinessLogic.lockDeleteOperation()).thenReturn(StorageOperationStatus.GENERAL_ERROR);
 367         migration.isLockDeleteOperationSucceeded();
 368         migration.unlockDeleteOperation();
 369         verify(componentsCleanBusinessLogic, times(0)).unlockDeleteOperation();
 370     }
 371
 372     @Test
 373     public void deleteLockSucceededAfterRetry() {
 374         when(componentsCleanBusinessLogic.lockDeleteOperation())
 375                 .thenReturn(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT)
 376                 .thenReturn(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT)
 377                 .thenReturn(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT)
 378                 .thenReturn(StorageOperationStatus.OK);
 379         migration.isLockDeleteOperationSucceeded();
 380         migration.unlockDeleteOperation();
 381         verify(componentsCleanBusinessLogic).unlockDeleteOperation();
 382     }
 383
 384     @Test
 385     public void deleteLockFailedAfterRetry() {
 386         when(componentsCleanBusinessLogic.lockDeleteOperation())
 387                 .thenReturn(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT);
 388         migration.isLockDeleteOperationSucceeded();
 389         migration.unlockDeleteOperation();
 390         verify(componentsCleanBusinessLogic, times(0)).unlockDeleteOperation();
 391     }
 392
 393     @Test
 394     public void deleteMarkedResourcesWhenLimitIsReached() {
 395         ArrayList<NodeTypeEnum> componentsToClean = new ArrayList<>();
 396         componentsToClean.add(NodeTypeEnum.Resource);
 397         migration.setUser(user);
 398         migration.setMarkedAsDeletedResourcesCnt(5);
 399         migration.deleteResourcesIfLimitIsReached();
 400         verify(componentsCleanBusinessLogic).cleanComponents(componentsToClean, true);
 401     }
 402
 403     @Test
 404     public void deleteMarkedResourcesNotCalledWhenLimitIsNotReached() {
 405         ArrayList<NodeTypeEnum> componentsToClean = new ArrayList<>();
 406         componentsToClean.add(NodeTypeEnum.Resource);
 407         migration.setUser(user);
 408         migration.setMarkedAsDeletedResourcesCnt(3);
 409         migration.deleteResourcesIfLimitIsReached();
 410         verify(componentsCleanBusinessLogic, times(0)).cleanComponents(componentsToClean, true);
 411     }
 412
 413     @Test
 414     public void deleteMarkedServicesWhenLimitIsReached() {
 415         ArrayList<NodeTypeEnum> componentsToClean = new ArrayList<>();
 416         componentsToClean.add(NodeTypeEnum.Service);
 417         migration.setUser(user);
 418         migration.setMarkedAsDeletedServicesCnt(5);
 419         migration.deleteServicesIfLimitIsReached();
 420         verify(componentsCleanBusinessLogic).cleanComponents(componentsToClean, true);
 421     }
 422
 423     @Test
 424     public void deleteMarkedServicesNotCalledWhenLimitIsNotReached() {
 425         ArrayList<NodeTypeEnum> componentsToClean = new ArrayList<>();
 426         componentsToClean.add(NodeTypeEnum.Service);
 427         migration.setUser(user);
 428         migration.setMarkedAsDeletedServicesCnt(2);
 429         migration.deleteServicesIfLimitIsReached();
 430         verify(componentsCleanBusinessLogic, times(0)).cleanComponents(componentsToClean, true);
 431     }
 432
 433     @Test
 434     public void getVfUpgradeStatusWhenUpgradeFailedAndItIsInstance() {
 435         assertEquals(UpgradeMigration1710.UpgradeStatus.NOT_UPGRADED, migration.getVfUpgradeStatus(false, true));
 436     }
 437
 438     @Test
 439     public void getVfUpgradeStatusWhenUpgradeFailedAndItIsNotInstance() {
 440         assertEquals(UpgradeMigration1710.UpgradeStatus.NOT_UPGRADED, migration.getVfUpgradeStatus(false, false));
 441     }
 442
 443     @Test
 444     public void getVfUpgradeStatusWhenUpgradeSucceededAndItIsInstance() {
 445         assertEquals(UpgradeMigration1710.UpgradeStatus.UPGRADED_AS_INSTANCE, migration.getVfUpgradeStatus(true, true));
 446     }
 447
 448     @Test
 449     public void getVfUpgradeStatusWhenUpgradeSucceededAndItIsNotInstance() {
 450         assertEquals(UpgradeMigration1710.UpgradeStatus.UPGRADED, migration.getVfUpgradeStatus(true, false));
 451     }
 452
 453     private void resolveUserAndDefineUpgradeLevel() {
 454         when(userAdminOperation.getUserData(anyString(), eq(false))).thenReturn(Either.left(user));
 455         configurationManager.getConfiguration().setToscaConformanceLevel(CONF_LEVEL);
 456         configurationManager.getConfiguration().setResourcesForUpgrade(resourcesForUpgrade);
 457     }
 458
 459     private void upgradeAllScenario(boolean upgradeServices) {
 460         final boolean failOnVfUpgrade = false;
 461         final boolean exceptionOnFvUpgrade = false;
 462         final boolean upgradeVFC = false;
 463         final boolean isFailed = false;
 464         final boolean isProxy = true;
 465
 466         resolveUserAndDefineUpgradeLevel();
 467         mockCheckoutFlow();
 468         when(resourceBusinessLogic.validateAndUpdateResourceFromCsar(any(Resource.class), any(), any(), any(),
 469                 any()))
 470                 .thenReturn(resource);
 471         upgradeRules(failOnVfUpgrade, exceptionOnFvUpgrade, upgradeServices, upgradeVFC, isFailed, isProxy);
 472     }
 473
 474     private void upgradeRules(boolean failedVfUpgrade, boolean exceptionOnVfUpgrade, boolean upgradeService,
 475                               boolean upgradeVFCs, boolean isFailed) {
 476         upgradeRules(failedVfUpgrade, exceptionOnVfUpgrade, upgradeService, upgradeVFCs, isFailed, false);
 477     }
 478
 479     private void upgradeRules(boolean failedVfUpgrade, boolean exceptionOnVfUpgrade, boolean upgradeService,
 480                               boolean upgradeVFCs, boolean isFailed, boolean isProxy) {
 481
 482         mockNodeTypesUpgrade();
 483         Either<Component, StorageOperationStatus> foundResource = Either.left(resource);
 484
 485         if (failedVfUpgrade) {
 486             getToscaElementMockForVfUpgradeFailedScenario(foundResource);
 487         } else {
 488             if (exceptionOnVfUpgrade) {
 489                 getToscaElementMockForExceptionOnUpgradeScenario(foundResource, upgradeService);
 490             } else {
 491                 when(toscaOperationFacade.getToscaElement(anyString()))
 492                         .thenReturn(foundResource);
 493             }
 494         }
 495         //happy flow
 496         if (upgradeService) {
 497             mockForUpgradeServiceScenario(foundResource, upgradeVFCs, isFailed);
 498         }
 499     }
 500
 501     private void mockNodeTypesUpgrade() {
 502         GraphVertex component = createComponent();
 503         List<GraphVertex> components = Lists.newArrayList();
 504         components.add(component);
 505
 506         when(titanDao.getByCriteria(any(), any(), any(), any()))
 507                 .thenReturn(Either.left(components));
 508         when(titanDao.getParentVertecies(any(GraphVertex.class), any(EdgeLabelEnum.class), any(JsonParseFlagEnum.class)))
 509                 //1th node to upgrade
 510                 .thenReturn(Either.left(components))
 511                 //parent of the 1th node - stop recursion
 512                 .thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
 513     }
 514
 515     private GraphVertex createComponent() {
 516         GraphVertex component = new GraphVertex();
 517         component.setJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE,LifecycleStateEnum.CERTIFIED.name());
 518         component.setJsonMetadataField(JsonPresentationFields.UNIQUE_ID,COMPONENT_UNIQUE_ID);
 519         component.setJsonMetadataField(JsonPresentationFields.CI_COMPONENT_VERSION,UPDATED_VERSION);
 520         return component;
 521     }
 522
 523     private void mockChangeComponentState() {
 524         List<ComponentInstance> instances = Lists.newArrayList();
 525         instances.add(createComponentInstance());
 526
 527         Resource checkedOutResource = new Resource();
 528         checkedOutResource.setUniqueId("123400");
 529         checkedOutResource.setComponentInstances(instances);
 530         Either<Resource, ResponseFormat> fromLifeCycle = Either.left(checkedOutResource);
 531         doReturn(fromLifeCycle).when(lifecycleBusinessLogic)
 532                 .changeComponentState(any(), any(), any(), any(), any(),eq(true), eq(false));
 533     }
 534
 535     private void getToscaElementMockForVfUpgradeFailedScenario(Either<Component, StorageOperationStatus> foundResource) {
 536         when(toscaOperationFacade.getToscaElement(anyString()))
 537                 .thenReturn(foundResource)
 538                 .thenReturn(foundResource)
 539                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 540     }
 541
 542     private void mockForUpgradeServiceScenario(Either<Component, StorageOperationStatus> foundResource, boolean upgradeVFC, boolean isFailed) {
 543         Either<Resource, StorageOperationStatus> foundService = Either.left(resource);
 544         if (upgradeVFC) {
 545             when(toscaOperationFacade.getToscaElement(anyString()))
 546                     .thenReturn(foundResource)
 547                     .thenReturn(foundResource)
 548                     .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 549         }
 550         else if (!isFailed) {
 551             when(toscaOperationFacade.getToscaElement(any(), any(ComponentParametersView.class)))
 552                     .thenReturn(Either.left(resource));
 553             when(toscaOperationFacade.getLatestCertifiedByToscaResourceName(any(), any(), any()))
 554                     .thenReturn(foundService);
 555         }
 556     }
 557
 558     private void getToscaElementMockForExceptionOnUpgradeScenario(Either<Component, StorageOperationStatus> foundResource, boolean upgradeService) {
 559         if (upgradeService) {
 560             service.setVersion(UPDATED_VERSION);
 561             Either<Component, StorageOperationStatus> foundService = Either.left(service);
 562             when(toscaOperationFacade.getToscaElement(anyString()))
 563                     .thenReturn(foundResource)
 564                     .thenReturn(foundResource)
 565                     .thenThrow(new RuntimeException())
 566                     .thenReturn(foundService);
 567         }
 568         else {
 569             when(toscaOperationFacade.getToscaElement(anyString()))
 570                     .thenReturn(foundResource)
 571                     .thenReturn(foundResource)
 572                     .thenThrow(new RuntimeException());
 573         }
 574     }
 575
 576     private void mockCheckoutFlow() {
 577         GraphVertex component = new GraphVertex();
 578         component.setJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE, LifecycleStateEnum.CERTIFIED.name());
 579         component.setJsonMetadataField(JsonPresentationFields.UNIQUE_ID, COMPONENT_UNIQUE_ID);
 580         List<GraphVertex> components = Lists.newArrayList();
 581         components.add(component);
 582
 583         when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
 584         when(titanDao.getByCriteria(any(), any(), any(), any()))
 585                 .thenReturn(Either.left(components));
 586         when(csarOperation.getCsarLatestVersion(anyString(), any()))
 587                 .thenReturn(Either.left("2.0"));
 588     }
 589
 590     private ComponentInstance createComponentInstance() {
 591         ComponentInstance instance = new ComponentInstance();
 592         instance.setIcon("");
 593         instance.setUniqueId("");
 594         instance.setName("");
 595         instance.setComponentUid("");
 596         instance.setCreationTime(1L);
 597         instance.setModificationTime(2L);
 598         instance.setDescription("");
 599         instance.setPosX("");
 600         instance.setPosY("");
 601         instance.setPropertyValueCounter(1);
 602         instance.setNormalizedName("");
 603         instance.setOriginType(OriginTypeEnum.CVFC);
 604         instance.setCustomizationUUID("");
 605         instance.setComponentName("");
 606         instance.setComponentVersion(OLD_VERSION);
 607         instance.setToscaComponentName("");
 608         instance.setInvariantName("");
 609         instance.setSourceModelInvariant("");
 610         instance.setSourceModelName("");
 611         instance.setSourceModelUuid("");
 612         instance.setSourceModelUid("");
 613         instance.setIsProxy(false);
 614         return instance;
 615     }
 616
 617
 618 }