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