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

   1 package org.openecomp.sdc.be.components.impl;
   2
   3
   4 import static org.assertj.core.api.Java6Assertions.assertThat;
   5 import static org.junit.Assert.assertEquals;
   6 import static org.junit.Assert.assertTrue;
   7 import static org.mockito.ArgumentMatchers.any;
   8 import static org.mockito.ArgumentMatchers.anyBoolean;
   9 import static org.mockito.ArgumentMatchers.anyMap;
  10 import static org.mockito.ArgumentMatchers.anyString;
  11 import static org.mockito.ArgumentMatchers.eq;
  12 import static org.mockito.Mockito.when;
  13
  14 import fj.data.Either;
  15 import java.util.Arrays;
  16 import java.util.Collections;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import java.util.Map;
  20 import org.junit.Assert;
  21 import org.junit.Before;
  22 import org.junit.BeforeClass;
  23 import org.junit.Test;
  24 import org.junit.runner.RunWith;
  25 import org.mockito.InjectMocks;
  26 import org.mockito.Mock;
  27 import org.mockito.junit.MockitoJUnitRunner;
  28 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  29 import org.openecomp.sdc.be.components.property.PropertyDeclarationOrchestrator;
  30 import org.openecomp.sdc.be.components.utils.ComponentInstanceBuilder;
  31 import org.openecomp.sdc.be.components.utils.GroupDefinitionBuilder;
  32 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  33 import org.openecomp.sdc.be.components.validation.UserValidations;
  34 import org.openecomp.sdc.be.config.ConfigurationManager;
  35 import org.openecomp.sdc.be.dao.api.ActionStatus;
  36 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  37 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  38 import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
  39 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  40 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  41 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  42 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  43 import org.openecomp.sdc.be.impl.ComponentsUtils;
  44 import org.openecomp.sdc.be.model.Component;
  45 import org.openecomp.sdc.be.model.ComponentInstance;
  46 import org.openecomp.sdc.be.model.ComponentParametersView;
  47 import org.openecomp.sdc.be.model.GroupDefinition;
  48 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  49 import org.openecomp.sdc.be.model.PolicyDefinition;
  50 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  51 import org.openecomp.sdc.be.model.Resource;
  52 import org.openecomp.sdc.be.model.User;
  53 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  54 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
  55 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  56 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
  57 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  58 import org.openecomp.sdc.be.model.operations.impl.PolicyTypeOperation;
  59 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  60 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  61 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  62 import org.openecomp.sdc.exception.ResponseFormat;
  63
  64 @RunWith(MockitoJUnitRunner.class)
  65 public class PolicyBusinessLogicTest {
  66
  67     @InjectMocks
  68     private PolicyBusinessLogic businessLogic;
  69     @Mock
  70     private ComponentsUtils componentsUtils;
  71     @Mock
  72     private ToscaOperationFacade toscaOperationFacade;
  73     @Mock
  74     private IGraphLockOperation graphLockOperation;
  75     @Mock
  76     private PolicyTypeOperation policyTypeOperation;
  77     @Mock
  78     private UserValidations userValidations;
  79     @Mock
  80     private TitanDao titanDao;
  81     @Mock
  82     private ApplicationDataTypeCache dataTypeCache;
  83     @Mock
  84     private PropertyOperation propertyOperation;
  85     @Mock
  86     PropertyDeclarationOrchestrator propertyDeclarationOrchestrator;
  87
  88     private final static String COMPONENT_ID = "componentId";
  89     private final static String COMPONENT_NAME = "componentName";
  90     private final static String POLICY_TYPE_NAME = "policyTypeName";
  91     private final static String POLICY_ID = "policyId";
  92     private final static String INVALID_POLICY_ID = "invalidPolicyId";
  93     private final static String POLICY_NAME = "policyName";
  94     private final static String OTHER_POLICY_NAME = "otherPolicyName";
  95     private final static String USER_ID = "jh0003";
  96     private final static String UNIQUE_ID_EXSISTS = "uniqueIdExists";
  97     private final static String UNIQUE_ID_DOESNT_EXSISTS = "uniqueIdDoesntExists";
  98     private final static String CREATE_POLICY = "create Policy";
  99     private final static User user = buildUser();
 100     private final static PolicyDefinition policy = buildPolicy(POLICY_NAME);
 101     private final static PolicyDefinition otherPolicy = buildPolicy(OTHER_POLICY_NAME);
 102     private final static Resource resource = buildResource();
 103     private final static PolicyTypeDefinition policyType = buildPolicyType();
 104
 105     private static Either<Component, StorageOperationStatus> componentSuccessEither;
 106     private static Either<PolicyTypeDefinition, StorageOperationStatus> getPolicyTypeSuccessEither;
 107     private static Either<PolicyDefinition, StorageOperationStatus> policySuccessEither;
 108     private static ResponseFormat notFoundResponse;
 109     private static ResponseFormat invalidContentResponse;
 110     private static ResponseFormat nameExistsResponse;
 111
 112     @BeforeClass
 113     public static void setup() {
 114         String appConfigDir = "src/test/resources/config/catalog-be";
 115         new ConfigurationManager(new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir));
 116         createResponses();
 117         new ConfigurationManager(new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir));
 118     }
 119
 120     @Before
 121     public void initBl() {
 122         businessLogic.setComponentsUtils(componentsUtils);
 123         businessLogic.setToscaOperationFacade(toscaOperationFacade);
 124         businessLogic.setTitanGenericDao(titanDao);
 125         businessLogic.setUserValidations(userValidations);
 126         businessLogic.setGraphLockOperation(graphLockOperation);
 127         businessLogic.setPolicyTypeOperation(policyTypeOperation);
 128         businessLogic.setDataTypeCache(dataTypeCache);
 129         businessLogic.setPropertyOperation(propertyOperation);
 130         businessLogic.setPropertyDeclarationOrchestrator(propertyDeclarationOrchestrator);
 131     }
 132
 133
 134     private static void createResponses() {
 135         componentSuccessEither = Either.left(resource);
 136         getPolicyTypeSuccessEither = Either.left(policyType);
 137         policySuccessEither = Either.left(policy);
 138         notFoundResponse = new ResponseFormat();
 139         notFoundResponse.setStatus(404);
 140         invalidContentResponse = new ResponseFormat();
 141         invalidContentResponse.setStatus(400);
 142         nameExistsResponse = new ResponseFormat();
 143         nameExistsResponse.setStatus(409);
 144     }
 145
 146     @Test
 147     public void createPolicySuccessTest(){
 148         stubValidateAndLockSuccess(CREATE_POLICY);
 149         when(policyTypeOperation.getLatestPolicyTypeByType(eq(POLICY_TYPE_NAME))).thenReturn(getPolicyTypeSuccessEither);
 150         when(toscaOperationFacade.associatePolicyToComponent(eq(COMPONENT_ID), any(PolicyDefinition.class), eq(0))).thenReturn(policySuccessEither);
 151         stubUnlockAndCommit();
 152         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
 153         assertTrue(response.isLeft());
 154     }
 155
 156     @Test
 157     public void createPolicyUserFailureTest(){
 158         ComponentException userNotFoundException = new ComponentException(ActionStatus.USER_NOT_FOUND);
 159         when(userValidations.validateUserExists(eq(USER_ID), eq(CREATE_POLICY), eq(false))).thenThrow(userNotFoundException);
 160         stubRollback();
 161         try{
 162             businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
 163         } catch(ComponentException e){
 164             assertEquals(e.getActionStatus(), userNotFoundException.getActionStatus());
 165         }
 166     }
 167
 168     private void assertNotFound(Either<PolicyDefinition, ResponseFormat> response) {
 169         assertTrue(response.isRight() && response.right().value().getStatus().equals(404));
 170     }
 171
 172     @Test
 173     public void createPolicyComponentFailureTest(){
 174         when(userValidations.validateUserExists(eq(USER_ID), eq(CREATE_POLICY), eq(false))).thenReturn(user);
 175         Either<Component, StorageOperationStatus> componentNotFoundResponse = Either.right(StorageOperationStatus.NOT_FOUND);
 176         when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.NOT_FOUND), eq(ComponentTypeEnum.RESOURCE))).thenReturn(ActionStatus.RESOURCE_NOT_FOUND);
 177         when(componentsUtils.getResponseFormat(eq(ActionStatus.RESOURCE_NOT_FOUND), anyString())).thenReturn(notFoundResponse);
 178         when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(componentNotFoundResponse);
 179         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
 180         assertNotFound(response);
 181     }
 182
 183     @Test
 184     public void createPolicyPolicyTypeFailureTest(){
 185         stubValidateAndLockSuccess(CREATE_POLICY);
 186         Either<PolicyTypeDefinition, StorageOperationStatus> getPolicyTypeFailed = Either.right(StorageOperationStatus.NOT_FOUND);
 187         when(policyTypeOperation.getLatestPolicyTypeByType(eq(POLICY_TYPE_NAME))).thenReturn(getPolicyTypeFailed);
 188         when(componentsUtils.convertFromStorageResponse(eq(getPolicyTypeFailed.right().value()))).thenReturn(ActionStatus.RESOURCE_NOT_FOUND);
 189         when(componentsUtils.getResponseFormat(eq(ActionStatus.RESOURCE_NOT_FOUND))).thenReturn(notFoundResponse);
 190         stubUnlockAndRollback();
 191         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
 192         assertNotFound(response);
 193     }
 194
 195     @Test
 196     public void createPolicyComponentTypeFailureTest(){
 197         stubValidateAndLockSuccess(CREATE_POLICY);
 198         when(policyTypeOperation.getLatestPolicyTypeByType(eq(POLICY_TYPE_NAME))).thenReturn(getPolicyTypeSuccessEither);
 199         Either<PolicyDefinition, StorageOperationStatus> addPolicyRes = Either.right(StorageOperationStatus.BAD_REQUEST);
 200         when(toscaOperationFacade.associatePolicyToComponent(eq(COMPONENT_ID), any(PolicyDefinition.class), eq(0))).thenReturn(addPolicyRes);
 201         when(componentsUtils.convertFromStorageResponse(eq(addPolicyRes.right().value()))).thenReturn(ActionStatus.INVALID_CONTENT);
 202         when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_CONTENT))).thenReturn(invalidContentResponse);
 203
 204         stubUnlockAndRollback();
 205         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
 206         assertTrue(response.isRight() && response.right().value().getStatus().equals(400));
 207     }
 208
 209     @Test
 210     public void updatePolicySuccessTest(){
 211         stubValidateAndLockSuccess(CREATE_POLICY);
 212         when(toscaOperationFacade.updatePolicyOfComponent(eq(COMPONENT_ID), any(PolicyDefinition.class))).thenReturn(policySuccessEither);
 213         stubUnlockAndCommit();
 214         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.updatePolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, otherPolicy, USER_ID, true);
 215         assertTrue(response.isLeft());
 216     }
 217
 218     @Test
 219     public void updatePolicyNameFailureTest(){
 220         stubValidateAndLockSuccess(CREATE_POLICY);
 221         when(componentsUtils.getResponseFormat(eq(ActionStatus.POLICY_NAME_ALREADY_EXIST), eq(POLICY_NAME))).thenReturn(nameExistsResponse);
 222         stubUnlockAndRollback();
 223         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.updatePolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, policy, USER_ID, true);
 224         assertTrue(response.isRight() && response.right().value().getStatus().equals(409));
 225     }
 226
 227     @Test
 228     public void getPolicySuccessTest(){
 229         stubValidationSuccess(CREATE_POLICY);
 230         stubCommit();
 231         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.getPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, USER_ID);
 232         assertTrue(response.isLeft());
 233     }
 234
 235     @Test
 236     public void getPolicyFailureTest(){
 237         stubValidationSuccess(CREATE_POLICY);
 238         stubRollback();
 239         when(componentsUtils.getResponseFormat(eq(ActionStatus.POLICY_NOT_FOUND_ON_CONTAINER), eq(INVALID_POLICY_ID), eq(COMPONENT_ID))).thenReturn(notFoundResponse);
 240         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.getPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, INVALID_POLICY_ID, USER_ID);
 241         assertTrue(response.isRight() && response.right().value().getStatus().equals(404));
 242     }
 243
 244     @Test
 245     public void deletePolicySuccessTest(){
 246         stubValidateAndLockSuccess(CREATE_POLICY);
 247         stubCommit();
 248         when(toscaOperationFacade.removePolicyFromComponent(eq(COMPONENT_ID),eq(POLICY_ID))).thenReturn(StorageOperationStatus.OK);
 249         when(propertyDeclarationOrchestrator.unDeclarePropertiesAsPolicies(any(), any())).thenReturn(StorageOperationStatus.OK);
 250         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.deletePolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, USER_ID, true);
 251         assertTrue(response.isLeft());
 252     }
 253
 254     @Test
 255     public void deletePolicyFailureTest(){
 256         stubValidateAndLockSuccess(CREATE_POLICY);
 257         stubCommit();
 258         stubComponentUtilsGetResponsePOLICY_NOT_FOUND_ON_CONTAINER();
 259         Either<PolicyDefinition, ResponseFormat>  response = businessLogic.deletePolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, INVALID_POLICY_ID, USER_ID, true);
 260         assertNotFound(response);
 261     }
 262
 263     private void stubComponentUtilsGetResponsePOLICY_NOT_FOUND_ON_CONTAINER() {
 264         when(componentsUtils.getResponseFormat(eq(ActionStatus.POLICY_NOT_FOUND_ON_CONTAINER), anyString(), anyString())).thenReturn(new ResponseFormat(404));
 265     }
 266
 267     @Test
 268     public void updatePolicyPropertiesSuccessTest(){
 269         stubValidateAndLockSuccess(CREATE_POLICY);
 270         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 271         String prop1 = "Name";
 272         String prop2 = "Type";
 273         when(propertyOperation.validateAndUpdatePropertyValue(eq(null), eq(prop1), anyBoolean(), eq(null), anyMap())).thenReturn(Either.left(prop1));
 274         when(propertyOperation.validateAndUpdatePropertyValue(eq(null), eq(prop2), anyBoolean(), eq(null), anyMap())).thenReturn(Either.left(prop2));
 275         when(toscaOperationFacade.updatePolicyOfComponent(eq(COMPONENT_ID), any(PolicyDefinition.class))).thenReturn(policySuccessEither);
 276         stubUnlockAndCommit();
 277         PropertyDataDefinition[] properties = getProperties(prop1, prop2);
 278         policy.setProperties(Arrays.asList(properties));
 279         Either<List<PropertyDataDefinition>, ResponseFormat>  response = businessLogic.updatePolicyProperties(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, properties , USER_ID, true);
 280         assertTrue(response.isLeft());
 281         List<PropertyDataDefinition> updatedProperties = response.left().value();
 282         assertThat(updatedProperties.size()).isEqualTo(2);
 283     }
 284
 285     @Test
 286     public void updatePolicyTargetsSuccessTest(){
 287         stubValidateAndLockSuccess(CREATE_POLICY);
 288         stubGetToscaFullElementSuccess();
 289         stubUpdatePolicyOfComponentSuccess();
 290         stubGetToscaElementSuccess();
 291         Either<PolicyDefinition, ResponseFormat> result = businessLogic.updatePolicyTargets(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, getTargets(), USER_ID);
 292         Assert.assertTrue(result.isLeft());
 293         PolicyDefinition policyResult = result.left().value();
 294         Map<PolicyTargetType, List<String>> targets = getTargets();
 295         assertThat(policyResult.getTargets().values()).usingFieldByFieldElementComparator().containsExactlyInAnyOrder(targets.get(PolicyTargetType.GROUPS), targets.get(PolicyTargetType.COMPONENT_INSTANCES));
 296
 297     }
 298
 299     @Test
 300     public void updatePolicyTargetsTargetIDFailureTest(){
 301         stubValidateAndLockSuccess(CREATE_POLICY);
 302         stubGetToscaFullElementSuccess();
 303         stubGetToscaElementSuccess();
 304         stubUpdatePolicyOfComponentSuccess();
 305         stubComponentUtilsGetResponseTargetNotFound();
 306         stubRollback();
 307
 308         Either<PolicyDefinition, ResponseFormat> result = businessLogic.updatePolicyTargets(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, getTargetListFakeId(), USER_ID);
 309
 310         Assert.assertTrue(result.isRight());
 311         ResponseFormat responseResult = result.right().value();
 312         Assert.assertEquals(responseResult.getStatus().longValue(), 400L);
 313
 314     }
 315
 316     private void stubComponentUtilsGetResponseTargetNotFound() {
 317         when(componentsUtils.getResponseFormat(eq(ActionStatus.POLICY_TARGET_DOES_NOT_EXIST), (anyString()))).thenReturn(new ResponseFormat(400));
 318     }
 319
 320     @Test
 321     public void updatePolicyTargetsTypeFailureTest(){
 322         stubValidateAndLockSuccess(CREATE_POLICY);
 323         stubGetToscaFullElementSuccess();
 324         stubGetToscaElementSuccess();
 325         stubUpdatePolicyOfComponentSuccess();
 326         stubComponentUtilsGetResponseTargetNotFound();
 327         stubRollback();
 328
 329         Either<PolicyDefinition, ResponseFormat> result = businessLogic.updatePolicyTargets(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, getTargetListFakeType(), USER_ID);
 330
 331         Assert.assertTrue(result.isRight());
 332         ResponseFormat responseResult = result.right().value();
 333         Assert.assertEquals(400, (int) responseResult.getStatus());
 334
 335     }
 336
 337     private void stubUpdatePolicyOfComponentSuccess() {
 338         when(toscaOperationFacade.updatePolicyOfComponent(eq(COMPONENT_ID), eq(policy))).thenReturn(policySuccessEither);
 339     }
 340
 341
 342     @Test
 343     public void updatePolicyPropertiesFailureTest(){
 344         stubValidateAndLockSuccess(CREATE_POLICY);
 345         when(componentsUtils.getResponseFormat(eq(ActionStatus.PROPERTY_NOT_FOUND))).thenReturn(notFoundResponse);
 346         stubUnlockAndRollback();
 347         policy.setProperties(null);
 348         Either<List<PropertyDataDefinition>, ResponseFormat>  response = businessLogic.updatePolicyProperties(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, getProperties("Name", "Type") , USER_ID, true);
 349         assertTrue(response.isRight() && response.right().value().getStatus().equals(404));
 350     }
 351
 352     private PropertyDataDefinition[] getProperties(String prop1, String prop2) {
 353         PropertyDataDefinition property1 = new PropertyDataDefinition();
 354         property1.setName(prop1);
 355         property1.setValue(prop1);
 356         PropertyDataDefinition property2 = new PropertyDataDefinition();
 357         property2.setName(prop2);
 358         property2.setValue(prop2);
 359         return new PropertyDataDefinition[]{property1, property2};
 360     }
 361
 362
 363     private void stubUnlockAndRollback() {
 364         when(graphLockOperation.unlockComponent(eq(COMPONENT_ID), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
 365         stubRollback();
 366     }
 367
 368     private void stubCommit() {
 369         when(titanDao.commit()).thenReturn(TitanOperationStatus.OK);
 370     }
 371
 372     private void stubRollback() {
 373         when(titanDao.rollback()).thenReturn(TitanOperationStatus.OK);
 374     }
 375
 376     private void stubUnlockAndCommit() {
 377         when(graphLockOperation.unlockComponent(eq(COMPONENT_ID), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
 378         stubCommit();
 379     }
 380
 381     private void stubValidateAndLockSuccess(String methodName) {
 382         stubValidationSuccess(methodName);
 383         when(graphLockOperation.lockComponent(eq(COMPONENT_ID), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
 384    }
 385
 386     private void stubValidationSuccess(String methodName) {
 387         when(userValidations.validateUserExists(eq(USER_ID), eq(methodName), eq(false))).thenReturn(user);
 388         when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(componentSuccessEither);
 389     }
 390
 391     private void stubGetToscaFullElementSuccess() {
 392         when(toscaOperationFacade.getToscaFullElement(eq(COMPONENT_ID))).thenReturn(buildElementEither());
 393     }
 394
 395     private void stubGetToscaElementSuccess() {
 396         when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID))).thenReturn(componentSuccessEither);
 397     }
 398
 399     private Either<Component, StorageOperationStatus> buildElementEither() {
 400         ResourceBuilder builder = new ResourceBuilder();
 401         GroupDefinition groupDefinition = GroupDefinitionBuilder.create().setUniqueId(UNIQUE_ID_EXSISTS).build();
 402         ComponentInstanceBuilder componentInstanceBuilder = new ComponentInstanceBuilder();
 403         ComponentInstance componentInstance = componentInstanceBuilder.setUniqueId(UNIQUE_ID_EXSISTS).build();
 404         return Either.left(builder.addGroup(groupDefinition).addComponentInstance(componentInstance).build());
 405     }
 406
 407     private Map<PolicyTargetType, List<String>> getTargets() {
 408         Map<PolicyTargetType, List<String>> targets = new HashMap<>();
 409         targets.put(PolicyTargetType.COMPONENT_INSTANCES, Collections.singletonList(UNIQUE_ID_EXSISTS));
 410         targets.put(PolicyTargetType.GROUPS, Collections.singletonList(UNIQUE_ID_EXSISTS));
 411         return targets;
 412     }
 413
 414
 415
 416     private static PolicyTypeDefinition buildPolicyType() {
 417         PolicyTypeDefinition policyType = new PolicyTypeDefinition();
 418         policyType.setType(POLICY_TYPE_NAME);
 419         return policyType;
 420     }
 421
 422     private static PolicyDefinition buildPolicy(String policyName) {
 423         PolicyDefinition policy = new PolicyDefinition();
 424         policy.setUniqueId(POLICY_ID);
 425         policy.setPolicyTypeName(POLICY_TYPE_NAME);
 426         policy.setComponentName(COMPONENT_NAME);
 427         policy.setName(policyName);
 428         return policy;
 429     }
 430
 431     private static Resource buildResource() {
 432         Resource resource = new Resource();
 433         resource.setUniqueId(COMPONENT_ID);
 434         resource.setName(COMPONENT_NAME);
 435         resource.setCreatorUserId(USER_ID);
 436         resource.setLastUpdaterUserId(USER_ID);
 437         resource.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 438         resource.setIsDeleted(false);
 439         resource.setResourceType(ResourceTypeEnum.VF);
 440         resource.setToscaType(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue());
 441         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 442         Map<String, PolicyDefinition> policies = new HashMap<>();
 443         policies.put(POLICY_ID, policy);
 444         resource.setPolicies(policies);
 445         return resource;
 446     }
 447
 448     private static User buildUser() {
 449         User user = new User();
 450         user.setUserId(USER_ID);
 451         return user;
 452     }
 453
 454     private Map<PolicyTargetType, List<String>> getTargetListFakeType() {
 455         Map<PolicyTargetType, List<String>> targets = new HashMap<>();
 456         targets.put(PolicyTargetType.TYPE_DOES_NOT_EXIST, Collections.singletonList(UNIQUE_ID_EXSISTS));
 457         return targets;
 458     }
 459
 460     private Map<PolicyTargetType, List<String>> getTargetListFakeId() {
 461         Map<PolicyTargetType, List<String>> targets = new HashMap<>();
 462         targets.put(PolicyTargetType.COMPONENT_INSTANCES, Collections.singletonList(UNIQUE_ID_DOESNT_EXSISTS));
 463         targets.put(PolicyTargetType.GROUPS, Collections.singletonList(UNIQUE_ID_DOESNT_EXSISTS));
 464         return targets;
 465     }
 466
 467 }