resourceType, resourceName, invariantUuid,
modifier, artifactData, comment, did);
break;
-// case DOWNLOAD_ARTIFACT:
-// factory = new AuditDownloadArtifactExternalApiEventFactory(commonFields, String resourceType, String resourceName,
-// String consumerId, String resourceUrl, ResourceAuditData prevParams, ResourceAuditData currParams,
-// String invariantUuid, User modifier, String artifactData);
-// break;
case DISTRIBUTION_STATE_CHANGE_REQUEST:
factory = new AuditDistStateChangeRequestResourceAdminEventFactory(commonFields, prevParams, currParams,
resourceType, resourceName, invariantUuid,
private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> doAction(String componentId, ComponentTypeEnum componentType, ArtifactOperationInfo operation, String artifactId, ArtifactDefinition artifactInfo, String origMd5,
String originData, String interfaceName, String operationName, AuditingActionEnum auditingAction, User user, org.openecomp.sdc.be.model.Component parent, boolean shouldLock, boolean inTransaction, boolean needUpdateGroup) {
- /*if (interfaceName != null && operationName != null) {
- interfaceName = interfaceName.toLowerCase();
- operationName = operationName.toLowerCase();
- }*/
switch (operation.getArtifactOperationEnum()) {
case DOWNLOAD:
if (artifactGenerationRequired(parent, artifactInfo)) {
return Either.right(validateGroupType.right().value());
}
}
- // TODO TEMP !!!
NodeTypeEnum parentType = convertParentType(componentType);
- // TODO TEMP !!!
boolean isCreate = ArtifactOperationEnum.isCreateOrLink(operation.getArtifactOperationEnum());
if (isDeploymentArtifact(artifactInfo)) {
package org.openecomp.sdc.be.components.impl;
-import static org.openecomp.sdc.be.components.property.GetInputUtils.isGetInputValueForInput;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.UUID;
-import java.util.function.BiConsumer;
-import java.util.stream.Collectors;
-
+import com.google.common.collect.Sets;
+import fj.data.Either;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
-import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.BiConsumer;
+import java.util.stream.Collectors;
-import fj.data.Either;
+import static org.openecomp.sdc.be.components.property.GetInputUtils.isGetInputValueForInput;
@org.springframework.stereotype.Component
public class ComponentInstanceBusinessLogic extends BaseBusinessLogic {
if (lockComponent.isRight()) {
return Either.right(lockComponent.right().value());
}
- // validate resource
- /*
- * if (!ComponentValidationUtils.canWorkOnComponent(containerComponentId, serviceOperation, userId)) { log.info( "Restricted operation for user " + userId + " on service " + containerComponentId); return Either.right(componentsUtils
- * .getResponseFormat(ActionStatus.RESTRICTED_OPERATION)); } // lock resource StorageOperationStatus lockStatus = graphLockOperation.lockComponent( containerComponentId, NodeTypeEnum.Service); if (lockStatus != StorageOperationStatus.OK) {
- * log.debug("Failed to lock service {}", containerComponentId); resultOp = Either.right(componentsUtils .getResponseFormat(componentsUtils .convertFromStorageResponse(lockStatus))); return resultOp; }
- */
+
Either<ComponentInstance, ResponseFormat> resultOp = null;
try {
resultOp = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
return deleteEither;
} finally {
- /*
- * if (resultOp == null || resultOp.isRight()) { titanGenericDao.rollback(); } else { titanGenericDao.commit(); } graphLockOperation.unlockComponent(containerComponentId, NodeTypeEnum.Service);
- */
unlockComponent(resultOp, containerComponent);
}
}
package org.openecomp.sdc.be.components.lifecycle;
-import java.util.Arrays;
-import java.util.List;
-
+import fj.data.Either;
import org.openecomp.sdc.be.components.impl.ComponentBusinessLogic;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import fj.data.Either;
+import java.util.Arrays;
+import java.util.List;
public class CheckoutTransition extends LifeCycleTransition {
return userValidationResponse;
}
- // Disabled as of 1604 patch after discussing with Ella/Eli/Michael
-
- /*
- * if (componentType == ComponentTypeEnum.PRODUCT){ Either<Boolean, ResponseFormat> productContactsEither = productContactsValidation((Product)component, modifier); if (productContactsEither.isRight()){ return productContactsEither; } }
- */
-
// check resource is not locked by another user
if (oldState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT)) {
ResponseFormat error = componentUtils.getResponseFormat(ActionStatus.COMPONENT_IN_CHECKOUT_STATE, componentName, componentType.name().toLowerCase(), owner.getFirstName(), owner.getLastName(), owner.getUserId());
package org.openecomp.sdc.be.externalapi.servlet;
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.Map;
-
-import javax.inject.Singleton;
-import javax.servlet.ServletContext;
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.DELETE;
-import javax.ws.rs.GET;
-import javax.ws.rs.HeaderParam;
-import javax.ws.rs.POST;
-import javax.ws.rs.Path;
-import javax.ws.rs.PathParam;
-import javax.ws.rs.Produces;
-import javax.ws.rs.core.Context;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-
+import com.jcabi.aspects.Loggable;
+import fj.data.Either;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiImplicitParams;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.jcabi.aspects.Loggable;
-
-import fj.data.Either;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiImplicitParam;
-import io.swagger.annotations.ApiImplicitParams;
-import io.swagger.annotations.ApiOperation;
-import io.swagger.annotations.ApiParam;
-import io.swagger.annotations.ApiResponse;
-import io.swagger.annotations.ApiResponses;
+import javax.inject.Singleton;
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.Map;
/**
* This Servlet serves external users operations on artifacts.
*
@Path("/{assetType}/{uuid}/artifacts/{artifactUUID}")
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "deletes an artifact of a resource or service", httpMethod = "DELETE", notes = "deletes an artifact of a resource or service", response = Response.class)
- /*@ApiResponses(value = { @ApiResponse(code = 200, message = "Artifact Deleted"), @ApiResponse(code = 401, message = "Authorization required"), @ApiResponse(code = 403, message = "Restricted operation"),
- @ApiResponse(code = 404, message = "Asset not found") })*/
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Artifact deleted", response = ArtifactDefinition.class),
@ApiResponse(code = 400, message = "Missing 'X-ECOMP-InstanceID' HTTP header - POL5001"),
package org.openecomp.sdc;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
+import fj.data.Either;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.graph.datatype.GraphNode;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.resources.data.CategoryData;
-import fj.data.Either;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
public class ElementOperationMock implements IElementOperation {
}
- /*
- * @Override public Either<Category, ActionStatus> getCategory(String name) { if (name.equals(resourceCategory.getName())){ return Either.left(resourceCategory); } else { return Either.right(ActionStatus.CATEGORY_NOT_FOUND); } }
- */
-
@Override
public Either<List<Tag>, ActionStatus> getAllTags() {
// TODO Auto-generated method stub
package org.openecomp.sdc.be.components;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.when;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import javax.servlet.ServletContext;
-
+import com.google.common.collect.Sets;
+import fj.data.Either;
import org.junit.Before;
import org.mockito.Mockito;
import org.openecomp.sdc.ElementOperationMock;
import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
import org.openecomp.sdc.common.impl.ExternalConfiguration;
import org.openecomp.sdc.common.impl.FSConfigurationSource;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import org.springframework.web.context.WebApplicationContext;
-import com.google.common.collect.Sets;
+import javax.servlet.ServletContext;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
-import fj.data.Either;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
public class BaseServiceBusinessLogicTest {
- private static final Logger log = LoggerFactory.getLogger(ServiceBusinessLogicTest.class);
private static final String SERVICE_CATEGORY = "Mobility";
final ServletContext servletContext = Mockito.mock(ServletContext.class);
UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
// Servlet Context attributes
when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
-// when(servletContext.getAttribute(Constants.SERVICE_OPERATION_MANAGER)).thenReturn(new ServiceOperation());
when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
createResourceAudit.setStatus("201");
createResourceAudit.setPrevVersion("");
createResourceAudit.setAction("Create");
- // fields.put("TIMESTAMP", "2015-11-22 09:19:12.977");
createResourceAudit.setPrevState("");
createResourceAudit.setResourceName("MyTestResource");
- // createResourceAudit.setFields(fields);
final ResourceAdminEvent checkInResourceAudit = new ResourceAdminEvent();
checkInResourceAudit.setModifier("Carlos Santana(cs0008)");
checkInResourceAudit.setStatus("200");
checkInResourceAudit.setPrevVersion("0.1");
checkInResourceAudit.setAction("Checkin");
- // fields.put("TIMESTAMP", "2015-11-22 09:25:03.797");
checkInResourceAudit.setPrevState("NOT_CERTIFIED_CHECKOUT");
checkInResourceAudit.setResourceName("MyTestResource");
checkOutResourceAudit.setStatus("200");
checkOutResourceAudit.setPrevVersion("0.1");
checkOutResourceAudit.setAction("Checkout");
- // fields.put("TIMESTAMP", "2015-11-22 09:39:41.024");
checkOutResourceAudit.setPrevState("NOT_CERTIFIED_CHECKIN");
checkOutResourceAudit.setResourceName("MyTestResource");
- // checkOutResourceAudit.setFields(fields);
-
- // Mockito.doAnswer(new Answer<Either<List<ESTimeBasedEvent>,
- // ActionStatus> >() {
- // public Either<List<ESTimeBasedEvent>, ActionStatus>
- // answer(InvocationOnMock invocation) {
- // final Either<List<ESTimeBasedEvent>, ActionStatus> either;
- // final List<ESTimeBasedEvent> list;
- // Object[] args = invocation.getArguments();
- // Map<AuditingFieldsKeysEnum, Object> filterMap =
- // (Map<AuditingFieldsKeysEnum, Object>) args[0];
- // if( filterMap.equals(FILTER_MAP_CERTIFIED_VERSION) ){
- // list = new
- // ArrayList<ESTimeBasedEvent>(){{add(createResourceAudit);add(checkInResourceAudit);add(checkOutResourceAudit);}};
- // either = Either.left(list);
- //
- // }
- // else if( filterMap.equals(FILTER_MAP_UNCERTIFIED_VERSION_PREV) ){
- // list = new ArrayList<ESTimeBasedEvent>();
- // either = Either.left(list);
- // }
- // else if( filterMap.equals(FILTER_MAP_UNCERTIFIED_VERSION_CURR) ){
- // list = new
- // ArrayList<ESTimeBasedEvent>(){{/*add(createResourceAudit);add(checkInResourceAudit);*/add(checkOutResourceAudit);}};
- // either = Either.left(list);
- // }
- // else{
- // either = null;
- // }
- // return either;
- // }
- // }).when(auditingDao).getFilteredResourceAdminAuditingEvents(Mockito.anyMap());
- //
- //
List<ResourceAdminEvent> list = new ArrayList<ResourceAdminEvent>() {
{
add(createResourceAudit);
};
Either<List<ResourceAdminEvent>, ActionStatus> resultCurr = Either.left(listCurr);
Mockito.when(auditingDao.getAuditByServiceIdAndCurrVersion(Mockito.anyString(), Mockito.anyString())).thenReturn(resultCurr);
-
}
protected Service createServiceObject(boolean afterCreate) {
List<String> tgs = new ArrayList<String>();
tgs.add(service.getName());
service.setTags(tgs);
- // service.setVendorName("Motorola");
- // service.setVendorRelease("1.0.0");
service.setIcon("MyIcon");
- // service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
service.setContactId("aa1234");
service.setProjectCode("12345");
package org.openecomp.sdc.be.components;
-import static org.mockito.Mockito.when;
-
-import javax.servlet.ServletContext;
-
import org.junit.Before;
import org.junit.BeforeClass;
-import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.openecomp.sdc.be.config.ConfigurationManager;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.impl.ComponentsUtils;
-import org.openecomp.sdc.be.model.GroupDefinition;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
-import org.openecomp.sdc.be.model.operations.impl.GroupOperation;
import org.openecomp.sdc.common.api.ConfigurationSource;
import org.openecomp.sdc.common.api.Constants;
import org.openecomp.sdc.common.impl.ExternalConfiguration;
import org.openecomp.sdc.common.impl.FSConfigurationSource;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletContext;
+
+import static org.mockito.Mockito.when;
/**
* tests GroupBusinessLogic class
* @author ns019t
*/
public class GroupBusinessLogicTest {
- private static final Logger log = LoggerFactory.getLogger(ServiceBusinessLogicTest.class);
ComponentsUtils componentsUtils;
final ServletContext servletContext = Mockito.mock(ServletContext.class);
private static IGraphLockOperation graphLockOperation = Mockito.mock(IGraphLockOperation.class);
- private static GroupOperation groupOperation = Mockito.mock(GroupOperation.class);
- private static GroupDefinition groupDefenition = Mockito.mock(GroupDefinition.class);
private static User user = Mockito.mock(User.class);
private static String componentId = "vfUniqueId-xxxx";
- private static String groupUniqueId = "groupUniqueId-xxxx";
@InjectMocks
static GroupBusinessLogic bl = new GroupBusinessLogic();
@BeforeClass
public static void setupBeforeClass() {
when(graphLockOperation.lockComponent(componentId, ComponentTypeEnum.RESOURCE.getNodeType())).thenReturn(StorageOperationStatus.OK);
-// when(groupOperation.getGroup(groupUniqueId)).thenReturn(Either.left(groupDefenition));
- }
-
- /**
- * tests the ValidateMinMaxAndInitialCountPropertyValues() method
- */
- @SuppressWarnings({ "rawtypes", "unchecked" })
- @Test
- public void testValidateMinMaxAndInitialCountPropertyValues(){
-
-// Class<GroupBusinessLogic> targetClass = GroupBusinessLogic.class;
-// String methodName = "validateMinMaxAndInitialCountPropertyValues";
-// Either<Boolean, ResponseFormat> validationRes;
-//
-// Map<PropertyNames, String> parentPropertyValues = new EnumMap<>(PropertyNames.class);
-// parentPropertyValues.put(PropertyNames.MIN_INSTANCES, "20");
-// parentPropertyValues.put(PropertyNames.MAX_INSTANCES, "100");
-// parentPropertyValues.put(PropertyNames.INITIAL_COUNT, "40");
-//
-// Map<PropertyNames, String> parentPropertyValues1 = new EnumMap<>(PropertyNames.class);
-// parentPropertyValues1.put(PropertyNames.MIN_INSTANCES, "20");
-// parentPropertyValues1.put(PropertyNames.MAX_INSTANCES, null);
-// parentPropertyValues1.put(PropertyNames.INITIAL_COUNT, "40");
-//
-// Map<PropertyNames, String> parentPropertyValues2 = new EnumMap<>(PropertyNames.class);
-// parentPropertyValues2.put(PropertyNames.MIN_INSTANCES, "20");
-// parentPropertyValues2.put(PropertyNames.MAX_INSTANCES, "null");
-// parentPropertyValues2.put(PropertyNames.INITIAL_COUNT, "40");
-//
-// Map<PropertyNames, String> validNewPropertyValues = new EnumMap<>(PropertyNames.class);
-// validNewPropertyValues.put(PropertyNames.MIN_INSTANCES, "20");
-// validNewPropertyValues.put(PropertyNames.MAX_INSTANCES, "100");
-// validNewPropertyValues.put(PropertyNames.INITIAL_COUNT, "50");
-//
-// Map<PropertyNames, String> validNewPropertyValues1 = new EnumMap<>(PropertyNames.class);
-// validNewPropertyValues1.put(PropertyNames.MIN_INSTANCES, "40");
-// validNewPropertyValues1.put(PropertyNames.MAX_INSTANCES, "90");
-// validNewPropertyValues1.put(PropertyNames.INITIAL_COUNT, "60");
-//
-// Map<PropertyNames, String> validNewPropertyValues2 = new EnumMap<>(PropertyNames.class);
-// validNewPropertyValues2.put(PropertyNames.MIN_INSTANCES, "40");
-// validNewPropertyValues2.put(PropertyNames.MAX_INSTANCES, null);
-// validNewPropertyValues2.put(PropertyNames.INITIAL_COUNT, "60");
-//
-// Map<PropertyNames, String> validNewPropertyValues3 = new EnumMap<>(PropertyNames.class);
-// validNewPropertyValues3.put(PropertyNames.MIN_INSTANCES, "40");
-// validNewPropertyValues3.put(PropertyNames.MAX_INSTANCES, "null");
-// validNewPropertyValues3.put(PropertyNames.INITIAL_COUNT, "60");
-//
-// Map<PropertyNames, String> validNewPropertyValues4 = new EnumMap<>(PropertyNames.class);
-// validNewPropertyValues4.put(PropertyNames.MIN_INSTANCES, null);
-// validNewPropertyValues4.put(PropertyNames.MAX_INSTANCES, null);
-// validNewPropertyValues4.put(PropertyNames.INITIAL_COUNT, "60");
-//
-// Map<PropertyNames, String> invalidNewPropertyValues = new EnumMap<>(PropertyNames.class);
-// invalidNewPropertyValues.put(PropertyNames.MIN_INSTANCES, "20");
-// invalidNewPropertyValues.put(PropertyNames.MAX_INSTANCES, "10");
-// invalidNewPropertyValues.put(PropertyNames.INITIAL_COUNT, "5");
-//
-// Map<PropertyNames, String> invalidNewPropertyValues1 = new EnumMap<>(PropertyNames.class);
-// invalidNewPropertyValues1.put(PropertyNames.MIN_INSTANCES, "5");
-// invalidNewPropertyValues1.put(PropertyNames.MAX_INSTANCES, "10");
-// invalidNewPropertyValues1.put(PropertyNames.INITIAL_COUNT, "20");
-//
-// Map<PropertyNames, String> invalidNewPropertyValues2 = new EnumMap<>(PropertyNames.class);
-// invalidNewPropertyValues2.put(PropertyNames.MIN_INSTANCES, "25");
-// invalidNewPropertyValues2.put(PropertyNames.MAX_INSTANCES, "95");
-// invalidNewPropertyValues2.put(PropertyNames.INITIAL_COUNT, "100");
-//
-// Map<PropertyNames, String> invalidNewPropertyValues3 = new EnumMap<>(PropertyNames.class);
-// invalidNewPropertyValues3.put(PropertyNames.MIN_INSTANCES, null);
-// invalidNewPropertyValues3.put(PropertyNames.MAX_INSTANCES, "95");
-// invalidNewPropertyValues3.put(PropertyNames.INITIAL_COUNT, "10");
-//
-// Map<PropertyNames, String> invalidNewPropertyValues4 = new EnumMap<>(PropertyNames.class);
-// invalidNewPropertyValues4.put(PropertyNames.MIN_INSTANCES, "30");
-// invalidNewPropertyValues4.put(PropertyNames.MAX_INSTANCES, "80");
-// invalidNewPropertyValues4.put(PropertyNames.INITIAL_COUNT, null);
-//
-//
-// Class[] argClasses = {Map.class, Map.class};
-// try {
-// Method method = targetClass.getDeclaredMethod(methodName, argClasses);
-// method.setAccessible(true);
-//
-// Object[] argObjects2 = {invalidNewPropertyValues, parentPropertyValues};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects2);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isRight());
-// assertTrue(validationRes.right().value().getMessageId().equals(ResponseEnum.INVALID_MIN_MAX.getMessageId()));
-//
-// Object[] argObjects3 = {invalidNewPropertyValues1, parentPropertyValues};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects3);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isRight());
-// assertTrue(validationRes.right().value().getMessageId().equals(ResponseEnum.INVALID_MIN_MAX.getMessageId()));
-//
-// Object[] argObjects7 = {invalidNewPropertyValues3, parentPropertyValues};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects7);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isRight());
-// assertTrue(validationRes.right().value().getMessageId().equals(ResponseEnum.INVALID_MIN_MAX.getMessageId()));
-//
-// Object[] argObjects = {validNewPropertyValues, parentPropertyValues};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isLeft());
-// assertTrue(validationRes.left().value());
-//
-// Object[] argObjects1 = {validNewPropertyValues1, parentPropertyValues};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects1);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isLeft());
-// assertTrue(validationRes.left().value());
-//
-// Object[] argObjects5 = {validNewPropertyValues2, parentPropertyValues2};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects5);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isLeft());
-// assertTrue(validationRes.left().value());
-//
-// Object[] argObjects6 = {validNewPropertyValues3, parentPropertyValues1};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects6);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isLeft());
-// assertTrue(validationRes.left().value());
-//
-// Object[] argObjects9 = {validNewPropertyValues4, parentPropertyValues1};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects9);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isLeft());
-// assertTrue(validationRes.left().value());
-//
-// Object[] argObjects4 = {invalidNewPropertyValues2, parentPropertyValues};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects4);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isRight());
-// assertTrue(validationRes.right().value().getMessageId().equals(ResponseEnum.INVALID_INITIAL_COUNT.getMessageId()));
-//
-// Object[] argObjects8 = {invalidNewPropertyValues4, parentPropertyValues};
-// validationRes = (Either<Boolean, ResponseFormat>) method.invoke(bl, argObjects8);
-// assertTrue(validationRes != null);
-// assertTrue(validationRes.isRight());
-// assertTrue(validationRes.right().value().getMessageId().equals(ResponseEnum.INVALID_INITIAL_COUNT.getMessageId()));
-// }
-// catch (Exception e) {
-// e.printStackTrace();
-// }
}
-
}
package org.openecomp.sdc.be.components;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.ArrayList;
-import java.util.List;
-
import org.junit.Test;
import org.openecomp.sdc.be.components.health.HealthCheckBusinessLogic;
import org.openecomp.sdc.common.api.Constants;
import org.openecomp.sdc.common.api.HealthCheckInfo;
import org.openecomp.sdc.common.api.HealthCheckInfo.HealthCheckStatus;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
public class HealthCheckBusinessLogicTest {
HealthCheckBusinessLogic healthCheckBusinessLogic = new HealthCheckBusinessLogic();
HealthCheckInfo checkInfoTitanUp = new HealthCheckInfo(Constants.HC_COMPONENT_TITAN, HealthCheckStatus.UP, null, null);
HealthCheckInfo checkInfoTitanDown = new HealthCheckInfo(Constants.HC_COMPONENT_TITAN, HealthCheckStatus.DOWN, null, null);
- /*
- * HealthCheckInfo checkInfoUebUp = new HealthCheckInfo(HealthCheckComponent.DE, HealthCheckStatus.UP, null, null); HealthCheckInfo checkInfoUebDown = new HealthCheckInfo(HealthCheckComponent.DE, HealthCheckStatus.DOWN, null, null);
- */
-
checkInfosLeft.add(checkInfoTitanUp);
checkInfosRight.add(checkInfoTitanUp);
package org.openecomp.sdc.be.components;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-
-import javax.servlet.ServletContext;
-
+import fj.data.Either;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.impl.WebAppContextWrapper;
-import org.openecomp.sdc.be.model.PropertyConstraint;
import org.openecomp.sdc.be.model.PropertyDefinition;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
import org.openecomp.sdc.be.model.operations.api.IPropertyOperation;
-import org.openecomp.sdc.be.resources.data.EntryData;
import org.openecomp.sdc.be.user.Role;
import org.openecomp.sdc.be.user.UserBusinessLogic;
import org.openecomp.sdc.common.api.ConfigurationSource;
import org.slf4j.LoggerFactory;
import org.springframework.web.context.WebApplicationContext;
-import fj.data.Either;
-import junit.framework.Assert;
+import javax.servlet.ServletContext;
+import java.util.Arrays;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
public class PropertyBusinessLogicTest {
when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
when(servletContext.getAttribute(Constants.PROPERTY_OPERATION_MANAGER)).thenReturn(propertyOperation);
when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
-// when(servletContext.getAttribute(Constants.RESOURCE_OPERATION_MANAGER)).thenReturn(resourceOperation);
when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
- // Resource Operation mock methods
- // getCount
-// Either<Integer, StorageOperationStatus> eitherCount = Either.left(0);
-// when(resourceOperation.getNumberOfResourcesByName("MyResourceName".toLowerCase())).thenReturn(eitherCount);
-// Either<Integer, StorageOperationStatus> eitherCountExist = Either.left(1);
-// when(resourceOperation.getNumberOfResourcesByName("alreadyExist".toLowerCase())).thenReturn(eitherCountExist);
-// Either<Integer, StorageOperationStatus> eitherCountRoot = Either.left(1);
-// when(resourceOperation.getNumberOfResourcesByName("Root".toLowerCase())).thenReturn(eitherCountRoot);
-//
-// Either<Resource, StorageOperationStatus> eitherGetResource = Either.left(createResourceObject(true));
-// when(resourceOperation.getResource(resourceId)).thenReturn(eitherGetResource);
-
- }
-
- // @Test
- public void testHappyScenario() {
-
- String propertyName = "disk_size";
- PropertyDefinition newPropertyDefinition = createPropertyObject(propertyName, resourceId);
- Either<EntryData<String, PropertyDefinition>, ResponseFormat> either = bl.createProperty(resourceId, propertyName, newPropertyDefinition, user.getUserId());
- if (either.isRight()) {
- Assert.assertFalse(true);
- }
- Assert.assertEquals(newPropertyDefinition, either.left().value());
}
@Test
private PropertyDefinition createPropertyObject(String propertyName, String resourceId) {
PropertyDefinition pd = new PropertyDefinition();
- List<PropertyConstraint> constraints = new ArrayList<PropertyConstraint>();
pd.setConstraints(null);
pd.setDefaultValue("100");
pd.setDescription("Size of thasdasdasdasde local disk, in Gigabytes (GB), available to applications running on the Compute node");
package org.openecomp.sdc.be.components;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import javax.servlet.ServletContext;
-
+import fj.data.Either;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.junit.Before;
import org.junit.Ignore;
import org.slf4j.LoggerFactory;
import org.springframework.web.context.WebApplicationContext;
-import fj.data.Either;
+import javax.servlet.ServletContext;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
public class ServiceBusinessLogicTest {
when(mockUserAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser);
when(userValidations.validateUserExists(eq("jh0003"), anyString(), eq(false))).thenReturn(Either.left(user));
when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(Either.left(user));
-// when(userValidations.validateUserRole(user))
- // Servlet Context attributes
when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
-// when(servletContext.getAttribute(Constants.SERVICE_OPERATION_MANAGER)).thenReturn(new ServiceOperation());
when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
assertEquals("assert error description", expectedResponse.getFormattedMessage(), actualResponse.getFormattedMessage());
}
- /* CREATE validations - start ***********************/
- // Service name - start
@Test
public void testFailedServiceValidations() {
testServiceNameAlreadyExists();
testServiceNameEmpty();
- // testServiceNameExceedsLimit();
testServiceNameWrongFormat();
testServiceDescriptionEmpty();
testServiceDescriptionMissing();
testServiceIconMissing();
testResourceIconInvalid();
testResourceIconExceedsLimit();
- // testTagsExceedsLimitCreate();
- // testTagsSingleExcessLimit();
testTagsNoServiceName();
testInvalidTag();
testServiceTagNotExist();
assertResponse(createResponse, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.SERVICE.getValue());
}
- // Service name - end
- // Service description - start
private void testServiceDescriptionEmpty() {
Service serviceExist = createServiceObject(false);
serviceExist.setDescription("");
assertResponse(createResponse, ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.SERVICE.getValue());
}
- public void markDistributionAsDeployedTestAlreadyDeployed() {
- String notifyAction = "DNotify";
- String requestAction = "DRequest";
- String resultAction = "DResult";
- String did = "123456";
-
- setupBeforeDeploy(notifyAction, requestAction, did);
- List<DistributionDeployEvent> resultList = new ArrayList<DistributionDeployEvent>();
- Map<String, Object> params = new HashMap<String, Object>();
- DistributionDeployEvent event = new DistributionDeployEvent();
-
- event.setAction(resultAction);
- event.setDid(did);
- event.setStatus("200");
- // ESTimeBasedEvent deployEvent = new ESTimeBasedEvent();
- // deployEvent.setFields(params);
- resultList.add(event);
- Either<List<DistributionDeployEvent>, ActionStatus> eventList = Either.left(resultList);
-
- Mockito.when(auditingDao.getDistributionDeployByStatus(Mockito.anyString(), Mockito.eq(resultAction), Mockito.anyString())).thenReturn(eventList);
-
- Either<Service, ResponseFormat> markDeployed = bl.markDistributionAsDeployed(did, did, user);
- assertTrue(markDeployed.isLeft());
-
- Mockito.verify(auditingDao, Mockito.times(0)).getDistributionRequest(did, requestAction);
-
- }
-
@Test
public void markDistributionAsDeployedTestSuccess() {
String notifyAction = "DNotify";
assertTrue(markDeployed.isLeft());
}
- //@Test
- public void markDistributionAsDeployedTestNotDistributed() {
- String notifyAction = "DNotify";
- String requestAction = "DRequest";
- String did = "123456";
-
- setupBeforeDeploy(notifyAction, requestAction, did);
- List<ResourceAdminEvent> emptyList = new ArrayList<ResourceAdminEvent>();
- Either<List<ResourceAdminEvent>, ActionStatus> emptyEventList = Either.left(emptyList);
- Mockito.when(auditingDao.getDistributionRequest(Mockito.anyString(), Mockito.eq(requestAction))).thenReturn(emptyEventList);
-
- Either<Component, StorageOperationStatus> notFound = Either.right(StorageOperationStatus.NOT_FOUND);
- Mockito.when(toscaOperationFacade.getToscaElement(did)).thenReturn(notFound);
-
- Either<Service, ResponseFormat> markDeployed = bl.markDistributionAsDeployed(did, did, user);
- assertTrue(markDeployed.isRight());
- assertEquals(404, markDeployed.right().value().getStatus().intValue());
-
- }
private void testServiceBadCategoryCreate() {
assertResponse(createResponse, ActionStatus.MISSING_PROJECT_CODE);
}
-// @Test
-// public void testDeleteMarkedServicesNoServices() {
-// List<String> ids = new ArrayList<String>();
-// Either<List<String>, StorageOperationStatus> eitherNoResources = Either.left(ids);
-// when(toscaOperationFacade.getAllComponentsMarkedForDeletion()).thenReturn(eitherNoResources);
-//
-// Either<List<String>, ResponseFormat> deleteMarkedResources = bl.deleteMarkedComponents();
-// assertTrue(deleteMarkedResources.isLeft());
-// assertTrue(deleteMarkedResources.left().value().isEmpty());
-//
-// Mockito.verify(artifactBl, Mockito.times(0)).deleteAllComponentArtifactsIfNotOnGraph(Mockito.anyList());
-//
-// }
-
@Test
@Ignore
public void testDeleteMarkedServices() {
List<ArtifactDefinition> artifacts = new ArrayList<ArtifactDefinition>();
Either<List<ArtifactDefinition>, StorageOperationStatus> getArtifactsResponse = Either.left(artifacts);
-// when(toscaOperationFacade.getComponentArtifactsForDelete(resourceFree, NodeTypeEnum.Service, true)).thenReturn(getArtifactsResponse);
when(toscaOperationFacade.isComponentInUse(resourceFree)).thenReturn(resourceFreeResponse);
when(toscaOperationFacade.isComponentInUse(resourceInUse)).thenReturn(resourceInUseResponse);
List<String> tgs = new ArrayList<String>();
tgs.add(service.getName());
service.setTags(tgs);
- // service.setVendorName("Motorola");
- // service.setVendorRelease("1.0.0");
service.setIcon("MyIcon");
- // service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
service.setContactId("aa1234");
service.setProjectCode("12345");
// fields.put("TIMESTAMP", "2015-11-22 09:39:41.024");
checkOutResourceAudit.setPrevState("NOT_CERTIFIED_CHECKIN");
checkOutResourceAudit.setResourceName("MyTestResource");
- // checkOutResourceAudit.setFields(fields);
-
- // Mockito.doAnswer(new Answer<Either<List<ESTimeBasedEvent>,
- // ActionStatus> >() {
- // public Either<List<ESTimeBasedEvent>, ActionStatus>
- // answer(InvocationOnMock invocation) {
- // final Either<List<ESTimeBasedEvent>, ActionStatus> either;
- // final List<ESTimeBasedEvent> list;
- // Object[] args = invocation.getArguments();
- // Map<AuditingFieldsKeysEnum, Object> filterMap =
- // (Map<AuditingFieldsKeysEnum, Object>) args[0];
- // if( filterMap.equals(FILTER_MAP_CERTIFIED_VERSION) ){
- // list = new
- // ArrayList<ESTimeBasedEvent>(){{add(createResourceAudit);add(checkInResourceAudit);add(checkOutResourceAudit);}};
- // either = Either.left(list);
- //
- // }
- // else if( filterMap.equals(FILTER_MAP_UNCERTIFIED_VERSION_PREV) ){
- // list = new ArrayList<ESTimeBasedEvent>();
- // either = Either.left(list);
- // }
- // else if( filterMap.equals(FILTER_MAP_UNCERTIFIED_VERSION_CURR) ){
- // list = new
- // ArrayList<ESTimeBasedEvent>(){{/*add(createResourceAudit);add(checkInResourceAudit);*/add(checkOutResourceAudit);}};
- // either = Either.left(list);
- // }
- // else{
- // either = null;
- // }
- // return either;
- // }
- // }).when(auditingDao).getFilteredResourceAdminAuditingEvents(Mockito.anyMap());
- //
- //
List<ResourceAdminEvent> list = new ArrayList<ResourceAdminEvent>() {
{
add(createResourceAudit);
package org.openecomp.sdc.be.components.distribution.engine;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
-
-import java.util.List;
-
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.openecomp.sdc.be.config.ConfigurationManager;
import org.openecomp.sdc.be.distribution.api.client.CambriaOperationStatus;
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
+import java.util.List;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
public class DistributionEngineHealthCheckTest extends BeConfDependentTest {
@Mock
private CambriaHandler cambriaHandler = Mockito.mock(CambriaHandler.class);
- DistributionEngineClusterHealth distributionEngineClusterHealth = new DistributionEngineClusterHealth();
-
- Gson gson = new Gson();
-
- Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
-
- //
- // @Test
- // public void validateDownWhenEnvAreDown() {
- //
- // Map<String, AtomicBoolean> envNamePerStatus = new HashMap<>();
- // envNamePerStatus.put("PROD1", new AtomicBoolean(false));
- // envNamePerStatus.put("PROD2", new AtomicBoolean(false));
- //
- // distributionEngineClusterHealth.startHealthCheckTask(envNamePerStatus);
- //
- // HealthCheckInfo healthCheckInfo =
- // distributionEngineClusterHealth.getHealthCheckInfo();
- // assertEquals("verify down", HealthCheckStatus.DOWN,
- // healthCheckInfo.getHealthCheckStatus());
- // assertEquals("verify DE component", HealthCheckComponent.DE,
- // healthCheckInfo.getHealthCheckComponent());
- //
- // }
-
@Test
public void validateUpWhenQuerySucceed() {
- // Map<String, AtomicBoolean> envNamePerStatus = new HashMap<>();
- // envNamePerStatus.put("PROD1", new AtomicBoolean(true));
- // envNamePerStatus.put("PROD2", new AtomicBoolean(false));
- //
- // distributionEngineClusterHealth.startHealthCheckTask(envNamePerStatus,
- // false);
-
CambriaErrorResponse cambriaOkResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, 200);
CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.INTERNAL_SERVER_ERROR, 500);
CambriaErrorResponse cambriaNotErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.AUTHENTICATION_ERROR, 403);
package org.openecomp.sdc.be.components.impl;
-import static org.junit.Assert.*;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-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 java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import javax.servlet.http.HttpServletRequest;
-
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import fj.data.Either;
+import mockit.Deencapsulation;
+import org.apache.commons.lang3.tuple.ImmutablePair;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.openecomp.sdc.be.model.HeatParameterDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.Operation;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.Service;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.resources.data.ESArtifactData;
import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
import org.openecomp.sdc.be.servlets.RepresentationUtils;
-import org.openecomp.sdc.be.user.IUserBusinessLogic;
import org.openecomp.sdc.be.user.Role;
import org.openecomp.sdc.be.user.UserBusinessLogic;
import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
import org.openecomp.sdc.common.api.ArtifactTypeEnum;
import org.openecomp.sdc.common.api.ConfigurationSource;
+import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
+import org.openecomp.sdc.common.datastructure.Wrapper;
import org.openecomp.sdc.common.impl.ExternalConfiguration;
import org.openecomp.sdc.common.impl.FSConfigurationSource;
import org.openecomp.sdc.exception.ResponseFormat;
-import org.xml.sax.XMLReader;
-import org.openecomp.sdc.be.model.Operation;
-import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
-import org.openecomp.sdc.common.datastructure.Wrapper;
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.JsonElement;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
-import fj.data.Either;
-import mockit.Deencapsulation;
-import java.util.*;
-import org.junit.Assert;
-import org.apache.commons.lang3.tuple.ImmutablePair;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+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;
public class ArtifactsBusinessLogicTest {
@Mock
TitanDao titanDao;
- // public static final InformationDeployedArtifactsBusinessLogic
- // informationDeployedArtifactsBusinessLogic =
- // Mockito.mock(InformationDeployedArtifactsBusinessLogic.class);
-
public static final Resource resource = Mockito.mock(Resource.class);
private Gson gson = new GsonBuilder().setPrettyPrinting().create();
assertNull(heatEnvParam.getCurrentValue());
}
- //////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////new tests///////////////////////////////////////
- /////////////////////////////////////////////////////////////////////////////////
private ArtifactsBusinessLogic createTestSubject() {
return new ArtifactsBusinessLogic();
}
testSubject = createTestSubject();
Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", new Object[] { NodeTemplateOperation.class });
}
-
- // @Test
- // public void convertAndValidateDeploymentArtifactNonHeatSuccess(){
- // ArtifactDefinition createArtifactDef = createArtifactDef();
- // createArtifactDef.setArtifactType(ArtifactTypeEnum.YANG_XML.getType());
- //
- // Either<ArtifactDefinition, ResponseFormat> validateResult = artifactBL
- //
- // assertTrue(validateResult.isLeft());
- // ArtifactDefinition validatedArtifact = validateResult.left().value();
- //
- // assertEquals(createArtifactDef.getArtifactGroupType(),
- // validatedArtifact.getArtifactGroupType());
- // assertEquals(new Integer(0), validatedArtifact.getTimeout());
- // assertFalse(validatedArtifact.getMandatory());
- // assertFalse(validatedArtifact.getServiceApi());
- //
- // }
-
}
package org.openecomp.sdc.be.components.impl;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anySet;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.BiPredicate;
-
+import fj.data.Either;
+import mockit.Deencapsulation;
import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.apache.commons.lang3.tuple.Pair;
import org.assertj.core.util.Lists;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.openecomp.sdc.be.components.validation.UserValidations;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
-import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
-import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.impl.ServletUtils;
import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
import org.openecomp.sdc.be.model.operations.api.IComponentInstanceOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
-import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
-import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
import org.openecomp.sdc.be.user.UserBusinessLogic;
import org.openecomp.sdc.exception.ResponseFormat;
-import org.openecomp.sdc.common.datastructure.Wrapper;
-import fj.data.Either;
-import javassist.CodeConverter.ArrayAccessReplacementMethodNames;
-import mockit.Deencapsulation;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BiPredicate;
-import java.util.*;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anySet;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
/**
* The test suite designed for test functionality of
ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services");
String containerComponentID = "Service-comp";
- String componentInstanceID = "NodeA1";
Service component = new Service();
component.addForwardingPath(createPath("path1", "NodeA1", "NodeB1", "1"));
}
private void getServiceRelationByIdUserValidationFailure(Component component) {
- // Either<User, ActionStatus> eitherCreator =
- // Either.right(ActionStatus.USER_NOT_FOUND);
- // when(userAdmin.getUser(eq(USER_ID),
- // eq(false))).thenReturn(eitherCreator);
when(userValidations.validateUserExists(eq(USER_ID), eq("get relation by Id"), eq(false)))
.thenReturn(Either.right(new ResponseFormat(404)));
Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic
package org.openecomp.sdc.be.components.impl;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import java.io.IOException;
-import java.nio.file.FileSystems;
-import java.nio.file.Files;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
+import fj.data.Either;
import org.junit.Test;
import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
import org.openecomp.sdc.be.components.impl.ImportUtils.ToscaElementTypeEnum;
import org.openecomp.sdc.common.api.ArtifactTypeEnum;
import org.yaml.snakeyaml.Yaml;
-import fj.data.Either;
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
public class ImportUtilsTest {
@Test
}
- // @Test
- // public void testCreateFullHeatParameterModuleWithInvalidType(){
- //
- // String name = "fullParameter";
- // String description = "description_text";
- //
- // Map<String, Object> parametersMap = new HashMap<String, Object>();
- // Map<String, Object> firstParam = createParameterMap("aaa", "aaa",
- // name, description);
- // parametersMap.put(ToscaTagNamesEnum.PARAMETERS.getElementName(),
- // firstParam);
- //
- // Either<List<HeatParameterDefinition>,ResultStatusEnum> heatParameters =
- // ImportUtils.getHeatParameters(parametersMap);
- // assertTrue(heatParameters.isRight());
- // assertEquals(ResultStatusEnum.INVALID_PROPERTY_TYPE,
- // heatParameters.right().value());
- //
- // }
-
@Test
public void testCreateFullHeatParameterModuleWithMissingType() {
package org.openecomp.sdc.be.components.impl;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyObject;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import javax.servlet.ServletContext;
-
+import fj.data.Either;
+import mockit.Deencapsulation;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.junit.Assert;
import org.junit.Before;
import org.slf4j.LoggerFactory;
import org.springframework.web.context.WebApplicationContext;
-import fj.data.Either;
-import mockit.Deencapsulation;
+import javax.servlet.ServletContext;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyObject;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
public class ResourceBusinessLogicTest implements InterfaceOperationTestUtils {
Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
when(toscaOperationFacade.validateComponentNameExists(eq(RESOURCE_NAME), any(ResourceTypeEnum.class),
eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherCount);
- /*
- * when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME,
- * ResourceTypeEnum.VF,
- * ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
- * when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME,
- * ResourceTypeEnum.PNF,
- * ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
- * when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME,
- * ResourceTypeEnum.CR,
- * ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
- */
when(interfaceOperation.updateInterface(anyString(), anyObject()))
.thenReturn(Either.left(mockInterfaceDefinitionToReturn(RESOURCE_NAME)));
Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
assertEquals(resource.getUniqueId(), updateResponse.left().value().getUniqueId());
}
- /* CREATE validations - start ***********************/
- // Resource name - start
@Test
public void testFailedResourceValidations() {
}
- private void testTagsSingleExceedsLimit() {
- Resource resourceExccedsNameLimit = createResourceObject(false);
- String tag1 = "afzs2qLBb5X6tZhiunkcEwiFX1qRQY8YZl3y3Du5M5xeQY5Nq9afcFHDZ9HaURw43gH27nAUWM36bMbMylwTFSzzNV8NO4v4ripe6Q15Vc2nPOFI";
- String tag2 = resourceExccedsNameLimit.getName();
- List<String> tagsList = new ArrayList<String>();
- tagsList.add(tag1);
- tagsList.add(tag2);
-
- resourceExccedsNameLimit.setTags(tagsList);
-
- Either<Resource, ResponseFormat> createResponse = bl.createResource(resourceExccedsNameLimit,
- AuditingActionEnum.CREATE_RESOURCE, user, null, null);
- assertTrue(createResponse.isRight());
- assertResponse(createResponse, ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT,
- "" + ValidationUtils.TAG_MAX_LENGTH);
-
- }
-
private void testTagsNoServiceName() {
Resource serviceExccedsNameLimit = createResourceObject(false);
String tag1 = "afzs2qLBb";
assertTrue(validatePropertiesDefaultValues.isRight());
}
- // @Test
- // public void testDeleteMarkedResourcesNoResources() {
- // List<GraphVertex> ids = new ArrayList<>();
- // Either<List<GraphVertex>, StorageOperationStatus> eitherNoResources =
- // Either.left(ids);
- // when(topologyTemplateOperation.getAllComponentsMarkedForDeletion(ComponentTypeEnum.RESOURCE)).thenReturn(eitherNoResources);
- //
- // Either<List<String>, ResponseFormat> deleteMarkedResources =
- // bl.deleteMarkedComponents();
- // assertTrue(deleteMarkedResources.isLeft());
- // assertTrue(deleteMarkedResources.left().value().isEmpty());
- //
- // Mockito.verify(artifactManager,
- // Mockito.times(0)).deleteAllComponentArtifactsIfNotOnGraph(Mockito.anyList());
- //
- // }
- //
- // @Test
- // public void testDeleteMarkedResources() {
- // List<String> ids = new ArrayList<String>();
- // String resourceInUse = "123";
- // ids.add(resourceInUse);
- // String resourceFree = "456";
- // ids.add(resourceFree);
- // Either<List<String>, StorageOperationStatus> eitherNoResources =
- // Either.left(ids);
- // when(toscaOperationFacade.getAllComponentsMarkedForDeletion()).thenReturn(eitherNoResources);
- //
- // Either<Boolean, StorageOperationStatus> resourceInUseResponse =
- // Either.left(true);
- // Either<Boolean, StorageOperationStatus> resourceFreeResponse =
- // Either.left(false);
- //
- // List<ArtifactDefinition> artifacts = new ArrayList<ArtifactDefinition>();
- // Either<List<ArtifactDefinition>, StorageOperationStatus>
- // getArtifactsResponse = Either.left(artifacts);
- // when(toscaOperationFacade.getComponentArtifactsForDelete(resourceFree,
- // NodeTypeEnum.Resource, true)).thenReturn(getArtifactsResponse);
- //
- // when(toscaOperationFacade.isComponentInUse(resourceFree)).thenReturn(resourceFreeResponse);
- // when(toscaOperationFacade.isComponentInUse(resourceInUse)).thenReturn(resourceInUseResponse);
- //
- // Either<Component, StorageOperationStatus> eitherDelete = Either.left(new
- // Resource());
- // when(toscaOperationFacade.deleteToscaComponent(resourceFree)).thenReturn(eitherDelete);
- //
- // when(artifactManager.deleteAllComponentArtifactsIfNotOnGraph(artifacts)).thenReturn(StorageOperationStatus.OK);
- // List<String> deletedComponents = new ArrayList<>();
- // deletedComponents.add(resourceFree);
- // when(toscaOperationFacade.deleteMarkedElements(ComponentTypeEnum.RESOURCE)).thenReturn(Either.left(deletedComponents));
- //
- // Either<List<String>, ResponseFormat> deleteMarkedResources =
- // bl.deleteMarkedComponents();
- // assertTrue(deleteMarkedResources.isLeft());
- // List<String> resourceIdList = deleteMarkedResources.left().value();
- // assertFalse(resourceIdList.isEmpty());
- // assertTrue(resourceIdList.contains(resourceFree));
- // assertFalse(resourceIdList.contains(resourceInUse));
- //
- // Mockito.verify(artifactManager,
- // Mockito.times(1)).deleteAllComponentArtifactsIfNotOnGraph(artifacts);
- // }
@SuppressWarnings("unchecked")
@Test
public void testValidateDerivedFromNotEmpty() throws Exception {
ResourceBusinessLogic testSubject;
Resource resource = createResourceObject(true);
- ;
AuditingActionEnum actionEnum = AuditingActionEnum.ADD_ECOMP_USER_CREDENTIALS;
Either<Boolean, ResponseFormat> result;
package org.openecomp.sdc.be.components.impl;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import java.util.ArrayList;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
+import fj.data.Either;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.openecomp.sdc.common.impl.FSConfigurationSource;
import org.openecomp.sdc.exception.ResponseFormat;
-import fj.data.Either;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
public class ResourceInstanceBusinessLogicTest {
@Before
public void initMocks() {
MockitoAnnotations.initMocks(this);
-// Mockito.reset(artifactBusinessLogic, serviceOperation, componentsUtils, userAdminManager);
setup();
}
Map<String, ArtifactDefinition> deploymentArtifacts = resourceInstance.getDeploymentArtifacts();
assertNotNull(deploymentArtifacts);
-// assertTrue(deploymentArtifacts.size() == 2);
ArtifactDefinition heatDefinition = deploymentArtifacts.get(HEAT_LABEL.toLowerCase());
assertNotNull(heatDefinition);
-// assertEquals(getHeatArtifactDefinition(USER_ID, RESOURCE_ID_WITH_HEAT_PARAMS, HEAT_LABEL, ARTIFACT_CREATION_TIME, false, true), heatDefinition);
-//
-// ArtifactDefinition heatEnvDefinition = deploymentArtifacts.get(HEAT_ENV_LABEL.toLowerCase());
-// assertNotNull(heatEnvDefinition);
-//
-// List<HeatParameterDefinition> heatParameters = heatDefinition.getListHeatParameters();
-// assertNotNull(heatParameters);
-//
-// List<HeatParameterDefinition> heatEnvParameters = heatEnvDefinition.getListHeatParameters();
-// assertNotNull(heatEnvParameters);
-//
-// assertEquals(heatParameters.size(), heatEnvParameters.size());
-//
-// int index = 0;
-// for (HeatParameterDefinition heatEnvParameter : heatEnvParameters) {
-// HeatParameterDefinition heatParameterDefinition = heatParameters.get(index);
-// assertEquals(heatEnvParameter.getUniqueId(), heatParameterDefinition.getUniqueId());
-// assertEquals(heatEnvParameter.getType(), heatParameterDefinition.getType());
-// assertEquals(heatEnvParameter.getName(), heatParameterDefinition.getName());
-// assertEquals(heatEnvParameter.getDescription(), heatParameterDefinition.getDescription());
-// assertEquals(heatEnvParameter.getCurrentValue(), heatParameterDefinition.getCurrentValue());
-// // current of heat parameter should be the default for heat env
-// // parameter
-// assertEquals(heatEnvParameter.getDefaultValue(), heatParameterDefinition.getCurrentValue());
-//
-// index++;
-// }
}
@Test
Map<String, ArtifactDefinition> deploymentArtifacts = resourceInstance.getDeploymentArtifacts();
assertNotNull(deploymentArtifacts);
-// assertTrue(deploymentArtifacts.size() == 2);
ArtifactDefinition heatDefinition = deploymentArtifacts.get(HEAT_LABEL.toLowerCase());
assertNotNull(heatDefinition);
-// assertEquals(getHeatArtifactDefinition(USER_ID, RESOURCE_ID_NO_HEAT_PARAMS, HEAT_LABEL, ARTIFACT_CREATION_TIME, false, false), heatDefinition);
-
-// ArtifactDefinition heatEnvDefinition = deploymentArtifacts.get(HEAT_ENV_LABEL.toLowerCase());
-// assertNotNull(heatEnvDefinition);
List<HeatParameterDefinition> heatParameters = heatDefinition.getListHeatParameters();
assertNull(heatParameters);
-// List<HeatParameterDefinition> heatEnvParameters = heatEnvDefinition.getListHeatParameters();
-// assertNull(heatEnvParameters);
-
}
@SuppressWarnings("unchecked")
artifactInfo.setUserIdCreator(userId);
String fullName = "Jim H";
artifactInfo.setUpdaterFullName(fullName);
- // long time = System.currentTimeMillis();
artifactInfo.setCreatorFullName(fullName);
artifactInfo.setCreationDate(time);
artifactInfo.setLastUpdateDate(time);
package org.openecomp.sdc.be.components.lifecycle;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
-
-import java.util.ArrayList;
-import java.util.List;
-
+import fj.data.Either;
import org.apache.http.HttpStatus;
import org.junit.Before;
import org.junit.Test;
import org.openecomp.sdc.be.user.Role;
import org.openecomp.sdc.exception.ResponseFormat;
-import fj.data.Either;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.Silent.class)
public class CertificationRequestTest extends LifecycleTestBase {
public void setup() {
super.setup();
rfcObj = new CertificationRequestTransition(componentsUtils, toscaElementLifecycleOperation, serviceDistributionArtifactsBuilder, serviceBusinessLogic, capabilityOperation, toscaExportUtils, toscaOperationFacade, titanDao);
- // checkout transition object
-// rfcObj.setLifeCycleOperation(toscaElementLifecycleOperation);
- // checkoutObj.setAuditingManager(iAuditingManager);
rfcObj.setConfigurationManager(configurationManager);
-
-// Either<ToscaRepresentation, ToscaError> either = Either.left(toscaRepresentation);
-// when(toscaExportUtils.exportComponent(Mockito.any())).thenReturn(either);
-
}
@Test
Either<User, ResponseFormat> ownerResponse = rfcObj.getComponentOwner(resource, ComponentTypeEnum.RESOURCE);
assertTrue(ownerResponse.isLeft());
User owner = ownerResponse.left().value();
- // changeStateResult = rfcObj.changeStateOperation(resource, user,
- // owner, false);
changeStateResult = rfcObj.changeState(ComponentTypeEnum.RESOURCE, resource, serviceBusinessLogic, user, owner, false, false);
assertEquals(changeStateResult.isLeft(), true);
resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
- // changeStateResult = rfcObj.changeStateOperation(resource, user,
- // owner, false);
changeStateResult = rfcObj.changeState(ComponentTypeEnum.RESOURCE, resource, serviceBusinessLogic, user, owner, false, false);
assertEquals(changeStateResult.isLeft(), true);
}
package org.openecomp.sdc.be.components.lifecycle;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
+import fj.data.Either;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.openecomp.sdc.be.user.Role;
import org.openecomp.sdc.exception.ResponseFormat;
-import fj.data.Either;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
public class CheckoutTest extends LifecycleTestBase {
Either<User, ResponseFormat> ownerResponse = checkoutObj.getComponentOwner(resource, ComponentTypeEnum.RESOURCE);
assertTrue(ownerResponse.isLeft());
User owner = ownerResponse.left().value();
- // changeStateResult = checkoutObj.changeStateOperation(resource, user,
- // owner);
Either<Boolean, ResponseFormat> validateBeforeTransition = checkoutObj.validateBeforeTransition(resource, ComponentTypeEnum.RESOURCE, user, owner, LifecycleStateEnum.READY_FOR_CERTIFICATION);
assertEquals(validateBeforeTransition.isLeft(), true);
// admin
modifier.setRole(Role.ADMIN.name());
- // changeStateResult = checkoutObj.changeStateOperation(resource, user,
- // owner);
validateBeforeTransition = checkoutObj.validateBeforeTransition(resource, ComponentTypeEnum.RESOURCE, modifier, owner, LifecycleStateEnum.READY_FOR_CERTIFICATION);
assertEquals(validateBeforeTransition.isLeft(), true);
Either<User, ResponseFormat> ownerResponse = checkoutObj.getComponentOwner(resource, ComponentTypeEnum.RESOURCE);
assertTrue(ownerResponse.isLeft());
User owner = ownerResponse.left().value();
- // changeStateResult = checkoutObj.changeStateOperation(resource,
- // modifier, owner);
Either<Boolean, ResponseFormat> validateBeforeTransition = checkoutObj.validateBeforeTransition(resource, ComponentTypeEnum.RESOURCE, modifier, owner, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
assertEquals(validateBeforeTransition.isLeft(), true);
modifier.setRole(Role.TESTER.name());
- // changeStateResult = checkoutObj.changeStateOperation(resource,
- // modifier, owner);
validateBeforeTransition = checkoutObj.validateBeforeTransition(resource, ComponentTypeEnum.RESOURCE, modifier, owner, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
assertEquals(validateBeforeTransition.isRight(), true);
changeStateResult = Either.right(validateBeforeTransition.right().value());
package org.openecomp.sdc.be.components.lifecycle;
-import static org.mockito.Mockito.when;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import javax.servlet.ServletContext;
-
+import fj.data.Either;
import org.junit.BeforeClass;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
import org.slf4j.LoggerFactory;
import org.springframework.web.context.WebApplicationContext;
-import fj.data.Either;
+import javax.servlet.ServletContext;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.Mockito.when;
public class LifecycleTestBase {
private static final Logger log = LoggerFactory.getLogger(LifecycleTestBase.class);
public void setup() {
-// ExternalConfiguration.setAppName("catalog-be");
-//
-// // init Configuration
-// String appConfigDir = "src/test/resources/config/catalog-be";
-// ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
-// configurationManager = new ConfigurationManager(configurationSource);
-
-
// User data and management
user = new User();
user.setUserId("jh003");
when(webAppContext.getBean(ToscaElementLifecycleOperation.class)).thenReturn(toscaElementLifecycleOperation);
when(webAppContext.getBean(ArtifactsBusinessLogic.class)).thenReturn(artifactsManager);
- // Resource Operation mock methods
- // getCount
-
// createResource
resourceResponse = createResourceObject();
Either<ToscaElement, StorageOperationStatus> eitherComponent = Either.left(ModelConverter.convertToToscaElement(resourceResponse));
package org.openecomp.sdc.be.components.merge.instance;
-import static org.mockito.Mockito.when;
-
-import java.util.Arrays;
-import java.util.List;
-
+import fj.data.Either;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
-import fj.data.Either;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.mockito.Mockito.when;
public class ComponentCapabilitiesPropertiesMergeBLTest {
@Test
public void testDescription() throws Exception {
- // ComponentCapabilitiesPropertiesMergeBL testSubject;
String result;
- // default test
- // testSubject = createTestSubject();
result = testSubject.description();
}
@Test
public void testMergeComponents() throws Exception {
- // ComponentCapabilitiesPropertiesMergeBL testSubject;
Component prevComponent = ObjectGenerator.buildResourceWithComponentInstance("mock3");
Component currentComponent = ObjectGenerator.buildResourceWithComponentInstance("mock1", "mock2");
currentComponent.setUniqueId("mock");
@Test
public void testMergeComponentInstanceCapabilities() throws Exception {
- // ComponentCapabilitiesPropertiesMergeBL testSubject;
Component currentComponent = null;
Component origInstanceCmpt = null;
String instanceId = "";
List<CapabilityDefinition> prevInstanceCapabilities = null;
ActionStatus result;
- // default test
- // testSubject = createTestSubject();
result = testSubject.mergeComponentInstanceCapabilities(currentComponent, origInstanceCmpt, instanceId,
prevInstanceCapabilities);
package org.openecomp.sdc.be.components.path;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
+import com.google.common.collect.Lists;
+import fj.data.Either;
import org.junit.Before;
import org.openecomp.sdc.be.components.BeConfDependentTest;
import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
import org.openecomp.sdc.exception.ResponseFormat;
import org.springframework.beans.factory.annotation.Autowired;
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
-import fj.data.Either;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
public class BaseForwardingPathTest extends BeConfDependentTest implements ForwardingPathTestUtils {
Either<Service, ResponseFormat> serviceCreateResult = bl.createService(createTestService(), user);
assertTrue("Failed to create service", serviceCreateResult.isLeft());
Service service = serviceCreateResult.left().value();
-// ComponentInstance componentInstance = new ComponentInstance();
-// componentInstance.setName("Test1");
-// componentInstance.setNormalizedName("Test1");
-// componentInstance.setUniqueId("Test1");
-// componentInstance.setInputValueCounter(1);
-// componentInstance.setAttributeValueCounter(1);
-// componentInstance.setIcon("network");
-// componentInstance.setComponentVersion("1.0");
-// componentInstance.setIsProxy(true);
-// componentInstance.setComponentUid(service.getUniqueId());
-// componentInstance.setPropertyValueCounter(1);
-// componentInstance.setPosX("333");
-// componentInstance.setPosY("333");
-// componentInstance.setOriginType(OriginTypeEnum.VF);
-//
-// Either<ComponentInstance, ResponseFormat> instanceResult = serviceComponentInstanceBusinessLogic.createComponentInstance("services", service.getUniqueId(), user.getUserId(), componentInstance);
-// assertTrue("Failed to create instance", instanceResult.isLeft());
return service;
}
}
package org.openecomp.sdc.be.datamodel.utils;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-import org.junit.Assert;
import org.junit.Test;
import org.openecomp.sdc.be.info.ArtifactTemplateInfo;
import org.openecomp.sdc.be.model.ArtifactDefinition;
import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
public class ArtifactUtilsTest {
private ArtifactUtils createTestSubject() {
artifactId = null;
result = ArtifactUtils.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
label, displayName, description, artifactContentent, updatedRequiredArtifacts, isFromCsar);
-
- // test 2
- /*artifactId = "";
- result = ArtifactUtils.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
- label, displayName, description, artifactContentent, updatedRequiredArtifacts, isFromCsar);
- Assert.assertEquals(null, result);*/
}
@Test
result = testSubject.getAvailableRoles();
}
- /*@Test
- public void testPushUserRole() throws Exception {
- EcompIntImpl testSubject;
- String loginId = "";
- List<EcompRole> roles = null;
-
- // test 1
- testSubject = createTestSubject();
- roles = null;
- testSubject.pushUserRole(loginId, roles);
- }*/
-
@Test(expected=PortalAPIException.class)
public void testGetUserRoles() throws Exception {
EcompIntImpl testSubject;
+++ /dev/null
-//package org.openecomp.sdc.be.servlets;
-//
-//import com.fasterxml.jackson.databind.DeserializationFeature;
-//import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider;
-//import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
-//import fj.data.Either;
-//import org.eclipse.jetty.http.HttpStatus;
-//import org.glassfish.hk2.utilities.binding.AbstractBinder;
-//import org.glassfish.jersey.client.ClientConfig;
-//import org.glassfish.jersey.server.ResourceConfig;
-//import org.glassfish.jersey.test.JerseyTest;
-//import org.glassfish.jersey.test.TestProperties;
-//import org.junit.Before;
-//import org.junit.Test;
-//import org.junit.runner.RunWith;
-//import org.mockito.Mock;
-//import org.mockito.junit.MockitoJUnitRunner;
-//import org.openecomp.sdc.be.DummyConfigurationManager;
-//import org.openecomp.sdc.be.components.impl.GroupBusinessLogic;
-//import org.openecomp.sdc.be.dao.api.ActionStatus;
-//import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
-//import org.openecomp.sdc.be.impl.ComponentsUtils;
-//import org.openecomp.sdc.be.impl.ServletUtils;
-//import org.openecomp.sdc.be.impl.WebAppContextWrapper;
-//import org.openecomp.sdc.be.info.GroupDefinitionInfo;
-//import org.openecomp.sdc.be.model.GroupDefinition;
-//import org.openecomp.sdc.common.api.Constants;
-//import org.openecomp.sdc.exception.ResponseFormat;
-//import org.springframework.web.context.WebApplicationContext;
-//
-//import javax.servlet.ServletContext;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpSession;
-//import javax.ws.rs.client.ClientBuilder;
-//import javax.ws.rs.client.Invocation;
-//import javax.ws.rs.core.Application;
-//import javax.ws.rs.core.MediaType;
-//import javax.ws.rs.core.Response;
-//
-//import static org.assertj.core.api.Assertions.assertThat;
-//import static org.junit.Assert.assertEquals;
-//import static org.mockito.ArgumentMatchers.*;
-//import static org.mockito.Mockito.when;
-//
-//@RunWith(MockitoJUnitRunner.class)
-//public class GroupEndpointTest extends JerseyTest {
-//
-// public static final String USER_ID = "jh0003";
-// public static final String INVALID_USER_ID = "jh0001";
-// final static String RESOURCE_TYPE = "resources";
-// private static final String COMPONENT_ID = "1234";
-// private static final String VALID_GROUP_ID = "1";
-// private static final String INVALID_GROUP_ID = "2";
-// private static final String NEW_GROUP_NAME = "new group";
-// private static final String VALID_GROUP_TYPE = "networkConnection";
-//
-// @Mock
-// private GroupBusinessLogic groupBusinessLogic;
-// @Mock
-// private ServletContext servletContext;
-// @Mock
-// private WebAppContextWrapper webAppContextWrapper;
-// @Mock
-// private WebApplicationContext webApplicationContext;
-// @Mock
-// private HttpServletRequest request;
-// @Mock
-// private HttpSession session;
-// @Mock
-// private ComponentsUtils componentUtils;
-// @Mock
-// private ServletUtils servletUtils;
-// @Mock
-// private ResponseFormat responseFormat;
-//
-// @Override
-// protected Application configure() {
-// ResourceConfig resourceConfig = new ResourceConfig()
-// .register(GroupServlet.class)
-// //.register(mapper)
-// ;
-// forceSet(TestProperties.CONTAINER_PORT, "0");
-// resourceConfig.register(new AbstractBinder() {
-// @Override
-// protected void configure() {
-// bind(request).to(HttpServletRequest.class);
-// }
-// });
-// return resourceConfig;
-// }
-//
-// @Before
-// public void before() {
-// when(request.getSession()).thenReturn(session);
-// when(session.getServletContext()).thenReturn(servletContext);
-// when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
-// when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webApplicationContext);
-// when(webApplicationContext.getBean(GroupBusinessLogic.class)).thenReturn(groupBusinessLogic);
-//// when(webApplicationContext.getBean(ComponentsUtils.class)).thenReturn(componentUtils);
-// when(webApplicationContext.getBean(ServletUtils.class)).thenReturn(servletUtils);
-// when(servletUtils.getComponentsUtils()).thenReturn(componentUtils);
-//// when(request.getHeader("USER_ID")).thenReturn(USER_ID);
-// final JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
-// setClient(ClientBuilder.newClient(new ClientConfig(jacksonJsonProvider)));
-// new DummyConfigurationManager();
-//// when(ConfigurationManager.getConfigurationManager().getConfiguration().getExcludedGroupTypesMapping()).thenReturn(buildExcludePolicyTypesMap());
-// }
-//
-// //@Test
-// public void createGroup() {
-// GroupDefinition groupDefinition = new GroupDefinition();
-// groupDefinition.setName(NEW_GROUP_NAME);
-// groupDefinition.setType(VALID_GROUP_TYPE);
-// when(groupBusinessLogic.createGroup(eq(NEW_GROUP_NAME), eq(ComponentTypeEnum.RESOURCE), eq(COMPONENT_ID), eq(USER_ID)))
-// .thenReturn(groupDefinition);
-// //List<GroupDefinition> gdList = buildCreateGroupCall().post(Response.class);
-//
-// }
-//
-// //@Test
-// public void deleteGroup_withInvalidUser_shouldReturn_401() {
-// int unauthorized401 = HttpStatus.UNAUTHORIZED_401;
-// int unauthorized403 = HttpStatus.FORBIDDEN_403;
-// when(groupBusinessLogic.validateUserExists(eq(INVALID_USER_ID), anyString(), anyBoolean()))
-// .thenReturn(Either.right(new ResponseFormat(unauthorized401)));
-//
-// Response response = buildDeleteGroupCall(INVALID_USER_ID, VALID_GROUP_ID).delete();
-// assertThat(response.getStatus()).isEqualTo(unauthorized401);
-// }
-//
-// @Test
-// public void getGroupById_internalServerError() {
-// when(groupBusinessLogic.getGroupWithArtifactsById(eq(ComponentTypeEnum.RESOURCE), eq(COMPONENT_ID), eq(VALID_GROUP_ID), eq(USER_ID), eq(false) ))
-// .thenReturn(Either.right(new ResponseFormat(HttpStatus.INTERNAL_SERVER_ERROR_500)));
-// Response response = buildGetGroupCall(VALID_GROUP_ID).get();
-// assertEquals(response.getStatus(), 500);
-// }
-//
-// @Test
-// public void getGroupById_Success() {
-// GroupDefinitionInfo groupDefinitionInfo = new GroupDefinitionInfo();
-// groupDefinitionInfo.setUniqueId(VALID_GROUP_ID);
-// when(groupBusinessLogic.getGroupWithArtifactsById(eq(ComponentTypeEnum.RESOURCE), eq(COMPONENT_ID), eq(VALID_GROUP_ID), eq(USER_ID), eq(false) ))
-// .thenReturn(Either.left(groupDefinitionInfo));
-// when(componentUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
-// when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200);
-// GroupDefinitionInfo gdi = buildGetGroupCall(VALID_GROUP_ID).get(GroupDefinitionInfo.class);
-// assertEquals(gdi.getUniqueId(), VALID_GROUP_ID);
-// }
-//
-// @Test
-// public void getGroupById_Failure() {
-// when(groupBusinessLogic.getGroupWithArtifactsById(eq(ComponentTypeEnum.RESOURCE), eq(COMPONENT_ID), eq(INVALID_GROUP_ID), eq(USER_ID), eq(false) ))
-// .thenReturn(Either.right(new ResponseFormat(HttpStatus.NOT_FOUND_404)));
-// Response response = buildGetGroupCall(INVALID_GROUP_ID).get();
-// assertEquals(response.getStatus(), 404);
-// }
-//
-// private Invocation.Builder buildGetGroupCall(String groupId) {
-// String path = "/v1/catalog/" + RESOURCE_TYPE + "/" + COMPONENT_ID + "/groups/" + groupId;
-// return target(path)
-// .request(MediaType.APPLICATION_JSON)
-// .header(Constants.USER_ID_HEADER, USER_ID);
-// }
-//
-// private Invocation.Builder buildDeleteGroupCall(String userId, String groupId) {
-// String path = "/v1/catalog/" + RESOURCE_TYPE + "/" + COMPONENT_ID + "/groups/" + groupId;
-// return target(path)
-// .request(MediaType.APPLICATION_JSON)
-// .header(Constants.USER_ID_HEADER, userId);
-// }
-//
-// private Invocation.Builder buildCreateGroupCall() {
-// String path = "/v1/catalog/" + RESOURCE_TYPE + "/" + COMPONENT_ID + "/groups";
-// return target(path)
-// .request(MediaType.APPLICATION_JSON)
-// .header(Constants.USER_ID_HEADER, USER_ID);
-// }
-//}
package org.openecomp.sdc.be.servlets;
-import static java.util.Arrays.asList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Stream;
-
-import javax.ws.rs.client.Invocation;
-import javax.ws.rs.core.GenericType;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Sets;
+import fj.data.Either;
import org.glassfish.jersey.client.ClientConfig;
import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider;
import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
import org.glassfish.jersey.server.ResourceConfig;
import org.junit.Before;
import org.junit.BeforeClass;
-import org.junit.Ignore;
import org.junit.Test;
import org.openecomp.sdc.be.DummyConfigurationManager;
import org.openecomp.sdc.be.components.impl.GroupTypeBusinessLogic;
import org.openecomp.sdc.be.components.utils.GroupTypeBuilder;
import org.openecomp.sdc.be.components.validation.UserValidations;
import org.openecomp.sdc.be.config.ConfigurationManager;
-import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.model.GroupTypeDefinition;
import org.openecomp.sdc.be.model.User;
-import org.openecomp.sdc.be.model.operations.StorageException;
-import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
import org.openecomp.sdc.common.api.Constants;
-import org.openecomp.sdc.exception.ResponseFormat;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
-import org.springframework.http.HttpStatus;
-import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Sets;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.MediaType;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
-import fj.data.Either;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
public class GroupTypesEndpointTest extends JerseySpringBaseTest {
verifyGroupTypesList(testConfigGroupTypes, fetchedGroupTypes);
}
- @Ignore
- public void getGroupTypes_dbError() {
- when(groupTypeOperation.getAllGroupTypes(EXCLUDED_TYPES)).thenThrow(new StorageException(StorageOperationStatus.NOT_FOUND));
- when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND)).thenReturn(ActionStatus.RESOURCE_NOT_FOUND);
- when(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND)).thenReturn(new ResponseFormat(HttpStatus.NOT_FOUND.value()));
- Response response = buildGetGroupTypesCall(USER_ID).get();
- assertThat(response.getStatus()).isEqualTo(HttpStatus.NOT_FOUND.value());
- }
-
- // TODO: simulate proper error with configuration error mapping and eactivate the test
- @Ignore
- public void getGroupTypes_invalidUser_Failure() {
- when(groupTypeOperation.getAllGroupTypes(EXCLUDED_TYPES)).thenReturn(buildGroupTypesList());
- Response response = buildGetGroupTypesCall(INVALID_USER_ID).get();
- assertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST.value());
- }
-
private void verifyGroupTypesList(List<GroupTypeDefinition> groupTypes, List<GroupTypeDefinition> fetchedGroupTypes) {
assertThat(fetchedGroupTypes)
.usingElementComparatorOnFields("version", "type", "uniqueId")
package org.openecomp.sdc.be.servlets;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
-
-import javax.servlet.ServletContext;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpSession;
-import javax.ws.rs.core.Application;
-
+import com.google.gson.Gson;
+import fj.data.Either;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.springframework.http.HttpStatus;
import org.springframework.web.context.WebApplicationContext;
-import com.google.gson.Gson;
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+import javax.ws.rs.core.Application;
-import fj.data.Either;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
public class UserAdminServletTest extends JerseyTest {
when(request.getHeader("USER_ID")).thenReturn(ADMIN_ATT_UID);
}
- /*
- * @Test public void deactivateUserSuccessfullyTest(){ String userToDeleteUserId = "admin1"; User adminUser = new User(); adminUser.setUserId(ADMIN_ATT_UID); Either<User, ActionStatus> eitherActiveUser = buildEitherUser(userToDeleteUserId, true);
- * User userToDelete = eitherActiveUser.left().value(); doReturn(eitherActiveUser).when(userAdminManager).getUser( userToDeleteUserId);
- *
- * Either<User, ActionStatus> eitherInactiveUser = buildEitherUser(userToDeleteUserId, false); doReturn(eitherInactiveUser).when(userAdminManager).deActivateUser( adminUser, userToDelete.getUserId());
- *
- *
- * Response response = target().path("/v1/user/"+userToDeleteUserId).request().delete(); assertTrue(response.getStatus() == HttpStatus.OK.value()); verify(userAdminManager, times(1)).deActivateUser(adminUser, userToDelete.getUserId()); }
- *
- *
- * @Test public void forceDeleteUserSuccessfullyTest(){ String userToDeleteUserId = "admin1"; when(request.getHeader(User.FORCE_DELETE_HEADER_FLAG)).thenReturn(User. FORCE_DELETE_HEADER_FLAG);
- *
- * User adminUser = new User(); adminUser.setUserId(ADMIN_ATT_UID);
- *
- * Either<User, ActionStatus> eitherActiveUser = buildEitherUser(userToDeleteUserId, true); User userToDelete = eitherActiveUser.left().value(); doReturn(eitherActiveUser).when(userAdminManager).getUser( userToDeleteUserId);
- *
- * Either<User, ActionStatus> eitherUser = buildEitherUser(userToDeleteUserId, true); doReturn(eitherUser).when(userAdminManager).deleteUser(userToDelete. getUserId());
- *
- *
- * Response response = target().path("/v1/user/"+userToDeleteUserId).request().delete(); assertTrue(response.getStatus() == HttpStatus.OK.value()); verify(userAdminManager, times(0)).deActivateUser(adminUser, userToDelete.getUserId());
- * verify(userAdminManager, times(1)).deleteUser(userToDelete.getUserId()); }
- */
-
@Override
protected Application configure() {
package org.openecomp.sdc.common.transaction.mngr;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
+import fj.data.Either;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.openecomp.sdc.common.transaction.api.TransactionUtils.TransactionStatusEnum;
import org.slf4j.Logger;
-import fj.data.Either;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
public class SdncTransactionTest {
private static ESCatalogDAO esCatalogDao = Mockito.mock(ESCatalogDAO.class);
TransactionCodeEnum finishTransaction = tx.finishTransaction();
assertTrue(finishTransaction == TransactionCodeEnum.TRANSACTION_CLOSED);
- // verify(log).error(LogMessages.COMMIT_ON_CLOSED_TRANSACTION,
- // transactionId, TransactionStatusEnum.CLOSED.name(),
- // TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.COMMIT_ON_CLOSED_TRANSACTION, transactionId, TransactionStatusEnum.CLOSED.name(), TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
assertTrue(doBasicTitanAction.isRight());
assertTrue(tx.getStatus() != TransactionStatusEnum.OPEN);
verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.DOUBLE_FINISH_FLAG_ACTION, transactionId, DBTypeEnum.TITAN.name(), TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
- // verify(log).error( LogMessages.DOUBLE_FINISH_FLAG_ACTION,
- // transactionId, DBTypeEnum.TITAN.name(), TransactionUtils.DUMMY_USER,
- // ActionTypeEnum.ADD_ARTIFACT.name());
}
@Test
assertTrue(eitherGeneralDBAction.right().value() == TransactionCodeEnum.TRANSACTION_CLOSED);
assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
- // verify(log, times(3)).error(LogMessages.ACTION_ON_CLOSED_TRANSACTION,
- // transactionId, TransactionUtils.DUMMY_USER,
- // ActionTypeEnum.ADD_ARTIFACT.name());
verify(log, times(3)).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.ACTION_ON_CLOSED_TRANSACTION, transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
}
assertTrue(eitherTransactionResult.isRight());
assertTrue(eitherTransactionResult.right().value() == TransactionCodeEnum.ROLLBACK_SUCCESS);
assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
- // verify(log).error(LogMessages.DB_ACTION_FAILED_WITH_EXCEPTION,
- // DBTypeEnum.TITAN.name(), transactionId, crushMessage,
- // TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.DB_ACTION_FAILED_WITH_EXCEPTION, DBTypeEnum.TITAN.name(), transactionId, crushMessage, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log, times(1)).debug(LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
assertTrue(eitherTransactionResult.isRight());
assertTrue(tx.getStatus() == TransactionStatusEnum.FAILED_ROLLBACK);
assertTrue(eitherTransactionResult.right().value() == TransactionCodeEnum.ROLLBACK_FAILED);
- // verify(log).error(LogMessages.DB_ACTION_FAILED_WITH_EXCEPTION,
- // DBTypeEnum.TITAN.name(), transactionId, crushMessage,
- // TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.DB_ACTION_FAILED_WITH_EXCEPTION, DBTypeEnum.TITAN.name(), transactionId, crushMessage, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log, times(1)).debug(LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log, times(1)).debug(LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
-
- // verify(log, times(1)).error(LogMessages.ROLLBACK_FAILED_GENERAL,
- // transactionId, TransactionUtils.DUMMY_USER,
- // ActionTypeEnum.ADD_ARTIFACT.name());
- // verify(log, times(1)).error(TransactionUtils.TRANSACTION_MARKER,
- // LogMessages.ROLLBACK_FAILED_GENERAL, transactionId,
- // TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
}
@Test
verify(log, times(1)).debug(LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
-
- // verify(log).error(LogMessages.ROLLBACK_FAILED_ON_DB_WITH_EXCEPTION,
- // transactionId, DBTypeEnum.ELASTIC_SEARCH.name(), esError,
- // TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
- // verify(log).error(TransactionUtils.TRANSACTION_MARKER,
- // LogMessages.ROLLBACK_FAILED_ON_DB_WITH_EXCEPTION, transactionId,
- // DBTypeEnum.ELASTIC_SEARCH.name(), esError,
- // TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
-
- // verify(log, times(1)).error(LogMessages.ROLLBACK_FAILED_GENERAL,
- // transactionId, TransactionUtils.DUMMY_USER,
- // ActionTypeEnum.ADD_ARTIFACT.name());
- // verify(log, times(1)).error(TransactionUtils.TRANSACTION_MARKER,
- // LogMessages.ROLLBACK_FAILED_GENERAL, transactionId,
- // TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
}
@Test
assertTrue(eitherResult.right().value() == TransactionCodeEnum.ROLLBACK_SUCCESS);
assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
- // verify(log).error(LogMessages.DB_ACTION_FAILED_WITH_EXCEPTION,
- // DBTypeEnum.MYSTERY.name(), transactionId, crushMessage,
- // TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.DB_ACTION_FAILED_WITH_EXCEPTION, DBTypeEnum.MYSTERY.name(), transactionId, crushMessage, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
verify(log, times(2)).debug(LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.MYSTERY.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
private ESArtifactData createDummyArtifactData() {
String strData = "qweqwqweqw34e4wrwer";
- String myNodeType = "MyNewNodeType";
ESArtifactData arData = new ESArtifactData("artifactNewMarina11", strData.getBytes());
return arData;
}
Code Review / sdc.git / commitdiff