/*
-
- * Copyright (c) 2018 AT&T Intellectual Property.
-
+ * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
*
-
* Licensed under the Apache License, Version 2.0 (the "License");
-
* you may not use this file except in compliance with the License.
-
* You may obtain a copy of the License at
-
*
-
* http://www.apache.org/licenses/LICENSE-2.0
-
*
-
* Unless required by applicable law or agreed to in writing, software
-
* distributed under the License is distributed on an "AS IS" BASIS,
-
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
* See the License for the specific language governing permissions and
-
* limitations under the License.
-
*/
package org.openecomp.sdc.be.components.impl;
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyBoolean;
+import static org.mockito.Mockito.anyList;
+import static org.mockito.Mockito.anyMap;
+import static org.mockito.Mockito.contains;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.isNull;
+import static org.mockito.Mockito.matches;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.openecomp.sdc.be.components.impl.ServiceImportBusinessLogic.CREATE_RESOURCE;
import fj.data.Either;
-import io.cucumber.java.hu.Ha;
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URISyntaxException;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.junit.Before;
-import org.junit.Test;
+import org.json.simple.JSONObject;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.openecomp.sdc.be.auditing.impl.AuditingManager;
-import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
import org.openecomp.sdc.be.components.csar.CsarInfo;
+import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
-import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
import org.openecomp.sdc.be.externalapi.servlet.ArtifactExternalServlet;
-import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.impl.ServletUtils;
import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
-import org.openecomp.sdc.be.model.*;
-import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.AttributeDefinition;
+import org.openecomp.sdc.be.model.CapabilityDefinition;
+import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceInput;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.ComponentMetadataDefinition;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.GroupDefinition;
+import org.openecomp.sdc.be.model.GroupTypeDefinition;
+import org.openecomp.sdc.be.model.IPropertyInputCommon;
+import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.NodeTypeInfo;
+import org.openecomp.sdc.be.model.Operation;
+import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
+import org.openecomp.sdc.be.model.PolicyDefinition;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
+import org.openecomp.sdc.be.model.RequirementDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
+import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
+import org.openecomp.sdc.be.model.UploadPropInfo;
+import org.openecomp.sdc.be.model.UploadReqInfo;
+import org.openecomp.sdc.be.model.UploadResourceInfo;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
+import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
import org.openecomp.sdc.be.servlets.AbstractValidationsServlet;
import org.openecomp.sdc.be.tosca.CsarUtils;
-import org.openecomp.sdc.be.user.UserBusinessLogic;
+import org.openecomp.sdc.be.tosca.ToscaExportHandler;
import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
import org.openecomp.sdc.common.api.ArtifactTypeEnum;
import org.openecomp.sdc.common.api.Constants;
+import org.openecomp.sdc.common.zip.ZipUtils;
+import org.openecomp.sdc.common.zip.exception.ZipException;
import org.openecomp.sdc.exception.ResponseFormat;
+import org.yaml.snakeyaml.Yaml;
+
+class ServiceImportBusinessLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
+
+ private final ArtifactDefinition artifactDefinition = mock(ArtifactDefinition.class);
+ private final ResourceImportManager resourceImportManager = mock(ResourceImportManager.class);
+ private final ServletUtils servletUtils = mock(ServletUtils.class);
+ private final AbstractValidationsServlet servlet = new ArtifactExternalServlet(
+ componentInstanceBusinessLogic, componentsUtils, servletUtils, resourceImportManager, artifactsBusinessLogic);
+ private final ApplicationDataTypeCache applicationDataTypeCache = mock(ApplicationDataTypeCache.class);
+ private final ArtifactTypeOperation artifactTypeOperation = mock(ArtifactTypeOperation.class);
+ private final DataTypeBusinessLogic dataTypeBusinessLogic = mock(DataTypeBusinessLogic.class);
+ private final ArtifactTypeImportManager artifactTypeImportManager = mock(ArtifactTypeImportManager.class);
+ private final GroupTypeOperation groupTypeOperation = mock(GroupTypeOperation.class);
+ private final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class);
+ private final CapabilityTypeImportManager capabilityTypeImportManager = mock(CapabilityTypeImportManager.class);
+ private final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager = mock(InterfaceLifecycleTypeImportManager.class);
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.nio.file.FileSystems;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.*;
+ @InjectMocks
+ private ServiceImportBusinessLogic sIBL;
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+ public static String loadFileNameToJsonString(String fileName) throws IOException {
+ String sourceDir = "src/test/resources/normativeTypes";
+ return loadFileNameToJsonString(sourceDir, fileName);
+ }
-public class ServiceImportBusinessLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
- private final static String DEFAULT_ICON = "defaulticon";
+ private static String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
+ java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
+ byte[] fileContent = Files.readAllBytes(filePath);
+ return new String(fileContent);
+ }
- @InjectMocks
- static ServiceImportBusinessLogic serviceImportBusinessLogic;
- @Mock
- private ServiceBusinessLogic serviceBusinessLogic;
- @Mock
- private CsarBusinessLogic csarBusinessLogic;
- @Mock
- private ToscaOperationFacade toscaOperationFacade;
- @Mock
- private ServiceImportParseLogic serviceImportParseLogic;
- @Mock
- ArtifactDefinition artifactDefinition =new ArtifactDefinition();
-
- private static UserBusinessLogic userBusinessLogic = Mockito.mock(UserBusinessLogic.class);
- private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
- private static ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
- private static ServletUtils servletUtils = mock(ServletUtils.class);
- private static ResourceImportManager resourceImportManager = mock(ResourceImportManager.class);
- private static ArtifactsBusinessLogic artifactsBusinessLogic = mock(ArtifactsBusinessLogic.class);
-
- private static AbstractValidationsServlet servlet = new ArtifactExternalServlet(userBusinessLogic,
- componentInstanceBusinessLogic, componentsUtils, servletUtils, resourceImportManager, artifactsBusinessLogic);
-
- @Before
- public void initMocks() {
- MockitoAnnotations.initMocks(this);
+ @BeforeEach
+ void initMocks() {
+ MockitoAnnotations.openMocks(this);
when(artifactDefinition.getMandatory()).thenReturn(true);
when(artifactDefinition.getArtifactName()).thenReturn("creatorFullName");
when(artifactDefinition.getArtifactType()).thenReturn("TOSCA_CSAR");
-
- sIB1.setServiceBusinessLogic(serviceBusinessLogic);
- sIB1.setCsarBusinessLogic(csarBusinessLogic);
- sIB1.setServiceImportParseLogic(serviceImportParseLogic);
- sIB1.setToscaOperationFacade(toscaOperationFacade);
- sIB1.setComponentsUtils(componentsUtils);
- sIB1.setCsarArtifactsAndGroupsBusinessLogic(csarArtifactsAndGroupsBusinessLogic);
-
- }
-
- @Test
- public void testGetComponentsUtils() {
- ComponentsUtils result;
- result = serviceImportBusinessLogic.getComponentsUtils();
}
@Test
- public void testSetComponentsUtils() {
- ComponentsUtils componentsUtils = null;
+ void testCreateService_OK() {
+ Service oldService = createServiceObject(true);
+ oldService.setComponentInstances(creatComponentInstances());
+ oldService.setComponentInstancesProperties(
+ Collections.singletonMap(COMPONENT_ID, Collections.singletonList(new ComponentInstanceProperty())));
+ String payloadName = "valid_vf";
+ Map<String, byte[]> payload = crateCsarFromPayload();
+ Service newService = createServiceObject(true);
+ newService.setComponentInstances(creatComponentInstances());
+ ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
+ componentInstanceProperty.setName("propertiesName");
+ final JSONObject jsonObject = new JSONObject();
+ jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), "zxjTestImportServiceAb_propertiesName");
+ componentInstanceProperty.setValue(jsonObject.toJSONString());
- serviceImportBusinessLogic.setComponentsUtils(componentsUtils);
- }
+ Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+ ArtifactDefinition artifactDef = new ArtifactDefinition();
+ String artifactUniqueId = "test_extcp_resource.assettoscatemplate";
+ artifactDef.setUniqueId(artifactUniqueId);
+ toscaArtifacts.put(ToscaExportHandler.ASSET_TOSCA_TEMPLATE, artifactDef);
+ Resource resource = new Resource();
+ String resourceUniqueId = "extcp_resource";
+ resource.setUniqueId(resourceUniqueId);
+ resource.setToscaArtifacts(toscaArtifacts);
+ resource.getComponentMetadataDefinition().getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ resource.setResourceType(ResourceTypeEnum.VF);
- @Test
- public void testCreateService() {
- Service oldService = createServiceObject(false);
+ ImmutablePair<String, byte[]> resourceTemplate = getNodeType();
+ String updatedNodeType = "org.openecomp.resource.cp.extCP";
+ resource.setToscaResourceName(updatedNodeType);
+
+ newService.setComponentInstancesProperties(
+ Collections.singletonMap(COMPONENT_ID + "." + "zxjTestImportServiceAb", Collections.singletonList(componentInstanceProperty)));
+ newService.setProperties(getProperties());
+
+ when(serviceBusinessLogic.validateServiceBeforeCreate(eq(newService), any(User.class), any(AuditingActionEnum.class)))
+ .thenReturn(Either.left(newService));
+ when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
+ ServiceCsarInfo csarInfo = getCsarInfo();
+ when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString(), any())).thenReturn(csarInfo);
+ when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
+ .thenReturn(Either.left(new HashMap<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>>()));
+ doReturn(getParsedToscaYamlInfo()).when(csarBusinessLogic)
+ .getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), any(), any(Service.class));
+ doReturn(getParsedToscaYamlInfo()).when(csarBusinessLogic).getParsedToscaYamlInfo(any(ServiceCsarInfo.class), any(Service.class));
+ when(serviceBusinessLogic.lockComponentByName(newService.getSystemName(), oldService, CREATE_RESOURCE)).thenReturn(Either.left(true));
+ when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
+ when(serviceImportParseLogic.createServiceTransaction(oldService, csarInfo.getModifier(), false,
+ AuditingActionEnum.CREATE_RESOURCE)).thenReturn(newService);
+ when(serviceImportParseLogic.createInputsOnService(eq(oldService), anyMap())).thenReturn(newService);
+ Assertions.assertDoesNotThrow(() -> {
+ when(serviceImportParseLogic.createSubstitutionFilterOnService(eq(oldService), any())).thenReturn(newService);
+ });
+ when(serviceImportParseLogic.getNodeTypesFromTemplate(anyMap())).thenReturn(getNodeTypes());
+ when(serviceImportParseLogic.createNodeTypeResourceFromYaml(anyString(), any(Map.Entry.class), any(User.class), anyMap(), any(Service.class),
+ anyBoolean(), any(), anyList(), anyBoolean(), any(CsarInfo.class), anyBoolean())).thenReturn(
+ new ImmutablePair<>(resource, ActionStatus.OK));
+ when(serviceImportParseLogic.getComponentWithInstancesFilter()).thenReturn(new ComponentParametersView());
+ when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(newService));
+ when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(new ComponentParametersView());
+ when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(newService));
+ when(serviceImportParseLogic.findAvailableRequirement(anyString(), anyString(), any(UploadComponentInstanceInfo.class),
+ any(ComponentInstance.class), anyString())).thenReturn(Either.left(new RequirementDefinition()));
+ when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class), any(ComponentInstance.class),
+ any(UploadReqInfo.class))).thenReturn(new CapabilityDefinition());
+ when(componentsUtils.getResponseFormat(eq(ActionStatus.OK), anyString())).thenReturn(new ResponseFormat(200));
+ when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(newService));
+ doNothing().when(compositionBusinessLogic).setPositionsForComponentInstances(any(Service.class), anyString());
+ when(groupBusinessLogic.validateUpdateVfGroupNames(anyMap(), anyString())).thenReturn(Either.left(new HashMap<>()));
+ when(csarArtifactsAndGroupsBusinessLogic.deleteVFModules(any(Service.class), any(CsarInfo.class), anyBoolean(), anyBoolean()))
+ .thenReturn(Either.left(newService));
+ when(serviceImportParseLogic.getServiceWithGroups(anyString())).thenReturn(newService);
+ when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
+ when(graphLockOperation.unlockComponentByName(anyString(), anyString(), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
+ when(serviceImportParseLogic.createOutputsOnService(any(Service.class), any(), anyString())).thenReturn(newService);
+ when(toscaOperationFacade.updateInputsToComponent(anyList(), eq(newService.getUniqueId()))).thenReturn(Either.left(new ArrayList<>()));
+
+ when(applicationDataTypeCache.get(any(), contains("tosca.datatypes.test_"))).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
+ DataTypeDefinition typeToBeUpdated = new DataTypeDefinition();
+ List<PropertyDefinition> properties = new ArrayList<>();
+ PropertyDefinition nameProperty = new PropertyDefinition();
+ nameProperty.setName("name");
+ nameProperty.setType("string");
+ properties.add(nameProperty);
+ PropertyDefinition versionProperty = new PropertyDefinition();
+ versionProperty.setName("version");
+ versionProperty.setType("string");
+ properties.add(versionProperty);
+ typeToBeUpdated.setProperties(properties);
+ when(applicationDataTypeCache.get(any(), eq("onap.datatypes.ToscaConceptIdentifier.datatype"))).thenReturn(Either.left(typeToBeUpdated));
+ when(applicationDataTypeCache.get(any(), matches("^((?!(tosca.datatypes.test_|onap.datatypes.ToscaConceptIdentifier)).)*$"))).thenReturn(
+ Either.left(new DataTypeDefinition()));
+
+ when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.testartifacts.Name"))).thenReturn(
+ Either.right(StorageOperationStatus.NOT_FOUND));
+ when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.artifacts"))).thenReturn(Either.left(null));
+
+ when(interfaceLifecycleTypeOperation.getInterface(contains("tosca.interfaces"))).thenReturn(Either.left(new InterfaceDefinition()));
+ when(interfaceLifecycleTypeOperation.getInterface(contains("tosca.interfaces.test"))).thenReturn(
+ Either.right(StorageOperationStatus.NOT_FOUND));
+
+ when(capabilityTypeOperation.getCapabilityType(anyString()))
+ .thenReturn(Either.left(new CapabilityTypeDefinition()));
+ when(capabilityTypeOperation.getCapabilityType(contains("tosca.testcapabilitytypes.Name")))
+ .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+
+ when(toscaOperationFacade.getLatestByToscaResourceName(contains("org.openecomp.resource"), isNull()))
+ .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+ when(toscaOperationFacade.getLatestByToscaResourceName(contains("tosca.nodes."), isNull()))
+ .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+ when(toscaOperationFacade.getLatestByToscaResourceName(updatedNodeType, null)).thenReturn(Either.left(resource));
+ when(toscaOperationFacade.getLatestByToscaResourceName(contains("org.openecomp.service."), isNull()))
+ .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+ when(artifactsBusinessLogic.handleDownloadRequestById(resourceUniqueId, artifactUniqueId, user.getUserId(), ComponentTypeEnum.RESOURCE, null,
+ null))
+ .thenReturn(resourceTemplate);
+ when(toscaOperationFacade.updatePropertyOfComponent(eq(oldService), any(PropertyDefinition.class))).thenReturn(Either.left(null));
+ when(toscaOperationFacade.updateComponentInstancePropsToComponent(anyMap(), anyString())).thenReturn(Either.left(null));
+ when(groupTypeOperation.getGroupTypeByUid(anyString())).thenReturn(Either.left(new GroupTypeDefinition()));
+
+ Service result = sIBL.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName);
+ assertNotNull(result);
+ assertNotNull(result.getComponentInstances());
+ assertEquals(1, result.getComponentInstances().size());
+ assertNotNull(result.getComponentInstances().get(0));
+ assertNotNull(result.getComponentInstances().get(0).getCapabilities());
+ assertEquals(1, result.getComponentInstances().get(0).getCapabilities().size());
+ assertNotNull(result.getComponentInstances().get(0).getRequirements());
+ assertEquals(1, result.getComponentInstances().get(0).getRequirements().size());
+ assertNotNull(result.getCategories());
+ assertEquals(1, result.getCategories().size());
+
+ ArgumentCaptor<String> yaml = ArgumentCaptor.forClass(String.class);
+ verify(dataTypeBusinessLogic).createDataTypeFromYaml(yaml.capture(), isNull(), anyBoolean());
+ Map<String, Object> yamlMap = new Yaml().load(yaml.getValue());
+ assertEquals(3, yamlMap.size());
+ assertNotNull(yamlMap.get("tosca.datatypes.test_a"));
+ assertNotNull(yamlMap.get("tosca.datatypes.test_b"));
+ assertNotNull(yamlMap.get("onap.datatypes.ToscaConceptIdentifier"));
+
+ ArgumentCaptor<String> artifactTypes = ArgumentCaptor.forClass(String.class);
+ verify(artifactTypeImportManager).createArtifactTypes(artifactTypes.capture(), isNull(), anyBoolean());
+ Map<String, Object> artifactTypesMap = new Yaml().load(artifactTypes.getValue());
+ assertEquals(1, artifactTypesMap.size());
+ assertNotNull(artifactTypesMap.get("tosca.testartifacts.Name"));
+
+ ArgumentCaptor<String> capabilityTypes = ArgumentCaptor.forClass(String.class);
+ verify(capabilityTypeImportManager).createCapabilityTypes(
+ capabilityTypes.capture(),
+ isNull(),
+ anyBoolean());
+ Map<String, Object> capabilityTypesMap = new Yaml().load(capabilityTypes.getValue());
+ assertEquals(1, capabilityTypesMap.size());
+ assertNotNull(capabilityTypesMap.get("tosca.testcapabilitytypes.Name"));
+
+ ArgumentCaptor<Map<String, Object>> nodeTypes = ArgumentCaptor.forClass(Map.class);
+ verify(resourceImportManager).importAllNormativeResource(nodeTypes.capture(), any(), any(), any(), any(),
+ anyBoolean(), anyBoolean());
+ Map<String, Object> nodeTypesMap = nodeTypes.getValue();
+ Map<String, Object> newUpdatedNodeType = (Map<String, Object>) nodeTypesMap.get(updatedNodeType);
+ assertEquals(8, ((Map<String, Object>) newUpdatedNodeType.get("properties")).size());
+ Assertions.assertNull(newUpdatedNodeType.get("attributes"));
+ assertEquals(3, ((List<Map<String, Object>>) newUpdatedNodeType.get("requirements")).size());
+ assertEquals(1, ((Map<String, Object>) newUpdatedNodeType.get("capabilities")).size());
+ assertEquals(2, ((Map<String, Object>) newUpdatedNodeType.get("interfaces")).size());
+
+ ArgumentCaptor<String> interfaceTypes = ArgumentCaptor.forClass(String.class);
+ verify(interfaceLifecycleTypeImportManager).createLifecycleTypes(interfaceTypes.capture(), any(), anyBoolean());
+ Map<String, Object> yamlInterfaceMap = new Yaml().load(interfaceTypes.getValue());
+ assertEquals(3, yamlInterfaceMap.size());
+ assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Attach"));
+ assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Detach"));
+ assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Reconfigure"));
+
+ }
+
+ @Test
+ void testCreateService_Fail_NotFoundNodeTypesArtifacts() {
+ Service oldService = createServiceObject(true);
String payloadName = "valid_vf";
Map<String, byte[]> payload = crateCsarFromPayload();
Service newService = createServiceObject(true);
- try {
- when(serviceBusinessLogic.validateServiceBeforeCreate(newService,user,AuditingActionEnum.CREATE_RESOURCE))
- .thenReturn(Either.left(newService));
- when(toscaOperationFacade.validateCsarUuidUniqueness(payloadName)).thenReturn(StorageOperationStatus.OK);
- sIB1.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+
+ when(serviceBusinessLogic.validateServiceBeforeCreate(any(Service.class), any(User.class), any(AuditingActionEnum.class)))
+ .thenReturn(Either.left(newService));
+ when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
+ when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString(), any())).thenReturn(getCsarInfo());
+ when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
+ .thenReturn(Either.right(ActionStatus.GENERAL_ERROR));
+ when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), anyString(),
+ any(Service.class))).thenReturn(getParsedToscaYamlInfo());
+
+ Assertions.assertThrows(ComponentException.class,
+ () -> sIBL.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName));
}
@Test
- public void testCreateServiceFromCsar(){
- Service oldService = createServiceObject(false);
+ void testCreateServiceFromCsar() {
+ Service oldService = createServiceObject(true);
String csarUUID = "valid_vf";
Map<String, byte[]> payload = crateCsarFromPayload();
- try {
- sIB1.createServiceFromCsar(oldService, user, payload, csarUUID);
- }catch (Exception e) {
- e.printStackTrace();
- }
+ ServiceCsarInfo csarInfo = getCsarInfo();
+ Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> map =
+ new HashedMap();
+
+ when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class),
+ any(Map.class), anyString(), any())).thenReturn(csarInfo);
+ when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class),
+ any(Service.class))).thenReturn(Either.left(map));
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromCsar(oldService,
+ user, payload, csarUUID, null));
}
@Test
- public void testCreateServiceFromYaml(){
- Service oldService = createServiceObject(false);
- String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");;
+ void testCreateServiceFromYaml() {
+ Service oldService = createServiceObject(true);
+ Resource resource = createOldResource();
+ String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
String yamlName = "group.yml";
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
- CsarInfo csarInfo =getCsarInfo();
+ ServiceCsarInfo csarInfo = getCsarInfo();
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- try {
- sIB1.createServiceFromYaml(oldService,topologyTemplateYaml,yamlName,nodeTypesInfo,
- csarInfo,nodeTypesArtifactsToCreate,true,true,nodeName);
- }catch (Exception e){
- e.printStackTrace();
- }
+
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
+ ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
+ when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
+ when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(Map.class),
+ eq(csarInfo), anyString(), any(Component.class))).thenReturn(parsedToscaYamlInfo);
+ when(serviceBusinessLogic.lockComponentByName(anyString(), any(Service.class), anyString()))
+ .thenReturn(Either.left(true));
+
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromYaml(oldService,
+ topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
+ nodeTypesArtifactsToCreate, false, true, nodeName, user.getUserId(), null));
}
@Test
- public void testCreateServiceAndRIsFromYaml(){
- Service oldService = createServiceObject(false);
+ void testCreateServiceAndRIsFromYaml() {
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
+ Service oldService = createServiceObject(true);
+ Resource resource = createOldResource();
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
CreateServiceFromYamlParameter csfyp = getCsfyp();
- try {
- sIB1.createServiceAndRIsFromYaml(oldService,false,
- nodeTypesArtifactsToCreate,true,true,csfyp);
- }catch (Exception e){
- e.printStackTrace();
- }
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
+ ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
+ csfyp.setNodeTypesInfo(nodeTypesInfo);
+ csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
+ when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
+ false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId(), null));
}
@Test
- public void testCreateServiceAndRIsFromYamlShoudLook(){
- Service oldService = createServiceObject(false);
+ void testCreateServiceAndRIsFromYamlShoudLook() {
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
+ Service oldService = createServiceObject(true);
+ Resource resource = createOldResource();
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
CreateServiceFromYamlParameter csfyp = getCsfyp();
- try {
- sIB1.createServiceAndRIsFromYaml(oldService,false,
- nodeTypesArtifactsToCreate,false,true,csfyp);
- }catch (Exception e){
- e.printStackTrace();
- }
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
+ ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
+ csfyp.setNodeTypesInfo(nodeTypesInfo);
+ csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
+ when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
+ false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId(), null));
}
@Test
- public void testCreateOrUpdateArtifacts(){
+ void testCreateOrUpdateArtifacts() {
ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
String yamlFileName = "group.yml";
- CsarInfo csarInfo =getCsarInfo();
+ CsarInfo csarInfo = getCsarInfo();
Resource preparedResource = createParseResourceObject(false);
preparedResource.setResourceType(ResourceTypeEnum.VF);
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle= new HashMap<>();
+ Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
- new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
+ new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactName");
artifactDefinitions.add(artifactDefinition);
enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
- artifactDefinitions);
- nodeTypesArtifactsToHandle.put(nodeName,enumListEnumMap);
- NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName,nodeTypesArtifactsToHandle);
+ artifactDefinitions);
+ nodeTypesArtifactsToHandle.put(nodeName, enumListEnumMap);
+ NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
nodeTypeInfoToUpdateArtifacts.setNodeName(nodeName);
nodeTypeInfoToUpdateArtifacts.setNodeTypesArtifactsToHandle(nodeTypesArtifactsToHandle);
- try {
- sIB1.createOrUpdateArtifacts(operation,createdArtifacts,yamlFileName,csarInfo,
- preparedResource,nodeTypeInfoToUpdateArtifacts,true,true);
- }catch (Exception e){
- e.printStackTrace();
- }
+ Assertions.assertNotNull(
+ sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
+ preparedResource, nodeTypeInfoToUpdateArtifacts, true, true)
+ );
}
@Test
- public void testHandleVfCsarArtifacts(){
- Resource resource = createParseResourceObject(false);
+ void testHandleVfCsarArtifacts() {
+ Resource resource = createParseResourceObject(true);
+ Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
+ ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+ artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
+ artifactDefinition.setUniqueId("uniqueId");
+ deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
+ resource.setDeploymentArtifacts(deploymentArtifacts);
CsarInfo csarInfo = getCsarInfo();
+ Map<String, byte[]> csar = new HashMap<>();
+ String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
+ byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
+ csar.put(csarKey, artifactsMetaBytes);
+ csarInfo.setCsar(csar);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
- when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
-
- try {
- sIB1.handleVfCsarArtifacts(resource,csarInfo,createdArtifacts,artifactOperation,true,true);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
+ when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
+ when(csarArtifactsAndGroupsBusinessLogic
+ .createResourceArtifactsFromCsar(any(CsarInfo.class), any(Resource.class), anyString(), anyString(),
+ anyList())).thenReturn(Either.left(resource));
+ Assertions.assertNotNull(
+ sIBL.handleVfCsarArtifacts(resource,
+ csarInfo, createdArtifacts, artifactOperation, true, true));
}
@Test
- public void testHandleVfCsarArtifactsGetToscaElement() {
- Resource resource = createParseResourceObject(false);
+ void testHandleVfCsarArtifactsGetToscaElement() {
+ Resource resource = createParseResourceObject(true);
Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
artifactDefinition.setUniqueId("uniqueId");
- deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
+ deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
resource.setDeploymentArtifacts(deploymentArtifacts);
CsarInfo csarInfo = getCsarInfo();
Map<String, byte[]> csar = new HashMap<>();
String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
- csar.put(csarKey,artifactsMetaBytes);
+ csar.put(csarKey, artifactsMetaBytes);
csarInfo.setCsar(csar);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
-
- try {
- sIB1.handleVfCsarArtifacts(resource,csarInfo,createdArtifacts,artifactOperation,true,true);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(csarArtifactsAndGroupsBusinessLogic
+ .createResourceArtifactsFromCsar(any(CsarInfo.class), any(Resource.class), anyString(), anyString(),
+ anyList())).thenReturn(Either.left(resource));
+ Assertions.assertNotNull(
+ sIBL.handleVfCsarArtifacts(resource,
+ csarInfo, createdArtifacts, artifactOperation, true, true));
}
@Test
- public void testCreateOrUpdateSingleNonMetaArtifactToComstants(){
+ void testCreateOrUpdateSingleNonMetaArtifactToComstants() {
Resource resource = createParseResourceObject(false);
CsarInfo csarInfo = getCsarInfo();
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactDefinition");
- deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
+ deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
resource.setDeploymentArtifacts(deploymentArtifacts);
- try {
- sIB1.createOrUpdateSingleNonMetaArtifactToComstants(resource,csarInfo,artifactOperation,true,true);
- }catch (Exception e) {
- e.printStackTrace();
- }
- }
+ Assertions.assertNotNull(resource);
+ Assertions.assertNotNull(csarInfo);
+ sIBL.createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, true, true);
+ }
@Test
- public void testCreateOrUpdateNonMetaArtifacts(){
+ void testCreateOrUpdateNonMetaArtifacts() {
CsarInfo csarInfo = getCsarInfo();
Resource resource = createParseResourceObject(false);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
- Either<Resource, ResponseFormat> result = sIB1.createOrUpdateNonMetaArtifacts(csarInfo, resource,
- createdArtifacts, true, true, artifactOperation);
- assertEquals(result.left().value(),resource);
+ Either<Resource, ResponseFormat> result = sIBL.createOrUpdateNonMetaArtifacts(csarInfo, resource,
+ createdArtifacts, true, true, artifactOperation);
+ assertEquals(result.left().value(), resource);
}
@Test
- public void testFindVfCsarArtifactsToHandle(){
+ void testFindVfCsarArtifactsToHandle() {
Resource resource = createParseResourceObject(false);
Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactDefinition");
- deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
+ deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
Map<String, ArtifactDefinition> artifacts = new HashMap<>();
- artifacts.put("artifacts",artifactDefinition);
+ artifacts.put("artifacts", artifactDefinition);
List<GroupDefinition> groups = new ArrayList<>();
GroupDefinition groupDefinition = new GroupDefinition();
groupDefinition.setUniqueId("groupDefinitionUniqueId");
List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
- ResponseFormat> result = sIB1.findVfCsarArtifactsToHandle(resource,artifactPathAndNameList,user);
+ ResponseFormat> result = sIBL.findVfCsarArtifactsToHandle(resource, artifactPathAndNameList, user);
assertNotNull(result.left().value());
}
-
@Test
- public void testIsNonMetaArtifact() {
- ArtifactDefinition artifactDefinition =new ArtifactDefinition();
- artifactDefinition.setMandatory(false);
- artifactDefinition.setArtifactName("creatorFullName");
- artifactDefinition.setArtifactType("TOSCA_CSAR");
-
- boolean nonMetaArtifact = sIB1.isNonMetaArtifact(artifactDefinition);
- assertTrue(nonMetaArtifact);
-
- }
-
- @Test
- public void testOrganizeVfCsarArtifactsByArtifactOperation(){
+ void testOrganizeVfCsarArtifactsByArtifactOperation() {
List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
artifactPathAndNameList.add(getNonMetaArtifactInfo());
List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
Resource resource = createParseResourceObject(false);
Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
- enumMapResponseFormatEither = sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, resource, user);
+ enumMapResponseFormatEither = sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
+ existingArtifactsToHandle,
+ resource, user);
assertNotNull(enumMapResponseFormatEither.left().value());
}
@Test
- public void testOrganizeVfCsarArtifactsByArtifactOperationElse(){
+ void testOrganizeVfCsarArtifactsByArtifactOperationElse() {
List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
artifactPathAndNameList.add(getNonMetaArtifactInfo());
List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
artifactDefinition.setArtifactChecksum("artifactChecksum");
existingArtifactsToHandle.add(artifactDefinition);
Resource resource = createParseResourceObject(false);
-
- try {
- sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, resource, user);
- } catch (Exception e) {
- e.printStackTrace();
- }
-
+ Assertions.assertNotNull(
+ sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, resource,
+ user));
}
@Test
- public void testProcessCsarArtifacts(){
+ void testProcessCsarArtifacts() {
CsarInfo csarInfo = getCsarInfo();
Resource resource = createParseResourceObject(false);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- Either<Resource, ResponseFormat> resStatus = null;
+ Either<Resource, ResponseFormat> resStatus = Either.left(resource);
List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
artifactPathAndNameList.add(getNonMetaArtifactInfo());
EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
- EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
- vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,artifactPathAndNameList);
- Either<Resource, ResponseFormat> rrfe = sIB1.processCsarArtifacts(csarInfo,
- resource, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle);
- assertNull(rrfe);
+ EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
+ vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactPathAndNameList);
+ Assertions.assertNotNull(
+ sIBL.processCsarArtifacts(csarInfo,
+ resource, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle));
}
@Test
- public void testCreateOrUpdateSingleNonMetaArtifact(){
+ void testCreateOrUpdateSingleNonMetaArtifact() {
Resource resource = createParseResourceObject(false);
CsarInfo csarInfo = getCsarInfo();
Map<String, byte[]> csar = csarInfo.getCsar();
} catch (IOException e) {
e.printStackTrace();
}
- csar.put("valid_vf.csar",data);
+ csar.put("valid_vf.csar", data);
String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- try {
- sIB1.createOrUpdateSingleNonMetaArtifact(resource, csarInfo, artifactPath, artifactFileName, artifactType, artifactGroupType,
- artifactLabel, artifactDisplayName, artifactDescription, artifactId, artifactOperation, createdArtifacts,
- true, true, true);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- @Test
- public void testHandleNodeTypeArtifacts(){
- Resource nodeTypeResource = createParseResourceObject(false);
- ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
- componentMetadataDataDefinition.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
- ComponentMetadataDefinition componentMetadataDefinition = new ComponentMetadataDefinition(componentMetadataDataDefinition);
- nodeTypeResource.setComponentMetadataDefinition(componentMetadataDefinition);
- Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = new HashMap<>();
- List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactName");
- artifactDefinitions.add(artifactDefinition);
- nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
- artifactDefinitions);
-
- List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- try {
- sIB1.handleNodeTypeArtifacts(nodeTypeResource, nodeTypeArtifactsToHandle,
- createdArtifacts, user, true, true);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Either<ArtifactDefinition, Operation> artifactDefinitionOperationEither = Either.left(artifactDefinition);
+ when(csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson(any(Resource.class), any(User.class),
+ any(Map.class), any(ArtifactOperationInfo.class))).thenReturn(Either.left(artifactDefinitionOperationEither));
+ when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
+ .thenReturn(Either.left(artifactDefinition));
+ Assertions.assertNotNull(
+ sIBL.createOrUpdateSingleNonMetaArtifact(resource, csarInfo, artifactPath,
+ artifactFileName, artifactType, artifactGroupType, artifactLabel,
+ artifactDisplayName, artifactDescription, artifactId, artifactOperation,
+ createdArtifacts, true, true, true));
}
-
@Test
- public void testCreateOrUpdateServiceArtifacts(){
+ void testCreateOrUpdateServiceArtifacts() throws IOException {
ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
String yamlFileName = "group.yml";
- CsarInfo csarInfo =getCsarInfo();
- Service preparedService = createServiceObject(false);
+ CsarInfo csarInfo = getCsarInfo();
+ Map<String, byte[]> csar = new HashMap<>();
+ String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
+ byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
+ csar.put(csarKey, artifactsMetaBytes);
+ csarInfo.setCsar(csar);
+ Service preparedService = createServiceObject(true);
Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactDefinition");
- deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
+ deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
preparedService.setDeploymentArtifacts(deploymentArtifacts);
- String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle= new HashMap<>();
- NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName,nodeTypesArtifactsToHandle);
- try {
- sIB1.createOrUpdateArtifacts(operation,createdArtifacts,yamlFileName,csarInfo,
- preparedService,nodeTypeInfoToUpdateArtifacts,true,true);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(createServiceObject(true)));
+ when(csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
+ anyString(), anyString(), anyList(), anyBoolean(), anyBoolean())).thenReturn(Either.left(preparedService));
+ Assertions.assertNotNull(
+ sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
+ preparedService, true, true));
}
@Test
- public void testHandleVfCsarServiceArtifacts(){
+ void testHandleVfCsarServiceArtifacts() {
Service service = createServiceObject(true);
Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
artifactDefinition.setUniqueId("uniqueId");
- deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
+ deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
service.setDeploymentArtifacts(deploymentArtifacts);
CsarInfo csarInfo = getCsarInfo();
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
- when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
-
- try {
- sIB1.handleVfCsarArtifacts(service,csarInfo,createdArtifacts,artifactOperation,true,true);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
+ when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
+ when(csarArtifactsAndGroupsBusinessLogic.deleteVFModules(any(Service.class), any(CsarInfo.class), anyBoolean(), anyBoolean())).thenReturn(
+ Either.left(service));
+ Assertions.assertNotNull(
+ sIBL.handleVfCsarArtifacts(service, csarInfo, createdArtifacts, artifactOperation, true, true));
}
@Test
- public void testHandleVfCsarServiceArtifactsGetToscaElement() throws IOException {
+ void testHandleVfCsarServiceArtifactsGetToscaElement() throws IOException {
Service service = createServiceObject(true);
Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
artifactDefinition.setUniqueId("uniqueId");
- deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
+ deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
service.setDeploymentArtifacts(deploymentArtifacts);
CsarInfo csarInfo = getCsarInfo();
Map<String, byte[]> csar = new HashMap<>();
String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
- csar.put(csarKey,artifactsMetaBytes);
+ csar.put(csarKey, artifactsMetaBytes);
csarInfo.setCsar(csar);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
-
- try {
- sIB1.handleVfCsarArtifacts(service,csarInfo,createdArtifacts,artifactOperation,true,true);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(csarArtifactsAndGroupsBusinessLogic.createResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
+ anyString(), anyString(), anyList())).thenReturn(Either.left(service));
+ Assertions.assertNotNull(
+ sIBL.handleVfCsarArtifacts(service,
+ csarInfo, createdArtifacts, artifactOperation, true, true));
}
@Test
- public void testCreateOrUpdateNonMetaServiceArtifacts(){
+ void testCreateOrUpdateNonMetaServiceArtifacts() {
CsarInfo csarInfo = getCsarInfo();
Service service = createServiceObject(true);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
- Either<Service, ResponseFormat> result = sIB1.createOrUpdateNonMetaArtifacts(csarInfo,
- service, createdArtifacts, true, true, artifactOperation);
- assertEquals(result.left().value(),service);
+ Either<Service, ResponseFormat> result = sIBL.createOrUpdateNonMetaArtifacts(csarInfo,
+ service, createdArtifacts, true, true, artifactOperation);
+ assertEquals(result.left().value(), service);
}
@Test
- public void testFindServiceCsarArtifactsToHandle(){
+ void testFindServiceCsarArtifactsToHandle() {
Service service = createServiceObject(true);
Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactDefinition");
- deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
+ deploymentArtifacts.put("deploymentArtifacts", artifactDefinition);
Map<String, ArtifactDefinition> artifacts = new HashMap<>();
- artifacts.put("artifacts",artifactDefinition);
+ artifacts.put("artifacts", artifactDefinition);
List<GroupDefinition> groups = new ArrayList<>();
GroupDefinition groupDefinition = new GroupDefinition();
groupDefinition.setUniqueId("groupDefinitionUniqueId");
List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
- ResponseFormat> result = sIB1.findVfCsarArtifactsToHandle(service, artifactPathAndNameList, user);
+ ResponseFormat> result = sIBL.findVfCsarArtifactsToHandle(service, artifactPathAndNameList, user);
assertNotNull(result.left().value());
}
@Test
- public void testOrganizeVfCsarArtifactsByServiceArtifactOperation(){
+ void testOrganizeVfCsarArtifactsByServiceArtifactOperation() {
List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
artifactPathAndNameList.add(getNonMetaArtifactInfo());
List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
Service service = createServiceObject(true);
Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
- enumMapResponseFormatEither = sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
- existingArtifactsToHandle, service, user);
+ enumMapResponseFormatEither = sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
+ existingArtifactsToHandle, service, user);
assertNotNull(enumMapResponseFormatEither.left().value());
}
@Test
- public void testOrganizeVfCsarArtifactsByServiceArtifactOperationElse(){
+ void testOrganizeVfCsarArtifactsByServiceArtifactOperationElse() {
List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
artifactPathAndNameList.add(getNonMetaArtifactInfo());
List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
artifactDefinition.setArtifactChecksum("artifactChecksum");
existingArtifactsToHandle.add(artifactDefinition);
Service service = createServiceObject(true);
-
- try {
- sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, service, user);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertNotNull(
+ sIBL.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, service, user));
}
@Test
- public void testProcessServiceCsarArtifacts(){
+ void testProcessServiceCsarArtifacts() {
CsarInfo csarInfo = getCsarInfo();
Service service = createServiceObject(true);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- Either<Service, ResponseFormat> resStatus = null;
+ Either<Service, ResponseFormat> resStatus = Either.left(service);
EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
- EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
- Either<Service, ResponseFormat> srfe = sIB1.processCsarArtifacts(csarInfo,
- service, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle);
- assertNull(srfe);
+ EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
+ List<CsarUtils.NonMetaArtifactInfo> objects = new ArrayList<>();
+ objects.add(getNonMetaArtifactInfo());
+ vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, objects);
+ Assertions.assertNotNull(
+ sIBL.processCsarArtifacts(csarInfo, service, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle));
}
@Test
- public void testGetValidArtifactNames(){
+ void testGetValidArtifactNames() {
CsarInfo csarInfo = getCsarInfo();
Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
- Either<List<CsarUtils.NonMetaArtifactInfo>, String> result = sIB1.getValidArtifactNames(csarInfo, collectedWarningMessages);
- System.out.println(result.left().value());
+ Either<List<CsarUtils.NonMetaArtifactInfo>, String> result = sIBL.getValidArtifactNames(csarInfo,
+ collectedWarningMessages);
assertNotNull(result.left().value());
}
@Test
- public void testCreateOrUpdateSingleNonMetaServiceArtifact(){
+ void testCreateOrUpdateSingleNonMetaServiceArtifact() {
Service service = createServiceObject(true);
CsarInfo csarInfo = getCsarInfo();
Map<String, byte[]> csar = csarInfo.getCsar();
} catch (IOException e) {
e.printStackTrace();
}
- csar.put("valid_vf.csar",data);
+ csar.put("valid_vf.csar", data);
csarInfo.setCsar(csar);
String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- try {
- sIB1.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName, artifactType, artifactGroupType,
- artifactLabel, artifactDisplayName, artifactDescription, artifactId, artifactOperation, createdArtifacts,
- true, true, true);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+ artifactDefinition.setArtifactName("artifactName");
+ Either<ArtifactDefinition, Operation> artifactDefinitionOperationEither = Either.left(artifactDefinition);
+ when(csarArtifactsAndGroupsBusinessLogic.createOrUpdateCsarArtifactFromJson(any(Service.class), any(User.class),
+ anyMap(), any(ArtifactOperationInfo.class))).thenReturn(Either.left(artifactDefinitionOperationEither));
+ when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
+ .thenReturn(Either.left(artifactDefinition));
+ Assertions.assertNotNull(
+ sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
+ artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
+ artifactDescription, artifactId, artifactOperation, createdArtifacts,
+ true, true, true));
}
@Test
- public void testCreateOrUpdateSingleNonMetaServiceArtifactNull(){
+ void testCreateOrUpdateSingleNonMetaServiceArtifactNull() {
Service service = createServiceObject(true);
CsarInfo csarInfo = getCsarInfo();
String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
- ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
+ ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true, true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- try {
- sIB1.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName, artifactType, artifactGroupType,
- artifactLabel, artifactDisplayName, artifactDescription, artifactId, artifactOperation, createdArtifacts,
- true, true, true);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(artifactsBusinessLogic.handleDelete(anyString(), anyString(), any(User.class), any(Component.class), anyBoolean(), anyBoolean()))
+ .thenReturn(Either.left(artifactDefinition));
+ Assertions.assertNotNull(
+ sIBL.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName,
+ artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
+ artifactDescription, artifactId, artifactOperation, createdArtifacts,
+ true, true, true));
}
@Test
- public void testCreateGroupsOnResource(){
+ void testCreateGroupsOnResource() {
Service service = createServiceObject(true);
- Map<String, GroupDefinition> groups = getGroups();
-
- try {
- Either<Service, ResponseFormat> result = sIB1.createGroupsOnResource(service, groups);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Map<String, GroupDefinition> groups = new HashMap<>();
+ Assertions.assertNotNull(sIBL.createGroupsOnResource(service, groups));
}
@Test
- public void testCreateGroupsOnResourceNull(){
+ void testCreateGroupsOnResourceNull() {
Service service = createServiceObject(true);
- Map<String, GroupDefinition> groups = null;
-
- Either<Service, ResponseFormat> result = sIB1.createGroupsOnResource(service, groups);
- assertNotNull(result);
-
+ Map<String, GroupDefinition> groups = new HashMap<>();
+ Assertions.assertNotNull(
+ sIBL.createGroupsOnResource(service, groups));
}
@Test
- public void testUpdateGroupsMembersUsingResource(){
+ void testUpdateGroupsMembersUsingResource() {
Service service = createServiceObject(true);
- Map<String, GroupDefinition> groups = null;
+ Map<String, GroupDefinition> groups = getGroups();
- List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups, service);
- for (GroupDefinition groupDefinition : groupDefinitions) {
- assertNull(groupDefinition);
- }
+ Assertions.assertNotNull(
+ sIBL.updateGroupsMembersUsingResource(groups, service));
}
@Test
- public void testUpdateGroupsMembersUsingResource_left(){
+ void testUpdateGroupsMembersUsingResource_left() {
Service service = createServiceObject(true);
Map<String, GroupDefinition> groups = getGroups();
- when(serviceImportParseLogic.validateCyclicGroupsDependencies(any()))
- .thenReturn(Either.left(true));
- List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups, service);
- for (GroupDefinition groupDefinition : groupDefinitions) {
- assertNotNull(groupDefinition);
- }
+ Assertions.assertNotNull(
+ sIBL.updateGroupsMembersUsingResource(groups, service));
}
@Test
- public void testCreateRIAndRelationsFromResourceYaml(){
+ void testCreateRIAndRelationsFromResourceYaml() throws IOException {
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
String yamlName = "group.yml";
Resource resource = createParseResourceObject(true);
Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
String topologyTemplateYaml = getMainTemplateContent();
List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
+
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
+
CsarInfo csarInfo = getCsarInfo();
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
- String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- try {
- sIB1.createRIAndRelationsFromYaml(yamlName,resource,uploadComponentInstanceInfoMap,topologyTemplateYaml,nodeTypesNewCreatedArtifacts,
- nodeTypesInfo,csarInfo,nodeTypesArtifactsToCreate,nodeName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap,
+ topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
+ csarInfo, nodeTypesArtifactsToCreate, nodeName));
}
-
@Test
- public void testCreateResourceInstancesRelations(){
+ void testCreateResourceInstancesRelations() {
String yamlName = "group.yml";
Resource resource = createParseResourceObject(true);
resource.setComponentInstances(creatComponentInstances());
resource.setResourceType(ResourceTypeEnum.VF);
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
- uploadResInstancesMap.put("uploadResInstancesMap",getuploadComponentInstanceInfo());
-
- try {
- sIB1.createResourceInstancesRelations(user,yamlName,resource,uploadResInstancesMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
+ when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
+ when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
}
@Test
- public void testCreateResourceInstancesRelations_Empty(){
+ void testCreateResourceInstancesRelations_Empty() {
String yamlName = "group.yml";
Resource resource = createParseResourceObject(true);
resource.setComponentInstances(creatComponentInstances());
- resource.setResourceType(ResourceTypeEnum.PNF);
+ resource.setResourceType(ResourceTypeEnum.VF);
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
- uploadResInstancesMap.put("uploadResInstancesMap",getuploadComponentInstanceInfo());
-
- try {
- sIB1.createResourceInstancesRelations(user,yamlName,resource,uploadResInstancesMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ uploadResInstancesMap.put("uploadResInstancesMap", getUploadComponentInstanceInfo());
+ when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(resource);
+ when(toscaOperationFacade.getToscaFullElement(anyString())).thenReturn(Either.left(resource));
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .createResourceInstancesRelations(user, yamlName, resource, uploadResInstancesMap));
}
-
@Test
- public void testProcessComponentInstance1(){
+ void testProcessComponentInstance1() {
String yamlName = "group.yml";
Resource resource = createParseResourceObject(true);
Resource originResource = createParseResourceObject(false);
+ originResource.setResourceType(ResourceTypeEnum.VF);
List<ComponentInstance> componentInstancesList = creatComponentInstances();
- Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
+ Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
+ DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
+ dataTypeDefinition.setName("dataTypeDefinitionName");
+ dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
+ Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
- Map<String, List< AttributeDataDefinition >> instAttributes = new HashMap<>();
+ Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
+ Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
Map<String, Resource> originCompMap = new HashMap<>();
- originCompMap.put("componentUid",originResource);
+ originCompMap.put("componentUid", originResource);
Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
-
- try {
- sIB1.processComponentInstance(yamlName, resource, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
- instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertNotNull(resource);
+ Assertions.assertNotNull(yamlName);
+ sIBL.processComponentInstance(yamlName, resource, componentInstancesList, allDataTypes.left().value(), instProperties,
+ instCapabilties, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes,
+ originCompMap, instInputs, instNodeFilter, null, uploadComponentInstanceInfo);
}
@Test
- public void testProcessComponentInstance_null(){
+ void testProcessComponentInstance_null() {
String yamlName = "group.yml";
Resource resource = createParseResourceObject(true);
Resource originResource = createParseResourceObject(false);
Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
- Map<String, List< AttributeDataDefinition >> instAttributes = new HashMap<>();
+ Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
Map<String, Resource> originCompMap = new HashMap<>();
- originCompMap.put("componentUid",originResource);
+ Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
+ originCompMap.put("componentUid", originResource);
Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
- try {
- sIB1.processComponentInstance(yamlName, resource, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
- instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
+ resource, componentInstancesList, null, instProperties, instCapabilties,
+ instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
+ instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
}
@Test
- public void testAddInputsValuesToRi(){
+ void testAddInputsValuesToRi() {
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
Map<String, List<UploadPropInfo>> properties = new HashMap<>();
- List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
- UploadPropInfo uploadPropInfo = new UploadPropInfo();
- uploadPropInfo.setName("uploadPropInfo");
- uploadPropInfoList.add(uploadPropInfo);
- uploadPropInfoList.add(uploadPropInfo);
- properties.put("propertiesMap",uploadPropInfoList);
+ List<UploadPropInfo> uploadPropInfoList = getPropertyList();
+ properties.put("propertiesMap", uploadPropInfoList);
uploadComponentInstanceInfo.setProperties(properties);
Resource resource = createParseResourceObject(true);
- Resource originResource =createParseResourceObject(false);
+ Resource originResource = createParseResourceObject(false);
List<InputDefinition> inputs = new ArrayList<>();
InputDefinition inputDefinition = new InputDefinition();
+ inputDefinition.setName("inputDefinitionName");
inputDefinition.setUniqueId("uniqueId");
+ inputDefinition.setType("inputDefinitionType");
inputs.add(inputDefinition);
originResource.setInputs(inputs);
ComponentInstance currentCompInstance = new ComponentInstance();
Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
+ DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
+ dataTypeDefinition.setName("dataTypeDefinitionName");
+ allDataTypes.put("dataTypeDefinitionMap", dataTypeDefinition);
- try {
- sIB1.addInputsValuesToRi(uploadComponentInstanceInfo,resource,originResource,
- currentCompInstance,instInputs,allDataTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
+ currentCompInstance, instInputs, allDataTypes));
}
@Test
- public void testProcessProperty(){
+ void testProcessProperty() {
Resource resource = createParseResourceObject(true);
List<InputDefinition> inputs = new ArrayList<>();
InputDefinition inputDefinition = new InputDefinition();
ComponentInstance currentCompInstance = null;
Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
- currPropertiesMap.put("propertyInfoName",inputDefinition);
+ currPropertiesMap.put("propertyInfoName", inputDefinition);
List<ComponentInstanceInput> instPropList = new ArrayList<>();
- List<UploadPropInfo> propertyList = new ArrayList<>();
- List<GetInputValueDataDefinition> get_input = new ArrayList<>();
- GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
- getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
- getInputValueDataDefinition.setInputName("inputDefinitionName");
- get_input.add(getInputValueDataDefinition);
- UploadPropInfo propertyInfo = new UploadPropInfo();
- propertyInfo.setValue("value");
- propertyInfo.setGet_input(get_input);
- propertyInfo.setName("propertyInfoName");
- propertyList.add(propertyInfo);
-
- try {
- sIB1.processProperty(resource, currentCompInstance, allDataTypes,
- currPropertiesMap, instPropList, propertyList);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ List<UploadPropInfo> propertyList = getPropertyList();
+ Assertions.assertNotNull(resource);
+ Assertions.assertNotNull(currPropertiesMap);
+ sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
}
@Test
- public void testHandleSubstitutionMappings(){
+ void testHandleSubstitutionMappings() {
Resource resource = createParseResourceObject(true);
resource.setResourceType(ResourceTypeEnum.VF);
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
when(toscaOperationFacade.getToscaFullElement(anyString()))
- .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+ .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
- try {
- sIB1.handleSubstitutionMappings(resource, uploadResInstancesMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class,
+ () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
}
@Test
- public void testHandleSubstitutionMappings_left(){
+ void testHandleSubstitutionMappings_left() {
Resource resource = createParseResourceObject(true);
resource.setResourceType(ResourceTypeEnum.VF);
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
when(toscaOperationFacade.getToscaFullElement(anyString()))
- .thenReturn(Either.left(resource));
+ .thenReturn(Either.left(resource));
- try {
- sIB1.handleSubstitutionMappings(resource, uploadResInstancesMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class,
+ () -> sIBL.handleSubstitutionMappings(resource, uploadResInstancesMap));
}
@Test
- public void testCreateResourceInstances(){
+ void testCreateResourceInstances() {
String yamlName = "group.yml";
Resource resource = createParseResourceObject(true);
Resource originResource = createParseResourceObject(false);
nodesInfoValue.setRequirements(gerRequirements());
uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
Map<String, Resource> nodeNamespaceMap = new HashMap<>();
- nodeNamespaceMap.put("resources",originResource);
+ nodeNamespaceMap.put("resources", originResource);
- try {
- sIB1.createResourceInstances(yamlName,resource,uploadResInstancesMap,nodeNamespaceMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class,
+ () -> sIBL.createResourceInstances(yamlName, resource, uploadResInstancesMap, nodeNamespaceMap));
}
@Test
- public void testHandleNodeTypes(){
+ void testHandleNodeTypes() throws IOException {
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
String yamlName = "group.yml";
Resource resource = createParseResourceObject(true);
String topologyTemplateYaml = getMainTemplateContent();
boolean needLock = true;
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
- NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
- nodeTypeInfo.setNested(false);
- String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- nodeTypesInfo.put(nodeName,nodeTypeInfo);
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
+ ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
CsarInfo csarInfo = getCsarInfo();
+ Assertions.assertNotNull(resource);
- try {
- sIB1.handleNodeTypes(yamlName,resource,topologyTemplateYaml,needLock,
- nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,nodeTypesInfo,
- csarInfo,nodeName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ sIBL.handleNodeTypes(yamlName, resource, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
+ nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeName);
}
@Test
- public void testHandleNestedVfc1(){
+ void testHandleNestedVfc1() {
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
Resource resource = createParseResourceObject(false);
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
nodeTypeInfo.setTemplateFileName("groups.yml");
nodeTypeInfo.setMappedToscaTemplate(new HashMap<>());
- nodesInfo.put(nodeName,nodeTypeInfo);
+ nodesInfo.put(nodeName, nodeTypeInfo);
CsarInfo csarInfo = getCsarInfo();
- try {
- sIB1.handleNestedVfc(resource,nodeTypesArtifactsToHandle,createdArtifacts,
- nodesInfo,csarInfo,nodeName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(resource,
+ nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
}
@Test
- public void testHandleComplexVfc1(){
+ void testHandleComplexVfc1() {
Resource resource = createParseResourceObject(true);
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
CsarInfo csarInfo = getCsarInfo();
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
String yamlName = "group.yml";
+ when(serviceImportParseLogic.buildValidComplexVfc(any(Resource.class), any(CsarInfo.class), anyString(),
+ anyMap())).thenReturn(createParseResourceObject(false));
when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
- .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+ .thenReturn(Either.left(resource));
+ when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class),
+ anyBoolean())).thenReturn(Either.left(true));
- try {
- sIB1.handleComplexVfc(resource,nodeTypesArtifactsToHandle,createdArtifacts,
- nodesInfo,csarInfo,nodeName,yamlName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.handleComplexVfc(resource,
+ nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName));
}
@Test
- public void testCreateResourcesFromYamlNodeTypesList1(){
- String yamlName = "group.yml";
- Resource resource = createParseResourceObject(false);
- Map<String, Object> mappedToscaTemplate = new HashMap<>();
- boolean needLock = true;
- Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
- List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
- CsarInfo csarInfo = getCsarInfo();
-
- try {
- sIB1.createResourcesFromYamlNodeTypesList(yamlName,resource,mappedToscaTemplate,
- needLock, nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,
- nodeTypesInfo,csarInfo);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- @Test
- public void testCreateNodeTypes1(){
+ void testCreateNodeTypes1() {
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
String yamlName = "group.yml";
Resource resource = createParseResourceObject(false);
boolean needLock = true;
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
- new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
+ new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactName");
artifactDefinitions.add(artifactDefinition);
enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
- artifactDefinitions);
- nodeTypesArtifactsToHandle.put("nodeTyp",enumListEnumMap);
+ artifactDefinitions);
+ nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
- NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
- nodeTypesInfo.put("nodeTyp",nodeTypeInfo);
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
+ ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
+
CsarInfo csarInfo = getCsarInfo();
- Map<String, Object> mapToConvert =new HashMap<>();
- Map<String, Object> nodeTypes =new HashMap<>();
- nodeTypes.put("nodeTyp",nodeTypeInfo);
+ Map<String, Object> mapToConvert = new HashMap<>();
+ Map<String, Object> nodeTypes = new HashMap<>();
+ nodeTypes.put(nodeName, "");
+ Assertions.assertNotNull(resource);
- try {
- sIB1.createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle,
- nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
- nodeTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ sIBL.createNodeTypes(yamlName,
+ resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
+ nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
}
@Test
- public void testCreateNodeTypeResourceFromYaml(){
+ void testCreateNodeTypeResourceFromYaml() throws IOException {
String yamlName = "group.yml";
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- Map<String,Object> nodeMap = new HashMap<>();
- nodeMap.put(nodeName,getGroupsYaml());
+ Map<String, Object> nodeMap = new HashMap<>();
+ nodeMap.put(nodeName, getGroupsYaml());
Map.Entry<String, Object> nodeNameValue = nodeMap.entrySet().iterator().next();
Map<String, Object> mapToConvert = new HashedMap();
Resource resourceVf = createParseResourceObject(false);
boolean forceCertificationAllowed = true;
CsarInfo csarInfo = getCsarInfo();
boolean isNested = true;
-
- try {
- sIB1.createNodeTypeResourceFromYaml(yamlName,nodeNameValue,user,mapToConvert,resourceVf,
- needLock,nodeTypeArtifactsToHandle,nodeTypesNewCreatedArtifacts,
- forceCertificationAllowed,csarInfo,isNested);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- @Test
- public void testCreateRIAndRelationsFromYaml(){
+ UploadResourceInfo resourceMetaData = new UploadResourceInfo();
+ resourceMetaData.setResourceType("VFC");
+ ImmutablePair<Resource, ActionStatus> immutablePair = new ImmutablePair<>(resourceVf, ActionStatus.CREATED);
+ when(serviceImportParseLogic.fillResourceMetadata(anyString(), any(Resource.class), anyString(), any(User.class)))
+ .thenReturn(resourceMetaData);
+ when(serviceImportParseLogic.buildNodeTypeYaml(any(Map.Entry.class), anyMap(), anyString(), any(CsarInfo.class)))
+ .thenReturn(nodeName);
+ when(serviceBusinessLogic.validateUser(any(User.class), anyString(), any(Component.class), any(AuditingActionEnum.class),
+ anyBoolean())).thenReturn(user);
+ when(serviceImportParseLogic.createResourceFromNodeType(anyString(), any(UploadResourceInfo.class), any(User.class), anyBoolean(),
+ anyBoolean(),
+ anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
+ anyString(), anyBoolean())).thenReturn(immutablePair);
+ Assertions.assertNotNull(
+ sIBL.createNodeTypeResourceFromYaml(yamlName, nodeNameValue, user, mapToConvert,
+ resourceVf, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts,
+ forceCertificationAllowed, csarInfo, isNested));
+ }
+
+ @Test
+ void testCreateRIAndRelationsFromYaml() {
String yamlName = "group.yml";
Service service = createServiceObject(true);
Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
- String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");;
+ String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
+ ;
List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
CsarInfo csarInfo = getCsarInfo();
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- try {
- sIB1.createRIAndRelationsFromYaml(yamlName,service,uploadComponentInstanceInfoMap,topologyTemplateYaml,nodeTypesNewCreatedArtifacts,
- nodeTypesInfo,csarInfo,nodeTypesArtifactsToCreate,nodeName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+
+ Assertions.assertNotNull(sIBL
+ .createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap,
+ topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
+ csarInfo, nodeTypesArtifactsToCreate, nodeName));
}
@Test
- public void testCreateServiceInstancesRelations(){
+ void testCreateServiceInstancesRelations() {
String yamlName = "group.yml";
Service service = createServiceObject(true);
service.setComponentInstances(creatComponentInstances());
- Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
- uploadResInstancesMap.put("uploadResInstancesMap",getuploadComponentInstanceInfo());
-
- try {
- sIB1.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Resource newResource = createNewResource();
+ Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
+ ComponentParametersView componentParametersView = new ComponentParametersView();
+ RequirementDefinition requirementDefinition = new RequirementDefinition();
+ CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
+ capabilityDefinition.setName("as");
+ capabilityDefinition.setUniqueId("1");
+ capabilityDefinition.setOwnerId("2");
+ ResponseFormat responseFormat = new ResponseFormat();
+ responseFormat.setStatus(200);
+ when(serviceImportParseLogic.getResourceAfterCreateRelations(any(Resource.class))).thenReturn(newResource);
+ when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
+ when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class))).thenReturn(Either.left(service));
+ when(serviceImportParseLogic.findAvailableRequirement(anyString(),
+ anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
+ anyString())).thenReturn(Either.left(requirementDefinition));
+ when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
+ any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
+ when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
+ when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
+ Assertions.assertNotNull(sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap, null));
}
@Test
- public void testCreateServiceInstancesRelations_Empty(){
+ void testCreateServiceInstancesRelations_Empty() {
String yamlName = "group.yml";
Service service = createServiceObject(true);
service.setComponentInstances(creatComponentInstances());
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
- try {
- sIB1.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class,
+ () -> sIBL.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap, null));
}
@Test
- public void testProcessComponentInstance(){
+ void testProcessComponentInstance() {
String yamlName = "group.yml";
Service service = createServiceObject(true);
Resource originResource = createParseResourceObject(false);
+ originResource.setResourceType(ResourceTypeEnum.VF);
List<ComponentInstance> componentInstancesList = creatComponentInstances();
- Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
+ Map<String, DataTypeDefinition> dataTypeDefinitionMap = new HashMap<>();
+ DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
+ dataTypeDefinition.setName("dataTypeDefinitionName");
+ dataTypeDefinitionMap.put("dataTypeDefinitionMap", dataTypeDefinition);
+ Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = Either.left(dataTypeDefinitionMap);
Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
- Map<String, List< AttributeDataDefinition >> instAttributes = new HashMap<>();
+ Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
+ Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
Map<String, Resource> originCompMap = new HashMap<>();
- originCompMap.put("componentUid",originResource);
+ originCompMap.put("componentUid", originResource);
Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
+ Assertions.assertNotNull(service);
- try {
- sIB1.processComponentInstance(yamlName, service, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
- instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ sIBL.processComponentInstance(yamlName, service, componentInstancesList, allDataTypes.left().value(),
+ instProperties, instCapabilties, instRequirements, instDeploymentArtifacts,
+ instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter, null,
+ uploadComponentInstanceInfo);
}
@Test
- public void testProcessComponentInstance_null2(){
+ void testProcessComponentInstance_null2() {
String yamlName = "group.yml";
Service service = createServiceObject(true);
Resource originResource = createParseResourceObject(false);
Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
- Map<String, List< AttributeDataDefinition >> instAttributes = new HashMap<>();
+ Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
+ Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
Map<String, Resource> originCompMap = new HashMap<>();
- originCompMap.put("componentUid",originResource);
+ originCompMap.put("componentUid", originResource);
Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
- try {
- sIB1.processComponentInstance(yamlName, service, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
- instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.processComponentInstance(yamlName,
+ service, componentInstancesList, null, instProperties, instCapabilties,
+ instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap,
+ instInputs, instNodeFilter, null, uploadComponentInstanceInfo));
}
@Test
- public void testAddInputsValuesToRi2(){
+ void testAddInputsValuesToRi2() {
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
Map<String, List<UploadPropInfo>> properties = new HashMap<>();
List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
uploadPropInfo.setName("uploadPropInfo");
uploadPropInfoList.add(uploadPropInfo);
uploadPropInfoList.add(uploadPropInfo);
- properties.put("propertiesMap",uploadPropInfoList);
+ properties.put("propertiesMap", uploadPropInfoList);
uploadComponentInstanceInfo.setProperties(properties);
Service resource = createServiceObject(true);
- Resource originResource =createParseResourceObject(false);
+ Resource originResource = createParseResourceObject(false);
List<InputDefinition> inputs = new ArrayList<>();
InputDefinition inputDefinition = new InputDefinition();
inputDefinition.setUniqueId("uniqueId");
Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
- try {
- sIB1.addInputsValuesToRi(uploadComponentInstanceInfo,resource,originResource,
- currentCompInstance,instInputs,allDataTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource,
+ currentCompInstance, instInputs, allDataTypes));
}
@Test
- public void testProcessProperty2(){
+ void testProcessProperty2() {
Service resource = createServiceObject(true);
List<InputDefinition> inputs = new ArrayList<>();
ComponentInstance currentCompInstance = null;
inputDefinition.setName("inputDefinitionName");
inputDefinition.setType("inputDefinitionType");
inputs.add(inputDefinition);
- currPropertiesMap.put("propertyInfoName",inputDefinition);
+ currPropertiesMap.put("propertyInfoName", inputDefinition);
resource.setInputs(inputs);
List<ComponentInstanceInput> instPropList = new ArrayList<>();
List<UploadPropInfo> propertyList = new ArrayList<>();
propertyInfo.setGet_input(get_input);
propertyInfo.setName("propertyInfoName");
propertyList.add(propertyInfo);
+ Assertions.assertNotNull(resource);
- try {
- sIB1.processProperty(resource, currentCompInstance, allDataTypes,
- currPropertiesMap, instPropList, propertyList);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ sIBL.processProperty(resource, allDataTypes, currPropertiesMap, instPropList, propertyList);
}
@Test
- public void testProcessGetInput(){
+ void testProcessGetInput() {
List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
List<InputDefinition> inputs = new ArrayList<>();
GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
- try {
- sIB1.processGetInput(getInputValues,inputs,getInputIndex);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.processGetInput(getInputValues, inputs, getInputIndex));
}
@Test
- public void testProcessGetInput_optional(){
+ void testProcessGetInput_optional() {
List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
List<InputDefinition> inputs = new ArrayList<>();
InputDefinition inputDefinition = new InputDefinition();
inputs.add(inputDefinition);
GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
getInputIndex.setInputName("InputName");
+ Assertions.assertNotNull(inputs);
- sIB1.processGetInput(getInputValues,inputs,getInputIndex);
+ sIBL.processGetInput(getInputValues, inputs, getInputIndex);
}
@Test
- public void testAddPropertyValuesToRi(){
+ void testAddPropertyValuesToRi() {
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
Resource resource = createParseResourceObject(true);
+ List<InputDefinition> inputs = new ArrayList<>();
+ InputDefinition inputDefinition = new InputDefinition();
+ inputDefinition.setName("inputDefinitionName");
+ inputDefinition.setUniqueId("uniqueId");
+ inputDefinition.setType("inputDefinitionType");
+ inputs.add(inputDefinition);
+ resource.setInputs(inputs);
Resource originResource = createParseResourceObject(false);
originResource.setProperties(getProperties());
ComponentInstance currentCompInstance = new ComponentInstance();
Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
- try {
- sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
- instProperties, allDataTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ ResponseFormat responseFormat = new ResponseFormat();
+ when(serviceImportParseLogic.findInputByName(eq(inputs), any(GetInputValueDataDefinition.class)))
+ .thenReturn(inputDefinition);
+ when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
+ Assertions.assertNotNull(
+ sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource,
+ currentCompInstance, instProperties, allDataTypes));
}
@Test
- public void testAddPropertyValuesToRi_else(){
+ void testAddPropertyValuesToRi_else() {
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
Resource resource = createParseResourceObject(true);
Resource originResource = createParseResourceObject(false);
ComponentInstance currentCompInstance = new ComponentInstance();
Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
- try {
- sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
- instProperties, allDataTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ ResponseFormat responseFormat = new ResponseFormat();
+ when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
+ Assertions.assertNotNull(
+ sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
+ instProperties, allDataTypes));
}
@Test
- public void testAddPropertyValuesToRi2(){
+ void testAddPropertyValuesToRi2() {
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
- Service service = createServiceObject(false);
+ Service service = createServiceObject(true);
+ List<InputDefinition> inputs = new ArrayList<>();
+ InputDefinition inputDefinition = new InputDefinition();
+ inputDefinition.setName("inputDefinitionName");
+ inputDefinition.setUniqueId("uniqueId");
+ inputDefinition.setType("inputDefinitionType");
+ inputs.add(inputDefinition);
+ service.setInputs(inputs);
Resource originResource = createParseResourceObject(false);
originResource.setProperties(getProperties());
ComponentInstance currentCompInstance = new ComponentInstance();
Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
-
- try {
- sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
- instProperties, allDataTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ ResponseFormat responseFormat = new ResponseFormat();
+ when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
+ when(serviceImportParseLogic.findInputByName(anyList(), any(GetInputValueDataDefinition.class)))
+ .thenReturn(inputDefinition);
+ Assertions.assertNotNull(
+ sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource,
+ currentCompInstance, instProperties, allDataTypes));
}
@Test
- public void testAddPropertyValuesToRi2_else(){
+ void testAddPropertyValuesToRi2_else() {
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
- Service service = createServiceObject(false);
+ Service service = createServiceObject(true);
Resource originResource = createParseResourceObject(false);
originResource.setProperties(getProperties());
ComponentInstance currentCompInstance = new ComponentInstance();
Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
-
- try {
- sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
- instProperties, allDataTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ ResponseFormat responseFormat = new ResponseFormat();
+ when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(responseFormat);
+ Assertions.assertNotNull(
+ sIBL.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
+ instProperties, allDataTypes));
}
@Test
- public void testProcessComponentInstanceCapabilities(){
+ void testProcessComponentInstanceCapabilities() {
Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
uploadComponentInstanceInfo.setCapabilities(getCapabilities());
ComponentInstance currentCompInstance = new ComponentInstance();
Resource originResource = createParseResourceObject(false);
+ Assertions.assertNotNull(originResource);
+ sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
+ originResource);
+ }
+
+ @Test
+ void testProcessComponentInstanceCapabilities_null() {
+ Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
+ Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
+ UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
+ ComponentInstance currentCompInstance = new ComponentInstance();
+ Resource originResource = createParseResourceObject(false);
+ Assertions.assertNotNull(originResource);
+
+ sIBL.processComponentInstanceCapabilities(null, instCapabilties, uploadComponentInstanceInfo, currentCompInstance,
+ originResource);
+ }
+
+ @Test
+ void testProcessComponentInstanceInterfaces() {
+ Service service = createServiceObject(true);
+ service.setModel("testModel");
+ Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
+ UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
+ uploadComponentInstanceInfo.setInterfaces(getInterfaces());
+ ComponentInstance currentCompInstance = new ComponentInstance();
+ Resource originResource = createParseResourceObject(false);
+ Assertions.assertNotNull(originResource);
+
+ InterfaceDefinition interfaceDef = new InterfaceDefinition();
+ interfaceDef.setUniqueId("tosca.interfaces.lifecycle.TestInterface");
+ Map<String, InterfaceDefinition> interfaceLifecycleTypes = new HashMap<>();
+ interfaceLifecycleTypes.put("tosca.interfaces.lifecycle.TestInterface", interfaceDef);
+ when(interfaceLifecycleTypeOperation.getAllInterfaceLifecycleTypes("testModel")).thenReturn(Either.left(interfaceLifecycleTypes));
- sIB1.processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo,
- currentCompInstance, originResource);
+ sIBL.addInterfaceValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance, instInterfaces);
}
@Test
- public void testProcessComponentInstanceCapabilities_null(){
- Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
- Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
+ void testProcessComponentInstanceInterfaces_null() {
+ Service service = createServiceObject(true);
+ Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
ComponentInstance currentCompInstance = new ComponentInstance();
Resource originResource = createParseResourceObject(false);
-
- sIB1.processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo,
- currentCompInstance, originResource);
+ Assertions.assertNotNull(originResource);
+ sIBL.addInterfaceValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance, instInterfaces);
}
@Test
- public void testUpdateCapabilityPropertiesValues(){
+ void testUpdateCapabilityPropertiesValues() {
Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
-
- sIB1.updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
+ Assertions.assertNull(allDataTypes);
+ sIBL.updateCapabilityPropertiesValues(null, originCapabilities, newPropertiesMap);
}
@Test
- public void testUpdatePropertyValues(){
+ void testUpdatePropertyValues() {
List<ComponentInstanceProperty> properties = new ArrayList<>();
Map<String, UploadPropInfo> newProperties = new HashMap<>();
Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
-
- sIB1.updatePropertyValues(properties,newProperties,allDataTypes);
+ Assertions.assertNotNull(allDataTypes);
+ sIBL.updatePropertyValues(properties, newProperties, allDataTypes);
}
@Test
- public void testUpdatePropertyValue(){
+ void testUpdatePropertyValue() {
ComponentInstanceProperty property = new ComponentInstanceProperty();
property.setType("services");
UploadPropInfo propertyInfo = new UploadPropInfo();
propertyInfo.setValue("value");
Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
-
- try {
- sIB1.updatePropertyValue(property,propertyInfo,allDataTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(serviceBusinessLogic.validatePropValueBeforeCreate(any(IPropertyInputCommon.class), anyString(), anyBoolean(), anyMap())).thenReturn(
+ "qw");
+ Assertions.assertNotNull(sIBL.updatePropertyValue(property, propertyInfo, allDataTypes));
}
@Test
- public void testGetOriginResource(){
+ void testGetOriginResource() {
String yamlName = "group.yml";
Map<String, Resource> originCompMap = new HashMap<>();
ComponentInstance currentCompInstance = new ComponentInstance();
currentCompInstance.setComponentUid("currentCompInstance");
-
- try {
- sIB1.getOriginResource(yamlName,originCompMap,currentCompInstance);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- @Test
- public void testHandleSubstitutionMappings2(){
- Service service = createServiceObject(false);
- Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
-
- sIB1.handleSubstitutionMappings(service, uploadResInstancesMap);
+ when(toscaOperationFacade.getToscaFullElement(anyString()))
+ .thenReturn(Either.left(createParseResourceObject(true)));
+ Assertions.assertNotNull(sIBL.getOriginResource(yamlName, originCompMap, currentCompInstance));
}
@Test
- public void testUpdateCalculatedCapReqWithSubstitutionMappings(){
+ void testUpdateCalculatedCapReqWithSubstitutionMappings() {
Resource resource = createParseResourceObject(false);
- Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
+ resource.setComponentInstances(creatComponentInstances());
+ Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
when(toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(any())).thenReturn(StorageOperationStatus.OK);
-
- try {
- sIB1.updateCalculatedCapReqWithSubstitutionMappings(resource,uploadResInstancesMap);
- } catch (Exception e) {
-
- }
+ Assertions.assertNotNull(sIBL.updateCalculatedCapReqWithSubstitutionMappings(resource, uploadResInstancesMap));
}
@Test
- public void testFillUpdatedInstCapabilitiesRequirements(){
+ void testFillUpdatedInstCapabilitiesRequirements() {
List<ComponentInstance> componentInstances = creatComponentInstances();
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirement = new HashMap<>();
+ Assertions.assertNotNull(componentInstances);
- sIB1.fillUpdatedInstCapabilitiesRequirements(componentInstances,uploadResInstancesMap,
- updatedInstCapabilities,updatedInstRequirement);
+ sIBL.fillUpdatedInstCapabilitiesRequirements(componentInstances, uploadResInstancesMap,
+ updatedInstCapabilities, updatedInstRequirement);
}
@Test
- public void testFillUpdatedInstCapabilities(){
+ void testFillUpdatedInstCapabilities() {
Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties = new HashMap<>();
Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
capabilityDefinition.setName("mme_ipu_vdu.feature");
capabilityDefinitionList.add(capabilityDefinition);
- capabilities.put("tosca.capabilities.Node",capabilityDefinitionList);
+ capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
ComponentInstance instance = new ComponentInstance();
instance.setCapabilities(capabilities);
Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
- capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature","capabilitiesNamesToUpdate");
+ capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
+ Assertions.assertNotNull(instance);
- sIB1.fillUpdatedInstCapabilities(updatedInstCapabilties,instance,capabilitiesNamesToUpdate);
+ sIBL.fillUpdatedInstCapabilities(updatedInstCapabilties, instance, capabilitiesNamesToUpdate);
}
@Test
- public void testFillUpdatedInstRequirements(){
+ void testFillUpdatedInstRequirements() {
Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new
- HashMap<>();
+ HashMap<>();
ComponentInstance instance = new ComponentInstance();
Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
RequirementDefinition requirementDefinition = new RequirementDefinition();
requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
requirementDefinitionList.add(requirementDefinition);
- requirements.put("tosca.capabilities.Node",requirementDefinitionList);
+ requirements.put("tosca.capabilities.Node", requirementDefinitionList);
instance.setRequirements(requirements);
Map<String, String> requirementsNamesToUpdate = new HashMap<>();
requirementsNamesToUpdate.put("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test",
- "requirementsNamesToUpdate");
-
+ "requirementsNamesToUpdate");
+ Assertions.assertNotNull(instance);
- sIB1.fillUpdatedInstRequirements(updatedInstRequirements,instance,requirementsNamesToUpdate);
+ sIBL.fillUpdatedInstRequirements(updatedInstRequirements, instance, requirementsNamesToUpdate);
}
@Test
- public void testAddRelationsToRI(){
+ void testAddRelationsToRI() {
String yamlName = "group.yml";
- Service service = createServiceObject(false);
+ Service service = createServiceObject(true);
+
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
- UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
+ UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
List<ComponentInstance> componentInstancesList = creatComponentInstances();
+ ComponentInstance componentInstance = new ComponentInstance();
+ componentInstance.setName("zxjTestImportServiceAb");
+ componentInstancesList.add(componentInstance);
+ service.setComponentInstances(componentInstancesList);
List<RequirementCapabilityRelDef> relations = new ArrayList<>();
+ RequirementDefinition requirementDefinition = new RequirementDefinition();
+ requirementDefinition.setOwnerId("1");
+ requirementDefinition.setUniqueId("2");
+ requirementDefinition.setCapability("3");
+ CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
+ capabilityDefinition.setName("4");
+ capabilityDefinition.setUniqueId("5");
+ capabilityDefinition.setOwnerId("6");
+ ResponseFormat responseFormat = new ResponseFormat();
+ responseFormat.setStatus(200);
+ when(serviceImportParseLogic.findAvailableRequirement(anyString(),
+ anyString(), any(UploadComponentInstanceInfo.class), any(ComponentInstance.class),
+ anyString())).thenReturn(Either.left(requirementDefinition));
+ when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
+ any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
+ when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
+ Assertions.assertNotNull(service);
- try {
- sIB1.addRelationsToRI(yamlName,service,uploadResInstancesMap,componentInstancesList,
- relations);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ sIBL.addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
}
@Test
- public void testAddRelationsToRI_null(){
+ void testAddRelationsToRI_null() {
String yamlName = "group.yml";
- Service service = createServiceObject(false);
+ Service service = createServiceObject(true);
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
- UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
+ UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
List<ComponentInstance> componentInstancesList = new ArrayList<>();
List<RequirementCapabilityRelDef> relations = new ArrayList<>();
- try {
- sIB1.addRelationsToRI(yamlName,service,uploadResInstancesMap,componentInstancesList,
- relations);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.addRelationsToRI(yamlName,
+ service, uploadResInstancesMap, componentInstancesList, relations));
}
@Test
- public void testAddRelationToRI(){
+ void testAddRelationToRI() {
String yamlName = "group.yml";
- Service service = createServiceObject(false);
+ Service service = createServiceObject(true);
service.setComponentInstances(creatComponentInstances());
- UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
+ UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
List<RequirementCapabilityRelDef> relations = new ArrayList<>();
-
- try {
- sIB1.addRelationToRI(yamlName,service,nodesInfoValue,relations);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ RequirementDefinition requirementDefinition = new RequirementDefinition();
+ requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
+ CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
+ capabilityDefinition.setName("capabilityDefinitionName");
+ capabilityDefinition.setUniqueId("capabilityDefinitionUniqueId");
+ capabilityDefinition.setOwnerId("capabilityDefinitionOwnerId");
+ ResponseFormat responseFormat = new ResponseFormat();
+ when(serviceImportParseLogic.findAvailableRequirement(anyString(), anyString(), any(UploadComponentInstanceInfo.class),
+ any(ComponentInstance.class), anyString())).thenReturn(Either.left(requirementDefinition));
+ when(serviceImportParseLogic.findAvailableCapabilityByTypeOrName(any(RequirementDefinition.class),
+ any(ComponentInstance.class), any(UploadReqInfo.class))).thenReturn(capabilityDefinition);
+ when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
+ Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
+ Assertions.assertNotNull(relations.get(0).getRelationships().get(0).getOperations());
}
@Test
- public void testAddRelationToRI_null(){
+ void testAddRelationToRI_null() {
String yamlName = "group.yml";
- Service service = createServiceObject(false);
+ Service service = createServiceObject(true);
List<ComponentInstance> componentInstancesList = new ArrayList<>();
service.setComponentInstances(componentInstancesList);
-
- UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
+ ResponseFormat responseFormat = new ResponseFormat();
+ UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
List<RequirementCapabilityRelDef> relations = new ArrayList<>();
-
- try {
- sIB1.addRelationToRI(yamlName,service,nodesInfoValue,relations);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(componentsUtils.getResponseFormat(any(ActionStatus.class), anyString())).thenReturn(responseFormat);
+ Assertions.assertNotNull(sIBL.addRelationToRI(yamlName, service, nodesInfoValue, relations));
}
@Test
- public void testGetResourceAfterCreateRelations(){
- Service service = createServiceObject(false);
+ void testGetResourceAfterCreateRelations() {
+ Service service = createServiceObject(true);
ComponentParametersView componentParametersView = createComponentParametersView();
when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
- try {
- sIB1.getResourceAfterCreateRelations(service);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
+ .thenReturn(Either.left(createServiceObject(true)));
+ Assertions.assertNotNull(sIBL.getResourceAfterCreateRelations(service));
}
@Test
- public void testCreateServiceInstances(){
+ void testCreateServiceInstances() {
String yamlName = "group.yml";
- Service service = createServiceObject(false);
+ Service service = createServiceObject(true);
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
- UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
- uploadResInstancesMap.put("uploadResInstancesMap",nodesInfoValue);
+ UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
+ uploadResInstancesMap.put("uploadResInstancesMap", nodesInfoValue);
Map<String, Resource> nodeNamespaceMap = new HashMap<>();
Resource resource = createParseResourceObject(true);
resource.setToscaResourceName("toscaResourceName");
- nodeNamespaceMap.put("nodeNamespaceMap",resource);
+ nodeNamespaceMap.put("nodeNamespaceMap", resource);
- try {
- sIB1.createServiceInstances(yamlName,service,uploadResInstancesMap,nodeNamespaceMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class,
+ () -> sIBL.createServiceInstances(yamlName, service, uploadResInstancesMap, nodeNamespaceMap));
}
@Test
- public void testCreateAndAddResourceInstance(){
- UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
+ void testCreateAndAddResourceInstance() {
+ UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
String yamlName = "group.yml";
Resource resource = createParseResourceObject(false);
Resource originResource = createParseResourceObject(true);
originResource.setResourceType(ResourceTypeEnum.VF);
Map<String, Resource> nodeNamespaceMap = new HashMap<>();
- nodeNamespaceMap.put("resources",originResource);
+ nodeNamespaceMap.put("resources", originResource);
Map<String, Resource> existingnodeTypeMap = new HashMap<>();
Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
- try {
- sIB1.createAndAddResourceInstance(uploadComponentInstanceInfo,yamlName,resource,nodeNamespaceMap,
- existingnodeTypeMap,resourcesInstancesMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, resource,
+ nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
}
@Test
- public void testCreateAndAddResourceInstances(){
- UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
+ void testCreateAndAddResourceInstances() {
+ UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
String yamlName = "group.yml";
- Service service = createServiceObject(false);
+ Service service = createServiceObject(true);
service.setServiceType("services");
Resource originResource = createParseResourceObject(true);
originResource.setResourceType(ResourceTypeEnum.VF);
Map<String, Resource> existingnodeTypeMap = new HashMap<>();
Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
- try {
- sIB1.createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, service, nodeNamespaceMap,
- existingnodeTypeMap, resourcesInstancesMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, service,
+ nodeNamespaceMap, existingnodeTypeMap, resourcesInstancesMap));
}
@Test
- public void testValidateResourceInstanceBeforeCreate(){
+ void testValidateResourceInstanceBeforeCreate() {
String yamlName = "group.yml";
- UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
+ UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
Resource originResource = createParseResourceObject(true);
ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
componentMetadataDataDefinition.setState(LifecycleStateEnum.CERTIFIED.name());
originResource.setComponentType(ComponentTypeEnum.RESOURCE);
originResource.setToscaResourceName("toscaResourceName");
originResource.setResourceType(ResourceTypeEnum.VF);
- originResource.setResourceType(ResourceTypeEnum.VF);
Map<String, Resource> nodeNamespaceMap = new HashMap<>();
nodeNamespaceMap.put("resources", originResource);
- when( toscaOperationFacade.getLatestResourceByToscaResourceName(anyString()))
- .thenReturn(Either.left(originResource));
-
- try {
- sIB1.validateResourceInstanceBeforeCreate(yamlName,uploadComponentInstanceInfo,nodeNamespaceMap);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(toscaOperationFacade.getLatestByToscaResourceName(RESOURCE_TOSCA_NAME, null)).thenReturn(Either.left(originResource));
+ Assertions.assertNotNull(
+ sIBL.validateResourceInstanceBeforeCreate(yamlName, null, uploadComponentInstanceInfo, nodeNamespaceMap));
}
@Test
- public void testHandleServiceNodeTypes(){
+ void testHandleServiceNodeTypes() {
String yamlName = "group.yml";
- Service service =createServiceObject(false);
- String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");;
+ Service service = createServiceObject(true);
+ String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");
+ ;
boolean needLock = true;
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
CsarInfo csarInfo = getCsarInfo();
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString()))
- .thenReturn(Either.left(createOldResource()));
+ when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
+ Assertions.assertNotNull(service);
- sIB1.handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, needLock,
- nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
- csarInfo, nodeName);
+ sIBL.handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, needLock, nodeTypesArtifactsToHandle,
+ nodeTypesNewCreatedArtifacts,
+ nodeTypesInfo, csarInfo, nodeName);
}
@Test
- public void testValidateResourceNotExisted(){
+ void testValidateResourceNotExisted() {
String type = "org.openecomp.resource.vf";
- boolean b = false;
- try {
- b = sIB1.validateResourceNotExisted(type);
- } catch (Exception e) {
- e.printStackTrace();
- }
+
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.validateResourceNotExisted(type));
}
@Test
- public void testHandleNestedVF(){
- Service service =createServiceObject(false);
+ void testHandleNestedVF() {
+ Service service = createServiceObject(true);
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
CsarInfo csarInfo = getCsarInfo();
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- try {
- sIB1.handleNestedVF(service,nodeTypesArtifactsToHandle,createdArtifacts,
- nodesInfo,csarInfo,nodeName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVF(service,
+ nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
}
@Test
- public void testHandleNestedVfc(){
- Service service =createServiceObject(false);
+ void testHandleNestedVfc() {
+ Service service = createServiceObject(true);
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
CsarInfo csarInfo = getCsarInfo();
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- try {
- sIB1.handleNestedVfc(service,nodeTypesArtifactsToHandle,createdArtifacts,
- nodesInfo,csarInfo,nodeName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.handleNestedVfc(service,
+ nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName));
}
@Test
- public void testHandleComplexVfc(){
+ void testHandleComplexVfc() {
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
CsarInfo csarInfo = getCsarInfo();
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
String yamlName = "group.yml";
+ when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
+ .thenReturn(createNewResource());
when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
- .thenReturn(Either.left(createNewResource()));
+ .thenReturn(Either.left(createNewResource()));
+ when(serviceImportParseLogic.validateNestedDerivedFromDuringUpdate(any(Resource.class), any(Resource.class), anyBoolean()))
+ .thenReturn(Either.left(true));
- try {
- sIB1.handleComplexVfc(nodeTypesArtifactsToHandle,createdArtifacts,
- nodesInfo,csarInfo,nodeName,yamlName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
+ csarInfo, nodeName, yamlName));
}
+ @Test
+ void testHandleComplexVfcStatus() {
+ Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
+ List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
+ Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
+ CsarInfo csarInfo = getCsarInfo();
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
+ String yamlName = "group.yml";
+ when(serviceImportParseLogic.buildValidComplexVfc(any(CsarInfo.class), anyString(), anyMap()))
+ .thenReturn(createNewResource());
+ when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
+ .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
+ csarInfo, nodeName, yamlName));
+ }
@Test
- public void testHandleComplexVfc2(){
+ void testHandleComplexVfc2() {
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
String yamlName = "group.yml";
CsarInfo csarInfo = getCsarInfo();
Map<String, byte[]> csar = new HashMap<>();
- csar.put(yamlName,yamlName.getBytes());
+ csar.put(yamlName, yamlName.getBytes());
csarInfo.setCsar(csar);
Resource oldComplexVfc = createParseResourceObject(false);
Resource newComplexVfc = createParseResourceObject(true);
- try {
- sIB1.handleComplexVfc(nodeTypesArtifactsToHandle,createdArtifacts,nodesInfo,
- csarInfo,nodeName,yamlName,oldComplexVfc,newComplexVfc);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .handleComplexVfc(nodeTypesArtifactsToHandle, createdArtifacts, nodesInfo,
+ csarInfo, nodeName, yamlName, oldComplexVfc, newComplexVfc));
}
@Test
- public void testUpdateResourceFromYaml(){
- Resource oldRresource = createParseResourceObject(false);
- Resource newRresource = createParseResourceObject(true);
+ void testUpdateResourceFromYaml() throws IOException {
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
+ Resource newResource = createNewResource();
+ Resource oldResource = createOldResource();
AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
String yamlFileName = "group.yml";
String yamlFileContent = getYamlFileContent();
CsarInfo csarInfo = getCsarInfo();
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
- String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
boolean isNested = true;
- try {
- sIB1.updateResourceFromYaml(oldRresource,newRresource,actionEnum,createdArtifacts,yamlFileName,yamlFileContent,
- csarInfo,nodeTypesInfo,nodeTypesArtifactsToHandle,nodeName,isNested);
- } catch (Exception e) {
-
- }
+ when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
+ anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
+ when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
+ any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
+ when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
+ any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
+ when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
+ .thenReturn(Either.left(newResource));
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .updateResourceFromYaml(oldResource, newResource, actionEnum, createdArtifacts,
+ yamlFileName, yamlFileContent, csarInfo, nodeTypesInfo,
+ nodeTypesArtifactsToHandle, nodeName, isNested));
}
@Test
- public void testCreateResourceFromYaml(){
+ void testCreateResourceFromYaml() throws IOException {
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
Resource resource = createParseResourceObject(true);
String topologyTemplateYaml = getMainTemplateContent();
String yamlName = "group.yml";
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
+
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
+
CsarInfo csarInfo = getCsarInfo();
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
- boolean shouldLock = true;
- boolean inTransaction =true;
- String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
-
- try {
- sIB1.createResourceFromYaml(resource,topologyTemplateYaml,yamlName,nodeTypesInfo,csarInfo,
- nodeTypesArtifactsToCreate,shouldLock,inTransaction,nodeName);
- } catch (Exception e) {
+ boolean shouldLock = false;
+ boolean inTransaction = true;
- }
+ when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), anyMap(), any(CsarInfo.class),
+ anyString(), any(Component.class))).thenReturn(getParsedToscaYamlInfo());
+ when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Component.class))).thenReturn(resource);
+ when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
+ .thenReturn(Either.left(false));
+ when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceFromYaml(resource,
+ topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
+ nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
}
@Test
- public void testCreateResourceAndRIsFromYaml(){
+ void testCreateResourceAndRIsFromYaml() throws IOException {
String yamlName = "group.yml";
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
Resource resource = createParseResourceObject(true);
resource.setSystemName("SystemName");
resource.setComponentType(ComponentTypeEnum.RESOURCE);
- ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
boolean isNormative = true;
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
String topologyTemplateYaml = getMainTemplateContent();
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
+ ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
+
CsarInfo csarInfo = getCsarInfo();
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
- boolean shouldLock = true;
+ boolean shouldLock = false;
boolean inTransaction = true;
- String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- when(serviceBusinessLogic.lockComponentByName(anyString(),any(),anyString()))
- .thenReturn(Either.left(true));
+ when(serviceBusinessLogic.fetchAndSetDerivedFromGenericType(any(Resource.class)))
+ .thenReturn(resource);
- try {
- sIB1.createResourceAndRIsFromYaml(yamlName,resource,parsedToscaYamlInfo,actionEnum,
- isNormative,createdArtifacts,topologyTemplateYaml,nodeTypesInfo,csarInfo,
- nodeTypesArtifactsToCreate,shouldLock,inTransaction,nodeName);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
+ when(serviceBusinessLogic.lockComponentByName(anyString(), any(), anyString()))
+ .thenReturn(Either.left(true));
- @Test
- public void testCreateResourceAndRIsFromYaml_False(){
- String yamlName = "group.yml";
- Resource resource = createParseResourceObject(false);
- ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
- AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
- boolean isNormative = true;
- List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- String topologyTemplateYaml = getMainTemplateContent();
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
- CsarInfo csarInfo = getCsarInfo();
- Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
- boolean shouldLock = false;
- boolean inTransaction = false;
- String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
+ when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
+ .thenReturn(Either.left(false));
- try {
- sIB1.createResourceAndRIsFromYaml(yamlName,resource,parsedToscaYamlInfo,actionEnum,
- isNormative,createdArtifacts,topologyTemplateYaml,nodeTypesInfo,csarInfo,
- nodeTypesArtifactsToCreate,shouldLock,inTransaction,nodeName);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
+
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, actionEnum,
+ isNormative, createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo,
+ nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName));
}
@Test
- public void testCreateGroupsOnResource2() {
+ void testCreateGroupsOnResource2() {
Resource resource = createParseResourceObject(false);
- Map<String, GroupDefinition> groups = getGroups();
- when(serviceImportParseLogic.validateCyclicGroupsDependencies(any()))
- .thenReturn(Either.left(true));
+ Map<String, GroupDefinition> groups = null;
+ List<GroupDefinition> groupDefinitionList = new ArrayList<>();
+ GroupDefinition groupDefinition = new GroupDefinition();
+ groupDefinition.setUniqueId("groupDefinitionUniqueId");
+ groupDefinition.setName("groupDefinition");
+ groupDefinitionList.add(groupDefinition);
- try {
- sIB1.createGroupsOnResource(resource, groups);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertNotNull(
+ sIBL.createGroupsOnResource(resource, groups));
}
@Test
- public void testCreateGroupsOnResource2_null() {
+ void testCreateGroupsOnResource2_null() {
Resource resource = createParseResourceObject(false);
Map<String, GroupDefinition> groups = null;
- Either<Resource, ResponseFormat> result = sIB1.createGroupsOnResource(resource, groups);
- assertEquals(result.left().value(),resource);
+ Either<Resource, ResponseFormat> result = sIBL.createGroupsOnResource(resource, groups);
+ assertEquals(result.left().value(), resource);
}
@Test
- public void testUpdateGroupsMembersUsingResource2(){
+ void testUpdateGroupsMembersUsingResource2() {
Resource resource = createParseResourceObject(true);
- Map<String, GroupDefinition> groups = null;
+ Map<String, GroupDefinition> groups = getGroups();
- List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups,resource);
- for (GroupDefinition groupDefinition : groupDefinitions) {
- assertNull(groupDefinition);
- }
+ Assertions.assertNotNull(
+ sIBL.updateGroupsMembersUsingResource(groups, resource));
}
@Test
- public void testUpdateGroupsMembersUsingResource_left2(){
+ void testUpdateGroupsMembersUsingResource_left2() {
Resource resource = createParseResourceObject(true);
Map<String, GroupDefinition> groups = getGroups();
- when(serviceImportParseLogic.validateCyclicGroupsDependencies(any()))
- .thenReturn(Either.left(true));
- List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups, resource);
- for (GroupDefinition groupDefinition : groupDefinitions) {
- assertNotNull(groupDefinition);
- }
+ Assertions.assertNotNull(
+ sIBL.updateGroupsMembersUsingResource(groups, resource));
}
@Test
- public void testUpdateGroupMembers(){
+ void testUpdateGroupMembers() throws IOException {
Map<String, GroupDefinition> groups = new HashMap<>();
GroupDefinition updatedGroupDefinition = new GroupDefinition();
Resource component = createParseResourceObject(true);
List<ComponentInstance> componentInstances = creatComponentInstances();
String groupName = "tosca_simple_yaml_1_1";
Map<String, String> members = new HashMap<>();
- members.put("zxjTestImportServiceAb",getGroupsYaml());
+ members.put("zxjTestImportServiceAb", getGroupsYaml());
+ Assertions.assertNotNull(component);
- try {
- sIB1.updateGroupMembers(groups,updatedGroupDefinition,component,componentInstances,
- groupName,members);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ sIBL.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
}
@Test
- public void testUpdateGroupMembers_null(){
+ void testUpdateGroupMembers_null() throws IOException {
Map<String, GroupDefinition> groups = new HashMap<>();
GroupDefinition updatedGroupDefinition = new GroupDefinition();
Resource component = createParseResourceObject(true);
List<ComponentInstance> componentInstances = new ArrayList<>();
String groupName = "tosca_simple_yaml_1_1";
Map<String, String> members = new HashMap<>();
- members.put("zxjTestImportServiceAb",getGroupsYaml());
+ members.put("zxjTestImportServiceAb", getGroupsYaml());
- try {
- sIB1.updateGroupMembers(groups,updatedGroupDefinition,component,componentInstances,
- groupName,members);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.updateGroupMembers(groups,
+ updatedGroupDefinition, component, componentInstances, groupName, members));
}
@Test
- public void setCreateResourceTransaction(){
+ void setCreateResourceTransaction() {
Resource resource = createParseResourceObject(false);
resource.setComponentType(ComponentTypeEnum.RESOURCE);
boolean isNormative = true;
- when(toscaOperationFacade.validateComponentNameExists(anyString(),any(),any()))
- .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+ when(toscaOperationFacade.validateComponentNameExists(anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class)))
+ .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
- try {
- sIB1.createResourceTransaction(resource,user,isNormative);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
}
@Test
- public void setCreateResourceTransaction_leftTrue() {
+ void setCreateResourceTransaction_leftTrue() {
Resource resource = createParseResourceObject(false);
resource.setComponentType(ComponentTypeEnum.RESOURCE);
boolean isNormative = true;
- when(toscaOperationFacade.validateComponentNameExists(anyString(),any(),any()))
- .thenReturn(Either.left(true));
+ when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(true));
- try {
- sIB1.createResourceTransaction(resource,user,isNormative);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.createResourceTransaction(resource, user, isNormative));
}
@Test
- public void setCreateResourceTransaction_Left() {
+ void setCreateResourceTransaction_Left() {
Resource resource = createParseResourceObject(false);
resource.setComponentType(ComponentTypeEnum.RESOURCE);
- when(toscaOperationFacade.validateComponentNameExists(anyString(),any(),any()))
- .thenReturn(Either.left(false));
-
- try {
- sIB1.createResourceTransaction(resource,user,false);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(toscaOperationFacade.validateComponentNameExists(anyString(), any(), any())).thenReturn(Either.left(false));
+ when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(Either.left(resource));
+ Assertions.assertNotNull(sIBL.createResourceTransaction(resource, user, false));
}
@Test
- public void testUpdateExistingResourceByImport(){
+ void testUpdateExistingResourceByImport() {
Resource newResource = createNewResource();
Resource oldResource = createOldResource();
-
- try {
- sIB1.updateExistingResourceByImport(newResource,oldResource,user,
- true,true,true);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ when(serviceImportParseLogic.prepareResourceForUpdate(any(Resource.class), any(Resource.class),
+ any(User.class), anyBoolean(), anyBoolean())).thenReturn(oldResource);
+ when(serviceImportParseLogic.validateCapabilityTypesCreate(any(User.class), any(ICapabilityTypeOperation.class),
+ any(Resource.class), any(AuditingActionEnum.class), anyBoolean())).thenReturn(Either.left(true));
+ when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class)))
+ .thenReturn(Either.left(newResource));
+ Assertions.assertNotNull(sIBL.updateExistingResourceByImport(newResource, oldResource, user, true, false, true));
}
@Test
- public void testCreateNewResourceToOldResource(){
+ void testCreateNewResourceToOldResource() {
Resource newResource = createNewResource();
Resource oldResource = createOldResource();
- try {
- sIB1.createNewResourceToOldResource(newResource,oldResource,user);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ sIBL.createNewResourceToOldResource(newResource, oldResource, user);
+ assertEquals(newResource.getSystemName(), oldResource.getSystemName());
}
@Test
- public void testCreateResourcesFromYamlNodeTypesList(){
+ void testCreateResourcesFromYamlNodeTypesList() {
String yamlName = "group.yml";
- Service service =createServiceObject(false);
+ Service service = createServiceObject(true);
Map<String, Object> mappedToscaTemplate = new HashMap<>();
boolean needLock = true;
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
CsarInfo csarInfo = getCsarInfo();
- try {
- sIB1.createResourcesFromYamlNodeTypesList(yamlName,service,mappedToscaTemplate,needLock,
- nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,nodeTypesInfo,csarInfo);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL
+ .createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock,
+ nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo));
}
@Test
- public void testCreateNodeTypes(){
+ void testCreateNodeTypes() {
String yamlName = "group.yml";
- Service service =createServiceObject(false);
+ Service service = createServiceObject(true);
boolean needLock = true;
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
- new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
+ new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactName");
artifactDefinitions.add(artifactDefinition);
enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
- artifactDefinitions);
- nodeTypesArtifactsToHandle.put("nodeTyp",enumListEnumMap);
+ artifactDefinitions);
+ nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
CsarInfo csarInfo = getCsarInfo();
- Map<String, Object> mapToConvert =new HashMap<>();
- Map<String, Object> nodeTypes =new HashMap<>();
+ Map<String, Object> mapToConvert = new HashMap<>();
+ Map<String, Object> nodeTypes = new HashMap<>();
NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
- nodeTypesInfo.put("nodeTyp",nodeTypeInfo);
+ nodeTypesInfo.put("nodeTyp", nodeTypeInfo);
nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
- nodeTypeInfo);
+ nodeTypeInfo);
- try {
- sIB1.createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle,
- nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
- nodeTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ Assertions.assertThrows(ComponentException.class, () -> sIBL.createNodeTypes(yamlName,
+ service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
+ nodeTypesInfo, csarInfo, mapToConvert, nodeTypes));
}
@Test
- public void testCreateNodeTypesElse(){
+ void testCreateNodeTypesElse() {
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
String yamlName = "group.yml";
- Service service =createServiceObject(false);
+ Service service = createServiceObject(true);
boolean needLock = true;
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
- new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
+ new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactName");
artifactDefinitions.add(artifactDefinition);
enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
- artifactDefinitions);
- nodeTypesArtifactsToHandle.put("nodeTyp",enumListEnumMap);
+ artifactDefinitions);
+ nodeTypesArtifactsToHandle.put("nodeTyp", enumListEnumMap);
List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
+ Map<String, Object> map = new HashMap<>();
+ map.put("tosca_definitions_version", "123");
+ nodeTypesInfo.get(nodeName).setMappedToscaTemplate(map);
+ ParsedToscaYamlInfo parsedToscaYamlInfo = getParsedToscaYamlInfo();
+
CsarInfo csarInfo = getCsarInfo();
- Map<String, Object> mapToConvert =new HashMap<>();
- Map<String, Object> nodeTypes =new HashMap<>();
+ Map<String, Object> mapToConvert = new HashMap<>();
+ Map<String, Object> nodeTypes = new HashMap<>();
NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
- nodeTypesInfo.put("nodeTyp",nodeTypeInfo);
- nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb0.test",
- nodeTypeInfo);
+ nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
+ nodeTypeInfo);
+ when(serviceImportParseLogic.createNodeTypeResourceFromYaml(anyString(), any(Map.Entry.class), any(User.class),
+ anyMap(), any(Service.class), anyBoolean(), anyMap(), anyList(), anyBoolean(), any(CsarInfo.class),
+ anyBoolean())).thenReturn(getResourceCreated());
+ Assertions.assertNotNull(service);
- try {
- sIB1.createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle,
- nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
- nodeTypes);
- } catch (Exception e) {
- e.printStackTrace();
- }
+ sIBL.createNodeTypes(yamlName,
+ service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
+ nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
+ }
+
+ protected ImmutablePair<Resource, ActionStatus> getResourceCreated() {
+ Resource resource = createOldResource();
+ ImmutablePair<Resource, ActionStatus> resourceCreated = new ImmutablePair<>(resource, ActionStatus.OK);
+
+ return resourceCreated;
}
- protected Resource createNewResource(){
+ protected Resource createNewResource() {
Resource newResource = createParseResourceObject(false);
newResource.setVersion("1.0");
newResource.setInvariantUUID("");
Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("artifactDefinition");
- toscaArtifacts.put("toscaArtifactsMap",artifactDefinition);
+ toscaArtifacts.put("toscaArtifactsMap", artifactDefinition);
Map<String, InterfaceDefinition> interfaces = new HashMap<>();
InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
interfaceDefinition.setOwnerId("OwnerId");
- interfaces.put("interfacesMap",interfaceDefinition);
+ interfaces.put("interfacesMap", interfaceDefinition);
newResource.setInterfaces(interfaces);
newResource.setToscaArtifacts(toscaArtifacts);
newResource.setProperties(getProperties());
return newResource;
}
- protected Resource createOldResource(){
+ protected Resource createOldResource() {
Resource newResource = createParseResourceObject(false);
newResource.setVersion("1.0");
+ newResource.setUniqueId("ResourceUniqueId");
newResource.setInvariantUUID("552e8f6c-340c-4fb4-8a82-fe7732fd8010");
newResource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
newResource.setUUID("13065b80-ca96-4331-b643-d28aeaf961cb");
Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("tosca_simple_yaml_1_1");
- toscaArtifacts.put("tosca_definitions_version",artifactDefinition);
+ toscaArtifacts.put("tosca_definitions_version", artifactDefinition);
Map<String, InterfaceDefinition> interfaces = new HashMap<>();
InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
interfaceDefinition.setDescription("Invoked upon receipt of an Instantiate VNF request");
- interfaces.put("tosca_simple_yaml_1_1",interfaceDefinition);
+ interfaces.put("tosca_simple_yaml_1_1", interfaceDefinition);
newResource.setInterfaces(interfaces);
newResource.setToscaArtifacts(toscaArtifacts);
List<PropertyDefinition> properties = new ArrayList<>();
return newResource;
}
+ protected Map<String, InputDefinition> getCurrPropertiesMap() {
+ Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
+ InputDefinition inputDefinition = new InputDefinition();
+ inputDefinition.setName("inputDefinitionName");
+ inputDefinition.setUniqueId("uniqueId");
+ inputDefinition.setType("inputDefinitionType");
+ currPropertiesMap.put("propertyInfoName", inputDefinition);
+ return currPropertiesMap;
+ }
+
protected List<UploadPropInfo> getPropertyList() {
List<UploadPropInfo> propertyList = new ArrayList<>();
- UploadPropInfo uploadPropInfo = new UploadPropInfo();
List<GetInputValueDataDefinition> get_input = new ArrayList<>();
GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
+ getInputValueDataDefinition.setInputName("inputDefinitionName");
get_input.add(getInputValueDataDefinition);
- uploadPropInfo.setName("propertiesName");
- uploadPropInfo.setValue("value");
- uploadPropInfo.setGet_input(get_input);
- propertyList.add(uploadPropInfo);
+ UploadPropInfo propertyInfo = new UploadPropInfo();
+ propertyInfo.setValue("value");
+ propertyInfo.setGet_input(get_input);
+ propertyInfo.setName("propertyInfoName");
+ propertyList.add(propertyInfo);
return propertyList;
}
-
- protected Map<String, NodeTypeInfo> getNodeTypesInfo(){
+ private Map<String, NodeTypeInfo> getNodeTypesInfo() {
Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
Map<String, Object> mappedToscaTemplate = new HashMap<>();
nodeTypeInfo.setTemplateFileName("templateFileName");
nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
- nodeTypesInfo.put(nodeName,nodeTypeInfo);
+ nodeTypesInfo.put(nodeName, nodeTypeInfo);
return nodeTypesInfo;
}
- protected Map<String, UploadComponentInstanceInfo> getUploadResInstancesMap(){
+ private Map<String, Object> getNodeTypes() {
+ Map<String, Object> nodeTypesInfo = new HashMap<>();
+ NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
+ Map<String, Object> mappedToscaTemplate = new HashMap<>();
+ nodeTypeInfo.setNested(true);
+ nodeTypeInfo.setTemplateFileName("templateFileName");
+ nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
+ String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
+ nodeTypesInfo.put(nodeName, nodeTypeInfo);
+ return nodeTypesInfo;
+ }
+
+ private Map<String, UploadComponentInstanceInfo> getUploadResInstancesMap() {
Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
- UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
+ UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
- capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature","capabilitiesNamesToUpdate");
+ capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
Map<String, String> requirementsNamesToUpdate = new HashMap<>();
- requirementsNamesToUpdate.put("mme_ipu_vdu.feature","capabilitiesNamesToUpdate");
- uploadResInstancesMap.put("zxjTestImportServiceAb",uploadComponentInstanceInfo);
+ requirementsNamesToUpdate.put("mme_ipu_vdu.feature", "capabilitiesNamesToUpdate");
+ uploadResInstancesMap.put("zxjTestImportServiceAb", uploadComponentInstanceInfo);
return uploadResInstancesMap;
}
- protected Map<String, List<UploadPropInfo>> getUploadPropInfoProperties(){
+ protected Map<String, List<UploadPropInfo>> getUploadPropInfoProperties() {
Map<String, List<UploadPropInfo>> properties = new HashMap<>();
List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
UploadPropInfo uploadPropInfo = new UploadPropInfo();
uploadPropInfo.setValue("value");
uploadPropInfo.setGet_input(get_input);
uploadPropInfoList.add(uploadPropInfo);
- properties.put("uploadComponentInstanceInfo",uploadPropInfoList);
+ properties.put("uploadComponentInstanceInfo", uploadPropInfoList);
return properties;
}
- protected List<PropertyDefinition> getProperties(){
+ protected List<PropertyDefinition> getProperties() {
List<PropertyDefinition> properties = new ArrayList<>();
PropertyDefinition propertyDefinition = new PropertyDefinition();
propertyDefinition.setName("propertiesName");
return properties;
}
- protected Map<String, List<UploadReqInfo>> gerRequirements(){
+ protected Map<String, List<UploadReqInfo>> gerRequirements() {
Map<String, List<UploadReqInfo>> uploadReqInfoMap = new HashMap<>();
String requirementName = "tosca.capabilities.Node";
List<UploadReqInfo> uploadReqInfoList = new ArrayList<>();
UploadReqInfo uploadReqInfo = new UploadReqInfo();
uploadReqInfo.setCapabilityName("tosca.capabilities.Node");
- uploadReqInfoMap.put(requirementName,uploadReqInfoList);
+ uploadReqInfoMap.put(requirementName, uploadReqInfoList);
return uploadReqInfoMap;
}
parametersView.setIgnoreGroups(false);
return parametersView;
}
+
protected Map<String, byte[]> crateCsarFromPayload() {
String payloadName = "valid_vf.csar";
String rootPath = System.getProperty("user.dir");
privateMethod = AbstractValidationsServlet.class.getDeclaredMethod("getCsarFromPayload", UploadResourceInfo.class);
privateMethod.setAccessible(true);
returnValue = (Map<String, byte[]>) privateMethod.invoke(servlet, resourceInfo);
- } catch (IOException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+ } catch (IOException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException |
+ InvocationTargetException e) {
e.printStackTrace();
}
return returnValue;
}
-
- protected List<ComponentInstance> creatComponentInstances(){
+ protected List<ComponentInstance> creatComponentInstances() {
List<ComponentInstance> componentInstances = new ArrayList<>();
ComponentInstance componentInstance = new ComponentInstance();
Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
capabilityDefinition.setName("mme_ipu_vdu.feature");
capabilityDefinitionList.add(capabilityDefinition);
- capabilities.put("tosca.capabilities.Node",capabilityDefinitionList);
+ capabilities.put("tosca.capabilities.Node", capabilityDefinitionList);
Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
RequirementDefinition requirementDefinition = new RequirementDefinition();
requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
requirementDefinitionList.add(requirementDefinition);
- requirements.put("tosca.capabilities.Node",requirementDefinitionList);
+ requirements.put("tosca.capabilities.Node", requirementDefinitionList);
componentInstance.setRequirements(requirements);
componentInstance.setCapabilities(capabilities);
componentInstance.setUniqueId("uniqueId");
componentInstance.setComponentUid("componentUid");
componentInstance.setName("zxjTestImportServiceAb");
+ componentInstance.setNormalizedName("zxjTestImportServiceAb");
+ componentInstance.setProperties(getProperties());
componentInstances.add(componentInstance);
return componentInstances;
}
- protected CreateServiceFromYamlParameter getCsfyp() {
+ private CreateServiceFromYamlParameter getCsfyp() {
CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
- List<ArtifactDefinition> createdArtifacts =new ArrayList<>();
- Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
+ List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
+ Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
csfyp.setNodeName("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test");
csfyp.setTopologyTemplateYaml(getMainTemplateContent("service_import_template.yml"));
return csfyp;
}
- protected ParsedToscaYamlInfo getParsedToscaYamlInfo(){
+ private ParsedToscaYamlInfo getParsedToscaYamlInfo() {
ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
Map<String, InputDefinition> inputs = new HashMap<>();
- Map<String, UploadComponentInstanceInfo> instances=new HashMap<>();
- Map<String, GroupDefinition> groups=new HashMap<>();
- Map<String, PolicyDefinition> policies=new HashMap<>();
+ Map<String, UploadComponentInstanceInfo> instances = new HashMap<>();
+ UploadComponentInstanceInfo uploadComponentInstanceInfo = getUploadComponentInstanceInfo();
+ instances.put("instances", uploadComponentInstanceInfo);
+ Map<String, GroupDefinition> groups = new HashMap<>();
+ Map<String, PolicyDefinition> policies = new HashMap<>();
parsedToscaYamlInfo.setGroups(groups);
parsedToscaYamlInfo.setInputs(inputs);
parsedToscaYamlInfo.setInstances(instances);
return parsedToscaYamlInfo;
}
- String getMainTemplateContent(String fileName){
+ String getMainTemplateContent(String fileName) {
String mainTemplateContent = null;
try {
mainTemplateContent = loadFileNameToJsonString(fileName);
return mainTemplateContent;
}
- protected CsarInfo getCsarInfo ()
- {
+ protected ServiceCsarInfo getCsarInfo() {
String csarUuid = "0010";
- User user = new User();
- Map<String, byte[]> csar = crateCsarFromPayload();
- String vfReousrceName = "resouceName";
- String mainTemplateName = "mainTemplateName";
- String mainTemplateContent = getMainTemplateContent("service_import_template.yml");
- CsarInfo csarInfo = new CsarInfo(user, csarUuid, csar, vfReousrceName, mainTemplateName, mainTemplateContent, false);
- return csarInfo;
- }
+ User user = new User("jh0003");
- public static String loadFileNameToJsonString(String fileName) throws IOException {
- String sourceDir = "src/test/resources/normativeTypes";
- return loadFileNameToJsonString(sourceDir, fileName);
- }
+ try {
+ File csarFile = new File(
+ ServiceImportBusinessLogicTest.class.getClassLoader().getResource("csars/service-Ser09080002-csar.csar").toURI());
+ Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
- private static String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
- java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
- byte[] fileContent = Files.readAllBytes(filePath);
- return new String(fileContent);
+ String vfReousrceName = "resouceName";
+ String mainTemplateName = "Definitions/service_import_template.yml";
+
+ Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Ser09080002-template.yml")).findAny();
+ byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
+ assertNotNull(mainTemplateService);
+ final String mainTemplateContent = new String(mainTemplateService);
+
+ return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, null, mainTemplateName, mainTemplateContent, false,
+ mock(ModelOperation.class));
+ } catch (URISyntaxException | ZipException e) {
+ fail(e);
+ }
+ return null;
}
+ private ImmutablePair<String, byte[]> getNodeType() {
+ try {
+ File resource = new File(
+ ServiceImportBusinessLogicTest.class.getClassLoader().getResource("node-types/resource-Extcp-template.yml").toURI());
+ byte[] extcpResource = Files.readAllBytes(resource.toPath());
+
+ return new ImmutablePair<>("org.openecomp.resource.cp.extCP", extcpResource);
+ } catch (URISyntaxException | IOException e) {
+ fail(e);
+ }
+ return null;
+ }
- protected CsarUtils.NonMetaArtifactInfo getNonMetaArtifactInfo(){
- String artifactName = "artifactName",path = "/src/test/resources/valid_vf.csar",artifactType = "AAI_SERVICE_MODEL";
+ protected CsarUtils.NonMetaArtifactInfo getNonMetaArtifactInfo() {
+ String artifactName = "artifactName", path = "/src/test/resources/valid_vf.csar", artifactType = "AAI_SERVICE_MODEL";
ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
String rootPath = System.getProperty("user.dir");
Path path2;
}
String artifactUniqueId = "artifactUniqueId";
boolean isFromCsar = true;
- CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo = new CsarUtils.NonMetaArtifactInfo(artifactName,
- path,artifactType,artifactGroupType,data,artifactUniqueId,isFromCsar);
+ CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo = new CsarUtils.NonMetaArtifactInfo(artifactName,
+ path, artifactType, artifactGroupType, data, artifactUniqueId, isFromCsar);
return nonMetaArtifactInfo;
}
-
+
protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
ResponseFormat actualResponse = e.getResponseFormat() != null ?
- e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
+ e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
assertParseResponse(actualResponse, expectedStatus, variables);
}
assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());
}
-}
\ No newline at end of file
+}
Code Review / sdc.git / blobdiff