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