gerrit.onap Code Review - sdc.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2020 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.junit.Before;
  25 import org.mockito.Mockito;
  26 import org.openecomp.sdc.ElementOperationMock;
  27 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  28 import org.openecomp.sdc.be.components.distribution.engine.DistributionEngine;
  29 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  30 import org.openecomp.sdc.be.components.impl.generic.GenericTypeBusinessLogic;
  31 import org.openecomp.sdc.be.components.path.ForwardingPathValidator;
  32 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
  33 import org.openecomp.sdc.be.components.validation.ServiceDistributionValidation;
  34 import org.openecomp.sdc.be.components.validation.UserValidations;
  35 import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator;
  36 import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator;
  37 import org.openecomp.sdc.be.components.validation.component.ComponentFieldValidator;
  38 import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator;
  39 import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator;
  40 import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator;
  41 import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator;
  42 import org.openecomp.sdc.be.components.validation.component.ComponentValidator;
  43 import org.openecomp.sdc.be.components.validation.service.ServiceCategoryValidator;
  44 import org.openecomp.sdc.be.components.validation.service.ServiceEnvironmentContextValidator;
  45 import org.openecomp.sdc.be.components.validation.service.ServiceFieldValidator;
  46 import org.openecomp.sdc.be.components.validation.service.ServiceFunctionValidator;
  47 import org.openecomp.sdc.be.components.validation.service.ServiceInstantiationTypeValidator;
  48 import org.openecomp.sdc.be.components.validation.service.ServiceNamingPolicyValidator;
  49 import org.openecomp.sdc.be.components.validation.service.ServiceRoleValidator;
  50 import org.openecomp.sdc.be.components.validation.service.ServiceTypeValidator;
  51 import org.openecomp.sdc.be.components.validation.service.ServiceValidator;
  52 import org.openecomp.sdc.be.dao.api.ActionStatus;
  53 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
  54 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  55 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
  56 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  57 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  58 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  59 import org.openecomp.sdc.be.facade.operations.CatalogOperation;
  60 import org.openecomp.sdc.be.impl.ComponentsUtils;
  61 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  62 import org.openecomp.sdc.be.model.ArtifactDefinition;
  63 import org.openecomp.sdc.be.model.Component;
  64 import org.openecomp.sdc.be.model.Resource;
  65 import org.openecomp.sdc.be.model.Service;
  66 import org.openecomp.sdc.be.model.User;
  67 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  68 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
  69 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  70 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  71 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  72 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  73 import org.openecomp.sdc.be.resources.data.auditing.DistributionDeployEvent;
  74 import org.openecomp.sdc.be.resources.data.auditing.DistributionNotificationEvent;
  75 import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
  76 import org.openecomp.sdc.be.user.Role;
  77 import org.openecomp.sdc.be.user.UserBusinessLogic;
  78 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  79 import org.openecomp.sdc.common.api.Constants;
  80 import org.openecomp.sdc.exception.ResponseFormat;
  81 import org.springframework.web.context.WebApplicationContext;
  82
  83 import javax.servlet.ServletContext;
  84 import java.util.ArrayList;
  85 import java.util.Arrays;
  86 import java.util.Collections;
  87 import java.util.List;
  88
  89 import static org.junit.Assert.assertEquals;
  90 import static org.mockito.ArgumentMatchers.anyString;
  91 import static org.mockito.ArgumentMatchers.eq;
  92 import static org.mockito.Mockito.when;
  93
  94 public class ServiceBussinessLogicBaseTestSetup extends BaseBusinessLogicMock{
  95
  96     protected ServiceBusinessLogic bl;
  97     protected static final String SERVICE_CATEGORY = "Mobility";
  98     protected static final String INSTANTIATION_TYPE = "A-la-carte";
  99     protected final ServletContext servletContext = Mockito.mock(ServletContext.class);
 100     protected UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
 101     protected WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
 102     protected WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
 103     protected ResponseFormatManager responseManager = null;
 104     protected ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
 105     protected AuditCassandraDao auditingDao = Mockito.mock(AuditCassandraDao.class);
 106     protected ArtifactsBusinessLogic artifactBl = Mockito.mock(ArtifactsBusinessLogic.class);
 107     protected GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
 108     protected JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
 109     protected ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
 110     protected GenericTypeBusinessLogic genericTypeBusinessLogic = Mockito.mock(GenericTypeBusinessLogic.class);
 111     protected UserValidations userValidations = Mockito.mock(UserValidations.class);
 112     protected ResourceAdminEvent auditArchive1 = Mockito.mock(ResourceAdminEvent.class);
 113     protected CatalogOperation catalogOperation = Mockito.mock(CatalogOperation.class);
 114     protected ResourceAdminEvent auditArchive2 = Mockito.mock(ResourceAdminEvent.class);
 115     protected ResourceAdminEvent auditRestore = Mockito.mock(ResourceAdminEvent.class);
 116     IElementOperation mockElementDao = new ElementOperationMock();
 117     DistributionEngine distributionEngine =  Mockito.mock(DistributionEngine.class);
 118     ServiceDistributionValidation serviceDistributionValidation = Mockito.mock(ServiceDistributionValidation.class);
 119     ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
 120     ForwardingPathValidator forwardingPathValidator = Mockito.mock(ForwardingPathValidator.class);
 121     UiComponentDataConverter uiComponentDataConverter = Mockito.mock(UiComponentDataConverter.class);
 122     protected final NodeFilterOperation serviceFilterOperation = Mockito.mock(NodeFilterOperation.class);
 123     protected final NodeFilterValidator serviceFilterValidator = Mockito.mock(NodeFilterValidator.class);
 124     protected ServiceTypeValidator serviceTypeValidator = new ServiceTypeValidator(componentsUtils);
 125     protected ServiceCategoryValidator serviceCategoryValidator = new ServiceCategoryValidator(componentsUtils, mockElementDao);
 126     protected ServiceRoleValidator serviceRoleValidator = new ServiceRoleValidator(componentsUtils);
 127     protected ServiceFunctionValidator serviceFunctionValidator = new ServiceFunctionValidator(componentsUtils);
 128     protected ServiceInstantiationTypeValidator serviceInstantiationTypeValidator = new ServiceInstantiationTypeValidator(componentsUtils);
 129     protected ComponentDescriptionValidator componentDescriptionValidator =  new ComponentDescriptionValidator(componentsUtils);
 130     protected ComponentProjectCodeValidator componentProjectCodeValidator =  new ComponentProjectCodeValidator(componentsUtils);
 131     protected ComponentIconValidator componentIconValidator = new ComponentIconValidator(componentsUtils);
 132     protected ComponentContactIdValidator componentContactIdValidator = new ComponentContactIdValidator(componentsUtils);
 133     protected ComponentTagsValidator componentTagsValidator = new ComponentTagsValidator(componentsUtils);
 134     protected ComponentNameValidator componentNameValidator = new ComponentNameValidator(componentsUtils, toscaOperationFacade);
 135     protected final ComponentValidator componentValidator = Mockito.mock(ComponentValidator.class);
 136     protected ServiceValidator serviceValidator = createServiceValidator();
 137
 138
 139
 140
 141     protected User user = null;
 142     protected Resource genericService = null;
 143
 144     protected static final String CERTIFIED_VERSION = "1.0";
 145     protected static final String UNCERTIFIED_VERSION = "0.2";
 146     protected static final String COMPONNET_ID = "myUniqueId";
 147     protected static final String GENERIC_SERVICE_NAME = "org.openecomp.resource.abstract.nodes.service";
 148
 149     protected static final String SERVICE_ROLE = JsonPresentationFields.SERVICE_ROLE.getPresentation();
 150     protected static final String SERVICE_TYPE = JsonPresentationFields.SERVICE_TYPE.getPresentation();
 151     protected static final String SERVICE_FUNCTION = JsonPresentationFields.SERVICE_FUNCTION.getPresentation();
 152
 153     public ServiceBussinessLogicBaseTestSetup() {
 154
 155     }
 156
 157     protected ServiceValidator createServiceValidator() {
 158         List<ComponentFieldValidator> componentFieldValidators = Arrays.asList(componentContactIdValidator,
 159                 componentDescriptionValidator,
 160                 componentIconValidator, componentNameValidator,
 161                 new ComponentProjectCodeValidator(componentsUtils),
 162                 componentTagsValidator);
 163
 164         List<ServiceFieldValidator> serviceFieldValidators = Arrays.asList(serviceCategoryValidator, new ServiceEnvironmentContextValidator(),
 165                 serviceInstantiationTypeValidator, new ServiceNamingPolicyValidator(componentsUtils),
 166                 serviceRoleValidator, serviceTypeValidator);
 167         return new ServiceValidator(componentsUtils, componentFieldValidators, serviceFieldValidators);
 168     }
 169
 170
 171
 172     @Before
 173     public void setup() {
 174
 175         // Elements
 176         IElementOperation mockElementDao = new ElementOperationMock();
 177
 178         // User data and management
 179         user = new User();
 180         user.setUserId("jh0003");
 181         user.setFirstName("Jimmi");
 182         user.setLastName("Hendrix");
 183         user.setRole(Role.ADMIN.name());
 184
 185         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
 186         when(userValidations.validateUserExists(eq("jh0003"))).thenReturn(user);
 187         when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
 188 //        when(userValidations.validateUserRole(user))
 189         // Servlet Context attributes
 190         when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
 191 //        when(servletContext.getAttribute(Constants.SERVICE_OPERATION_MANAGER)).thenReturn(new ServiceOperation());
 192         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
 193         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
 194         when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
 195         when(graphLockOperation.lockComponent(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Service))).thenReturn(StorageOperationStatus.OK);
 196         when(graphLockOperation.lockComponentByName(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Service))).thenReturn(StorageOperationStatus.OK);
 197         when(catalogOperation.updateCatalog(Mockito.any(), Mockito.any())).thenReturn(ActionStatus.OK);
 198         // artifact bussinesslogic
 199         ArtifactDefinition artifactDef = new ArtifactDefinition();
 200         when(artifactBl.createArtifactPlaceHolderInfo(Mockito.any(), Mockito.anyString(), Mockito.anyMap(), Mockito.any(User.class), Mockito.any(ArtifactGroupTypeEnum.class))).thenReturn(artifactDef);
 201
 202         // createService
 203         Service serviceResponse = createServiceObject(true);
 204         Either<Component, StorageOperationStatus> eitherCreate = Either.left(serviceResponse);
 205         when(toscaOperationFacade.createToscaComponent(Mockito.any(Component.class))).thenReturn(eitherCreate);
 206         Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
 207         when(toscaOperationFacade.validateComponentNameExists("Service", null, ComponentTypeEnum.SERVICE)).thenReturn(eitherCount);
 208         Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
 209         when(toscaOperationFacade.validateComponentNameExists("alreadyExist", null, ComponentTypeEnum.SERVICE)).thenReturn(eitherCountExist);
 210         when(userValidations.validateUserExists(user)).thenReturn(user);
 211
 212         genericService = setupGenericServiceMock();
 213         Either<Resource, StorageOperationStatus> findLatestGeneric = Either.left(genericService);
 214         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_SERVICE_NAME)).thenReturn(findLatestGeneric);
 215
 216
 217         bl = new ServiceBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
 218                 groupTypeOperation, groupBusinessLogic, interfaceOperation, interfaceLifecycleTypeOperation,
 219                 artifactBl, distributionEngine, componentInstanceBusinessLogic,
 220                 serviceDistributionValidation, forwardingPathValidator, uiComponentDataConverter,
 221                 serviceFilterOperation, serviceFilterValidator, artifactToscaOperation, componentContactIdValidator,
 222                 componentNameValidator, componentTagsValidator, componentValidator,
 223                 componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
 224         bl.setComponentContactIdValidator(componentContactIdValidator);
 225         bl.setComponentIconValidator(componentIconValidator);
 226         bl.setComponentTagsValidator(componentTagsValidator);
 227         bl.setComponentNameValidator(componentNameValidator);
 228         bl.setComponentDescriptionValidator(componentDescriptionValidator);
 229         bl.setComponentProjectCodeValidator(componentProjectCodeValidator);
 230         bl.setServiceCategoryValidator(serviceCategoryValidator);
 231         bl.setServiceTypeValidator(serviceTypeValidator);
 232         bl.setServiceFunctionValidator(serviceFunctionValidator);
 233         bl.setElementDao(mockElementDao);
 234         bl.setUserAdmin(mockUserAdmin);
 235         bl.setArtifactBl(artifactBl);
 236         bl.setServiceValidator(createServiceValidator());
 237         bl.setGraphLockOperation(graphLockOperation);
 238         bl.setJanusGraphDao(mockJanusGraphDao);
 239         bl.setToscaOperationFacade(toscaOperationFacade);
 240         bl.setGenericTypeBusinessLogic(genericTypeBusinessLogic);
 241         bl.setComponentsUtils(componentsUtils);
 242         bl.setCassandraAuditingDao(auditingDao);
 243         bl.setUserValidations(userValidations);
 244         bl.setCatalogOperations(catalogOperation);
 245
 246         mockAuditingDaoLogic();
 247
 248         responseManager = ResponseFormatManager.getInstance();
 249
 250
 251     }
 252
 253     protected Resource setupGenericServiceMock(){
 254         Resource genericService = new Resource();
 255         genericService.setVersion("1.0");
 256         genericService.setToscaResourceName(GENERIC_SERVICE_NAME);
 257         return genericService;
 258     }
 259
 260     protected Service createServiceObject(boolean afterCreate) {
 261         Service service = new Service();
 262         service.setUniqueId("sid");
 263         service.setName("Service");
 264         CategoryDefinition category = new CategoryDefinition();
 265         category.setName(SERVICE_CATEGORY);
 266         category.setIcons(Collections.singletonList("defaulticon"));
 267         List<CategoryDefinition> categories = new ArrayList<>();
 268         categories.add(category);
 269         service.setCategories(categories);
 270         service.setInstantiationType(INSTANTIATION_TYPE);
 271
 272         service.setDescription("description");
 273         List<String> tgs = new ArrayList<>();
 274         tgs.add(service.getName());
 275         service.setTags(tgs);
 276         // service.setVendorName("Motorola");
 277         // service.setVendorRelease("1.0.0");
 278         service.setIcon("defaulticon");
 279         // service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 280         service.setContactId("aa1234");
 281         service.setProjectCode("12345");
 282         service.setEcompGeneratedNaming(true);
 283
 284         if (afterCreate) {
 285             service.setVersion("0.1");
 286             service.setUniqueId(service.getName() + ":" + service.getVersion());
 287             service.setCreatorUserId(user.getUserId());
 288             service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 289         }
 290         return service;
 291     }
 292
 293     private void mockAuditingDaoLogic() {
 294         final ResourceAdminEvent createResourceAudit = new ResourceAdminEvent();
 295         createResourceAudit.setModifier("Carlos Santana(cs0008)");
 296         createResourceAudit.setCurrState("NOT_CERTIFIED_CHECKOUT");
 297         createResourceAudit.setCurrVersion("0.1");
 298         createResourceAudit.setServiceInstanceId("82eddd99-0bd9-4742-ab0a-1bdb5e262a05");
 299         createResourceAudit.setRequestId("3e65cea1-7403-4bc7-b461-e2544d83799f");
 300         createResourceAudit.setDesc("OK");
 301         createResourceAudit.setResourceType("Resource");
 302         createResourceAudit.setStatus("201");
 303         createResourceAudit.setPrevVersion("");
 304         createResourceAudit.setAction("Create");
 305         // fields.put("TIMESTAMP", "2015-11-22 09:19:12.977");
 306         createResourceAudit.setPrevState("");
 307         createResourceAudit.setResourceName("MyTestResource");
 308         // createResourceAudit.setFields(fields);
 309
 310         final ResourceAdminEvent checkInResourceAudit = new ResourceAdminEvent();
 311         checkInResourceAudit.setModifier("Carlos Santana(cs0008)");
 312         checkInResourceAudit.setCurrState("NOT_CERTIFIED_CHECKIN");
 313         checkInResourceAudit.setCurrVersion("0.1");
 314         checkInResourceAudit.setServiceInstanceId("82eddd99-0bd9-4742-ab0a-1bdb5e262a05");
 315         checkInResourceAudit.setRequestId("ffacbf5d-eeb1-43c6-a310-37fe7e1cc091");
 316         checkInResourceAudit.setDesc("OK");
 317         checkInResourceAudit.setComment("Stam");
 318         checkInResourceAudit.setResourceType("Resource");
 319         checkInResourceAudit.setStatus("200");
 320         checkInResourceAudit.setPrevVersion("0.1");
 321         checkInResourceAudit.setAction("Checkin");
 322         // fields.put("TIMESTAMP", "2015-11-22 09:25:03.797");
 323         checkInResourceAudit.setPrevState("NOT_CERTIFIED_CHECKOUT");
 324         checkInResourceAudit.setResourceName("MyTestResource");
 325
 326         final ResourceAdminEvent checkOutResourceAudit = new ResourceAdminEvent();
 327         checkOutResourceAudit.setModifier("Carlos Santana(cs0008)");
 328         checkOutResourceAudit.setCurrState("NOT_CERTIFIED_CHECKOUT");
 329         checkOutResourceAudit.setCurrVersion("0.2");
 330         checkOutResourceAudit.setServiceInstanceId("82eddd99-0bd9-4742-ab0a-1bdb5e262a05");
 331         checkOutResourceAudit.setRequestId("7add5078-4c16-4d74-9691-cc150e3c96b8");
 332         checkOutResourceAudit.setDesc("OK");
 333         checkOutResourceAudit.setComment("");
 334         checkOutResourceAudit.setResourceType("Resource");
 335         checkOutResourceAudit.setStatus("200");
 336         checkOutResourceAudit.setPrevVersion("0.1");
 337         checkOutResourceAudit.setAction("Checkout");
 338         // fields.put("TIMESTAMP", "2015-11-22 09:39:41.024");
 339         checkOutResourceAudit.setPrevState("NOT_CERTIFIED_CHECKIN");
 340         checkOutResourceAudit.setResourceName("MyTestResource");
 341         // checkOutResourceAudit.setFields(fields);
 342
 343         // Mockito.doAnswer(new Answer<Either<List<ESTimeBasedEvent>,
 344         // ActionStatus> >() {
 345         // public Either<List<ESTimeBasedEvent>, ActionStatus>
 346         // answer(InvocationOnMock invocation) {
 347         // final Either<List<ESTimeBasedEvent>, ActionStatus> either;
 348         // final List<ESTimeBasedEvent> list;
 349         // Object[] args = invocation.getArguments();
 350         // Map<AuditingFieldsKey, Object> filterMap =
 351         // (Map<AuditingFieldsKey, Object>) args[0];
 352         // if( filterMap.equals(FILTER_MAP_CERTIFIED_VERSION) ){
 353         // list = new
 354         // ArrayList<ESTimeBasedEvent>(){{add(createResourceAudit);add(checkInResourceAudit);add(checkOutResourceAudit);}};
 355         // either = Either.left(list);
 356         //
 357         // }
 358         // else if( filterMap.equals(FILTER_MAP_UNCERTIFIED_VERSION_PREV) ){
 359         // list = new ArrayList<ESTimeBasedEvent>();
 360         // either = Either.left(list);
 361         // }
 362         // else if( filterMap.equals(FILTER_MAP_UNCERTIFIED_VERSION_CURR) ){
 363         // list = new
 364         // ArrayList<ESTimeBasedEvent>(){{/*add(createResourceAudit);add(checkInResourceAudit);*/add(checkOutResourceAudit);}};
 365         // either = Either.left(list);
 366         // }
 367         // else{
 368         // either = null;
 369         // }
 370         // return either;
 371         // }
 372         // }).when(auditingDao).getFilteredResourceAdminAuditingEvents(Mockito.anyMap());
 373         //
 374         //
 375         List<ResourceAdminEvent> list = new ArrayList<ResourceAdminEvent>() {
 376             {
 377                 add(createResourceAudit);
 378                 add(checkInResourceAudit);
 379                 add(checkOutResourceAudit);
 380             }
 381         };
 382         Either<List<ResourceAdminEvent>, ActionStatus> result = Either.left(list);
 383         Mockito.when(auditingDao.getByServiceInstanceId(Mockito.anyString())).thenReturn(result);
 384
 385         List<ResourceAdminEvent> listPrev = new ArrayList<>();
 386         Either<List<ResourceAdminEvent>, ActionStatus> resultPrev = Either.left(listPrev);
 387         Mockito.when(auditingDao.getAuditByServiceIdAndPrevVersion(Mockito.anyString(), Mockito.anyString())).thenReturn(resultPrev);
 388
 389         List<ResourceAdminEvent> listCurr = new ArrayList<ResourceAdminEvent>() {
 390             {
 391                 add(checkOutResourceAudit);
 392             }
 393         };
 394         Either<List<ResourceAdminEvent>, ActionStatus> resultCurr = Either.left(listCurr);
 395         Mockito.when(auditingDao.getAuditByServiceIdAndCurrVersion(Mockito.anyString(), Mockito.anyString())).thenReturn(resultCurr);
 396
 397         Either<List<ResourceAdminEvent>, ActionStatus> archiveAuditList = Either.left(Arrays.asList(auditArchive1, auditArchive2));
 398         when(auditingDao.getArchiveAuditByServiceInstanceId(anyString())).thenReturn(archiveAuditList);
 399
 400         Either<List<ResourceAdminEvent>, ActionStatus> restoreAuditList = Either.left(Collections.singletonList(auditRestore));
 401         when(auditingDao.getRestoreAuditByServiceInstanceId(anyString())).thenReturn(restoreAuditList);
 402
 403     }
 404
 405     protected void setupBeforeDeploy(String notifyAction, String requestAction, String did) {
 406
 407         DistributionNotificationEvent notifyEvent = new DistributionNotificationEvent();
 408         notifyEvent.setAction(notifyAction);
 409         notifyEvent.setDid(did);
 410         notifyEvent.setStatus("200");
 411
 412         ResourceAdminEvent requestEvent = new ResourceAdminEvent();
 413         requestEvent.setAction(requestAction);
 414         requestEvent.setDid(did);
 415         requestEvent.setStatus("200");
 416
 417         List<DistributionNotificationEvent> notifyResults = Collections.singletonList(notifyEvent);
 418         Either<List<DistributionNotificationEvent>, ActionStatus> eitherNotify = Either.left(notifyResults);
 419
 420         Mockito.when(auditingDao.getDistributionNotify(Mockito.anyString(), Mockito.eq(notifyAction))).thenReturn(eitherNotify);
 421
 422         List<ResourceAdminEvent> requestResults = Collections.singletonList(requestEvent);
 423         Either<List<ResourceAdminEvent>, ActionStatus> eitherRequest = Either.left(requestResults);
 424         Mockito.when(auditingDao.getDistributionRequest(Mockito.anyString(), Mockito.eq(requestAction))).thenReturn(eitherRequest);
 425
 426         Either<Component, StorageOperationStatus> eitherService = Either.left(createServiceObject(true));
 427         Mockito.when(toscaOperationFacade.getToscaElement(Mockito.anyString())).thenReturn(eitherService);
 428
 429         Either<List<DistributionDeployEvent>, ActionStatus> emptyEventList = Either.left(Collections.emptyList());
 430         Mockito.when(auditingDao.getDistributionDeployByStatus(Mockito.anyString(), Mockito.eq("DResult"), Mockito.anyString())).thenReturn(emptyEventList);
 431     }
 432
 433     private void assertResponse(Either<Service, ResponseFormat> createResponse, ActionStatus expectedStatus, String... variables) {
 434         assertResponse(createResponse.right().value(), expectedStatus, variables);
 435     }
 436
 437     protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
 438         ResponseFormat actualResponse = e.getResponseFormat() != null ?
 439                 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
 440         assertResponse(actualResponse, expectedStatus, variables);
 441     }
 442
 443     protected void assertResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
 444         ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
 445         assertEquals(expectedResponse.getStatus(), actualResponse.getStatus());
 446         assertEquals("assert error description", expectedResponse.getFormattedMessage(), actualResponse.getFormattedMessage());
 447     }
 448
 449 }