package org.openecomp.sdc.be.components.impl;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_ENV_NAME;
+import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_VF_ENV_NAME;
+
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import fj.data.Either;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
import mockit.Deencapsulation;
import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.junit.Assert;
import org.junit.Before;
import org.openecomp.sdc.be.MockGenerator;
import org.openecomp.sdc.be.components.ArtifactsResolver;
import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
-import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationInfo;
+import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
+import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
import org.openecomp.sdc.be.components.utils.ArtifactBuilder;
import org.openecomp.sdc.be.components.utils.ObjectGenerator;
import org.openecomp.sdc.be.components.validation.UserValidations;
+import org.openecomp.sdc.be.config.ArtifactConfigManager;
+import org.openecomp.sdc.be.config.ArtifactConfiguration;
+import org.openecomp.sdc.be.config.ComponentType;
import org.openecomp.sdc.be.config.Configuration.ArtifactTypeConfig;
import org.openecomp.sdc.be.config.ConfigurationManager;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
-import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
+import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation;
import org.openecomp.sdc.be.resources.data.DAOArtifactData;
import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
import org.openecomp.sdc.common.util.GeneralUtility;
import org.openecomp.sdc.exception.ResponseFormat;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyList;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_ENV_NAME;
-import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_VF_ENV_NAME;
-
@RunWith(MockitoJUnitRunner.Silent.class)
-public class ArtifactsBusinessLogicTest extends BaseBusinessLogicMock{
+public class ArtifactsBusinessLogicTest extends BaseBusinessLogicMock {
+ public static final Resource resource = Mockito.mock(Resource.class);
private static final User USER = new User("John", "Doh", "jh0003", "jh0003@gmail.com", "ADMIN",
- System.currentTimeMillis());
+ System.currentTimeMillis());
private static final String RESOURCE_INSTANCE_NAME = "Service-111";
private static final String INSTANCE_ID = "S-123-444-ghghghg";
-
private static final String ARTIFACT_NAME = "service-Myservice-template.yml";
private static final String ARTIFACT_LABEL = "assettoscatemplate";
private static final String ES_ARTIFACT_ID = "123123dfgdfgd0";
private static final String RESOURCE_NAME = "My-Resource_Name with space";
private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
private static final String RESOURCE_SUBCATEGORY = "Router";
- public static final String RESOURCE_CATEGORY = "Network Layer 2-3/Router";
- public static final Resource resource = Mockito.mock(Resource.class);
-
- @InjectMocks
- private ArtifactsBusinessLogic artifactBL;
+ private static final String ARTIFACT_PLACEHOLDER_FILE_EXTENSION = "fileExtension";
private static User user = null;
private static Resource resourceResponse = null;
- private static ResponseFormatManager responseManager = null;
final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
@Mock
public ComponentsUtils componentsUtils;
JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
@Mock
JanusGraphDao janusGraphDao;
+ @InjectMocks
+ private ArtifactsBusinessLogic artifactBL;
@Mock
private UserBusinessLogic userBusinessLogic;
@Mock
private ToscaExportHandler toscaExportHandler;
@Mock
private LifecycleBusinessLogic lifecycleBusinessLogic;
+ @Mock
+ private ArtifactTypeOperation artifactTypeOperation;
+
private Gson gson = new GsonBuilder().setPrettyPrinting().create();
private static List<ArtifactType> getAllTypes() {
- List<ArtifactType> artifactTypes = new ArrayList<ArtifactType>();
- List<String> artifactTypesList = ConfigurationManager.getConfigurationManager().getConfiguration()
- .getArtifactTypes();
- for (String artifactType : artifactTypesList) {
- ArtifactType artifactT = new ArtifactType();
- artifactT.setName(artifactType);
- artifactTypes.add(artifactT);
- }
- return artifactTypes;
+ final List<ArtifactConfiguration> artifactConfigurationList = ConfigurationManager.getConfigurationManager()
+ .getConfiguration().getArtifacts();
+ return artifactConfigurationList.stream().map(artifactConfiguration -> {
+ final ArtifactType artifactType = new ArtifactType();
+ artifactType.setName(artifactConfiguration.getType());
+ return artifactType;
+ }).collect(Collectors.toList());
}
@Before
public void initMocks() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
Either<ArtifactDefinition, StorageOperationStatus> NotFoundResult = Either
- .right(StorageOperationStatus.NOT_FOUND);
+ .right(StorageOperationStatus.NOT_FOUND);
Either<Map<String, ArtifactDefinition>, StorageOperationStatus> NotFoundResult2 = Either
- .right(StorageOperationStatus.NOT_FOUND);
+ .right(StorageOperationStatus.NOT_FOUND);
when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Service), Mockito.anyBoolean()))
- .thenReturn(NotFoundResult2);
+ .thenReturn(NotFoundResult2);
when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Resource), Mockito.anyBoolean()))
- .thenReturn(NotFoundResult2);
+ .thenReturn(NotFoundResult2);
Either<Map<String, InterfaceDefinition>, StorageOperationStatus> notFoundInterfaces = Either
- .right(StorageOperationStatus.NOT_FOUND);
+ .right(StorageOperationStatus.NOT_FOUND);
when(lifecycleOperation.getAllInterfacesOfResource(Mockito.anyString(), Mockito.anyBoolean()))
- .thenReturn(notFoundInterfaces);
+ .thenReturn(notFoundInterfaces);
- when(userOperation.getUserData("jh0003", false)).thenReturn(Either.left(USER));
+ when(userOperation.getUserData("jh0003", false)).thenReturn(Either.left(USER));
- Either<List<ArtifactType>, ActionStatus> getType = Either.left(getAllTypes());
- when(elementOperation.getAllArtifactTypes()).thenReturn(getType);
+ when(elementOperation.getAllArtifactTypes()).thenReturn(getAllTypes());
when(resource.getResourceType()).thenReturn(ResourceTypeEnum.VFC);
when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(StorageOperationStatus.OK);
Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<String, DataTypeDefinition>();
- when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
+ when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(emptyDataTypes));
when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
Either<Component, StorageOperationStatus> resourceStorageOperationStatusEither = Either
- .right(StorageOperationStatus.BAD_REQUEST);
+ .right(StorageOperationStatus.BAD_REQUEST);
when(toscaOperationFacade.getToscaElement(resourceResponse.getUniqueId()))
- .thenReturn(resourceStorageOperationStatusEither);
+ .thenReturn(resourceStorageOperationStatusEither);
}
@Test
}
ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact,
- ArtifactDefinition.class, false);
+ ArtifactDefinition.class, false);
assertEquals(ad, afterConvert);
}
ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
ComponentInstance ci = new ComponentInstance();
ci.setUniqueId("ciid");
- ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact,envArtifact, origEnvArtifact));
+ ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
GroupInstance groupInstance = new GroupInstance();
groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
groupInstance.setCustomizationUUID("custUid");
service.setComponentInstances(Collections.singletonList(ci));
service.setUniqueId("suid");
- when (artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
- heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(Either.left(heatArtifact));
+ when(artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
+ heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(
+ Either.left(heatArtifact));
when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
- .thenReturn(StorageOperationStatus.OK);
- when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
- .thenReturn(Either.left(new ArrayList()));
- when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(), new ArrayList<>(Arrays.asList("guid"))))
- .thenReturn(StorageOperationStatus.OK);
- artifactBL.handleUpdate(ci.getUniqueId(),ComponentTypeEnum.RESOURCE_INSTANCE,artifactBL.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
- "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
+ .thenReturn(Either.left(new ArrayList()));
+ when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(),
+ new ArrayList<>(Arrays.asList("guid"))))
+ .thenReturn(StorageOperationStatus.OK);
+ artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
+ new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
+ "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
assertThat(ci.getDeploymentArtifacts().get("HEAT").getTimeout()).isEqualTo(envArtifact.getTimeout());
assertThat(ci.getDeploymentArtifacts().get("HEAT_ENV").getTimeout()).isEqualTo(origEnvArtifact.getTimeout());
}
ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
ComponentInstance ci = new ComponentInstance();
ci.setUniqueId("ciid");
- ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact,envArtifact, origEnvArtifact));
+ ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
GroupInstance groupInstance = new GroupInstance();
groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
groupInstance.setCustomizationUUID("custUid");
service.setUniqueId("suid");
envArtifact.setTimeout(130);
- when (artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
- heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(Either.left(heatArtifact));
+ when(artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
+ heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(
+ Either.left(heatArtifact));
when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
- .thenReturn(StorageOperationStatus.OK);
- when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
- .thenReturn(Either.left(new ArrayList()));
- when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(), new ArrayList<>(Arrays.asList("guid"))))
- .thenReturn(StorageOperationStatus.OK);
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
+ .thenReturn(Either.left(new ArrayList()));
+ when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(),
+ new ArrayList<>(Arrays.asList("guid"))))
+ .thenReturn(StorageOperationStatus.OK);
try {
- artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE, artifactBL.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
- "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
+ artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
+ new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
+ "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
} catch (ComponentException exp) {
assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_INVALID_TIMEOUT);
return;
ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
ComponentInstance ci = new ComponentInstance();
ci.setUniqueId("ciid");
- ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact,envArtifact, origEnvArtifact));
+ ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
GroupInstance groupInstance = new GroupInstance();
groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
groupInstance.setCustomizationUUID("custUid");
service.setUniqueId("suid");
envArtifact.setTimeout(-1);
- when (artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
- heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(Either.left(heatArtifact));
+ when(artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
+ heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(
+ Either.left(heatArtifact));
when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
- .thenReturn(StorageOperationStatus.OK);
- when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
- .thenReturn(Either.left(new ArrayList()));
- when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(), new ArrayList<>(Arrays.asList("guid"))))
- .thenReturn(StorageOperationStatus.OK);
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
+ .thenReturn(Either.left(new ArrayList()));
+ when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(),
+ new ArrayList<>(Arrays.asList("guid"))))
+ .thenReturn(StorageOperationStatus.OK);
try {
- artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE, artifactBL.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
- "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
+ artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
+ new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
+ "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
} catch (ComponentException exp) {
assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_INVALID_TIMEOUT);
return;
ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
ComponentInstance ci = new ComponentInstance();
ci.setUniqueId("ciid");
- ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact,envArtifact, origEnvArtifact));
+ ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
envArtifact.setTimeout(heatArtifact.getTimeout());
GroupInstance groupInstance = new GroupInstance();
groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
service.setUniqueId("suid");
when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
- .thenReturn(StorageOperationStatus.OK);
- when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
- .thenReturn(Either.left(new ArrayList()));
- artifactBL.handleUpdate(ci.getUniqueId(),ComponentTypeEnum.RESOURCE_INSTANCE,artifactBL.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
- "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
+ .thenReturn(Either.left(new ArrayList()));
+ artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
+ new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
+ "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
assertThat(ci.getDeploymentArtifacts().get("HEAT").getTimeout()).isEqualTo(origEnvArtifact.getTimeout());
}
service.setUniqueId("suid");
when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
- .thenReturn(StorageOperationStatus.OK);
- when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service),eq(ci.getUniqueId()), any(List.class)))
- .thenReturn(Either.left(new ArrayList()));
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
+ .thenReturn(Either.left(new ArrayList()));
assertThatThrownBy(() -> {
- artifactBL.handleUpdate(ci.getUniqueId(),ComponentTypeEnum.RESOURCE_INSTANCE,artifactBL.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
- "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
+ artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
+ new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
+ "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
}).isInstanceOf(ComponentException.class);
}
envArtifact.setArtifactType("invalid");
try {
- artifactBL.handleUpdate("uid", ComponentTypeEnum.RESOURCE_INSTANCE, artifactBL.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
- "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, null, true);
+ artifactBL.handleUpdate("uid", ComponentTypeEnum.RESOURCE_INSTANCE, new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
+ "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, null, true);
fail();
- } catch(ComponentException exp) {
+ } catch (ComponentException exp) {
assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED);
assertThat(exp.getParams()[0]).isEqualTo("invalid");
}
}
- private Map<String, ArtifactDefinition> fillDeploymentArtifacts(ArtifactDefinition heatArtifact, ArtifactDefinition envArtifact, ArtifactDefinition origEnvArtifact) {
+ private Map<String, ArtifactDefinition> fillDeploymentArtifacts(ArtifactDefinition heatArtifact, ArtifactDefinition envArtifact,
+ ArtifactDefinition origEnvArtifact) {
heatArtifact.setArtifactType("HEAT");
heatArtifact.setTimeout(60);
heatArtifact.setEsId("es");
deploymentArtifacts.put(heatArtifact.getArtifactType(), heatArtifact);
//deploymentArtifacts.put(envArtifact.getArtifactType(), envArtifact);
deploymentArtifacts.put(envArtifact.getArtifactType(), origEnvArtifact);
- return deploymentArtifacts;
+ return deploymentArtifacts;
}
@Test
jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
- ArtifactDefinition.class, false);
+ ArtifactDefinition.class, false);
assertNull(afterConvert);
}
jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
- ArtifactDefinition.class, false);
+ ArtifactDefinition.class, false);
assertNull(afterConvert);
}
jsonArtifact.getAsJsonObject().add("artifactType", null);
try {
RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
- ArtifactDefinition.class, true);
+ ArtifactDefinition.class, true);
fail();
} catch (ComponentException exp) {
assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MANDATORY_PROPERTY_MISSING_VALUE);
try {
RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
- ArtifactDefinition.class, false);
+ ArtifactDefinition.class, false);
fail();
} catch (ComponentException exp) {
assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_MANDATORY_PROPERTY);
try {
RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
- ArtifactDefinition.class, true);
+ ArtifactDefinition.class, true);
fail();
} catch (ComponentException exp) {
assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_MANDATORY_PROPERTY);
jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
- ArtifactDefinition.class, false);
+ ArtifactDefinition.class, false);
assertNull(afterConvert);
}
jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
- ArtifactDefinition.class, true);
+ ArtifactDefinition.class, true);
assertNull(afterConvert);
}
@Test
- public void testValidMibAritactsConfiguration() {
- Map<String, ArtifactTypeConfig> componentDeploymentArtifacts = ConfigurationManager.getConfigurationManager()
- .getConfiguration().getResourceDeploymentArtifacts();
- Map<String, ArtifactTypeConfig> componentInstanceDeploymentArtifacts = ConfigurationManager
- .getConfigurationManager().getConfiguration().getResourceInstanceDeploymentArtifacts();
- assertTrue(componentDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_POLL.getType()));
- assertTrue(componentDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_TRAP.getType()));
- assertTrue(componentInstanceDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_POLL.getType()));
- assertTrue(componentInstanceDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_TRAP.getType()));
+ public void testValidMibArtifactsConfiguration() {
+ final ArtifactConfigManager artifactConfigManager = ArtifactConfigManager.getInstance();
+ Optional<ArtifactConfiguration> artifactConfiguration = artifactConfigManager
+ .find(ArtifactTypeEnum.SNMP_POLL.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE);
+ assertThat(artifactConfiguration.isPresent()).isTrue();
+
+ artifactConfiguration = artifactConfigManager
+ .find(ArtifactTypeEnum.SNMP_TRAP.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE);
+ assertThat(artifactConfiguration.isPresent()).isTrue();
+
+ artifactConfiguration = artifactConfigManager
+ .find(ArtifactTypeEnum.SNMP_POLL.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE_INSTANCE);
+ assertThat(artifactConfiguration.isPresent()).isTrue();
+ artifactConfiguration = artifactConfigManager
+ .find(ArtifactTypeEnum.SNMP_TRAP.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE_INSTANCE);
+ assertThat(artifactConfiguration.isPresent()).isTrue();
}
@Test
DAOArtifactData.setDataAsArray(payload);
Either<DAOArtifactData, CassandraOperationStatus> artifactfromESres = Either.left(DAOArtifactData);
when(artifactCassandraDao.getArtifact(esArtifactId)).thenReturn(artifactfromESres);
- List<org.openecomp.sdc.be.model.Component> serviceList = new ArrayList<>();
- serviceList.add(service);
- Either<List<org.openecomp.sdc.be.model.Component>, StorageOperationStatus> getServiceRes = Either
- .left(serviceList);
- when(toscaOperationFacade.getBySystemName(ComponentTypeEnum.SERVICE, serviceName)).thenReturn(getServiceRes);
+ when(toscaOperationFacade.getBySystemNameAndVersion(ComponentTypeEnum.SERVICE, serviceName, serviceVersion)).thenReturn(Either.left(service));
byte[] downloadServiceArtifactByNamesRes = artifactBL
- .downloadServiceArtifactByNames(serviceName, serviceVersion, artifactName);
- assertTrue(downloadServiceArtifactByNamesRes != null
- && downloadServiceArtifactByNamesRes.length == payload.length);
+ .downloadServiceArtifactByNames(serviceName, serviceVersion, artifactName);
+ assertThat(downloadServiceArtifactByNamesRes != null
+ && downloadServiceArtifactByNamesRes.length == payload.length).isTrue();
}
@Test
public void createHeatEnvPlaceHolder_vf_emptyHeatParameters() throws Exception {
ArtifactDefinition heatArtifact = new ArtifactBuilder()
- .addHeatParam(ObjectGenerator.buildHeatParam("defVal1", "val1"))
- .addHeatParam(ObjectGenerator.buildHeatParam("defVal2", "val2")).build();
+ .addHeatParam(ObjectGenerator.buildHeatParam("defVal1", "val1"))
+ .addHeatParam(ObjectGenerator.buildHeatParam("defVal2", "val2")).build();
Resource component = new Resource();
component.setComponentType(ComponentTypeEnum.RESOURCE);
- when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
+ when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
when(artifactToscaOperation.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
- eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
- .thenReturn(Either.left(new ArtifactDefinition()));
+ eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
+ .thenReturn(Either.left(new ArtifactDefinition()));
ArtifactDefinition heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
- new ArrayList<>(), heatArtifact, HEAT_VF_ENV_NAME, "parentId", NodeTypeEnum.Resource, "parentName", USER, component,
- Collections.emptyMap());
+ new ArrayList<>(), heatArtifact, HEAT_VF_ENV_NAME, "parentId", NodeTypeEnum.Resource, "parentName", USER, component,
+ Collections.emptyMap());
assertNull(heatEnvPlaceHolder.getListHeatParameters());
}
@Test
public void createHeatEnvPlaceHolder_resourceInstance_copyHeatParamasCurrValuesToHeatEnvDefaultVal()
- throws Exception {
+ throws Exception {
HeatParameterDefinition heatParam1 = ObjectGenerator.buildHeatParam("defVal1", "val1");
HeatParameterDefinition heatParam2 = ObjectGenerator.buildHeatParam("defVal2", "val2");
HeatParameterDefinition heatParam3 = ObjectGenerator.buildHeatParam("defVal3", "val3");
ArtifactDefinition heatArtifact = new ArtifactBuilder().addHeatParam(heatParam1).addHeatParam(heatParam2)
- .addHeatParam(heatParam3).build();
+ .addHeatParam(heatParam3).build();
Resource component = new Resource();
- when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
+ when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
when(artifactToscaOperation.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
- eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
- .thenReturn(Either.left(new ArtifactDefinition()));
+ eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
+ .thenReturn(Either.left(new ArtifactDefinition()));
ArtifactDefinition heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
- new ArrayList<>(), heatArtifact, HEAT_ENV_NAME, "parentId", NodeTypeEnum.ResourceInstance, "parentName", USER, component,
- Collections.emptyMap());
+ new ArrayList<>(), heatArtifact, HEAT_ENV_NAME, "parentId", NodeTypeEnum.ResourceInstance, "parentName", USER, component,
+ Collections.emptyMap());
ArtifactDefinition heatEnvArtifact = heatEnvPlaceHolder;
List<HeatParameterDefinition> listHeatParameters = heatEnvArtifact.getListHeatParameters();
when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
- any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
+ any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
- ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, true);
+ ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, true);
}
@Test
when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
- any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
+ any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
- ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
+ ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
verify(janusGraphDao, times(1)).commit();
}
when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
- any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
+ any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
- ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
+ ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
verify(janusGraphDao, times(1)).commit();
return artifactDefinition;
}
return getTestSubject();
}
- @Test
- public void testBuildJsonStringForCsarVfcArtifact() throws Exception {
- ArtifactsBusinessLogic testSubject;
- ArtifactDefinition artifact = new ArtifactDefinition();
- String result;
-
- // default test
- testSubject = createTestSubject();
- result = Deencapsulation.invoke(testSubject, "buildJsonStringForCsarVfcArtifact", new Object[]{artifact});
- }
-
- @Test
- public void testCheckArtifactInComponent() throws Exception {
- ArtifactsBusinessLogic testSubject;
- Component component = new Resource();
- component.setComponentType(ComponentTypeEnum.RESOURCE);
- String artifactId = "";
- boolean result;
-
- // default test
- testSubject = createTestSubject();
- result = Deencapsulation.invoke(testSubject, "checkArtifactInComponent",
- new Object[]{component, artifactId});
- }
-
-
@Test
public void testCheckCreateFields() throws Exception {
ArtifactsBusinessLogic testSubject;
// test 1
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "composeArtifactId",
- new Object[]{resourceId, artifactId, artifactInfo, interfaceName, operationName});
+ new Object[]{resourceId, artifactId, artifactInfo, interfaceName, operationName});
}
@Test
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "convertToOperation",
- new Object[]{artifactInfo, operationName});
+ new Object[]{artifactInfo, operationName});
}
@Test
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "createInterfaceArtifactNameFromOperation",
- new Object[]{operationName, artifactName});
+ new Object[]{operationName, artifactName});
}
@Test
// default test
testSubject = createTestSubject();
Deencapsulation.invoke(testSubject, "fetchArtifactsFromComponent",
- artifactId, component, artifacts);
+ artifactId, component, artifacts);
}
-
@Test
public void testValidateArtifact() throws Exception {
ArtifactsBusinessLogic testSubject;
String componentId = "";
ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
ArtifactsBusinessLogic arb = getTestSubject();
- ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
+ ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
String artifactId = "";
ArtifactDefinition artifactInfo = buildArtifactPayload();
AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
// default test
testSubject = createTestSubject();
- testSubject.validateArtifact(componentId, componentType, operation, artifactId, artifactInfo, auditingAction, user, component, shouldLock, inTransaction);
+ testSubject.validateArtifact(componentId, componentType, operation, artifactId, artifactInfo, auditingAction, user, component, shouldLock,
+ inTransaction);
}
@Test
boolean shouldLock = false;
boolean inTransaction = false;
-
// default test
testSubject = createTestSubject();
testSubject.handleHeatEnvDownload(componentId, componentType, user, component, artifactInfo, shouldLock, inTransaction);
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "artifactGenerationRequired",
- new Object[]{component, artifactInfo});
+ new Object[]{component, artifactInfo});
}
@Test
// default test
testSubject = createTestSubject();
testSubject.updateGroupForHeat(artifactInfo, artifactInfo, artifactInfo,
- artifactInfo, component);
+ artifactInfo, component);
}
testSubject = createTestSubject();
testSubject.setComponentsUtils(MockGenerator.mockComponentUtils());
testSubject.handleAuditing(auditingActionEnum, component, componentId, user, artifactDefinition,
- prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
+ prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
}
@Test
public void testIgnoreUnupdateableFieldsInUpdate() throws Exception {
ArtifactsBusinessLogic testSubject;
ArtifactsBusinessLogic arb = getTestSubject();
- ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
+ ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
ArtifactDefinition artifactInfo = buildArtifactPayload();
ArtifactDefinition currentArtifactInfo = null;
// default test
testSubject = createTestSubject();
Deencapsulation.invoke(testSubject, "ignoreUnupdateableFieldsInUpdate",
- operation, artifactInfo, artifactInfo);
+ operation, artifactInfo, artifactInfo);
}
@Test
- public void testFindArtifactOnParentComponent() throws Exception {
+ public void testFindArtifactOnParentComponent() {
ArtifactsBusinessLogic testSubject;
Component component = createResourceObject(true);
ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
String parentId = "";
ArtifactsBusinessLogic arb = getTestSubject();
- ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
+ ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
String artifactId = "";
Either<ArtifactDefinition, ResponseFormat> result;
// default test
testSubject = createTestSubject();
- result = Deencapsulation.invoke(testSubject, "findArtifactOnParentComponent", new Object[]{component,
- componentType, parentId, operation, artifactId});
+ result = Deencapsulation.invoke(testSubject, "findArtifact", new Object[]{component,
+ componentType, parentId, operation, artifactId});
}
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "validateInformationalArtifact",
- new Object[]{artifactInfo, component});
+ new Object[]{artifactInfo, component});
}
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "findArtifact",
- new Object[]{artifactId, component, parentId, componentType});
+ new Object[]{artifactId, component, parentId, componentType});
}
Map<String, ArtifactDefinition> artifacts = new HashMap<>();
ComponentInstance instance = new ComponentInstance();
-
// default test
testSubject = createTestSubject();
Deencapsulation.invoke(testSubject, "fetchArtifactsFromInstance", new Object[]{artifactId, artifacts, instance});
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "generateCustomizationUUIDOnInstance",
- new Object[]{componentId, instanceId, componentType});
+ new Object[]{componentId, instanceId, componentType});
}
-
@Test
- public void testFindComponentInstance() throws Exception {
+ public void testFindComponentInstance() {
ArtifactsBusinessLogic testSubject;
String componentInstanceId = "";
Component component = createResourceObject(true);
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "findComponentInstance",
- new Object[]{componentInstanceId, component});
+ new Object[]{componentInstanceId, component});
}
-
- @Test(expected= ComponentException.class)
- public void testDeploymentArtifactTypeIsLegalForParent_shouldThrowException() throws Exception {
+ @Test(expected = ComponentException.class)
+ public void testDeploymentArtifactTypeIsLegalForParent_shouldThrowException() {
ArtifactsBusinessLogic testSubject;
ArtifactDefinition artifactInfo = buildArtifactPayload();
ArtifactTypeEnum artifactType = ArtifactTypeEnum.AAI_SERVICE_MODEL;
testSubject.validateDeploymentArtifactTypeIsLegalForParent(artifactInfo, artifactType, resourceDeploymentArtifacts);
}
-
@Test
- public void testFillDeploymentArtifactTypeConf() throws Exception {
- ArtifactsBusinessLogic testSubject;
- NodeTypeEnum parentType = NodeTypeEnum.AdditionalInfoParameters;
- Map<String, ArtifactTypeConfig> result;
+ public void testLoadArtifactTypeConfig() {
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
+ //null artifactType
+ Optional<ArtifactConfiguration> artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(null);
+ assertThat(artifactConfiguration.isPresent()).isFalse();
+ //not configured artifactType
+ artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig("NotConfiguredArtifactType");
+ assertThat(artifactConfiguration.isPresent()).isFalse();
- // default test
- testSubject = createTestSubject();
- result = Deencapsulation.invoke(testSubject, "fillDeploymentArtifactTypeConf",
- new Object[]{parentType});
+ //valid artifactType
+ final String artifactType = ArtifactTypeEnum.YANG.getType();
+ artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(artifactType);
+ assertThat(artifactConfiguration.isPresent()).isTrue();
+ final ArtifactConfiguration artifactConfiguration1 = artifactConfiguration.get();
+ assertThat(artifactConfiguration1.getType()).isEqualTo(artifactType);
+ assertThat(artifactConfiguration1.getCategories()).hasSize(1);
+ assertThat(artifactConfiguration1.getCategories()).contains(ArtifactGroupTypeEnum.INFORMATIONAL);
+ assertThat(artifactConfiguration1.getComponentTypes()).hasSize(1);
+ assertThat(artifactConfiguration1.getComponentTypes()).contains(ComponentType.RESOURCE);
+ assertThat(artifactConfiguration1.getResourceTypes()).hasSize(11);
+ assertThat(artifactConfiguration1.getResourceTypes())
+ .contains(ResourceTypeEnum.VFC.getValue(), ResourceTypeEnum.CP.getValue(), ResourceTypeEnum.VL.getValue(),
+ ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.VFCMT.getValue(), "Abstract",
+ ResourceTypeEnum.CVFC.getValue());
}
-
@Test
- public void testValidateArtifactTypeExists() throws Exception {
- ArtifactsBusinessLogic testSubject;
- Wrapper<ResponseFormat> responseWrapper = null;
- ArtifactDefinition artifactInfo = buildArtifactPayload();
+ public void testValidateArtifactExtension_acceptedExtension() {
+ final ArtifactDefinition artifactInfo = new ArtifactDefinition();
+ artifactInfo.setArtifactName("artifact.yml");
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
+ //empty accepted types
+ assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(new ArtifactConfiguration(), artifactInfo))
+ .doesNotThrowAnyException();
- // default test
- testSubject = createTestSubject();
- testSubject.getValidArtifactType(artifactInfo);
+ final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
+ artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
+ assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo))
+ .doesNotThrowAnyException();
}
+ @Test(expected = ComponentException.class)
+ public void testValidateArtifactExtension_notAcceptedExtension() {
+ final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
+ artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
+ final ArtifactDefinition artifactInfo = new ArtifactDefinition();
+ //not accepted extension
+ artifactInfo.setArtifactName("artifact.xml");
- @Test
- public void testGetDeploymentArtifactTypeConfig() throws Exception {
- ArtifactsBusinessLogic testSubject;
- NodeTypeEnum parentType = NodeTypeEnum.AdditionalInfoParameters;
- ArtifactTypeEnum artifactType = ArtifactTypeEnum.AAI_SERVICE_MODEL;
- ArtifactTypeConfig result;
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
- // default test
- testSubject = createTestSubject();
- result = Deencapsulation.invoke(testSubject, "getDeploymentArtifactTypeConfig",
- new Object[]{parentType, artifactType});
+ artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
}
+ @Test(expected = ComponentException.class)
+ public void testValidateArtifactExtension_noExtension() {
+ final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
+ artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
+ final ArtifactDefinition artifactInfo = new ArtifactDefinition();
+ //no extension in the artifact name
+ artifactInfo.setArtifactName("artifact");
+
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
- @Test(expected= ComponentException.class)
- public void testValidateHeatEnvDeploymentArtifact_shouldThrowException() throws Exception {
+ artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
+ }
+
+ @Test(expected = ComponentException.class)
+ public void testValidateHeatEnvDeploymentArtifact_shouldThrowException() {
ArtifactsBusinessLogic testSubject;
Component component = createResourceObject(true);
String parentId = "";
ArtifactDefinition artifactInfo = buildArtifactPayload();
- NodeTypeEnum parentType = NodeTypeEnum.AdditionalInfoParameters;
// default test
testSubject = createTestSubject();
- testSubject.validateHeatEnvDeploymentArtifact(component, parentId, artifactInfo, parentType);
+ testSubject.validateHeatEnvDeploymentArtifact(component, parentId, artifactInfo);
}
@Test
testSubject.fillArtifactPayload(payloadWrapper, artifactDefinition);
}
-
-
- @Test
- public void testIsValidXml() throws Exception {
- ArtifactsBusinessLogic testSubject;
- byte[] xmlToParse = new byte[]{' '};
- boolean result;
-
- // default test
- testSubject = createTestSubject();
- result = Deencapsulation.invoke(testSubject, "isValidXml", new Object[]{xmlToParse});
+ @Test(expected = ByActionStatusComponentException.class)
+ public void testHeatTimeoutValue() {
+ final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
+ final ArtifactDefinition artifactInfo = buildArtifactPayload();
+ artifactInfo.setTimeout(1);
+ artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
+ artifactInfo.setTimeout(0);
+ artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
}
@Test
- public void testHeatTimeoutValue() throws Exception {
- ArtifactsBusinessLogic testSubject;
- boolean isCreate = false;
- ArtifactDefinition artifactInfo = buildArtifactPayload();
- ArtifactDefinition currentArtifact = null;
- Either<Boolean, ResponseFormat> result;
-
- // default test
- testSubject = createTestSubject();
- testSubject.validateHeatTimeoutValue(isCreate, artifactInfo, artifactInfo);
+ public void testValidateResourceType_resourceTypeIsAccepted() {
+ final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
+ final ArtifactDefinition artifactInfo = buildArtifactPayload();
+ final List<String> typeList = Arrays
+ .asList(ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.PNF.getValue(), ResourceTypeEnum.VFC.getValue());
+ assertThatCode(() -> {
+ artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
+ }).doesNotThrowAnyException();
}
- @Test
- public void testValidateHeatDeploymentArtifact() throws Exception {
- ArtifactsBusinessLogic testSubject;
- boolean isCreate = false;
- ArtifactDefinition artifactInfo = buildArtifactPayload();
- ArtifactDefinition currentArtifact = null;
- Either<Boolean, ResponseFormat> result;
-
- // default test
- testSubject = createTestSubject();
- testSubject.validateHeatTimeoutValue(isCreate, artifactInfo, artifactInfo);
+ @Test(expected = ComponentException.class)
+ public void testValidateResourceType_invalidResourceType() {
+ final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
+ final ArtifactDefinition artifactInfo = buildArtifactPayload();
+ final List<String> typeList = Collections.singletonList(ResourceTypeEnum.PNF.getValue());
+ artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
}
-
- @Test(expected= ComponentException.class)
- public void testValidateResourceType_shouldThrowException() throws Exception {
- ArtifactsBusinessLogic testSubject;
- ResourceTypeEnum resourceType = ResourceTypeEnum.VF;
- ArtifactDefinition artifactInfo = buildArtifactPayload();
- List<String> typeList = new ArrayList<>();
- Either<Boolean, ResponseFormat> result;
-
- // test 1
- testSubject = createTestSubject();
- testSubject.validateResourceType(resourceType, artifactInfo, typeList);
- result = Deencapsulation.invoke(testSubject, "validateResourceType", new Object[]{resourceType, artifactInfo, typeList});
+ @Test
+ public void testValidateResourceType_emptyResourceTypeConfig_resourceTypeIsAccepted() {
+ final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
+ final ArtifactDefinition artifactInfo = buildArtifactPayload();
+ assertThatCode(() -> {
+ artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, null);
+ }).doesNotThrowAnyException();
+ assertThatCode(() -> {
+ artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, new ArrayList<>());
+ }).doesNotThrowAnyException();
}
-
@Test
public void testValidateAndConvertHeatParameters() throws Exception {
ArtifactsBusinessLogic testSubject;
// default test
testSubject = createTestSubject();
- result = testSubject.getDeploymentArtifacts(component, parentType, ciId);
+ result = testSubject.getDeploymentArtifacts(component, ciId);
}
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "validateFirstUpdateHasPayload",
- new Object[]{artifactInfo, artifactInfo});
+ new Object[]{artifactInfo, artifactInfo});
}
@Test
testSubject.validateAndSetArtifactName(artifactInfo);
}
+ @Test(expected = ComponentException.class)
+ public void testValidateArtifactType_notConfiguredArtifactType() {
+ final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
+ final ArtifactDefinition artifactInfo = buildArtifactPayload();
+ artifactInfo.setArtifactType("notConfiguredType");
+ Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
+ }
+
+ @Test(expected = ComponentException.class)
+ public void testValidateArtifactType_componentTypeNotSupportedByArtifactType() {
+ final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
+ final ArtifactDefinition artifactInfo = buildArtifactPayload();
+ artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
+
+ Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
+ }
+
+ @Test(expected = ComponentException.class)
+ public void testValidateArtifactType_groupTypeNotSupportedByArtifactType() {
+ final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
+ final ArtifactDefinition artifactInfo = buildArtifactPayload();
+ artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
+ artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
+
+ Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.SERVICE);
+ }
+
@Test
public void testValidateArtifactTypeNotChanged() throws Exception {
ArtifactsBusinessLogic testSubject;
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "validateArtifactTypeNotChanged",
- new Object[]{artifactInfo, artifactInfo});
+ new Object[]{artifactInfo, artifactInfo});
}
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "validateOrSetArtifactGroupType",
- new Object[]{artifactInfo, artifactInfo});
+ new Object[]{artifactInfo, artifactInfo});
}
@Test
testSubject = createTestSubject();
type = null;
Deencapsulation.invoke(testSubject, "checkAndSetUnUpdatableFields", user,
- artifactInfo, artifactInfo, ArtifactGroupTypeEnum.class);
+ artifactInfo, artifactInfo, ArtifactGroupTypeEnum.class);
}
@Test
List<HeatParameterDefinition> heatParameters = new ArrayList<>();
List<HeatParameterDefinition> currentParameters = new ArrayList<>();
-
// default test
testSubject = createTestSubject();
Deencapsulation.invoke(testSubject, "checkAndSetUnupdatableHeatParams", new Object[]{heatParameters, currentParameters});
ArtifactsBusinessLogic testSubject = getTestSubject();
Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
- new Object[] { artifactInfo, isArtifactMetadataUpdate });
+ new Object[]{artifactInfo, isArtifactMetadataUpdate});
assertArrayEquals(payload, result.left().value());
}
-
-
-
@Test
- public void testGivenInValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
- final int expectedStatus = 100;
- when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_YAML), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
- final byte[] payload = "invalidYaml".getBytes();
- ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
+ public void testGivenInValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
+ final int expectedStatus = 100;
+ when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_YAML), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
+ final byte[] payload = "invalidYaml".getBytes();
+ ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
final boolean isArtifactMetadataUpdate = false;
ArtifactsBusinessLogic testSubject = getTestSubject();
testSubject.setComponentsUtils(componentsUtils);
Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
- new Object[]{artifactInfo, isArtifactMetadataUpdate});
+ new Object[]{artifactInfo, isArtifactMetadataUpdate});
int status = result.right().value().getStatus();
assertEquals(expectedStatus, status);
}
@Test
- public void testGivenEmptyVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsMissingData() {
- final int expectedStatus = 101;
- when(componentsUtils.getResponseFormat(eq(ActionStatus.MISSING_DATA), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
- final byte[] payload = "".getBytes();
- ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
+ public void testGivenEmptyVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsMissingData() {
+ final int expectedStatus = 101;
+ when(componentsUtils.getResponseFormat(eq(ActionStatus.MISSING_DATA), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
+ final byte[] payload = "".getBytes();
+ ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
final boolean isArtifactMetadataUpdate = false;
ArtifactsBusinessLogic testSubject = getTestSubject();
testSubject.setComponentsUtils(componentsUtils);
Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
- new Object[]{artifactInfo, isArtifactMetadataUpdate});
+ new Object[]{artifactInfo, isArtifactMetadataUpdate});
- int status = result.right().value().getStatus();
- assertEquals(expectedStatus, status);
+ int status = result.right().value().getStatus();
+ assertEquals(expectedStatus, status);
}
@Test
- public void testGivenValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
- final byte[] payload = "heat_template_version: 1.0".getBytes();
- ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
+ public void testGivenValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
+ final byte[] payload = "heat_template_version: 1.0".getBytes();
+ ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
final boolean isArtifactMetadataUpdate = false;
ArtifactsBusinessLogic testSubject = getTestSubject();
Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
- new Object[]{artifactInfo, isArtifactMetadataUpdate});
+ new Object[]{artifactInfo, isArtifactMetadataUpdate});
assertArrayEquals(payload, result.left().value());
}
@Test
- public void testGivenInValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
- final int expectedStatus = 1000;
- when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
- final byte[] payload = "validYaml: butNoHeatTemplateVersion".getBytes();
- ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
+ public void testGivenInValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
+ final int expectedStatus = 1000;
+ when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT), any(String.class))).thenReturn(
+ new ResponseFormat(expectedStatus));
+ final byte[] payload = "validYaml: butNoHeatTemplateVersion".getBytes();
+ ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
final boolean isArtifactMetadataUpdate = false;
ArtifactsBusinessLogic testSubject = getTestSubject();
testSubject.setComponentsUtils(componentsUtils);
Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
- new Object[]{artifactInfo, isArtifactMetadataUpdate});
+ new Object[]{artifactInfo, isArtifactMetadataUpdate});
int status = result.right().value().getStatus();
assertEquals(expectedStatus, status);
String artifactId = "";
ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
ArtifactsBusinessLogic arb = getTestSubject();
- ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
+ ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
Either<Boolean, ResponseFormat> result;
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "validateUserRole",
- new Object[]{user, auditingAction, componentId, artifactId, componentType,
- operation});
+ new Object[]{user, auditingAction, componentId, artifactId, componentType,
+ operation});
+ assertNull(result);
}
@Test
public void testDetectAuditingType() throws Exception {
ArtifactsBusinessLogic testSubject;
ArtifactsBusinessLogic arb = getTestSubject();
- ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
+ ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
String origMd5 = "";
AuditingActionEnum result;
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "detectAuditingType",
- new Object[]{operation, origMd5});
+ new Object[]{operation, origMd5});
+ assertNotNull(result);
}
+ @Test
+ public void testDetectNoAuditingType() throws Exception {
+ ArtifactsBusinessLogic testSubject;
+ ArtifactsBusinessLogic arb = getTestSubject();
+ ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.LINK);
+ String origMd5 = "";
+ AuditingActionEnum result;
+
+ // default test
+ testSubject = createTestSubject();
+ result = Deencapsulation.invoke(testSubject, "detectAuditingType",
+ new Object[]{operation, origMd5});
+ assertNull(result);
+ }
@Test
public void testCreateEsArtifactData() throws Exception {
// default test
testSubject = createTestSubject();
result = testSubject.createEsArtifactData(artifactInfo, artifactPayload);
+ assertNotNull(result);
}
@Test
- public void testIsArtifactMetadataUpdate() throws Exception {
+ public void testIsArtifactMetadataUpdateTrue() throws Exception {
+ ArtifactsBusinessLogic testSubject;
+ AuditingActionEnum auditingActionEnum = AuditingActionEnum.ARTIFACT_METADATA_UPDATE;
+ boolean result;
+
+ // default test
+ testSubject = createTestSubject();
+ result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
+ new Object[]{auditingActionEnum});
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ public void testIsArtifactMetadataUpdateFalse() throws Exception {
ArtifactsBusinessLogic testSubject;
AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
boolean result;
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
- new Object[]{auditingActionEnum});
+ new Object[]{auditingActionEnum});
+ assertThat(result).isFalse();
}
@Test
- public void testIsDeploymentArtifact() throws Exception {
+ public void testIsDeploymentArtifactTrue() throws Exception {
ArtifactsBusinessLogic testSubject;
ArtifactDefinition artifactInfo = buildArtifactPayload();
+ artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
boolean result;
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
+ assertThat(result).isTrue();
}
+ @Test
+ public void testIsDeploymentArtifactFalse() throws Exception {
+ ArtifactsBusinessLogic testSubject;
+ ArtifactDefinition artifactInfo = buildArtifactPayload(); // artifactGroupType == ArtifactGroupTypeEnum.TOSCA
+ boolean result;
+
+ // default test
+ testSubject = createTestSubject();
+ result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
+ assertThat(result).isFalse();
+ }
@Test
public void testSetArtifactPlaceholderCommonFields() throws Exception {
ArtifactsBusinessLogic testSubject;
- String resourceId = "";
+ String resourceId = ES_ARTIFACT_ID;
ArtifactDefinition artifactInfo = buildArtifactPayload();
// test 1
testSubject = createTestSubject();
Deencapsulation.invoke(testSubject, "setArtifactPlaceholderCommonFields",
- resourceId, user, artifactInfo);
-
+ resourceId, user, artifactInfo);
+ assertEquals(resourceId + "." + ARTIFACT_LABEL, artifactInfo.getUniqueId());
+ assertEquals(user.getFullName(), artifactInfo.getCreatorFullName());
}
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "createEsHeatEnvArtifactDataFromString",
- new Object[]{artifactDefinition, payloadStr});
+ new Object[]{artifactDefinition, payloadStr});
+ assertThat(result.isLeft()).isTrue();
}
@Test
// test 1
testSubject = createTestSubject();
- testSubject.updateArtifactOnGroupInstance(component, instanceId, prevUUID, artifactInfo, artifactInfo);
+ result = testSubject.updateArtifactOnGroupInstance(component, instanceId, prevUUID, artifactInfo, artifactInfo);
+ assertThat(result.isLeft()).isTrue();
}
@Test
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "generateHeatEnvPayload",
- new Object[]{artifactDefinition});
+ new Object[]{artifactDefinition});
+ assertThat(result.isEmpty()).isFalse();
}
// default test
testSubject = createTestSubject();
result = testSubject.buildJsonForUpdateArtifact(artifactInfo, artifactGroupType, updatedRequiredArtifacts);
+ assertThat(MapUtils.isNotEmpty(result)).isTrue();
}
@Test
testSubject = createTestSubject();
artifactId = "";
result = testSubject.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
- label, displayName, description, artifactContent, updatedRequiredArtifacts, heatParameters);
+ label, displayName, description, artifactContent, updatedRequiredArtifacts, heatParameters);
+ assertThat(MapUtils.isNotEmpty(result)).isTrue();
}
@Test
- public void testReplaceCurrHeatValueWithUpdatedValue() throws Exception {
+ public void testNotReplaceCurrHeatValueWithUpdatedValue() throws Exception {
ArtifactsBusinessLogic testSubject;
List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
+ // default test
+ testSubject = createTestSubject();
+ boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue",
+ new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
+ assertThat(result).isFalse();
+ }
+
+
+ @Test
+ public void testReplaceCurrHeatValueWithUpdatedValue() throws Exception {
+ ArtifactsBusinessLogic testSubject;
+ HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
+ hpdOrig.setName("param1");
+ hpdOrig.setCurrentValue("value1");
+
+ HeatParameterDefinition hpdUpd = new HeatParameterDefinition();
+ hpdUpd.setName("param1");
+ hpdUpd.setCurrentValue("value2");
+
+ List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
+ currentHeatEnvParams.add(hpdOrig);
+
+ List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
+ updatedHeatEnvParams.add(hpdUpd);
// default test
testSubject = createTestSubject();
- Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue", new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
+ boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue",
+ new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
+ assertThat(result).isTrue();
+ assertEquals(hpdUpd.getCurrentValue(), hpdOrig.getCurrentValue());
}
// default test
testSubject = createTestSubject();
result = testSubject.extractArtifactDefinition(eitherArtifact);
+ assertNotNull(result);
+ assertEquals(artifactDefinition, result);
}
@Test
public void testSetHeatCurrentValuesOnHeatEnvDefaultValues() throws Exception {
ArtifactsBusinessLogic testSubject;
- ArtifactDefinition artifact = null;
- ArtifactDefinition artifactInfo = buildArtifactPayload();
+ ArtifactDefinition artifact = buildArtifactPayload();
+ ArtifactDefinition artifactInfo = new ArtifactDefinition();
+
+ HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
+ hpdOrig.setName("param1");
+ hpdOrig.setCurrentValue("value1");
+ List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
+ currentHeatEnvParams.add(hpdOrig);
+ artifact.setListHeatParameters(currentHeatEnvParams);
// default test
testSubject = createTestSubject();
Deencapsulation.invoke(testSubject, "setHeatCurrentValuesOnHeatEnvDefaultValues",
- artifactInfo, artifactInfo);
+ artifact, artifactInfo);
+
+ assertNotEquals(artifact, artifactInfo);
+ assertEquals(1, artifact.getListHeatParameters().size());
+ assertEquals(1, artifactInfo.getListHeatParameters().size());
+
+ String hpdOrigCurrValue = artifact.getListHeatParameters().get(0).getCurrentValue();
+ String hpdNewDefaultValue = artifactInfo.getListHeatParameters().get(0).getDefaultValue();
+
+ assertEquals(hpdOrigCurrValue, hpdNewDefaultValue);
}
@Test
- public void testBuildHeatEnvFileName() throws Exception {
+ public void testBuildHeatEnvFileNameArtifactNameNotNull() throws Exception {
+ String heatEnvExt = "zip";
ArtifactsBusinessLogic testSubject;
- ArtifactDefinition heatArtifact = null;
- ArtifactDefinition artifactInfo = buildArtifactPayload();
+ ArtifactDefinition heatArtifact = buildArtifactPayload();
+ ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
Map<String, Object> placeHolderData = new HashMap<>();
+ placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
+ String artName = ARTIFACT_NAME.split("\\.")[0];
+ // default test
+ testSubject = createTestSubject();
+ Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
+ assertThat(heatEnvArtifact.getArtifactName().startsWith(artName)).isTrue();
+ assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
+ }
+
+ @Test
+ public void testBuildHeatEnvFileNameArtifactNameIsNull() throws Exception {
+ String heatEnvExt = "zip";
+ ArtifactsBusinessLogic testSubject;
+ ArtifactDefinition heatArtifact = buildArtifactPayload();
+ heatArtifact.setArtifactName(null);
+ ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
+ Map<String, Object> placeHolderData = new HashMap<>();
+ placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
// default test
testSubject = createTestSubject();
- Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{artifactInfo, artifactInfo, placeHolderData});
+ Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
+ assertThat(heatEnvArtifact.getArtifactName().startsWith(ARTIFACT_LABEL)).isTrue();
+ assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
}
@Test
public void testHandleEnvArtifactVersion() throws Exception {
ArtifactsBusinessLogic testSubject;
+ String existingVersion = "1.0";
ArtifactDefinition artifactInfo = buildArtifactPayload();
Map<String, String> existingEnvVersions = new HashMap<>();
-
+ existingEnvVersions.put(artifactInfo.getArtifactName(), existingVersion);
// test 1
testSubject = createTestSubject();
Deencapsulation.invoke(testSubject, "handleEnvArtifactVersion", artifactInfo, existingEnvVersions);
+ assertEquals(existingVersion, artifactInfo.getArtifactVersion());
}
@Test
List<ArtifactDefinition> vfcsNewCreatedArtifacts = new ArrayList<>();
ArtifactsBusinessLogic arb = getTestSubject();
- ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
+ ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
boolean shouldLock = false;
boolean inTransaction = false;
List<ArtifactDefinition> result;
// default test
testSubject = createTestSubject();
result = testSubject.handleArtifactsForInnerVfcComponent(artifactsToHandle, component, user,
- vfcsNewCreatedArtifacts, operation, shouldLock, inTransaction);
+ vfcsNewCreatedArtifacts, operation, shouldLock, inTransaction);
+
+ assertThat(CollectionUtils.isEmpty(result)).isTrue();
}
@Test
public void testSetNodeTemplateOperation() throws Exception {
ArtifactsBusinessLogic testSubject;
- NodeTemplateOperation nodeTemplateOperation = null;
+ NodeTemplateOperation nodeTemplateOperation = new NodeTemplateOperation();
// default test
testSubject = createTestSubject();
- Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", NodeTemplateOperation.class);
+ Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", nodeTemplateOperation);
+ assertEquals(Deencapsulation.getField(testSubject, "nodeTemplateOperation"), nodeTemplateOperation);
+ }
+
+
+ @Test(expected = ComponentException.class)
+ public void validateDeploymentArtifact_invalidComponentType() {
+ ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+ Component component = new Resource();
+ component.setComponentType(ComponentTypeEnum.PRODUCT);
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
+ Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
+ }
+
+ @Test(expected = ComponentException.class)
+ public void validateDeploymentArtifact_notConfiguredArtifactType() {
+ ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+ Component component = new Resource();
+ component.setComponentType(ComponentTypeEnum.RESOURCE);
+ artifactDefinition.setArtifactType("NotConfiguredType");
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
+ Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
+ }
+
+ @Test(expected = ComponentException.class)
+ public void validateDeploymentArtifact_unsupportedResourceType() {
+ final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+ artifactDefinition.setArtifactType(ArtifactTypeEnum.ANSIBLE_PLAYBOOK.getType());
+ artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+ final Resource resourceComponent = new Resource();
+ resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
+ resourceComponent.setResourceType(ResourceTypeEnum.ServiceProxy);
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
+ Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
+ }
+
+ @Test
+ public void validateDeploymentArtifact_validArtifact() {
+ final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+ artifactDefinition.setArtifactType(ArtifactTypeEnum.YANG.getType());
+ artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
+ final Resource resourceComponent = new Resource();
+ resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
+ resourceComponent.setResourceType(ResourceTypeEnum.VF);
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
+ assertThatCode(() -> {
+ Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
+ }).doesNotThrowAnyException();
+
+ }
+
+ @Test
+ public void validateHeatArtifact_validArtifact() {
+ final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+ artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
+ artifactDefinition.setTimeout(1);
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
+ assertThatCode(() -> {
+ Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateHeatArtifact", new Resource(), "componentId", artifactDefinition);
+ }).doesNotThrowAnyException();
+ }
+
+ @Test
+ public void validateInputForResourceInstance() {
+ final String artifactId = "artifactId";
+ ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+ artifactDefinition.setUniqueId(artifactId);
+ artifactDefinition.setArtifactName(ARTIFACT_NAME);
+ artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
+ artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
+ artifactDefinition.setEsId(ES_ARTIFACT_ID);
+ artifactDefinition.setPayload(PAYLOAD);
+ artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
+ artifactDefinition.setDescription("artifact description");
+ artifactDefinition.setServiceApi(true);
+ artifactDefinition.setApiUrl("dumbUrl");
+
+ final User user = new User();
+ user.setUserId("userId");
+ user.setRole(Role.ADMIN.name());
+
+ final String parentId = "parentId";
+ final Service service = new Service();
+ service.setComponentType(ComponentTypeEnum.SERVICE);
+ service.setUniqueId(parentId);
+ service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ service.setLastUpdaterUserId(user.getUserId());
+
+ final ArtifactOperationInfo operationInfo =
+ new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
+
+ final String componentId = "componentId";
+ final ComponentInstance componentInstance = new ComponentInstance();
+ componentInstance.setUniqueId(componentId);
+ componentInstance.setComponentUid(componentId);
+ service.setComponentInstances(Collections.singletonList(componentInstance));
+
+ final Resource resource = new Resource();
+ when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
+ when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
+
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
+ artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
+ Object result = Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
+ user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
+ assertTrue(result instanceof Either<?, ?>);
+ assertTrue(((Either<?, ?>) result).isLeft());
+
+ artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+
+ result = Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
+ user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
+ assertTrue(result instanceof Either<?, ?>);
+ assertTrue(((Either<?, ?>) result).isLeft());
}
+ @Test
+ public void validateInputForResourceInstanceDeploymentArtifact() {
+ final String artifactId = "artifactId";
+ ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+ artifactDefinition.setUniqueId(artifactId);
+ artifactDefinition.setArtifactName(ARTIFACT_NAME);
+ artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
+ artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
+ artifactDefinition.setEsId(ES_ARTIFACT_ID);
+ artifactDefinition.setPayload(PAYLOAD);
+ artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+ artifactDefinition.setDescription("artifact description");
+
+ final User user = new User();
+ user.setUserId("userId");
+ user.setRole(Role.ADMIN.name());
+
+ final String parentId = "parentId";
+ final Service service = new Service();
+ service.setComponentType(ComponentTypeEnum.SERVICE);
+ service.setUniqueId(parentId);
+ service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ service.setLastUpdaterUserId(user.getUserId());
+
+ final ArtifactOperationInfo operationInfo =
+ new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
+
+ final String componentId = "componentId";
+ final ComponentInstance componentInstance = new ComponentInstance();
+ componentInstance.setUniqueId(componentId);
+ componentInstance.setComponentUid(componentId);
+ service.setComponentInstances(Collections.singletonList(componentInstance));
+
+ final Resource resource = new Resource();
+ when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
+ when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
+
+ final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
+ artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
+
+ final Object result = Deencapsulation
+ .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
+ user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
+ assertTrue(result instanceof Either<?, ?>);
+ assertTrue(((Either<?, ?>) result).isLeft());
+ }
+
+
@Test
public void testHandleArtifactRequest() {
String componentId = "componentId";
- ArtifactOperationInfo operationInfo = artifactBL.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE);
+ ArtifactOperationInfo operationInfo = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE);
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setArtifactName("other");
artifactDefinition.setUniqueId("artifactId");
artifactDefinition.setPayload("Test".getBytes());
artifactDefinition.setArtifactLabel("other");
artifactDefinition.setDescription("Test artifact");
- artifactDefinition.setArtifactType(ArtifactTypeEnum.OTHER.name());
+ artifactDefinition.setArtifactType(ArtifactTypeEnum.OTHER.getType());
artifactDefinition.setArtifactUUID("artifactUId");
artifactDefinition.setArtifactLabel("test");
artifactDefinition.setArtifactDisplayName("Test");
user.setRole(Role.ADMIN.name());
when(userValidations.validateUserExists(Mockito.eq("userId")))
- .thenReturn(user);
+ .thenReturn(user);
+ when(userValidations.isSameUser(Mockito.eq("userId"), Mockito.eq("userId")))
+ .thenReturn(true);
when(toscaOperationFacade.getToscaFullElement(any()))
- .thenReturn(Either.left(resource));
+ .thenReturn(Either.left(resource));
when(artifactToscaOperation.getArtifactById(any(), any(), any(), any()))
- .thenReturn(Either.left(artifactDefinition));
+ .thenReturn(Either.left(artifactDefinition));
when(artifactsResolver.findArtifactOnComponent(any(), any(ComponentTypeEnum.class), anyString()))
- .thenReturn(artifactDefinition);
+ .thenReturn(artifactDefinition);
when(graphLockOperation.lockComponent(eq(resource.getUniqueId()), any(NodeTypeEnum.class)))
- .thenReturn(StorageOperationStatus.OK);
- when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), anyString(), any(NodeTypeEnum.class), any(), anyBoolean()))
- .thenReturn(Either.left(artifactDefinition));
- when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class)))
- .thenReturn(CassandraOperationStatus.OK);
- when(toscaOperationFacade.getToscaElement(anyString()))
- .thenReturn(Either.left(resource));
- when(interfaceOperation.updateInterfaces(anyString(), anyList()))
- .thenReturn(Either.left(interfaceDefinitionsList));
+ .thenReturn(StorageOperationStatus.OK);
+ when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), anyString(), any(NodeTypeEnum.class), any(),
+ anyBoolean()))
+ .thenReturn(Either.left(artifactDefinition));
+ when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class))).thenReturn(CassandraOperationStatus.OK);
+ when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
+ when(interfaceOperation.updateInterfaces(any(Component.class), anyList())).thenReturn(Either.left(interfaceDefinitionsList));
when(artifactToscaOperation.getAllInstanceArtifacts(resource.getUniqueId(), componentId)).thenReturn(Either.left(artifactDefinitionMap));
when(toscaOperationFacade.generateCustomizationUUIDOnInstance(any(), any())).thenReturn(StorageOperationStatus.OK);
- Either<ArtifactDefinition, Operation> result = artifactBL.handleArtifactRequest(componentId, user.getUserId(), ComponentTypeEnum.RESOURCE_INSTANCE
- , operationInfo, artifactDefinition.getUniqueId(), artifactDefinition, requestMd5, "data", "iuuid",
- null, componentId, "resources");
+ Either<ArtifactDefinition, Operation> result = artifactBL.handleArtifactRequest(componentId, user.getUserId(),
+ ComponentTypeEnum.RESOURCE_INSTANCE
+ , operationInfo, artifactDefinition.getUniqueId(), artifactDefinition, requestMd5, "data", "iuuid",
+ null, componentId, "resources");
- assertTrue(result.isLeft());
+ assertThat(result.isLeft()).isTrue();
ArtifactDefinition leftValue = result.left().value();
assertEquals(artifactDefinition.getArtifactName(), leftValue.getArtifactName());
}
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
artifactDefinition.setUniqueId("artifactId");
- artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_CSAR.name());
+ artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_CSAR.getType());
User user = new User();
boolean inCertificationRequest = false;
boolean fetchTemplatesFromDB = false;
byte[] csar = "test.csar".getBytes();
when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
- .thenReturn(Either.left(csar));
- when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(Component.class), anyString(), any(NodeTypeEnum.class), anyString(), anyBoolean()))
- .thenReturn(Either.left(artifactDefinition));
+ .thenReturn(Either.left(csar));
+ when(
+ artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(Component.class), anyString(), any(NodeTypeEnum.class),
+ anyString(), anyBoolean()))
+ .thenReturn(Either.left(artifactDefinition));
when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class)))
- .thenReturn(CassandraOperationStatus.OK);
+ .thenReturn(CassandraOperationStatus.OK);
Either<ArtifactDefinition, Operation> result
- = artifactBL.generateAndSaveToscaArtifact(artifactDefinition, resource, user, inCertificationRequest,
- shouldLock, inTransaction, fetchTemplatesFromDB);
-
+ = artifactBL.generateAndSaveToscaArtifact(artifactDefinition, resource, user, inCertificationRequest,
+ shouldLock, inTransaction, fetchTemplatesFromDB);
Assert.assertEquals(artifactDefinition.getUniqueId(), result.left().value().getUniqueId());
}
ArtifactDefinition csarArtifact = new ArtifactDefinition();
csarArtifact.setArtifactName("csarArtifact");
- csarArtifact.setArtifactType(ArtifactTypeEnum.HEAT_ENV.name());
+ csarArtifact.setArtifactType(ArtifactTypeEnum.HEAT_ENV.getType());
csarArtifact.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
- .thenReturn(Either.left(generatedCsar));
+ .thenReturn(Either.left(generatedCsar));
ImmutablePair<String, byte[]> result =
- testSubject.handleDownloadToscaModelRequest(resource, csarArtifact);
+ testSubject.handleDownloadToscaModelRequest(resource, csarArtifact);
assertEquals(csarArtifact.getArtifactName(), result.getKey());
}
artifactDefinition.setArtifactName("test.csar");
artifactDefinition.setArtifactType(ComponentTypeEnum.RESOURCE.name());
- artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.name());
+ artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
artifactDefinition.setUniqueId(artifactId);
artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
user.setUserId("userId");
when(userValidations.validateUserExists(eq(user.getUserId())))
- .thenReturn(user);
+ .thenReturn(user);
+ when(userValidations.isSameUser(Mockito.eq("userId"), Mockito.eq("userId")))
+ .thenReturn(true);
when(toscaOperationFacade.getToscaFullElement(eq(componentId)))
- .thenReturn(Either.left(resource));
+ .thenReturn(Either.left(resource));
when(artifactToscaOperation.getArtifactById(anyString(), anyString(), any(ComponentTypeEnum.class), anyString()))
- .thenReturn(Either.left(artifactDefinition));
+ .thenReturn(Either.left(artifactDefinition));
when(artifactCassandraDao.getArtifact(any()))
- .thenReturn(Either.left(daoArtifactData));
+ .thenReturn(Either.left(daoArtifactData));
when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
ImmutablePair<String, byte[]> result =
- artifactBL.handleDownloadRequestById(componentId, artifactId, user.getUserId(), ComponentTypeEnum.RESOURCE,
- parentId, null);
+ artifactBL.handleDownloadRequestById(componentId, artifactId, user.getUserId(), ComponentTypeEnum.RESOURCE,
+ parentId, null);
Assert.assertEquals(artifactDefinition.getArtifactName(), result.getKey());
}
try {
ImmutablePair<String, byte[]> result =
- artifactBL.handleDownloadRequestById(componentId, artifactId, userId, ComponentTypeEnum.RESOURCE, componentId
- , null);
+ artifactBL.handleDownloadRequestById(componentId, artifactId, userId, ComponentTypeEnum.RESOURCE, componentId
+ , null);
} catch (ComponentException e) {
assertEquals(e.getActionStatus(), ActionStatus.MISSING_INFORMATION);
return;
service.setUniqueId(componentId);
when(toscaOperationFacade.getToscaElement(eq(componentId), any(ComponentParametersView.class)))
- .thenReturn(Either.left(service));
+ .thenReturn(Either.left(service));
when(graphLockOperation.lockComponent(eq(componentId), any(NodeTypeEnum.class)))
- .thenReturn(StorageOperationStatus.OK);
+ .thenReturn(StorageOperationStatus.OK);
when(artifactToscaOperation.getArtifacts(any(), any(NodeTypeEnum.class), any(ArtifactGroupTypeEnum.class), any()))
- .thenReturn(Either.left(artifactDefinitionMap));
+ .thenReturn(Either.left(artifactDefinitionMap));
Map<String, ArtifactDefinition> result =
- artifactBL.handleGetArtifactsByType(ComponentTypeEnum.SERVICE.name(), parentId, ComponentTypeEnum.SERVICE,
- componentId, artifactGroupType, userId);
+ artifactBL.handleGetArtifactsByType(ComponentTypeEnum.SERVICE.name(), parentId, ComponentTypeEnum.SERVICE,
+ componentId, artifactGroupType, userId);
Assert.assertEquals(artifactDefinition.getArtifactName(), result.get("artifact1").getArtifactName());
}
resource.setComponentInstances(componentInstanceList);
componentInstance.setDeploymentArtifacts(deploymentArtifacts);
- List<ArtifactDefinition> result = artifactBL.getDeploymentArtifacts(resource, parentType, ciId);
- Assert.assertTrue(result.size() == 1);
+ List<ArtifactDefinition> result = artifactBL.getDeploymentArtifacts(resource, ciId);
+ assertThat(result.size() == 1).isTrue();
Assert.assertEquals(artifactDefinition.getArtifactName(), result.get(0).getArtifactName());
}
String parentId = "parentId";
String artifactId = "artifactId";
- AuditingActionEnum auditingAction = AuditingActionEnum.ARTIFACT_DELETE;
ArtifactDefinition artifactDefinition = new ArtifactDefinition();
Resource resource = new Resource();
- ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
- boolean shouldUnlock = true;
- boolean inTransaction = false;
User user = new User();
artifactDefinition.setArtifactName("test.csar");
resource.setDeploymentArtifacts(deploymentArtifacts);
when(graphLockOperation.lockComponent(eq(parentId), any(NodeTypeEnum.class)))
- .thenReturn(StorageOperationStatus.OK);
+ .thenReturn(StorageOperationStatus.OK);
when(toscaOperationFacade.getToscaElement(eq(parentId)))
- .thenReturn(Either.left(resource));
+ .thenReturn(Either.left(resource));
when(artifactToscaOperation.isCloneNeeded(any(), any(ArtifactDefinition.class), any(NodeTypeEnum.class)))
- .thenReturn(Either.left(Boolean.FALSE));
+ .thenReturn(Either.left(Boolean.FALSE));
when(artifactToscaOperation.removeArtifactOnGraph(any(ArtifactDefinition.class), any(), any(), any(NodeTypeEnum.class), anyBoolean()))
- .thenReturn(Either.left(artifactDataDefinition));
+ .thenReturn(Either.left(artifactDataDefinition));
when(artifactCassandraDao.deleteArtifact(any()))
- .thenReturn(CassandraOperationStatus.OK);
+ .thenReturn(CassandraOperationStatus.OK);
- Either<Either<ArtifactDefinition, Operation>, ResponseFormat> result = artifactBL.handleDelete(parentId, artifactId, user, auditingAction, componentType, resource, shouldUnlock, inTransaction);
- Either<ArtifactDefinition, Operation> leftValue = result.left().value();
- Assert.assertEquals(artifactDefinition.getArtifactName(), leftValue.left().value().getArtifactName());
+ Either<ArtifactDefinition, ResponseFormat> result = artifactBL.handleDelete(
+ parentId, artifactId, user, resource, true, false);
+ Assert.assertEquals(artifactDefinition.getArtifactName(), result.left().value().getArtifactName());
}
@Test
String resourceVersion = "1.0";
String artifactName = "artifactName";
- try{
+ try {
artifactBL.downloadRsrcArtifactByNames(serviceName, serviceVersion, resourceName, resourceVersion, artifactName);
- } catch(ComponentException e) {
+ } catch (ComponentException e) {
assertEquals(ActionStatus.INVALID_CONTENT, e.getActionStatus());
return;
}
esArtifactData.setDataAsArray("test".getBytes());
artifactDefinition.setArtifactName(artifactName);
- List<Service> serviceList = new ArrayList<>();
Map<String, ArtifactDefinition> artifacts = new HashMap<>();
artifacts.put(artifactName, artifactDefinition);
-
- serviceList.add(service);
resource.setDeploymentArtifacts(artifacts);
- when(toscaOperationFacade.getComponentByNameAndVersion(eq(ComponentTypeEnum.RESOURCE), eq(resourceName), eq(version), eq(JsonParseFlagEnum.ParseMetadata)))
- .thenReturn(Either.left(resource));
- doReturn(Either.left(serviceList)).when(toscaOperationFacade).getBySystemName(eq(ComponentTypeEnum.SERVICE), eq(serviceName));
- when(artifactCassandraDao.getArtifact(any()))
- .thenReturn(Either.left(esArtifactData));
+ when(toscaOperationFacade.getComponentByNameAndVersion(eq(ComponentTypeEnum.RESOURCE), eq(resourceName), eq(version),
+ eq(JsonParseFlagEnum.ParseMetadata)))
+ .thenReturn(Either.left(resource));
+ doReturn(Either.left(service)).when(toscaOperationFacade).getBySystemNameAndVersion(ComponentTypeEnum.SERVICE, serviceName, version);
+ when(artifactCassandraDao.getArtifact(any())).thenReturn(Either.left(esArtifactData));
byte[] result = artifactBL.downloadRsrcArtifactByNames(serviceName, version, resourceName, version, artifactName);
Assert.assertEquals(esArtifactData.getDataAsArray(), result);
}
private ArtifactsBusinessLogic getTestSubject() {
- return new ArtifactsBusinessLogic(artifactCassandraDao, toscaExportHandler, csarUtils, lifecycleBusinessLogic,
- userBusinessLogic, artifactsResolver, elementDao, groupOperation, groupInstanceOperation, groupTypeOperation,
- interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation);
- }
-}
\ No newline at end of file
+ final ArtifactsBusinessLogic artifactsBusinessLogic = new ArtifactsBusinessLogic(artifactCassandraDao,
+ toscaExportHandler, csarUtils, lifecycleBusinessLogic,
+ userBusinessLogic, artifactsResolver, elementDao, groupOperation, groupInstanceOperation,
+ groupTypeOperation,
+ interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation, artifactTypeOperation);
+ artifactsBusinessLogic.setComponentsUtils(componentsUtils);
+ return artifactsBusinessLogic;
+ }
+}