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

   1 /*
   2  * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.openecomp.sdc.be.components.impl;
  17
  18 import fj.data.Either;
  19 import org.junit.jupiter.api.BeforeEach;
  20 import org.mockito.Mockito;
  21 import org.openecomp.sdc.ElementOperationMock;
  22 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  23 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
  24 import org.openecomp.sdc.be.components.csar.CsarInfo;
  25 import org.openecomp.sdc.be.components.distribution.engine.DistributionEngine;
  26 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  27 import org.openecomp.sdc.be.components.impl.generic.GenericTypeBusinessLogic;
  28 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
  29 import org.openecomp.sdc.be.components.path.ForwardingPathValidator;
  30 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
  31 import org.openecomp.sdc.be.components.validation.ServiceDistributionValidation;
  32 import org.openecomp.sdc.be.components.validation.UserValidations;
  33 import org.openecomp.sdc.be.components.validation.component.*;
  34 import org.openecomp.sdc.be.components.validation.service.*;
  35 import org.openecomp.sdc.be.dao.api.ActionStatus;
  36 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
  37 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  38 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
  39 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  40 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  41 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  42 import org.openecomp.sdc.be.externalapi.servlet.representation.*;
  43 import org.openecomp.sdc.be.facade.operations.CatalogOperation;
  44 import org.openecomp.sdc.be.impl.ComponentsUtils;
  45 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  46 import org.openecomp.sdc.be.model.*;
  47 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  48 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
  49 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  50 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  51 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  52 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  53 import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
  54 import org.openecomp.sdc.be.user.Role;
  55 import org.openecomp.sdc.be.user.UserBusinessLogic;
  56 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  57 import org.openecomp.sdc.common.api.Constants;
  58 import org.openecomp.sdc.common.api.UploadArtifactInfo;
  59 import org.openecomp.sdc.exception.ResponseFormat;
  60 import org.springframework.web.context.WebApplicationContext;
  61
  62 import javax.servlet.ServletContext;
  63 import java.io.IOException;
  64 import java.nio.file.Files;
  65 import java.nio.file.Path;
  66 import java.nio.file.Paths;
  67 import java.util.*;
  68
  69 import static org.junit.jupiter.api.Assertions.assertEquals;
  70 import static org.mockito.ArgumentMatchers.*;
  71 import static org.mockito.Mockito.when;
  72
  73 public class ServiceImportBussinessLogicBaseTestSetup extends BaseBusinessLogicMock {
  74     protected ServiceImportBusinessLogic sIB1;
  75     protected static final String SERVICE_CATEGORY = "Mobility";
  76     protected static final String INSTANTIATION_TYPE = "A-la-carte";
  77     protected final ServletContext servletContext = Mockito.mock(ServletContext.class);
  78     protected UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
  79     protected WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
  80     protected WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
  81     protected ResponseFormatManager responseManager = null;
  82     protected ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
  83     protected AuditCassandraDao auditingDao = Mockito.mock(AuditCassandraDao.class);
  84     protected ArtifactsBusinessLogic artifactBl = Mockito.mock(ArtifactsBusinessLogic.class);
  85     protected GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
  86     protected JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
  87     protected ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
  88     protected CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic = Mockito.mock(CsarArtifactsAndGroupsBusinessLogic.class);
  89     protected GenericTypeBusinessLogic genericTypeBusinessLogic = Mockito.mock(GenericTypeBusinessLogic.class);
  90     protected UserValidations userValidations = Mockito.mock(UserValidations.class);
  91     protected ResourceAdminEvent auditArchive1 = Mockito.mock(ResourceAdminEvent.class);
  92     protected CatalogOperation catalogOperation = Mockito.mock(CatalogOperation.class);
  93     protected ResourceAdminEvent auditArchive2 = Mockito.mock(ResourceAdminEvent.class);
  94     protected ResourceAdminEvent auditRestore = Mockito.mock(ResourceAdminEvent.class);
  95     protected ServiceImportParseLogic serviceImportParseLogic = Mockito.mock(ServiceImportParseLogic.class);
  96     IElementOperation mockElementDao = new ElementOperationMock();
  97     DistributionEngine distributionEngine = Mockito.mock(DistributionEngine.class);
  98     ServiceDistributionValidation serviceDistributionValidation = Mockito.mock(ServiceDistributionValidation.class);
  99     ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
 100     ForwardingPathValidator forwardingPathValidator = Mockito.mock(ForwardingPathValidator.class);
 101     UiComponentDataConverter uiComponentDataConverter = Mockito.mock(UiComponentDataConverter.class);
 102     NodeFilterOperation serviceFilterOperation = Mockito.mock(NodeFilterOperation.class);
 103     NodeFilterValidator serviceFilterValidator = Mockito.mock(NodeFilterValidator.class);
 104     protected ServiceTypeValidator serviceTypeValidator = new ServiceTypeValidator(componentsUtils);
 105     protected ServiceCategoryValidator serviceCategoryValidator = new ServiceCategoryValidator(componentsUtils, mockElementDao);
 106     protected ServiceRoleValidator serviceRoleValidator = new ServiceRoleValidator(componentsUtils);
 107     protected ServiceFunctionValidator serviceFunctionValidator = new ServiceFunctionValidator(componentsUtils);
 108     protected ServiceInstantiationTypeValidator serviceInstantiationTypeValidator = new ServiceInstantiationTypeValidator(componentsUtils);
 109     protected ComponentDescriptionValidator componentDescriptionValidator = new ComponentDescriptionValidator(componentsUtils);
 110     protected ComponentProjectCodeValidator componentProjectCodeValidator = new ComponentProjectCodeValidator(componentsUtils);
 111     protected ComponentIconValidator componentIconValidator = new ComponentIconValidator(componentsUtils);
 112     protected ComponentContactIdValidator componentContactIdValidator = new ComponentContactIdValidator(componentsUtils);
 113     protected ComponentTagsValidator componentTagsValidator = new ComponentTagsValidator(componentsUtils);
 114     protected ComponentNameValidator componentNameValidator = new ComponentNameValidator(componentsUtils, toscaOperationFacade);
 115     protected final ComponentValidator componentValidator = Mockito.mock(ComponentValidator.class);
 116     protected ServiceValidator serviceValidator = createServiceValidator();
 117
 118     protected User user = null;
 119     protected Resource genericService = null;
 120
 121     private static final String RESOURCE_NAME = "My-Resource_Name with   space";
 122     private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name";
 123     private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
 124     private static final String RESOURCE_SUBCATEGORY = "Router";
 125     protected static final String CERTIFIED_VERSION = "1.0";
 126     protected static final String UNCERTIFIED_VERSION = "0.2";
 127     protected static final String COMPONNET_ID = "myUniqueId";
 128     protected static final String GENERIC_SERVICE_NAME = "org.openecomp.resource.abstract.nodes.service";
 129
 130     protected static final String SERVICE_ROLE = JsonPresentationFields.SERVICE_ROLE.getPresentation();
 131     protected static final String SERVICE_TYPE = JsonPresentationFields.SERVICE_TYPE.getPresentation();
 132     protected static final String SERVICE_FUNCTION = JsonPresentationFields.SERVICE_FUNCTION.getPresentation();
 133
 134     public ServiceImportBussinessLogicBaseTestSetup() {
 135
 136     }
 137
 138     protected ServiceValidator createServiceValidator() {
 139         List<ComponentFieldValidator> componentFieldValidators = Arrays.asList(componentContactIdValidator,
 140                 componentDescriptionValidator,
 141                 componentIconValidator, componentNameValidator,
 142                 new ComponentProjectCodeValidator(componentsUtils),
 143                 componentTagsValidator);
 144
 145         List<ServiceFieldValidator> serviceFieldValidators = Arrays.asList(serviceCategoryValidator, new ServiceEnvironmentContextValidator(),
 146                 serviceInstantiationTypeValidator, new ServiceNamingPolicyValidator(componentsUtils),
 147                 serviceRoleValidator, serviceTypeValidator);
 148         return new ServiceValidator(componentsUtils, componentFieldValidators, serviceFieldValidators);
 149     }
 150
 151     @BeforeEach
 152     public void setup() throws IOException {
 153
 154         // Elements
 155         IElementOperation mockElementDao = new ElementOperationMock();
 156
 157         // User data and management
 158         user = new User();
 159         user.setUserId("jh0003");
 160         user.setFirstName("Jimmi");
 161         user.setLastName("Hendrix");
 162         user.setRole(Role.ADMIN.name());
 163
 164         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
 165         when(userValidations.validateUserExists(eq("jh0003"))).thenReturn(user);
 166         when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
 167 //        when(userValidations.validateUserRole(user))
 168         // Servlet Context attributes
 169         when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
 170 //        when(servletContext.getAttribute(Constants.SERVICE_OPERATION_MANAGER)).thenReturn(new ServiceOperation());
 171         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
 172         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
 173         when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
 174         when(graphLockOperation.lockComponent(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Service))).thenReturn(StorageOperationStatus.OK);
 175         when(graphLockOperation.lockComponentByName(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Service))).thenReturn(StorageOperationStatus.OK);
 176         when(catalogOperation.updateCatalog(Mockito.any(), Mockito.any())).thenReturn(ActionStatus.OK);
 177         // artifact bussinesslogic
 178         ArtifactDefinition artifactDef = new ArtifactDefinition();
 179         when(artifactBl.createArtifactPlaceHolderInfo(Mockito.any(), Mockito.anyString(), Mockito.anyMap(), Mockito.any(User.class), Mockito.any(ArtifactGroupTypeEnum.class))).thenReturn(artifactDef);
 180
 181         // createService
 182         Service serviceResponse = createServiceObject(true);
 183         Either<Component, StorageOperationStatus> eitherCreate = Either.left(serviceResponse);
 184         when(toscaOperationFacade.createToscaComponent(Mockito.any(Component.class))).thenReturn(eitherCreate);
 185         when(toscaOperationFacade.getToscaElement(Mockito.anyString())).thenReturn(eitherCreate);
 186         Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
 187         when(toscaOperationFacade.validateComponentNameExists("Service", null, ComponentTypeEnum.SERVICE)).thenReturn(eitherCount);
 188         Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
 189         when(toscaOperationFacade.validateComponentNameExists("alreadyExist", null, ComponentTypeEnum.SERVICE)).thenReturn(eitherCountExist);
 190         when(userValidations.validateUserExists(user)).thenReturn(user);
 191
 192         // createResource
 193         Resource resourceRsponse = createParseResourceObject(true);
 194         Either<Component, StorageOperationStatus> eitherResourceCreate = Either.left(resourceRsponse);
 195         when(toscaOperationFacade.createToscaComponent(Mockito.any(Component.class))).thenReturn(eitherResourceCreate);
 196         Either<Component, StorageOperationStatus> eitherResourceRes = Either.left(resourceRsponse);
 197         when(toscaOperationFacade.getToscaFullElement(Mockito.anyString())).thenReturn(eitherResourceRes);
 198
 199         Either<Boolean, StorageOperationStatus> eitherResourceCount = Either.left(false);
 200         when(toscaOperationFacade.validateComponentNameExists("Resource", null, ComponentTypeEnum.RESOURCE)).thenReturn(eitherResourceCount);
 201         Either<Boolean, StorageOperationStatus> eitherResourceCountExist = Either.left(true);
 202         when(toscaOperationFacade.validateComponentNameExists("alreadyExist", null, ComponentTypeEnum.RESOURCE)).thenReturn(eitherResourceCountExist);
 203
 204         genericService = setupGenericServiceMock();
 205         Either<Resource, StorageOperationStatus> findLatestGeneric = Either.left(genericService);
 206         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_SERVICE_NAME)).thenReturn(findLatestGeneric);
 207
 208         when(serviceImportParseLogic.isArtifactDeletionRequired(anyString(),any(),anyBoolean())).thenReturn(true);
 209         Either<Boolean, ResponseFormat> validateCGD = Either.left(true);
 210         when(serviceImportParseLogic.validateCyclicGroupsDependencies(any())).thenReturn(validateCGD);
 211
 212         sIB1 = new ServiceImportBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
 213                 groupTypeOperation, groupBusinessLogic, interfaceOperation, interfaceLifecycleTypeOperation,
 214                 artifactBl, distributionEngine, componentInstanceBusinessLogic,
 215                 serviceDistributionValidation, forwardingPathValidator, uiComponentDataConverter, serviceFilterOperation,
 216                 serviceFilterValidator, artifactToscaOperation, componentContactIdValidator,
 217                 componentNameValidator, componentTagsValidator, componentValidator,
 218                 componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
 219
 220
 221         mockAbstract();
 222
 223         responseManager = ResponseFormatManager.getInstance();
 224     }
 225
 226     protected Service createServiceObject(boolean afterCreate) {
 227         Service service = new Service();
 228         service.setUniqueId("sid");
 229         service.setName("Service");
 230         CategoryDefinition category = new CategoryDefinition();
 231         category.setName(SERVICE_CATEGORY);
 232         category.setIcons(Collections.singletonList("defaulticon"));
 233         List<CategoryDefinition> categories = new ArrayList<>();
 234         categories.add(category);
 235         service.setCategories(categories);
 236         service.setInstantiationType(INSTANTIATION_TYPE);
 237
 238         service.setDescription("description");
 239         List<String> tgs = new ArrayList<>();
 240         tgs.add(service.getName());
 241         service.setTags(tgs);
 242         // service.setVendorName("Motorola");
 243         // service.setVendorRelease("1.0.0");
 244         service.setIcon("defaulticon");
 245         // service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 246         service.setContactId("aa1234");
 247         service.setProjectCode("12345");
 248         service.setEcompGeneratedNaming(true);
 249
 250         if (afterCreate) {
 251             service.setVersion("0.1");
 252             service.setUniqueId(service.getName() + ":" + service.getVersion());
 253             service.setCreatorUserId(user.getUserId());
 254             service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 255         }
 256         return service;
 257     }
 258
 259     protected Resource createResourceObject(boolean afterCreate) {
 260         Resource resource = new Resource();
 261         resource.setUniqueId("sid");
 262         resource.setName("Service");
 263         CategoryDefinition category = new CategoryDefinition();
 264         category.setName(SERVICE_CATEGORY);
 265         category.setIcons(Collections.singletonList("defaulticon"));
 266         List<CategoryDefinition> categories = new ArrayList<>();
 267         categories.add(category);
 268         resource.setCategories(categories);
 269
 270
 271         resource.setDescription("description");
 272         List<String> tgs = new ArrayList<>();
 273         tgs.add(resource.getName());
 274         resource.setTags(tgs);
 275         resource.setIcon("defaulticon");
 276         resource.setContactId("aa1234");
 277         resource.setProjectCode("12345");
 278
 279
 280         if (afterCreate) {
 281             resource.setVersion("0.1");
 282             resource.setUniqueId(resource.getName() + ":" + resource.getVersion());
 283             resource.setCreatorUserId(user.getUserId());
 284             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 285         }
 286         return resource;
 287     }
 288
 289 protected Resource createParseResourceObject(boolean afterCreate) {
 290         Resource resource = new Resource();
 291         resource.setName(RESOURCE_NAME);
 292         resource.setToscaResourceName(RESOURCE_TOSCA_NAME);
 293         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 294         resource.setDescription("My short description");
 295         List<String> tgs = new ArrayList<>();
 296         tgs.add("test");
 297         tgs.add(resource.getName());
 298         resource.setTags(tgs);
 299         List<String> template = new ArrayList<>();
 300         template.add("tosca.nodes.Root");
 301         resource.setDerivedFrom(template);
 302         resource.setVendorName("Motorola");
 303         resource.setVendorRelease("1.0.0");
 304         resource.setContactId("ya5467");
 305         resource.setIcon("defaulticon");
 306         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 307         List<RequirementDefinition> requirementDefinitionList= new ArrayList<>();
 308         requirements.put("test", requirementDefinitionList);
 309         resource.setRequirements(requirements);
 310
 311         if (afterCreate) {
 312             resource.setName(resource.getName());
 313             resource.setVersion("0.1");
 314             resource.setUniqueId(resource.getName()
 315                     .toLowerCase() + ":" + resource.getVersion());
 316             resource.setCreatorUserId(user.getUserId());
 317             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 318             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 319         }
 320         return resource;
 321     }
 322     protected Resource setupGenericServiceMock() {
 323         Resource genericService = new Resource();
 324         genericService.setVersion("1.0");
 325         genericService.setToscaResourceName(GENERIC_SERVICE_NAME);
 326         return genericService;
 327     }
 328
 329
 330     protected Map<String, GroupDefinition> getGroups() {
 331         Map<String, GroupDefinition> groups = new HashMap<>();
 332         GroupDefinition groupDefinition = new GroupDefinition();
 333         groupDefinition.setName("groupDefinitionName");
 334         groups.put("groupsMap",groupDefinition);
 335         return groups;
 336     }
 337
 338     protected UploadComponentInstanceInfo getuploadComponentInstanceInfo(){
 339         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 340         uploadComponentInstanceInfo.setType("resources");
 341         Collection<String> directives = new Collection<String>() {
 342             @Override
 343             public int size() {
 344                 return 0;
 345             }
 346
 347             @Override
 348             public boolean isEmpty() {
 349                 return false;
 350             }
 351
 352             @Override
 353             public boolean contains(Object o) {
 354                 return false;
 355             }
 356
 357             @Override
 358             public Iterator<String> iterator() {
 359                 return null;
 360             }
 361
 362             @Override
 363             public Object[] toArray() {
 364                 return new Object[0];
 365             }
 366
 367             @Override
 368             public <T> T[] toArray(T[] ts) {
 369                 return null;
 370             }
 371
 372             @Override
 373             public boolean add(String s) {
 374                 return false;
 375             }
 376
 377             @Override
 378             public boolean remove(Object o) {
 379                 return false;
 380             }
 381
 382             @Override
 383             public boolean containsAll(Collection<?> collection) {
 384                 return false;
 385             }
 386
 387             @Override
 388             public boolean addAll(Collection<? extends String> collection) {
 389                 return false;
 390             }
 391
 392             @Override
 393             public boolean removeAll(Collection<?> collection) {
 394                 return false;
 395             }
 396
 397             @Override
 398             public boolean retainAll(Collection<?> collection) {
 399                 return false;
 400             }
 401
 402             @Override
 403             public void clear() {
 404
 405             }
 406         };
 407         uploadComponentInstanceInfo.setDirectives(directives);
 408         UploadNodeFilterInfo uploadNodeFilterInfo = new UploadNodeFilterInfo();
 409         Map<String, List<UploadReqInfo>> requirements = new HashMap<>();
 410         List<UploadReqInfo> uploadReqInfoList = new ArrayList<>();
 411         UploadReqInfo uploadReqInfo = new UploadReqInfo();
 412         uploadReqInfo.setName("uploadReqInfo");
 413         uploadReqInfo.setNode("zxjTestImportServiceAb");
 414         uploadReqInfo.setCapabilityName("tosca.capabilities.Node");
 415         uploadReqInfoList.add(uploadReqInfo);
 416         requirements.put("requirements",uploadReqInfoList);
 417         uploadNodeFilterInfo.setName("mme_ipu_vdu.virtualbinding");
 418         uploadComponentInstanceInfo.setCapabilities(getCapabilities());
 419         uploadComponentInstanceInfo.setRequirements(requirements);
 420         uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
 421         return uploadComponentInstanceInfo;
 422     }
 423
 424     protected Map<String, List<UploadCapInfo>> getCapabilities(){
 425         List<UploadCapInfo> uploadCapInfoList = new ArrayList<>();
 426         UploadCapInfo uploadCapInfo = new UploadCapInfo();
 427         uploadCapInfo.setNode("tosca.nodes.Root");
 428         uploadCapInfo.setName("mme_ipu_vdu.dependency");
 429         uploadCapInfoList.add(uploadCapInfo);
 430         Map<String, List<UploadCapInfo>> uploadCapInfoMap = new HashMap<>();
 431         uploadCapInfoMap.put("tosca.capabilities.Node",uploadCapInfoList);
 432         return uploadCapInfoMap;
 433     }
 434
 435     protected List<ComponentInstance> creatComponentInstances(){
 436         List<ComponentInstance> componentInstances = new ArrayList<>();
 437         ComponentInstance componentInstance = new ComponentInstance();
 438         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 439         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
 440         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 441         capabilityDefinition.setName("mme_ipu_vdu.feature");
 442         capabilityDefinitionList.add(capabilityDefinition);
 443         capabilities.put("tosca.capabilities.Node",capabilityDefinitionList);
 444
 445         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 446         List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
 447         RequirementDefinition requirementDefinition = new RequirementDefinition();
 448         requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
 449         requirementDefinitionList.add(requirementDefinition);
 450         requirements.put("tosca.capabilities.Node",requirementDefinitionList);
 451         componentInstance.setRequirements(requirements);
 452         componentInstance.setCapabilities(capabilities);
 453         componentInstance.setUniqueId("uniqueId");
 454         componentInstance.setComponentUid("componentUid");
 455         componentInstance.setName("zxjTestImportServiceAb");
 456         componentInstances.add(componentInstance);
 457         return componentInstances;
 458     }
 459
 460     protected UploadComponentInstanceInfo createUploadComponentInstanceInfo(){
 461         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 462         uploadComponentInstanceInfo.setName("UploadComponentInstanceInfo");
 463         return uploadComponentInstanceInfo;
 464     }
 465
 466     private void mockAbstract() throws IOException {
 467         checkCreateAbstract();
 468         checkCreateOther();
 469         checkCreateFile();
 470     }
 471
 472     private void checkCreateAbstract(){
 473         AbstractResourceInfo abstractResourceInfo = new AbstractResourceInfo();
 474         List<RequirementCapabilityRelDef> componentInstancesRelations = new ArrayList<>();
 475         abstractResourceInfo.setComponentInstancesRelations(componentInstancesRelations);
 476         abstractResourceInfo.setAbstractResourceUniqueId("abstractResourceUniqueId");
 477         abstractResourceInfo.setAbstractResourceName("abstractResourceName");
 478         abstractResourceInfo.setAbstractResourceUUid("abstractResourceUUid");
 479
 480         AbstractResourceInfo getAbstractResourceInfo = new AbstractResourceInfo();
 481         getAbstractResourceInfo.getAbstractResourceName();
 482         getAbstractResourceInfo.getAbstractResourceUniqueId();
 483         getAbstractResourceInfo.getAbstractResourceUUid();
 484         getAbstractResourceInfo.getComponentInstancesRelations();
 485
 486         AbstractTemplateInfo createAbstractTemplateInfo = new AbstractTemplateInfo();
 487         List<AbstractResourceInfo> abstractResourceInfoList = new ArrayList<>();
 488         abstractResourceInfoList.add(abstractResourceInfo);
 489         createAbstractTemplateInfo.setAbstractResourceInfoList(abstractResourceInfoList);
 490         createAbstractTemplateInfo.setServiceUniqueId("serviceUniqueId");
 491         createAbstractTemplateInfo.setIsAbstractTemplate(true);
 492         createAbstractTemplateInfo.setServiceUUid("serviceUUid");
 493
 494         AbstractTemplateInfo getAbstractTemplateInfo = new AbstractTemplateInfo();
 495         getAbstractTemplateInfo.getAbstractResourceInfoList();
 496         getAbstractTemplateInfo.getIsAbstractTemplate();
 497         getAbstractTemplateInfo.getServiceUniqueId();
 498         getAbstractTemplateInfo.getServiceUUid();
 499
 500         CopyServiceInfo copyServiceInfo = new CopyServiceInfo();
 501         copyServiceInfo.setNewServiceName("newServiceName");
 502         copyServiceInfo.setNewServiceUUid("serviceUUid");
 503         copyServiceInfo.setOldServiceUUid("oldServiceUUid");
 504
 505         CopyServiceInfo getCopyServiceInfo = new CopyServiceInfo();
 506         getCopyServiceInfo.getNewServiceName();
 507         getCopyServiceInfo.getNewServiceUUid();
 508         getCopyServiceInfo.getOldServiceUUid();
 509
 510         ReplaceVNFInfo replaceVNFInfo = new ReplaceVNFInfo();
 511         ComponentInstance realVNFComponentInstance = new ComponentInstance();
 512         replaceVNFInfo.setAbstractResourceUniqueId("abstractResourceUniqueId");
 513         replaceVNFInfo.setRealVNFComponentInstance(realVNFComponentInstance);
 514         replaceVNFInfo.setServiceUniqueId("serviceUniqueId");
 515
 516         ReplaceVNFInfo getReplaceVNFInfo = new ReplaceVNFInfo();
 517         getReplaceVNFInfo.getServiceUniqueId();
 518         getReplaceVNFInfo.getAbstractResourceUniqueId();
 519         getReplaceVNFInfo.getRealVNFComponentInstance();
 520     }
 521
 522     private void checkCreateOther(){
 523         ResourceInstanceMetadata resourceInstanceMetadata = new ResourceInstanceMetadata();
 524         List<ArtifactMetadata> artifacts = new ArrayList<>();
 525         resourceInstanceMetadata.setArtifacts(artifacts);
 526         resourceInstanceMetadata.setResoucreType("resoucreType");
 527         resourceInstanceMetadata.setResourceInstanceName("resourceInstanceName");
 528         resourceInstanceMetadata.setResourceInvariantUUID("resourceInvariantUUID");
 529         resourceInstanceMetadata.setResourceName("resourceName");
 530         resourceInstanceMetadata.setResourceUUID("resourceUUID");
 531         resourceInstanceMetadata.setResourceVersion("resourceVersion");
 532
 533         ResourceInstanceMetadata getResourceInstanceMetadata = new ResourceInstanceMetadata();
 534         getResourceInstanceMetadata.getArtifacts();
 535         getResourceInstanceMetadata.getResoucreType();
 536         getResourceInstanceMetadata.getResourceInstanceName();
 537         getResourceInstanceMetadata.getResourceInvariantUUID();
 538         getResourceInstanceMetadata.getResourceName();
 539         getResourceInstanceMetadata.getResourceUUID();
 540         getResourceInstanceMetadata.getResourceVersion();
 541
 542         UploadServiceInfo uploadServiceInfo = new UploadServiceInfo();
 543         List<String> tags = new ArrayList<>();
 544         List<CategoryDefinition> categories = new ArrayList<>();
 545         List<UploadArtifactInfo> artifactList = new ArrayList<>();
 546         uploadServiceInfo.setProjectCode("projectCode");
 547         uploadServiceInfo.setCategories(categories);
 548         uploadServiceInfo.setServiceType("");
 549         uploadServiceInfo.setServiceVendorModelNumber("serviceVendorModelNumber");
 550         uploadServiceInfo.setVendorRelease("vendorRelease");
 551         uploadServiceInfo.setVendorName("vendorName");
 552         uploadServiceInfo.setServiceIconPath("serviceIconPath");
 553         uploadServiceInfo.setName("uploadServiceInfo");
 554         uploadServiceInfo.setContactId("contactId");
 555         uploadServiceInfo.setIcon("icon");
 556         uploadServiceInfo.setNamingPolicy("namingPolicy");
 557         uploadServiceInfo.setEcompGeneratedNaming("ecompGeneratedNaming");
 558         uploadServiceInfo.setServiceEcompNaming("serviceEcompNaming");
 559         uploadServiceInfo.setServiceRole("serviceRole");
 560         uploadServiceInfo.setSubcategory("subcategory");
 561         uploadServiceInfo.setCategory("category");
 562         uploadServiceInfo.setType("type");
 563         uploadServiceInfo.setUUID("UUID");
 564         uploadServiceInfo.setInvariantUUID("invariantUUID");
 565         uploadServiceInfo.setResourceVendorRelease("resourceVendorRelease");
 566         uploadServiceInfo.setResourceVendor("resourceVendor");
 567         uploadServiceInfo.setDescription("description");
 568         uploadServiceInfo.setTags(tags);
 569         uploadServiceInfo.setArtifactList(artifactList);
 570         uploadServiceInfo.setPayloadName("payloadName");
 571         uploadServiceInfo.setPayloadData("payloadData");
 572     }
 573
 574     protected void checkGetUploadServiceInfo(){
 575         UploadServiceInfo uploadServiceInfo = new UploadServiceInfo();
 576         List<String> tags = new ArrayList<>();
 577         List<CategoryDefinition> categories = new ArrayList<>();
 578         List<UploadArtifactInfo> artifactList = new ArrayList<>();
 579         uploadServiceInfo.getProjectCode();
 580         uploadServiceInfo.getCategories();
 581         uploadServiceInfo.getServiceType();
 582         uploadServiceInfo.getServiceVendorModelNumber();
 583         uploadServiceInfo.getVendorRelease();
 584         uploadServiceInfo.getVendorName();
 585         uploadServiceInfo.getServiceIconPath();
 586         uploadServiceInfo.getName();
 587         uploadServiceInfo.getContactId();
 588         uploadServiceInfo.getIcon();
 589         uploadServiceInfo.getNamingPolicy();
 590         uploadServiceInfo.getEcompGeneratedNaming();
 591         uploadServiceInfo.getServiceEcompNaming();
 592         uploadServiceInfo.getServiceRole();
 593         uploadServiceInfo.getSubcategory();
 594         uploadServiceInfo.getCategory();
 595         uploadServiceInfo.getType();
 596         uploadServiceInfo.getUUID();
 597         uploadServiceInfo.getInvariantUUID();
 598         uploadServiceInfo.getResourceVendorRelease();
 599         uploadServiceInfo.getResourceVendor();
 600         uploadServiceInfo.getDescription();
 601         uploadServiceInfo.getTags();
 602         uploadServiceInfo.getArtifactList();
 603         uploadServiceInfo.getPayloadName();
 604         uploadServiceInfo.getPayloadData();
 605     }
 606
 607     private void checkCreateFile() throws IOException {
 608         CreateServiceFromYamlParameter csfp = new CreateServiceFromYamlParameter();
 609         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
 610         ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
 611         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 612         CsarInfo csarInfo = getCsarInfo();
 613         csfp.setYamlName("yamlName");
 614         csfp.setNodeTypesInfo(nodeTypesInfo);
 615         csfp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
 616         csfp.setCsarInfo(csarInfo);
 617         csfp.setCreatedArtifacts(createdArtifacts);
 618         csfp.setYamlName("yamlName");
 619         csfp.setShouldLock(true);
 620         csfp.setInTransaction(true);
 621         csfp.setNodeName("nodeName");
 622
 623         CreateServiceFromYamlParameter getCsfy = new CreateServiceFromYamlParameter();
 624         getCsfy.getYamlName();
 625         getCsfy.getNodeTypesInfo();
 626         getCsfy.getParsedToscaYamlInfo();
 627         getCsfy.getCsarInfo();
 628         getCsfy.getCreatedArtifacts();
 629         getCsfy.getYamlName();
 630         getCsfy.isShouldLock();
 631         getCsfy.isInTransaction();
 632         getCsfy.getNodeName();
 633     }
 634
 635     protected CsarInfo getCsarInfo () throws IOException {
 636         String csarUuid = "0010";
 637         User user = new User();
 638         Map<String, byte[]> csar = crateCsarFromPayload();
 639         String vfReousrceName = "resouceName";
 640         String mainTemplateName = "mainTemplateName";
 641         String mainTemplateContent = getMainTemplateContent();
 642         final Service service = createServiceObject(false);
 643         CsarInfo csarInfo = new CsarInfo(user, csarUuid,  csar, vfReousrceName, mainTemplateName, mainTemplateContent, false);
 644         return csarInfo;
 645     }
 646
 647     protected Map<String, byte[]> crateCsarFromPayload() {
 648         String payloadName = "valid_vf.csar";
 649         byte[] data = new byte[1024];
 650         Map<String, byte[]> returnValue = new HashMap<>();
 651         returnValue.put(payloadName,data);
 652
 653         return returnValue;
 654     }
 655
 656     protected String getGroupsYaml() throws IOException {
 657         Path filePath = Paths.get("src/test/resources/types/groups.yml");
 658         byte[] fileContent = Files.readAllBytes(filePath);
 659         return new String(fileContent);
 660     }
 661
 662     protected String getYamlFileContent() throws IOException {
 663         Path filePath = Paths.get("src/test/resources/types/fileContent.yml");
 664         byte[] fileContent = Files.readAllBytes(filePath);
 665         return new String(fileContent);
 666     }
 667
 668     public String getMainTemplateContent() throws IOException {
 669         Path filePath = Paths.get("src/test/resources/types/mainTemplateContent.yml");
 670         byte[] fileContent = Files.readAllBytes(filePath);
 671         return new String(fileContent);
 672     }
 673
 674     protected String getArtifactsYml() throws IOException {
 675         Path filePath = Paths.get("src/test/resources/types/artifacts.yml");
 676         byte[] fileContent = Files.readAllBytes(filePath);
 677         return new String(fileContent);
 678     }
 679
 680     protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
 681         ResponseFormat actualResponse = e.getResponseFormat() != null ?
 682                 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
 683         assertResponse(actualResponse, expectedStatus, variables);
 684     }
 685
 686     protected void assertResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
 687         ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
 688         assertEquals(expectedResponse.getStatus(), actualResponse.getStatus());
 689         assertEquals("assert error description", expectedResponse.getFormattedMessage(), actualResponse.getFormattedMessage());
 690     }
 691
 692 }