package org.openecomp.sdc.be.impl;
import fj.data.Either;
-import junit.framework.Assert;
+import java.util.ArrayList;
import org.apache.tinkerpop.gremlin.structure.T;
import org.junit.Before;
import org.junit.Test;
import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.model.GroupTypeDefinition;
import org.openecomp.sdc.be.model.PolicyTypeDefinition;
+import org.openecomp.sdc.be.model.RequirementDefinition;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
}
@Test
- public void testGetAuditingManager() throws Exception {
+ public void testGetAuditingManager() {
ComponentsUtils testSubject;
AuditingManager result;
// default test
testSubject = createTestSubject();
result = testSubject.getAuditingManager();
+ assertThat(result).isInstanceOf(AuditingManager.class);
}
@Test
- public void testGetResponseFormat() throws Exception {
+ public void testGetResponseFormat() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
String[] params = new String[] { "" };
// default test
testSubject = createTestSubject();
result = testSubject.getResponseFormat(actionStatus, params);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus().toString().startsWith("2")).isTrue();
}
@Test
- public void testGetResponseFormat_1() throws Exception {
+ public void testGetResponseFormat_1() {
ComponentsUtils testSubject;
StorageOperationStatus storageStatus = null;
String[] params = new String[] { "" };
// default test
testSubject = createTestSubject();
result = testSubject.getResponseFormat(storageStatus, params);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus().toString().startsWith("5")).isTrue();
}
@Test
- public void testConvertToResponseFormatOrNotFoundErrorToEmptyList() throws Exception {
+ public void testConvertToResponseFormatOrNotFoundErrorToEmptyList() {
ComponentsUtils testSubject;
StorageOperationStatus storageOperationStatus = StorageOperationStatus.ARTIFACT_NOT_FOUND;
Either<List<T>, ResponseFormat> result;
// default test
testSubject = createTestSubject();
result = testSubject.convertToResponseFormatOrNotFoundErrorToEmptyList(storageOperationStatus);
+ assertThat(result.isRight()).isTrue();
+ }
+
+ @Test
+ public void testConvertToResponseFormatOrNotFoundErrorToEmptyList_1() {
+ ComponentsUtils testSubject;
+ StorageOperationStatus storageOperationStatus = StorageOperationStatus.NOT_FOUND;
+ Either<List<T>, ResponseFormat> result;
+
+ // default test
+ testSubject = createTestSubject();
+ result = testSubject.convertToResponseFormatOrNotFoundErrorToEmptyList(storageOperationStatus);
+ assertThat(result.isLeft()).isTrue();
}
@Test
- public void testGetResponseFormatByResource() throws Exception {
+ public void testGetResponseFormatByResource() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
ResponseFormat result;
// test 1
testSubject = createTestSubject();
result = testSubject.getResponseFormatByResource(actionStatus, resource);
+
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
+
resource = new Resource();
result = testSubject.getResponseFormatByResource(actionStatus, resource);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
+
result = testSubject.getResponseFormatByResource(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, resource);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
+
result = testSubject.getResponseFormatByResource(ActionStatus.RESOURCE_NOT_FOUND, resource);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(404);
+
result = testSubject.getResponseFormatByResource(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, resource);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
+
result = testSubject.getResponseFormatByResource(ActionStatus.COMPONENT_IN_USE, resource);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(403);
}
@Test
- public void testGetResponseFormatByResource_1() throws Exception {
+ public void testGetResponseFormatByResource_1() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
String resourceName = "";
testSubject = createTestSubject();
resourceName = null;
result = testSubject.getResponseFormatByResource(actionStatus, resourceName);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
// test 2
testSubject = createTestSubject();
- resourceName = "";
+ resourceName = "mock-name";
result = testSubject.getResponseFormatByResource(actionStatus, resourceName);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
+
result = testSubject.getResponseFormatByResource(ActionStatus.RESOURCE_NOT_FOUND, resourceName);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(404);
}
// test 1
testSubject = createTestSubject();
result = testSubject.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, null);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
+
result = testSubject.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, capabilityType);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
+
result = testSubject.getResponseFormatByCapabilityType(ActionStatus.AAI_ARTIFACT_GENERATION_FAILED, capabilityType);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(500);
}
// test 1
testSubject = createTestSubject();
+
obj = null;
result = testSubject.getResponseFormatByElement(actionStatus, obj);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
+
obj = new Object();
+
result = testSubject.getResponseFormatByElement(actionStatus, obj);
- result = testSubject.getResponseFormatByElement(ActionStatus.MISSING_CAPABILITY_TYPE, obj);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
+
+ List<Object> obj1 = new ArrayList<>();
+ obj1.add(new RequirementDefinition());
+
+ result = testSubject.getResponseFormatByElement(ActionStatus.MISSING_CAPABILITY_TYPE, obj1);
+ assertThat(result.getStatus()).isEqualTo(400);
}
@Test
- public void testGetResponseFormatByUser() throws Exception {
+ public void testGetResponseFormatByUser() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
User user = null;
testSubject = createTestSubject();
user = null;
result = testSubject.getResponseFormatByUser(actionStatus, user);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
+
user = new User();
result = testSubject.getResponseFormatByUser(ActionStatus.INVALID_USER_ID, user);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
+
result = testSubject.getResponseFormatByUser(ActionStatus.INVALID_EMAIL_ADDRESS, user);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
+
result = testSubject.getResponseFormatByUser(ActionStatus.INVALID_ROLE, user);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
+
result = testSubject.getResponseFormatByUser(ActionStatus.USER_NOT_FOUND, user);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(404);
+
result = testSubject.getResponseFormatByUser(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED, user);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
}
@Test
- public void testGetResponseFormatByUserId() throws Exception {
+ public void testGetResponseFormatByUserId() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
String userId = "";
// default test
testSubject = createTestSubject();
result = testSubject.getResponseFormatByUserId(actionStatus, userId);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
}
@Test
- public void testGetResponseFormatByDE() throws Exception {
+ public void testGetResponseFormatByDE() {
ComponentsUtils testSubject;
- ActionStatus actionStatus = ActionStatus.ACCEPTED;
String serviceId = "";
String envName = "";
ResponseFormat result;
// default test
testSubject = createTestSubject();
- result = testSubject.getResponseFormatByDE(actionStatus, serviceId);
+ result = testSubject.getResponseFormatByDE(ActionStatus.ACCEPTED, serviceId);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
+
+ result = testSubject.getResponseFormatByDE(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE, serviceId);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(500);
+
+ result = testSubject.getResponseFormatByDE(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND, serviceId);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
}
@Test
public void testGetResponseFormatByArtifactId() throws Exception {
ComponentsUtils testSubject;
- ActionStatus actionStatus = ActionStatus.ACCEPTED;
String artifactId = "";
ResponseFormat result;
// default test
testSubject = createTestSubject();
- result = testSubject.getResponseFormatByArtifactId(actionStatus, artifactId);
+
+ result = testSubject.getResponseFormatByArtifactId(ActionStatus.ACCEPTED, artifactId);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
+
result = testSubject.getResponseFormatByArtifactId(ActionStatus.RESOURCE_NOT_FOUND, artifactId);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(404);
}
@Test
}
@Test
- public void testConvertFromStorageResponse() throws Exception {
+ public void testConvertFromStorageResponse() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = null;
ActionStatus result;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromStorageResponse(storageResponse);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testConvertFromStorageResponse_1() throws Exception {
+ public void testConvertFromStorageResponse_1() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = null;
ComponentTypeEnum type = null;
testSubject = createTestSubject();
storageResponse = null;
result = testSubject.convertFromStorageResponse(storageResponse, type);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);;
}
@Test
- public void testConvertFromToscaError() throws Exception {
+ public void testConvertFromToscaError() {
ComponentsUtils testSubject;
ToscaError toscaError = null;
ActionStatus result;
testSubject = createTestSubject();
toscaError = null;
result = testSubject.convertFromToscaError(toscaError);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testConvertFromStorageResponseForCapabilityType() throws Exception {
+ public void testConvertFromStorageResponseForCapabilityType() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY;
ActionStatus result;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromStorageResponseForCapabilityType(storageResponse);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testConvertFromStorageResponseForLifecycleType() throws Exception {
+ public void testConvertFromStorageResponseForLifecycleType() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
ActionStatus result;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromStorageResponseForLifecycleType(storageResponse);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testConvertFromStorageResponseForResourceInstance() throws Exception {
+ public void testConvertFromStorageResponseForResourceInstance() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
boolean isRelation = false;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromStorageResponseForResourceInstance(storageResponse, isRelation);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testGetResponseFormatForResourceInstance() throws Exception {
+ public void testGetResponseFormatForResourceInstance() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
String serviceName = "";
// default test
testSubject = createTestSubject();
result = testSubject.getResponseFormatForResourceInstance(actionStatus, serviceName, resourceInstanceName);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
}
@Test
- public void testGetResponseFormatForResourceInstanceProperty() throws Exception {
+ public void testGetResponseFormatForResourceInstanceProperty() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
String resourceInstanceName = "";
// default test
testSubject = createTestSubject();
result = testSubject.getResponseFormatForResourceInstanceProperty(actionStatus, resourceInstanceName);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
}
@Test
- public void testConvertFromStorageResponseForResourceInstanceProperty() throws Exception {
+ public void testConvertFromStorageResponseForResourceInstanceProperty() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
ActionStatus result;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromStorageResponseForResourceInstanceProperty(storageResponse);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testValidateStringNotEmpty() throws Exception {
+ public void testValidateStringNotEmpty() {
ComponentsUtils testSubject;
String value = "";
boolean result;
// default test
testSubject = createTestSubject();
result = testSubject.validateStringNotEmpty(value);
+ assertThat(result).isFalse();
}
@Test
- public void testConvertFromStorageResponseForAdditionalInformation() throws Exception {
+ public void testConvertFromStorageResponseForAdditionalInformation() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
ActionStatus result;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromStorageResponseForAdditionalInformation(storageResponse);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testConvertFromResultStatusEnum() throws Exception {
+ public void testConvertFromResultStatusEnum() {
ComponentsUtils testSubject;
ResultStatusEnum resultStatus = ResultStatusEnum.ELEMENT_NOT_FOUND;
JsonPresentationFields elementType = null;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromResultStatusEnum(resultStatus, elementType);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testGetResponseFormatAdditionalProperty() throws Exception {
+ public void testGetResponseFormatAdditionalProperty() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
AdditionalInfoParameterInfo additionalInfoParameterInfo = null;
additionalInfoParameterInfo = null;
result = testSubject.getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType,
labelOrValue);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
// test 2
testSubject = createTestSubject();
labelOrValue = null;
result = testSubject.getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType,
labelOrValue);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
}
@Test
- public void testGetResponseFormatAdditionalProperty_1() throws Exception {
+ public void testGetResponseFormatAdditionalProperty_1() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
ResponseFormat result;
// default test
testSubject = createTestSubject();
result = testSubject.getResponseFormatAdditionalProperty(actionStatus);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
}
@Test
- public void testConvertFromStorageResponseForConsumer() throws Exception {
+ public void testConvertFromStorageResponseForConsumer() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
ActionStatus result;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromStorageResponseForConsumer(storageResponse);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testConvertFromStorageResponseForGroupType() throws Exception {
+ public void testConvertFromStorageResponseForGroupType() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
ActionStatus result;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromStorageResponseForGroupType(storageResponse);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testConvertFromStorageResponseForDataType() throws Exception {
+ public void testConvertFromStorageResponseForDataType() {
ComponentsUtils testSubject;
StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
ActionStatus result;
// default test
testSubject = createTestSubject();
result = testSubject.convertFromStorageResponseForDataType(storageResponse);
+ assertThat(result)
+ .isInstanceOf(ActionStatus.class)
+ .isEqualTo(ActionStatus.GENERAL_ERROR);
}
@Test
- public void testGetResponseFormatByGroupType() throws Exception {
+ public void testGetResponseFormatByGroupType() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
GroupTypeDefinition groupType = null;
testSubject = createTestSubject();
groupType = null;
result = testSubject.getResponseFormatByGroupType(actionStatus, groupType);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
}
@Test
- public void testGetResponseFormatByPolicyType() throws Exception {
+ public void testGetResponseFormatByPolicyType() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.ACCEPTED;
PolicyTypeDefinition policyType = new PolicyTypeDefinition();
// test 1
testSubject = createTestSubject();
result = testSubject.getResponseFormatByPolicyType(actionStatus, policyType);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
}
@Test
- public void testGetResponseFormatByDataType() throws Exception {
+ public void testGetResponseFormatByDataType() {
ComponentsUtils testSubject;
ActionStatus actionStatus = ActionStatus.AAI_ARTIFACT_GENERATION_FAILED;
DataTypeDefinition dataType = null;
testSubject = createTestSubject();
dataType = null;
result = testSubject.getResponseFormatByDataType(actionStatus, dataType, properties);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(500);
}
@Test
- public void testconvertJsonToObject() throws Exception {
+ public void testconvertJsonToObject() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
Either<User,ResponseFormat> response=compUtils.convertJsonToObject(data,user,User.class,AuditingActionEnum.ADD_USER);
User assertuser = new User("xyz","xyz","12","demo.z@ymail.com","123",null);
- Assert.assertEquals(assertuser,response.left().value());
+ assertThat(response.isLeft()).isTrue();
+ assertThat(response.left().value()).isEqualTo(assertuser);
}
@Test
- public void testconvertJsonToObject_NllData() throws Exception {
+ public void testconvertJsonToObject_NllData() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
String data=null;
Either<User,ResponseFormat> response=compUtils.convertJsonToObject(data,user,User.class,AuditingActionEnum.ADD_USER);
- Assert.assertEquals(true,response.isRight());
+ assertThat(response.isRight()).isTrue();
}
@Test
- public void testconvertJsonToObjectInvalidData() throws Exception {
+ public void testconvertJsonToObjectInvalidData() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
Either<User,ResponseFormat> response=compUtils.convertJsonToObject(data,user,User.class,AuditingActionEnum.ADD_USER);
-
- Assert.assertEquals(true,response.isRight());
+ assertThat(response.isRight()).isTrue();
}
@Test
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- Assert.assertEquals(StorageOperationStatus.OK,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.OK));
- Assert.assertEquals(StorageOperationStatus.NOT_FOUND,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.NOT_FOUND));
- Assert.assertEquals(StorageOperationStatus.GENERAL_ERROR,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.GENERAL_ERROR));
- Assert.assertEquals(StorageOperationStatus.CONNECTION_FAILURE,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.CLUSTER_NOT_CONNECTED));
- Assert.assertEquals(StorageOperationStatus.CONNECTION_FAILURE,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.KEYSPACE_NOT_CONNECTED));
+ assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.OK)).isEqualTo(StorageOperationStatus.OK);
+ assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.NOT_FOUND)).isEqualTo(StorageOperationStatus.NOT_FOUND);
+ assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.GENERAL_ERROR)).isEqualTo(StorageOperationStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.CLUSTER_NOT_CONNECTED)).isEqualTo(StorageOperationStatus.CONNECTION_FAILURE);
+ assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.KEYSPACE_NOT_CONNECTED)).isEqualTo(StorageOperationStatus.CONNECTION_FAILURE);
}
@Test
DataTypeDefinition dataType = new DataTypeDefinition();
dataType.setName("demo");
List<String> properties;
- ResponseFormat responseFormat = compUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_ALREADY_EXIST, dataType, null);
- Assert.assertNotNull(responseFormat);
- Assert.assertEquals((Integer) 409,responseFormat.getStatus());
+ ResponseFormat result = compUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_ALREADY_EXIST, dataType, null);
+
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
}
@Test
- public void testGetResponseFormatByPolicyType_POLICY_TYPE_ALREADY_EXIST() throws Exception {
+ public void testGetResponseFormatByPolicyType_POLICY_TYPE_ALREADY_EXIST() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
PolicyTypeDefinition policyType = new PolicyTypeDefinition();
policyType.setType("Demo");
- ResponseFormat responseFormat = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST, policyType);
- Assert.assertNotNull(responseFormat);
- Assert.assertEquals((Integer) 409,responseFormat.getStatus());
+ ResponseFormat result = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST, policyType);
+
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
}
@Test
- public void testGetResponseFormatByPolicyType_PolicyID_NULL() throws Exception {
+ public void testGetResponseFormatByPolicyType_PolicyID_NULL() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- ResponseFormat responseFormat = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST, null);
- Assert.assertNotNull(responseFormat);
- Assert.assertEquals((Integer) 409,responseFormat.getStatus());
+ ResponseFormat result = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST, null);
+
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
}
@Test
- public void testGetResponseFormatByGroupType_GROUP_MEMBER_EMPTY() throws Exception {
+ public void testGetResponseFormatByGroupType_GROUP_MEMBER_EMPTY() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
GroupTypeDefinition groupType = new GroupTypeDefinition();
groupType.setType("Demo");
- ResponseFormat responseFormat = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_MEMBER_EMPTY, groupType);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_TYPE_ALREADY_EXIST, groupType);
- Assert.assertNotNull(responseFormat);
+
+ ResponseFormat result = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_MEMBER_EMPTY, groupType);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
+
+ result = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_TYPE_ALREADY_EXIST, groupType);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
}
@Test
- public void testConvertFromStorageResponseForDataType_ALL() throws Exception {
+ public void testConvertFromStorageResponseForDataType_ALL() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.OK));
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CONNECTION_FAILURE));
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.GRAPH_IS_LOCK));
- Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.BAD_REQUEST));
- Assert.assertEquals(ActionStatus.DATA_TYPE_ALREADY_EXIST,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.ENTITY_ALREADY_EXISTS));
- Assert.assertEquals(ActionStatus.DATA_TYPE_ALREADY_EXIST,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.SCHEMA_VIOLATION));
- Assert.assertEquals(ActionStatus.DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY));
-
+ assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
+ assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CONNECTION_FAILURE)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
+ assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(ActionStatus.DATA_TYPE_ALREADY_EXIST);
+ assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(ActionStatus.DATA_TYPE_ALREADY_EXIST);
+ assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY)).isEqualTo(ActionStatus.DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST);
}
@Test
- public void testConvertFromStorageResponseForGroupType_ALL() throws Exception {
+ public void testConvertFromStorageResponseForGroupType_ALL() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.OK));
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.CONNECTION_FAILURE));
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.GRAPH_IS_LOCK));
- Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.BAD_REQUEST));
- Assert.assertEquals(ActionStatus.GROUP_TYPE_ALREADY_EXIST,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.ENTITY_ALREADY_EXISTS));
- Assert.assertEquals(ActionStatus.GROUP_TYPE_ALREADY_EXIST,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.SCHEMA_VIOLATION));
+ assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
+ assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.CONNECTION_FAILURE)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
+ assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(ActionStatus.GROUP_TYPE_ALREADY_EXIST);
+ assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(ActionStatus.GROUP_TYPE_ALREADY_EXIST);
}
@Test
- public void testConvertFromStorageResponseForConsumer_ALL() throws Exception {
+ public void testConvertFromStorageResponseForConsumer_ALL() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.OK));
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.CONNECTION_FAILURE));
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.GRAPH_IS_LOCK));
- Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.BAD_REQUEST));
- Assert.assertEquals(ActionStatus.CONSUMER_ALREADY_EXISTS,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.ENTITY_ALREADY_EXISTS));
- Assert.assertEquals(ActionStatus.CONSUMER_ALREADY_EXISTS,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.SCHEMA_VIOLATION));
- Assert.assertEquals(ActionStatus.ECOMP_USER_NOT_FOUND,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.NOT_FOUND));
+ assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
+ assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.CONNECTION_FAILURE)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
+ assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(ActionStatus.CONSUMER_ALREADY_EXISTS);
+ assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(ActionStatus.CONSUMER_ALREADY_EXISTS);
+ assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.NOT_FOUND)).isEqualTo(ActionStatus.ECOMP_USER_NOT_FOUND);
}
@Test
- public void testGetResponseFormatAdditionalProperty_ALL() throws Exception {
+ public void testGetResponseFormatAdditionalProperty_ALL() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
NodeTypeEnum nodeType = null;
AdditionalInformationEnum labelOrValue = null;
- ResponseFormat responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, additionalInfoParameterInfo, nodeType,
+ ResponseFormat result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, additionalInfoParameterInfo, nodeType,
labelOrValue);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EXCEEDS_LIMIT, additionalInfoParameterInfo, nodeType,
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
+
+ result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EXCEEDS_LIMIT, additionalInfoParameterInfo, nodeType,
labelOrValue);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_MAX_NUMBER_REACHED, additionalInfoParameterInfo, NodeTypeEnum.Group,
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
+
+ result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_MAX_NUMBER_REACHED, additionalInfoParameterInfo, NodeTypeEnum.Group,
labelOrValue);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED, additionalInfoParameterInfo, nodeType,
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
+
+ result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED, additionalInfoParameterInfo, nodeType,
labelOrValue);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_KEY_NOT_ALLOWED_CHARACTERS, additionalInfoParameterInfo, nodeType,
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
+
+ result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_KEY_NOT_ALLOWED_CHARACTERS, additionalInfoParameterInfo, nodeType,
labelOrValue);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_VALUE_NOT_ALLOWED_CHARACTERS, additionalInfoParameterInfo, nodeType,
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
+
+ result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_VALUE_NOT_ALLOWED_CHARACTERS, additionalInfoParameterInfo, nodeType,
labelOrValue);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND, additionalInfoParameterInfo, nodeType,
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(400);
+
+ result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND, additionalInfoParameterInfo, nodeType,
labelOrValue);
- Assert.assertNotNull(responseFormat);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
}
@Test
- public void testConvertFromResultStatusEnum_ALL() throws Exception {
+ public void testConvertFromResultStatusEnum_ALL() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- Assert.assertEquals(ActionStatus.OK,compUtils.convertFromResultStatusEnum(ResultStatusEnum.OK, null));
- Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_DEFAULT_VALUE, null));
- Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_TYPE, null));
- Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_VALUE, null));
- Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_NAME, null));
- Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.MISSING_ENTRY_SCHEMA_TYPE, null));
+ assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.OK, null)).isEqualTo(ActionStatus.OK);
+ assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_DEFAULT_VALUE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
+ assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_TYPE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
+ assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_VALUE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
+ assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_NAME, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
+ assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.MISSING_ENTRY_SCHEMA_TYPE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
}
@Test
- public void testconvertFromStorageResponseForAdditionalInformation() throws Exception{
+ public void testconvertFromStorageResponseForAdditionalInformation() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.OK));
- Assert.assertEquals(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.ENTITY_ALREADY_EXISTS));
- Assert.assertEquals(ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND,compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.INVALID_ID));
+ assertThat(compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
+ assertThat(compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(ActionStatus.COMPONENT_NAME_ALREADY_EXIST);
+ assertThat(compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.INVALID_ID)).isEqualTo(ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND);
}
@Test
- public void testgetResponseFormatByComponent() throws Exception{
+ public void testgetResponseFormatByComponent() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
Component component = new Resource();
- ResponseFormat responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, component, ComponentTypeEnum.RESOURCE);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.RESOURCE_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, component, ComponentTypeEnum.RESOURCE);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_IN_USE, component, ComponentTypeEnum.RESOURCE);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.SERVICE_DEPLOYMENT_ARTIFACT_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
- Assert.assertNotNull(responseFormat);
- responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.ACCEPTED, component, ComponentTypeEnum.RESOURCE);
- Assert.assertNotNull(responseFormat);
+ ResponseFormat result = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, component, ComponentTypeEnum.RESOURCE);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
+
+ result = compUtils.getResponseFormatByComponent(ActionStatus.RESOURCE_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(404);
+
+ result = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, component, ComponentTypeEnum.RESOURCE);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(409);
+
+ result = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_IN_USE, component, ComponentTypeEnum.RESOURCE);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(403);
+
+ result = compUtils.getResponseFormatByComponent(ActionStatus.SERVICE_DEPLOYMENT_ARTIFACT_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(403);
+
+ result = compUtils.getResponseFormatByComponent(ActionStatus.ACCEPTED, component, ComponentTypeEnum.RESOURCE);
+ assertThat(result).isInstanceOf(ResponseFormat.class);
+ assertThat(result.getStatus()).isEqualTo(202);
}
@Test
- public void testConvertFromStorageResponseForResourceInstanceProperty_ALL() throws Exception {
+ public void testConvertFromStorageResponseForResourceInstanceProperty_ALL() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.OK));
- Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.INVALID_ID));
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.GRAPH_IS_LOCK));
- Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.BAD_REQUEST));
- Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.MATCH_NOT_FOUND));
- Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.SCHEMA_VIOLATION));
- Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.NOT_FOUND));
+
+ assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.INVALID_ID)).isEqualTo(ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.MATCH_NOT_FOUND)).isEqualTo(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.NOT_FOUND)).isEqualTo(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND);
}
@Test
- public void testConvertFromStorageResponseForResourceInstance_ALL() throws Exception {
+ public void testConvertFromStorageResponseForResourceInstance_ALL() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.ARTIFACT_NOT_FOUND, false));
- Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_ID, false));
- Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_PROPERTY, false));
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.GRAPH_IS_LOCK, false));
- Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.BAD_REQUEST, false));
- Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.MATCH_NOT_FOUND, false));
- Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.SCHEMA_VIOLATION, false));
- Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, true));
- Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, false));
+
+ assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.ARTIFACT_NOT_FOUND, false)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_ID, false)).isEqualTo(ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_PROPERTY, false)).isEqualTo(ActionStatus.INVALID_PROPERTY);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.GRAPH_IS_LOCK, false)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.BAD_REQUEST, false)).isEqualTo(ActionStatus.INVALID_CONTENT);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.MATCH_NOT_FOUND, false)).isEqualTo(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.SCHEMA_VIOLATION, false)).isEqualTo(ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, true)).isEqualTo(ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND);
+ assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, false)).isEqualTo(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND);
}
@Test
- public void testConvertFromStorageResponse_ALL() throws Exception {
+ public void testConvertFromStorageResponse_ALL() {
AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
when(auditingmanager.auditEvent(any())).thenReturn("OK");
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponse(StorageOperationStatus.CONNECTION_FAILURE, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponse(StorageOperationStatus.GRAPH_IS_LOCK, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,compUtils.convertFromStorageResponse(StorageOperationStatus.ENTITY_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.PARENT_RESOURCE_NOT_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.MULTIPLE_PARENT_RESOURCE_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.MULTIPLE_PARENT_RESOURCE_FOUND, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.COMPONENT_IN_USE,compUtils.convertFromStorageResponse(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE,compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_AVAILABLE, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_FOUND, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.DISTRIBUTION_ENVIRONMENT_INVALID,compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_SENT_IS_INVALID, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_TYPE, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.CSAR_NOT_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.CSAR_NOT_FOUND, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.PROPERTY_NAME_ALREADY_EXISTS,compUtils.convertFromStorageResponse(StorageOperationStatus.PROPERTY_NAME_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY,compUtils.convertFromStorageResponse(StorageOperationStatus.MATCH_NOT_FOUND, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.CATEGORY_NOT_FOUND, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_PROPERTY, ComponentTypeEnum.RESOURCE));
- Assert.assertEquals(ActionStatus.COMPONENT_IS_ARCHIVED,compUtils.convertFromStorageResponse(StorageOperationStatus.COMPONENT_IS_ARCHIVED, ComponentTypeEnum.RESOURCE));
+
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.CONNECTION_FAILURE, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.GRAPH_IS_LOCK, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.GENERAL_ERROR);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.INVALID_CONTENT);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.ENTITY_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.COMPONENT_NAME_ALREADY_EXIST);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.PARENT_RESOURCE_NOT_FOUND);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.MULTIPLE_PARENT_RESOURCE_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.MULTIPLE_PARENT_RESOURCE_FOUND);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.COMPONENT_IN_USE);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_AVAILABLE, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_SENT_IS_INVALID, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.DISTRIBUTION_ENVIRONMENT_INVALID);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_TYPE, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.INVALID_CONTENT);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.INVALID_CONTENT);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.CSAR_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.CSAR_NOT_FOUND);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.PROPERTY_NAME_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.PROPERTY_NAME_ALREADY_EXISTS);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.MATCH_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.CATEGORY_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_PROPERTY, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.INVALID_PROPERTY);
+ assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.COMPONENT_IS_ARCHIVED, ComponentTypeEnum.RESOURCE)).isEqualTo(ActionStatus.COMPONENT_IS_ARCHIVED);
}
}
\ No newline at end of file
Code Review / sdc.git / blobdiff