PLAN:
acceptedTypes:
- xml
+ WORKFLOW:
+ acceptedTypes:
+
resourceDeploymentArtifacts:
HEAT:
validForResourceTypes:
- VF
- VFC
+ WORKFLOW:
+ acceptedTypes:
+ validForResourceTypes: *allResourceTypes
resourceInstanceDeploymentArtifacts:
HEAT_ENV:
Operation operation = optionalOperation.get();
ArtifactDefinition implementationArtifact = operation.getImplementationArtifact();
- implementationArtifact.setArtifactName(operation.getName() + "_" + artifactInfo.getArtifactName());
+ implementationArtifact.setArtifactName(artifactInfo.getArtifactName());
implementationArtifact.setDescription(artifactInfo.getDescription());
implementationArtifact.setArtifactType(artifactInfo.getArtifactType());
+ implementationArtifact.setArtifactLabel(artifactInfo.getUniqueId());
+ implementationArtifact.setEsId(artifactInfo.getEsId());
operation.setImplementation(implementationArtifact);
gotInterface.setOperationsMap(operationsMap);
Either<InterfaceDefinition, StorageOperationStatus> interfaceDefinitionStorageOperationStatusEither =
String artifactUUID = UUID.randomUUID().toString();
artifactDefinition.setArtifactUUID(artifactUUID);
artifactDefinition.setUniqueId(artifactUUID);
- artifactDefinition.setArtifactType(ArtifactTypeEnum.PLAN.getType());
- artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.LIFE_CYCLE);
+ artifactDefinition.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
+ artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
operation.setUniqueId(UUID.randomUUID().toString());
operation.setImplementation(artifactDefinition);
}
import fj.data.Either;
import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.collections.MapUtils;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.lang.WordUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
import org.openecomp.sdc.be.dao.cassandra.SdcSchemaFilesCassandraDao;
-import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.model.*;
public static final String RESOURCES_PATH = "Resources/";
public static final String INFORMATIONAL_ARTIFACTS = "Informational/";
public static final String DEPLOYMENT_ARTIFACTS = "Deployment/";
- public static final String WORKFLOW_ARTIFACT_DIR = "Workflows" + File.separator + "BPMN" + File.separator;
- public static final String DEPLOYMENT_ARTIFACTS_DIR = "Deployment" + File.separator;
public static final String DEFINITIONS_PATH = "Definitions/";
private static final String CSAR_META_VERSION = "1.0";
// US798487 - Abstraction of complex types
if (!ModelConverter.isAtomicComponent(component)) {
log.debug("Component {} is complex - generating abstract type for it..", component.getName());
- writeComponentInterface(component, zip, fileName);
+ writeComponentInterface(component, zip, fileName, false);
}
if (dependencies == null) {
// add component interface to zip
if (!ModelConverter.isAtomicComponent(innerComponent)) {
- writeComponentInterface(innerComponent, zip, icFileName);
+ writeComponentInterface(innerComponent, zip, icFileName, true);
}
}
}
}
private Either<ZipOutputStream, ResponseFormat> writeComponentInterface(Component component, ZipOutputStream zip,
- String fileName) {
+ String fileName, boolean isAssociatedResourceComponent) {
try {
Either<ToscaRepresentation, ToscaError> componentInterface = toscaExportUtils
- .exportComponentInterface(component);
+ .exportComponentInterface(component, isAssociatedResourceComponent);
ToscaRepresentation componentInterfaceYaml = componentInterface.left().value();
String mainYaml = componentInterfaceYaml.getMainYaml();
String interfaceFileName = DEFINITIONS_PATH + ToscaExportHandler.getInterfaceFilename(fileName);
return Either.right(writeComponentArtifactsToSpecifiedPath.right().value());
}
}
- writeComponentArtifactsToSpecifiedPath = writeOperationsArtifactsToCsar(mainComponent, zipstream);
-
- if (writeComponentArtifactsToSpecifiedPath.isRight()) {
- return Either.right(writeComponentArtifactsToSpecifiedPath.right().value());
- }
return Either.left(zipstream);
}
- private Either<ZipOutputStream, ResponseFormat> writeOperationsArtifactsToCsar(Component component,
- ZipOutputStream zipstream) {
- if (component instanceof Service) {
- return Either.left(zipstream);
- }
- if (Objects.isNull(((Resource) component).getInterfaces())) {
- log.debug("Component Name {}- no interfaces found", component.getNormalizedName());
- return Either.left(zipstream);
- }
- final Map<String, InterfaceDefinition> interfaces = ((Resource) component).getInterfaces();
-
- for (Map.Entry<String, InterfaceDefinition> interfaceEntry : interfaces.entrySet()) {
- for (OperationDataDefinition operation : interfaceEntry.getValue().getOperations().values()) {
- try {
- if (Objects.isNull(operation.getImplementation())) {
- log.debug(
- "Component Name {}, Interface Id {}, Operation Name {} - no Operation Implementation found",
- component.getNormalizedName(), interfaceEntry.getValue().getUniqueId(),
- operation.getName());
- continue;
- }
- if (Objects.isNull(operation.getImplementation().getArtifactName())) {
- log.debug("Component Name {}, Interface Id {}, Operation Name {} - no artifact found",
- component.getNormalizedName(), interfaceEntry.getValue().getUniqueId(),
- operation.getName());
- continue;
- }
-
- final String artifactUUID = operation.getImplementation().getArtifactUUID();
-
- final Either<byte[], ActionStatus> artifactFromCassandra = getFromCassandra(artifactUUID);
- final String artifactName = operation.getImplementation().getArtifactName();
- if (artifactFromCassandra.isRight()) {
- log.error("ArtifactName {}, unique ID {}", artifactName, artifactUUID);
- log.error("Failed to get {} payload from DB reason: {}", artifactName,
- artifactFromCassandra.right().value());
- return Either.right(componentsUtils.getResponseFormat(
- ActionStatus.ARTIFACT_PAYLOAD_NOT_FOUND_DURING_CSAR_CREATION, "Resource",
- component.getUniqueId(), artifactName, artifactUUID));
- }
-
- final byte[] payloadData = artifactFromCassandra.left().value();
- zipstream.putNextEntry(new ZipEntry(
- OperationArtifactUtil.createOperationArtifactPath(component.getNormalizedName(),
- interfaceEntry.getValue().getToscaResourceName(), operation)));
- zipstream.write(payloadData);
-
- } catch (IOException | NullPointerException e) {
- log.error("Component Name {}, Interface Name {}, Operation Name {}", component.getNormalizedName(),
- interfaceEntry.getKey(), operation.getName());
- log.error("Error while writing the operation's artifacts to the CSAR " + "{}", e);
- return Either.right(componentsUtils.getResponseFormat(ActionStatus.ERROR_DURING_CSAR_CREATION,
- "Resource", component.getUniqueId()));
- }
- }
- }
- return Either.left(zipstream);
-
- }
-
private Either<ZipOutputStream, ResponseFormat> writeComponentArtifactsToSpecifiedPath(Component mainComponent,
ComponentArtifacts componentArtifacts, ZipOutputStream zipstream, String currentPath,
boolean isInCertificationRequest) throws IOException {
Set<ArtifactGroupTypeEnum> groupTypeEnumKeySet = artifactsInfo.keySet();
for (ArtifactGroupTypeEnum artifactGroupTypeEnum : groupTypeEnumKeySet) {
- String groupTypeFolder = path + WordUtils.capitalizeFully(artifactGroupTypeEnum.getType()) + "/";
+ String groupTypeFolder = path + WordUtils.capitalizeFully(artifactGroupTypeEnum.getType()) + File.separator;
Map<ArtifactTypeEnum, List<ArtifactDefinition>> artifactTypesMap = artifactsInfo.get(artifactGroupTypeEnum);
Set<ArtifactTypeEnum> artifactTypeEnumKeySet = artifactTypesMap.keySet();
for (ArtifactTypeEnum artifactTypeEnum : artifactTypeEnumKeySet) {
List<ArtifactDefinition> artifactDefinitionList = artifactTypesMap.get(artifactTypeEnum);
- String artifactTypeFolder = groupTypeFolder + artifactTypeEnum.toString() + "/";
+ String artifactTypeFolder = groupTypeFolder + artifactTypeEnum.toString() + File.separator;
+ if (artifactTypeEnum == ArtifactTypeEnum.WORKFLOW) {
+ artifactTypeFolder += OperationArtifactUtil.BPMN_ARTIFACT_PATH + File.separator;
+ }
Either<ZipOutputStream, ResponseFormat> writeArtifactDefinition = writeArtifactDefinition(mainComponent,
zip, artifactDefinitionList, artifactTypeFolder, isInCertificationRequest);
public void addArtifactsToGroup(ArtifactGroupTypeEnum artifactGroup,
Map<ArtifactTypeEnum, List<ArtifactDefinition>> artifactsDefinition) {
- artifactsInfoField.put(artifactGroup, artifactsDefinition);
+ if (artifactsInfoField.get(artifactGroup) == null) {
+ artifactsInfoField.put(artifactGroup, artifactsDefinition);
+ } else {
+ Map<ArtifactTypeEnum, List<ArtifactDefinition>> artifactTypeEnumListMap =
+ artifactsInfoField.get(artifactGroup);
+ artifactTypeEnumListMap.putAll(artifactsDefinition);
+ artifactsInfoField.put(artifactGroup, artifactTypeEnumListMap);
+ }
+
}
public boolean isEmpty() {
Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
Map<ArtifactTypeEnum, List<ArtifactDefinition>> deploymentArtifactsByType = collectGroupArtifacts(
deploymentArtifacts);
+ Map<String, ArtifactDefinition> interfaceOperationArtifacts =
+ OperationArtifactUtil.getDistinctInterfaceOperationArtifactsByName(component);
+ Map<ArtifactTypeEnum, List<ArtifactDefinition>> interfaceOperationArtifactsByType = collectGroupArtifacts(
+ interfaceOperationArtifacts);
ArtifactsInfo artifactsInfo = new ArtifactsInfo();
if (!informationalArtifactsByType.isEmpty()) {
artifactsInfo.addArtifactsToGroup(ArtifactGroupTypeEnum.INFORMATIONAL, informationalArtifactsByType);
if (!deploymentArtifactsByType.isEmpty()) {
artifactsInfo.addArtifactsToGroup(ArtifactGroupTypeEnum.DEPLOYMENT, deploymentArtifactsByType);
}
+ //Add component interface operation artifacts
+ if(MapUtils.isNotEmpty(interfaceOperationArtifacts)) {
+ artifactsInfo.addArtifactsToGroup(ArtifactGroupTypeEnum.DEPLOYMENT, interfaceOperationArtifactsByType);
+ }
return artifactsInfo;
}
return Either.left(toscaRepresentation);
}
- public Either<ToscaRepresentation, ToscaError> exportComponentInterface(Component component) {
+ public Either<ToscaRepresentation, ToscaError> exportComponentInterface(Component component,
+ boolean isAssociatedResourceComponent) {
if (null == DEFAULT_IMPORTS) {
log.debug(FAILED_TO_GET_DEFAULT_IMPORTS_CONFIGURATION);
return Either.right(ToscaError.GENERAL_ERROR);
ToscaTemplate toscaTemplate = new ToscaTemplate(TOSCA_VERSION);
toscaTemplate.setImports(new ArrayList<>(DEFAULT_IMPORTS));
Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
- Either<ToscaTemplate, ToscaError> toscaTemplateRes = convertInterfaceNodeType(new HashMap<>(), component, toscaTemplate,
- nodeTypes);
+ Either<ToscaTemplate, ToscaError> toscaTemplateRes = convertInterfaceNodeType(new HashMap<>(), component,
+ toscaTemplate, nodeTypes, isAssociatedResourceComponent);
if (toscaTemplateRes.isRight()) {
return Either.right(toscaTemplateRes.right().value());
}
return convertReqCapAndTypeName(componentsCache, component, toscaNode, nodeTypes, toscaNodeType, dataTypes);
}
- private Either<ToscaTemplate, ToscaError> convertInterfaceNodeType(Map<String, Component> componentsCache, Component component, ToscaTemplate toscaNode,
- Map<String, ToscaNodeType> nodeTypes) {
+ private Either<ToscaTemplate, ToscaError> convertInterfaceNodeType(Map<String, Component> componentsCache,
+ Component component, ToscaTemplate toscaNode,
+ Map<String, ToscaNodeType> nodeTypes,
+ boolean isAssociatedResourceComponent) {
log.debug("start convert node type for {}", component.getUniqueId());
ToscaNodeType toscaNodeType = createNodeType(component);
toscaNode.setInterface_types(addInterfaceTypeElement(component));
List<InputDefinition> inputDef = component.getInputs();
Map<String, ToscaProperty> inputs = new HashMap<>();
- addInterfaceDefinitionElement(component, toscaNodeType);
+ addInterfaceDefinitionElement(component, toscaNodeType, isAssociatedResourceComponent);
if (inputDef != null) {
inputDef.forEach(i -> {
ToscaProperty property = propertyConvertor.convertProperty(dataTypes, i, false);
* @param component to work on
* @param nodeType to which the interfaces element will be added
*/
- public static void addInterfaceDefinitionElement(Component component, ToscaNodeType nodeType) {
+ public static void addInterfaceDefinitionElement(Component component, ToscaNodeType nodeType,
+ boolean isAssociatedResourceComponent) {
if (component instanceof Product) {
return;
}
ToscaLifecycleOperationDefinition toscaOperation = new ToscaLifecycleOperationDefinition();
if (isArtifactPresent(operationEntry)) {
operationArtifactPath = OperationArtifactUtil
- .createOperationArtifactPath(component.getNormalizedName(),
- interfaceDefinition.getToscaResourceName(),
- operationEntry.getValue());
+ .createOperationArtifactPath(component, operationEntry.getValue(),
+ isAssociatedResourceComponent);
toscaOperation.setImplementation(operationArtifactPath);
}
toscaOperation.setDescription(operationEntry.getValue().getDescription());
package org.openecomp.sdc.be.tosca.utils;
+import java.io.File;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.WordUtils;
+import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.Operation;
+import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.tosca.CsarUtils;
-
-import java.io.File;
+import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
+import org.openecomp.sdc.common.api.ArtifactTypeEnum;
public class OperationArtifactUtil {
+ public static final String BPMN_ARTIFACT_PATH = "BPMN";
+
+ private OperationArtifactUtil() {
+ //Hiding implicit public constructor
+ }
/**
* This method assumes that operation.getImplementation() is not NULL ( it should be verified by the caller method)
*
- * @param componentName component's normalized name
- * @param interfaceType the specific interface type
* @param operation the specific operation name
* @return the full path including file name for operation's artifacts
*/
+ static String createOperationArtifactPath(Component component, OperationDataDefinition operation,
+ boolean isAssociatedResourceComponent) {
+ if (!(component instanceof Resource)) {
+ return null;
+ }
+ if (isAssociatedResourceComponent) {
+ ResourceMetadataDataDefinition resourceMetadataDataDefinition = (ResourceMetadataDataDefinition)
+ component.getComponentMetadataDefinition().getMetadataDataDefinition();
+ return createOperationArtifactPathInService(resourceMetadataDataDefinition.getToscaResourceName() +
+ "_v" + component.getVersion(), operation);
+ }
+ return createOperationArtifactPathInResource(operation);
+ }
+
+
+ private static String createOperationArtifactPathInResource(OperationDataDefinition operation) {
+ return CsarUtils.ARTIFACTS + File.separator + WordUtils.capitalizeFully(ArtifactGroupTypeEnum.DEPLOYMENT.name())
+ + File.separator + ArtifactTypeEnum.WORKFLOW.name() + File.separator + BPMN_ARTIFACT_PATH
+ + File.separator + operation.getImplementation().getArtifactName();
+ }
+
+ private static String createOperationArtifactPathInService(String toscaComponentName,
+ OperationDataDefinition operation) {
+ return CsarUtils.ARTIFACTS + File.separator + toscaComponentName + File.separator +
+ WordUtils.capitalizeFully(ArtifactGroupTypeEnum.DEPLOYMENT.name()) + File.separator +
+ ArtifactTypeEnum.WORKFLOW.name() + File.separator + BPMN_ARTIFACT_PATH + File.separator +
+ operation.getImplementation().getArtifactName();
+ }
+
+ public static Map<String, ArtifactDefinition> getDistinctInterfaceOperationArtifactsByName(Component originComponent) {
+ Map<String, ArtifactDefinition> distinctInterfaceArtifactsByName = new HashMap<>();
+ Map<String, InterfaceDefinition> interfaces = originComponent.getInterfaces();
+ if (MapUtils.isEmpty(interfaces)) {
+ return distinctInterfaceArtifactsByName;
+ }
+ Map<String, ArtifactDefinition> interfaceArtifacts = interfaces.values().stream()
+ .flatMap(interfaceDefinition -> interfaceDefinition.getOperationsMap().values().stream())
+ .map(Operation::getImplementationArtifact)
+ .collect(Collectors.toMap(ArtifactDataDefinition::getUniqueId,
+ artifactDefinition -> artifactDefinition));
+ if (MapUtils.isNotEmpty(interfaceArtifacts)) {
+ Set<String> artifactNameSet = new HashSet<>();
+ for (Map.Entry<String, ArtifactDefinition> interfaceArtifactEntry : interfaceArtifacts.entrySet()) {
+ String artifactName = interfaceArtifactEntry.getValue().getArtifactName();
+ if (artifactNameSet.contains(artifactName)) {
+ continue;
+ }
+ distinctInterfaceArtifactsByName.put(interfaceArtifactEntry.getKey(),
+ interfaceArtifactEntry.getValue());
+ artifactNameSet.add(artifactName);
+ }
- public static String createOperationArtifactPath(String componentName, String interfaceType,
- OperationDataDefinition operation) {
- return CsarUtils.ARTIFACTS + File.separator + componentName + File.separator + interfaceType + File.separator
- + CsarUtils.DEPLOYMENT_ARTIFACTS_DIR + CsarUtils.WORKFLOW_ARTIFACT_DIR + operation
- .getImplementation()
- .getArtifactName();
+ }
+ return distinctInterfaceArtifactsByName;
}
}
.thenReturn(Either.right(ToscaError.GENERAL_ERROR));
try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, false, false);
+ Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, false);
} catch (Exception e) {
e.printStackTrace();
}
.thenReturn(Either.right(ToscaError.GENERAL_ERROR));
try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, false, false);
+ Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, false);
} catch (Exception e) {
e.printStackTrace();
}
.thenReturn(Either.left(toscaTemplate));
try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+ Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true);
} catch (Exception e) {
e.printStackTrace();
}
.thenReturn(Either.left(toscaTemplate));
try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+ Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true);
} catch (Exception e) {
e.printStackTrace();
}
.thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+ Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true);
} catch (Exception e) {
e.printStackTrace();
}
.thenReturn(Either.left(schemaList));
try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+ Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true);
} catch (Exception e) {
e.printStackTrace();
}
Mockito.any(Boolean.class))).thenReturn(new User());
try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+ Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true);
} catch (Exception e) {
e.printStackTrace();
}
ToscaRepresentation tosca = new ToscaRepresentation();
tosca.setMainYaml("value");
- Mockito.when(toscaExportUtils.exportComponentInterface(Mockito.any(Component.class)))
+ Mockito.when(toscaExportUtils.exportComponentInterface(Mockito.any(Component.class), Mockito.any(Boolean.class)))
.thenReturn(Either.left(tosca));
try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "writeComponentInterface", new Resource(), zip, fileName);
+ Deencapsulation.invoke(testSubject, "writeComponentInterface", new Resource(), zip, fileName, false);
} catch (IOException e) {
e.printStackTrace();
}
CsarUtils.validateNonMetaArtifact("", new byte[0], new HashMap<>());
}
- @Test
- public void testWriteAllFilesToCsarWhenWriteOperationsArtifactsToCsarIsRight() {
- Component component = new Resource();
- Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
- ArtifactDefinition artifact = new ArtifactDefinition();
- artifact.setArtifactName("artifactName");
- artifact.setEsId("esId");
- artifact.setArtifactUUID("artifactUUID");
- artifact.setArtifactType("YANG");
- toscaArtifacts.put("assettoscatemplate", artifact);
-
- component.setToscaArtifacts(toscaArtifacts);
- component.setDeploymentArtifacts(toscaArtifacts);
- component.setArtifacts(toscaArtifacts);
- Map<String, InterfaceDefinition> interfaces = new HashMap<>();
- InterfaceDefinition interfaceDef = new InterfaceDefinition();
- Map<String, OperationDataDefinition> operations = new HashMap<>();
- OperationDataDefinition operation = new OperationDataDefinition();
- ArtifactDataDefinition implementation = new ArtifactDataDefinition();
- implementation.setArtifactUUID("artifactUUID");
- implementation.setArtifactName("artifactName");
- operation.setImplementation(implementation);
- operations.put("key", operation);
- interfaceDef.setOperations(operations);
- interfaces.put("key", interfaceDef);
- ((Resource) component).setInterfaces(interfaces);
-
- ESArtifactData artifactData = new ESArtifactData();
- byte[] data = "value".getBytes();
- artifactData.setDataAsArray(data);
-
- ToscaTemplate toscaTemplate = new ToscaTemplate("version");
- List<Triple<String, String, Component>> dependencies = new ArrayList<>();
- toscaTemplate.setDependencies(dependencies);
-
- List<SdcSchemaFilesData> filesData = new ArrayList<>();
- SdcSchemaFilesData filedata = new SdcSchemaFilesData();
- filedata.setPayloadAsArray(data);
- filesData.add(filedata);
-
- Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData),
- Either.right(CassandraOperationStatus.GENERAL_ERROR));
-
- Mockito.when(componentsUtils.convertFromStorageResponse(Mockito.any(StorageOperationStatus.class)))
- .thenReturn(ActionStatus.GENERAL_ERROR);
-
- Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
- .thenReturn(Either.left(toscaTemplate));
-
- Mockito.when(
- sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
- .thenReturn(Either.left(filesData));
-
- testSubject.createCsar(component, false, true);
- }
-
- @Test
- public void testWriteOperationsArtifactsToCsarWhenComponentIsService() {
- Component component = new Service();
-
- try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- @Test
- public void testWriteOperationsArtifactsToCsarWhenOperationGetImplementaionIsNull() {
- Component component = new Resource();
- Map<String, InterfaceDefinition> interfaces = new HashMap<>();
- InterfaceDefinition interfaceDef = new InterfaceDefinition();
- Map<String, OperationDataDefinition> operations = new HashMap<>();
- operations.put("key", new OperationDataDefinition());
- interfaceDef.setOperations(operations);
- interfaces.put("key", interfaceDef);
-
- ((Resource) component).setInterfaces(interfaces);
-
- try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- @Test
- public void testWriteOperationsArtifactsToCsarWhenOperationGetArtifactNameIsNull() {
- Component component = new Resource();
-
- Map<String, InterfaceDefinition> interfaces = new HashMap<>();
- InterfaceDefinition interfaceDef = new InterfaceDefinition();
- Map<String, OperationDataDefinition> operations = new HashMap<>();
- OperationDataDefinition operation = new OperationDataDefinition();
- ArtifactDataDefinition implementation = new ArtifactDataDefinition();
- operation.setImplementation(implementation);
- operations.put("key", operation);
- interfaceDef.setOperations(operations);
- interfaces.put("key", interfaceDef);
- ((Resource) component).setInterfaces(interfaces);
-
- try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- @Test
- public void testWriteOperationsArtifactsToCsarWhenGettingArtifactFromCassandra() {
- Component component = new Resource();
-
- Map<String, InterfaceDefinition> interfaces = new HashMap<>();
- InterfaceDefinition interfaceDef = new InterfaceDefinition();
- Map<String, OperationDataDefinition> operations = new HashMap<>();
- OperationDataDefinition operation = new OperationDataDefinition();
- ArtifactDataDefinition implementation = new ArtifactDataDefinition();
- implementation.setArtifactName("artifactName");
- implementation.setArtifactUUID("artifactUUID");
- operation.setImplementation(implementation);
- operations.put("key", operation);
- interfaceDef.setOperations(operations);
- interfaceDef.setToscaResourceName("toscaResourceName");
- interfaces.put("key", interfaceDef);
- ((Resource) component).setInterfaces(interfaces);
- component.setNormalizedName("normalizedName");
-
- ESArtifactData data = new ESArtifactData();
- data.setDataAsArray("data".getBytes());
-
- Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(data));
-
- try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- @Test
- public void testWriteOperationsArtifactsToCsarWhenNullPointerExceptionIsCaught() {
- Component component = new Resource();
-
- Map<String, InterfaceDefinition> interfaces = new HashMap<>();
- InterfaceDefinition interfaceDef = new InterfaceDefinition();
- Map<String, OperationDataDefinition> operations = new HashMap<>();
- OperationDataDefinition operation = new OperationDataDefinition();
- ArtifactDataDefinition implementation = new ArtifactDataDefinition();
- implementation.setArtifactName("artifactName");
- implementation.setArtifactUUID("artifactUUID");
- operation.setImplementation(implementation);
- operations.put("key", operation);
- interfaceDef.setOperations(operations);
- interfaceDef.setToscaResourceName("toscaResourceName");
- interfaces.put("key", interfaceDef);
- ((Resource) component).setInterfaces(interfaces);
- component.setNormalizedName("normalizedName");
-
- Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class)))
- .thenReturn(Either.left(new ESArtifactData()));
-
- try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
- Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
@Test
public void testWriteArtifactDefinition() {
Component component = new Service();
Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
// default test when convertInterfaceNodeType is right
- result = testSubject.exportComponentInterface(component);
+ result = testSubject.exportComponentInterface(component, false);
Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
// default test when convertInterfaceNodeType is left
- result = testSubject.exportComponentInterface(component);
+ result = testSubject.exportComponentInterface(component, false);
}
Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
// default test
- result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType",new HashMap<>(), component, toscaNode, nodeTypes);
+ result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType",new HashMap<>(), component, toscaNode
+ , nodeTypes, false);
}
@Ignore("need to fix change in injected class.")
@Test
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType);
+ InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false);
ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null);
ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME);
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType);
+ InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, true);
ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null);
ToscaTemplate template = new ToscaTemplate("testService");
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType);
+ InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false);
ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null);
ToscaTemplate template = new ToscaTemplate("test");
*/
package org.openecomp.sdc.be.tosca.utils;
+import static org.junit.Assert.assertEquals;
+import static org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil.BPMN_ARTIFACT_PATH;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import org.apache.commons.lang.WordUtils;
+import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.openecomp.sdc.be.DummyConfigurationManager;
+import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentMetadataDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.Resource;
-
-import java.io.File;
-import java.util.HashMap;
-
-import static org.junit.Assert.assertEquals;
+import org.openecomp.sdc.be.tosca.CsarUtils;
+import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
+import org.openecomp.sdc.common.api.ArtifactTypeEnum;
public class OperationArtifactUtilTest {
@Test
public void testCorrectPathForOperationArtifacts() {
- Component component = new Resource();
- component.setNormalizedName("normalizedComponentName");
- final InterfaceDefinition addedInterface = new InterfaceDefinition();
+ ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
+ componentMetadataDataDefinition.setToscaResourceName("org.openecomp.resource.vf.TestResource");
+ final ComponentMetadataDefinition componentMetadataDefinition =
+ new ComponentMetadataDefinition(componentMetadataDataDefinition);
+ Component component = new Resource(componentMetadataDefinition);
+ final OperationDataDefinition op = new OperationDataDefinition();
+ final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
+ implementation.setArtifactName("createBPMN.bpmn");
+ op.setImplementation(implementation);
+ final String actualArtifactPath = OperationArtifactUtil.createOperationArtifactPath(component, op, false);
+ String expectedArtifactPath = CsarUtils.ARTIFACTS + File.separator +
+ WordUtils.capitalizeFully(ArtifactGroupTypeEnum.DEPLOYMENT.name()) + File.separator +
+ ArtifactTypeEnum.WORKFLOW.name() + File.separator + BPMN_ARTIFACT_PATH + File.separator +
+ "createBPMN.bpmn";
+
+
+ assertEquals(expectedArtifactPath,actualArtifactPath);
+ }
+
+ @Test
+ public void testCorrectPathForOperationArtifactsInService() {
+ ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
+ componentMetadataDataDefinition.setToscaResourceName("org.openecomp.resource.vf.TestResource");
+ final ComponentMetadataDefinition componentMetadataDefinition =
+ new ComponentMetadataDefinition(componentMetadataDataDefinition);
+ Component component = new Resource(componentMetadataDefinition);
+ component.setVersion("1.0");
final OperationDataDefinition op = new OperationDataDefinition();
final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
implementation.setArtifactName("createBPMN.bpmn");
op.setImplementation(implementation);
+ final String actualArtifactPath = OperationArtifactUtil.createOperationArtifactPath(component, op, true);
+ String expectedArtifactPath = CsarUtils.ARTIFACTS + File.separator +
+ "org.openecomp.resource.vf.TestResource_v1.0" + File.separator +
+ WordUtils.capitalizeFully(ArtifactGroupTypeEnum.DEPLOYMENT.name()) + File.separator +
+ ArtifactTypeEnum.WORKFLOW.name() +
+ File.separator + BPMN_ARTIFACT_PATH + File.separator + "createBPMN.bpmn";
+
+
+ assertEquals(expectedArtifactPath,actualArtifactPath);
+ }
+
+ @Test
+ public void testGetDistinctInterfaceOperationArtifactsByName() {
+ Component component = new Resource();
+ component.setNormalizedName("normalizedComponentName");
+ final InterfaceDefinition addedInterface = new InterfaceDefinition();
+ OperationDataDefinition op1 = createInterfaceOperation("createBPMN.bpmn");
+ OperationDataDefinition op2 = createInterfaceOperation("createBPMN.bpmn");
addedInterface.setOperations(new HashMap<>());
- addedInterface.getOperations().put("create", op);
+ addedInterface.getOperations().put("create", op1);
+ addedInterface.getOperations().put("update", op2);
final String interfaceType = "normalizedComponentName-interface";
- ((Resource) component).setInterfaces(new HashMap<>());
- ((Resource) component).getInterfaces().put(interfaceType, addedInterface);
- final String actualArtifactPath = OperationArtifactUtil.createOperationArtifactPath(component.getNormalizedName(), interfaceType, op);
- String expectedArtifactPath ="Artifacts"+ File.separator+"normalizedComponentName"+File.separator
- +"normalizedComponentName-interface"+File.separator+"Deployment"
- +File.separator+"Workflows"+File.separator+"BPMN"
- +File.separator+"createBPMN.bpmn";
+ component.setInterfaces(new HashMap<>());
+ component.getInterfaces().put(interfaceType, addedInterface);
+ Map<String, ArtifactDefinition> distinctInterfaceOperationArtifactsByName =
+ OperationArtifactUtil.getDistinctInterfaceOperationArtifactsByName(component);
+ Assert.assertEquals(1, distinctInterfaceOperationArtifactsByName.size());
+ }
- assertEquals(expectedArtifactPath,actualArtifactPath);
+ @Test
+ public void testGetDistinctInterfaceOperationArtifactsByNameAllDistinct() {
+ Component component = new Resource();
+ component.setNormalizedName("normalizedComponentName");
+ final InterfaceDefinition addedInterface = new InterfaceDefinition();
+ OperationDataDefinition op1 = createInterfaceOperation("createBPMN.bpmn");
+ OperationDataDefinition op2 = createInterfaceOperation("updateBPMN.bpmn");
+ addedInterface.setOperations(new HashMap<>());
+ addedInterface.getOperations().put("create", op1);
+ addedInterface.getOperations().put("update", op2);
+ final String interfaceType = "normalizedComponentName-interface";
+ component.setInterfaces(new HashMap<>());
+ component.getInterfaces().put(interfaceType, addedInterface);
+
+ Map<String, ArtifactDefinition> distinctInterfaceOperationArtifactsByName =
+ OperationArtifactUtil.getDistinctInterfaceOperationArtifactsByName(component);
+ Assert.assertEquals(2, distinctInterfaceOperationArtifactsByName.size());
+ }
+
+ private OperationDataDefinition createInterfaceOperation(String artifactName) {
+ final OperationDataDefinition op = new OperationDataDefinition();
+ final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
+ implementation.setUniqueId(UUID.randomUUID().toString());
+ implementation.setArtifactName(artifactName);
+ op.setImplementation(implementation);
+ return op;
}
}
\ No newline at end of file
Code Review / sdc.git / commitdiff