catalog-be/src/test/java/org/openecomp/sdc/be/servlets/PolicyServletTest.java

   1 package org.openecomp.sdc.be.servlets;
   2
   3 import com.fasterxml.jackson.databind.DeserializationFeature;
   4 import fj.data.Either;
   5 import org.glassfish.grizzly.http.util.HttpStatus;
   6 import org.glassfish.jersey.client.ClientConfig;
   7 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider;
   8 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
   9 import org.glassfish.jersey.server.ResourceConfig;
  10 import org.junit.Before;
  11 import org.junit.BeforeClass;
  12 import org.junit.Test;
  13 import org.mockito.Mockito;
  14 import org.openecomp.sdc.be.components.impl.PolicyBusinessLogic;
  15 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
  16 import org.openecomp.sdc.be.dao.api.ActionStatus;
  17 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  18 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  19 import org.openecomp.sdc.be.impl.ComponentsUtils;
  20 import org.openecomp.sdc.be.impl.ServletUtils;
  21 import org.openecomp.sdc.be.model.PolicyDefinition;
  22 import org.openecomp.sdc.be.model.PolicyTargetDTO;
  23 import org.openecomp.sdc.be.model.PropertyDefinition;
  24 import org.openecomp.sdc.common.api.Constants;
  25 import org.openecomp.sdc.exception.ResponseFormat;
  26
  27 import javax.ws.rs.client.ClientBuilder;
  28 import javax.ws.rs.client.Entity;
  29 import javax.ws.rs.client.Invocation;
  30 import javax.ws.rs.core.GenericType;
  31 import javax.ws.rs.core.MediaType;
  32 import javax.ws.rs.core.Response;
  33 import java.util.Arrays;
  34 import java.util.Collections;
  35 import java.util.List;
  36
  37 import static org.assertj.core.api.Assertions.assertThat;
  38 import static org.junit.Assert.assertEquals;
  39 import static org.junit.Assert.assertTrue;
  40 import static org.mockito.ArgumentMatchers.*;
  41 import static org.mockito.Mockito.when;
  42
  43 public class PolicyServletTest extends JerseySpringBaseTest{
  44
  45     private final static String USER_ID = "jh0003";
  46     private static final String COMPONENT_ID = "componentId";
  47     private static PolicyBusinessLogic businessLogic;
  48     private static ComponentsUtils componentsUtils;
  49     private static ServletUtils servletUtils;
  50     private static ResponseFormat responseFormat;
  51
  52     private static String validComponentType = "resources";
  53     private static String unsupportedComponentType = "unsupported";
  54     private static String componentId = "componentId";
  55     private static String policyTypeName = "policyTypeName";
  56
  57     private static final String PROPS_URL = "/v1/catalog/{componentType}/{serviceId}/policies/{policyId}/properties";
  58     private static final String SERVICE_ID = "serviceId";
  59     private static final String POLICY_ID = "policyId";
  60
  61     private static final String UPDATE_TARGETS_URL = "/v1/catalog/{componentType}/{componentId}/policies/{policyId}/targets";
  62
  63     @BeforeClass
  64     public static void initClass() {
  65         createMocks();
  66         when(servletUtils.getComponentsUtils()).thenReturn(componentsUtils);
  67     }
  68
  69     @Before
  70     public void beforeMethod() {
  71         final JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  72         setClient(ClientBuilder.newClient(new ClientConfig(jacksonJsonProvider)));
  73     }
  74
  75     @Test
  76     public void testGetPolicySuccess(){
  77         String path = "/v1/catalog/" + validComponentType + "/" + componentId + "/policies/" + POLICY_ID;
  78         Either<PolicyDefinition, ResponseFormat> successResponse = Either.left(new PolicyDefinition());
  79         when(businessLogic.getPolicy(eq(ComponentTypeEnum.RESOURCE), eq(componentId), eq(POLICY_ID), eq(USER_ID))).thenReturn(successResponse);
  80         when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200.getStatusCode());
  81         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
  82         Response response = target()
  83                 .path(path)
  84                 .request(MediaType.APPLICATION_JSON)
  85                 .header("USER_ID", USER_ID)
  86                 .get(Response.class);
  87
  88         assertEquals(response.getStatus(), HttpStatus.OK_200.getStatusCode());
  89     }
  90
  91     @Test
  92     public void testGetPolicyFailure(){
  93         String path = "/v1/catalog/" + unsupportedComponentType + "/" + componentId + "/policies/" + POLICY_ID;
  94         when(responseFormat.getStatus()).thenReturn(HttpStatus.BAD_REQUEST_400.getStatusCode());
  95         when(componentsUtils.getResponseFormat(eq(ActionStatus.UNSUPPORTED_ERROR), eq(unsupportedComponentType))).thenReturn(responseFormat);
  96         Response response = target()
  97                 .path(path)
  98                 .request(MediaType.APPLICATION_JSON)
  99                 .header("USER_ID", USER_ID)
 100                 .get(Response.class);
 101
 102         assertEquals(response.getStatus(), HttpStatus.BAD_REQUEST_400.getStatusCode());
 103     }
 104
 105     @Test
 106     public void testPostPolicySuccess(){
 107         String path = "/v1/catalog/" + validComponentType + "/" + componentId + "/policies/" + policyTypeName;
 108         PolicyDefinition policy = new PolicyDefinition();
 109         Either<PolicyDefinition, ResponseFormat> successResponse = Either.left(policy);
 110         when(businessLogic.createPolicy(eq(ComponentTypeEnum.RESOURCE), eq(componentId), eq(policyTypeName), eq(USER_ID), eq(true))).thenReturn(successResponse);
 111         when(responseFormat.getStatus()).thenReturn(HttpStatus.CREATED_201.getStatusCode());
 112         when(componentsUtils.getResponseFormat(ActionStatus.CREATED)).thenReturn(responseFormat);
 113         Response response = target()
 114                 .path(path)
 115                 .request(MediaType.APPLICATION_JSON)
 116                 .header("USER_ID", USER_ID)
 117                 .post(Entity.entity(policy, MediaType.APPLICATION_JSON),Response.class);
 118
 119         assertEquals(response.getStatus(), HttpStatus.CREATED_201.getStatusCode());
 120     }
 121
 122     @Test
 123     public void testPostPolicyFailure(){
 124         String path = "/v1/catalog/" + unsupportedComponentType + "/" + componentId + "/policies/" + policyTypeName;
 125         PolicyDefinition policy = new PolicyDefinition();
 126         when(responseFormat.getStatus()).thenReturn(HttpStatus.BAD_REQUEST_400.getStatusCode());
 127         when(componentsUtils.getResponseFormat(eq(ActionStatus.UNSUPPORTED_ERROR), eq(unsupportedComponentType))).thenReturn(responseFormat);
 128         Response response = target()
 129                 .path(path)
 130                 .request(MediaType.APPLICATION_JSON)
 131                 .header("USER_ID", USER_ID)
 132                 .post(Entity.entity(policy, MediaType.APPLICATION_JSON),Response.class);
 133
 134         assertEquals(response.getStatus(), HttpStatus.BAD_REQUEST_400.getStatusCode());
 135     }
 136
 137     @Test
 138     public void testPutPolicySuccess(){
 139         String path = "/v1/catalog/" + validComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 140         PolicyDefinition policy = new PolicyDefinition();
 141         policy.setUniqueId(POLICY_ID);
 142         Either<PolicyDefinition, ResponseFormat> successResponse = Either.left(policy);
 143         when(businessLogic.updatePolicy(eq(ComponentTypeEnum.RESOURCE), eq(componentId), any(PolicyDefinition.class), eq(USER_ID), eq(true))).thenReturn(successResponse);
 144         when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200.getStatusCode());
 145         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 146         Response response = target()
 147                 .path(path)
 148                 .request(MediaType.APPLICATION_JSON)
 149                 .header("USER_ID", USER_ID)
 150                 .put(Entity.entity(policy, MediaType.APPLICATION_JSON),Response.class);
 151
 152         assertEquals(response.getStatus(), HttpStatus.OK_200.getStatusCode());
 153     }
 154
 155     @Test
 156     public void testPutPolicyFailure(){
 157         String path = "/v1/catalog/" + unsupportedComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 158         PolicyDefinition policy = new PolicyDefinition();
 159         when(responseFormat.getStatus()).thenReturn(HttpStatus.BAD_REQUEST_400.getStatusCode());
 160         when(componentsUtils.getResponseFormat(eq(ActionStatus.UNSUPPORTED_ERROR), eq(unsupportedComponentType))).thenReturn(responseFormat);
 161         Response response = target()
 162                 .path(path)
 163                 .request(MediaType.APPLICATION_JSON)
 164                 .header("USER_ID", USER_ID)
 165                 .put(Entity.entity(policy, MediaType.APPLICATION_JSON),Response.class);
 166
 167         assertEquals(response.getStatus(), HttpStatus.BAD_REQUEST_400.getStatusCode());
 168     }
 169
 170     @Test
 171     public void testDeletePolicySuccess(){
 172         String path = "/v1/catalog/" + validComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 173         Either<PolicyDefinition, ResponseFormat> successResponse = Either.left(new PolicyDefinition());
 174         when(businessLogic.deletePolicy(eq(ComponentTypeEnum.RESOURCE), eq(componentId), eq(POLICY_ID), eq(USER_ID), eq(true))).thenReturn(successResponse);
 175         when(responseFormat.getStatus()).thenReturn(HttpStatus.NO_CONTENT_204.getStatusCode());
 176         when(componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT)).thenReturn(responseFormat);
 177         Response response = target()
 178                 .path(path)
 179                 .request(MediaType.APPLICATION_JSON)
 180                 .header("USER_ID", USER_ID)
 181                 .delete(Response.class);
 182
 183         assertEquals(response.getStatus(), HttpStatus.NO_CONTENT_204.getStatusCode());
 184     }
 185
 186     @Test
 187     public void testDeletePolicyFailure(){
 188         String path = "/v1/catalog/" + unsupportedComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 189         when(responseFormat.getStatus()).thenReturn(HttpStatus.BAD_REQUEST_400.getStatusCode());
 190         when(componentsUtils.getResponseFormat(eq(ActionStatus.UNSUPPORTED_ERROR), eq(unsupportedComponentType))).thenReturn(responseFormat);
 191         Response response = target()
 192                 .path(path)
 193                 .request(MediaType.APPLICATION_JSON)
 194                 .header("USER_ID", USER_ID)
 195                 .delete(Response.class);
 196
 197         assertEquals(response.getStatus(), HttpStatus.BAD_REQUEST_400.getStatusCode());
 198     }
 199
 200     @Test
 201     public void getPolicyProperties_operationForbidden() {
 202         when(businessLogic.getPolicyProperties(ComponentTypeEnum.SERVICE, SERVICE_ID, POLICY_ID, USER_ID)).thenReturn(Either.right(new ResponseFormat(Response.Status.FORBIDDEN.getStatusCode())));
 203         Response response = buildGetPropertiesRequest().get();
 204         assertThat(response.getStatus()).isEqualTo(Response.Status.FORBIDDEN.getStatusCode());
 205     }
 206
 207     @Test
 208     public void getPolicyProperties_unHandledError_returnGeneralError() {
 209         when(businessLogic.getPolicyProperties(ComponentTypeEnum.SERVICE, SERVICE_ID, POLICY_ID, USER_ID)).thenThrow(new RuntimeException());
 210         Response response = buildGetPropertiesRequest().get();
 211         assertThat(response.getStatus()).isEqualTo(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode());
 212     }
 213
 214     @Test
 215     public void getPolicyProperties_wrongComponentType() {
 216         Response response = buildGetPropertiesRequest("unknownType").get();
 217         assertThat(response.getStatus()).isEqualTo(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode());
 218         //verifyZeroInteractions(businessLogic);
 219     }
 220
 221     @Test
 222     public void getPolicyProperties() {
 223         List<PropertyDataDefinition> properties = getPropertiesList();
 224         when(businessLogic.getPolicyProperties(ComponentTypeEnum.SERVICE, SERVICE_ID, POLICY_ID, USER_ID)).thenReturn(Either.left(properties));
 225         List<PropertyDataDefinition> policyProps = buildGetPropertiesRequest().get(new GenericType<List<PropertyDataDefinition>>() {});
 226         assertThat(policyProps)
 227                 .usingElementComparatorOnFields("uniqueId")
 228                 .containsExactlyInAnyOrder(properties.get(0), properties.get(1));
 229     }
 230
 231     @Test
 232     public void updatePolicyPropertiesSuccess() {
 233         List<PropertyDataDefinition> properties = getPropertiesList();
 234         when(businessLogic.updatePolicyProperties(eq(ComponentTypeEnum.SERVICE), eq(SERVICE_ID), eq(POLICY_ID), any(PropertyDataDefinition[].class), eq(USER_ID), eq(true))).thenReturn(Either.left(properties));
 235         List<PropertyDataDefinition> policyProps = buildUpdatePropertiesRequest(ComponentTypeEnum.SERVICE_PARAM_NAME, properties).invoke(new GenericType<List<PropertyDataDefinition>>() {});
 236         assertThat(policyProps)
 237                 .usingElementComparatorOnFields("uniqueId")
 238                 .containsExactlyInAnyOrder(properties.get(0), properties.get(1));
 239     }
 240
 241     @Test
 242     public void updatePolicyTargetsSuccess() {
 243         List<PolicyTargetDTO> targets = getTargetDTOList();
 244         when(businessLogic.updatePolicyTargets(eq(ComponentTypeEnum.RESOURCE), eq(COMPONENT_ID), eq(POLICY_ID), anyMap(), eq(USER_ID))).thenReturn(Either.left(new PolicyDefinition()));
 245         Response policyTargets = buildUpdateTargetsRequest(ComponentTypeEnum.RESOURCE_PARAM_NAME, targets).invoke();
 246         assertThat(policyTargets.getStatus()).isEqualTo(200);
 247     }
 248
 249     @Test
 250     public void updatePolicyPropertiesFailure() {
 251         List<PropertyDataDefinition> properties = getPropertiesList();
 252         ResponseFormat notFoundResponse = new ResponseFormat(HttpStatus.NOT_FOUND_404.getStatusCode());
 253         when(businessLogic.updatePolicyProperties(eq(ComponentTypeEnum.SERVICE), eq(SERVICE_ID), eq(POLICY_ID), any(PropertyDataDefinition[].class), eq(USER_ID), eq(true))).thenReturn(Either.right(notFoundResponse));
 254         Response policyProps = buildUpdatePropertiesRequest(ComponentTypeEnum.SERVICE_PARAM_NAME, properties).invoke();
 255         assertEquals(HttpStatus.NOT_FOUND_404.getStatusCode(), policyProps.getStatus());
 256     }
 257
 258     private List<PropertyDataDefinition> getPropertiesList() {
 259         PropertyDefinition prop1 = new PropertyDataDefinitionBuilder()
 260                 .setUniqueId("prop1")
 261                 .build();
 262
 263         PropertyDefinition prop2 = new PropertyDataDefinitionBuilder()
 264                 .setUniqueId("prop2")
 265                 .build();
 266         return Arrays.asList(prop1, prop2);
 267     }
 268
 269     private List<PolicyTargetDTO> getTargetDTOList() {
 270         PolicyTargetDTO target1 = new PolicyTargetDTO();
 271         target1.setUniqueIds(Collections.singletonList("uniqueId"));
 272         target1.setType("GROUPS");
 273
 274         PolicyTargetDTO target2 = new PolicyTargetDTO();
 275         target2.setUniqueIds(Collections.singletonList("uniqueId"));
 276         target2.setType("component_Instances");
 277
 278         return Arrays.asList(target1, target2);
 279     }
 280
 281     private Invocation.Builder buildGetPropertiesRequest(String componentType) {
 282         return target(PROPS_URL)
 283                 .resolveTemplate("componentType", componentType)
 284                 .resolveTemplate("serviceId", SERVICE_ID)
 285                 .resolveTemplate("policyId", POLICY_ID)
 286                 .request(MediaType.APPLICATION_JSON)
 287                 .header(Constants.USER_ID_HEADER, USER_ID);
 288
 289     }
 290
 291     private Invocation buildUpdatePropertiesRequest(String componentType, List<PropertyDataDefinition> properties) {
 292         return target(PROPS_URL)
 293                 .resolveTemplate("componentType", componentType)
 294                 .resolveTemplate("serviceId", SERVICE_ID)
 295                 .resolveTemplate("policyId", POLICY_ID)
 296                 .request(MediaType.APPLICATION_JSON)
 297                 .header(Constants.USER_ID_HEADER, USER_ID)
 298                 .buildPut(Entity.entity(properties, MediaType.APPLICATION_JSON));
 299     }
 300
 301     private Invocation buildUpdateTargetsRequest(String componentType, List<PolicyTargetDTO> targets) {
 302         return target(UPDATE_TARGETS_URL)
 303                 .resolveTemplate("componentType", componentType)
 304                 .resolveTemplate("componentId", COMPONENT_ID)
 305                 .resolveTemplate("policyId", POLICY_ID)
 306                 .request(MediaType.APPLICATION_JSON)
 307                 .header(Constants.USER_ID_HEADER, USER_ID)
 308                 .buildPost(Entity.entity(targets, MediaType.APPLICATION_JSON));
 309     }
 310
 311     private Invocation.Builder buildGetPropertiesRequest() {
 312         return target(PROPS_URL)
 313                 .resolveTemplate("componentType", "services")
 314                 .resolveTemplate("serviceId", SERVICE_ID)
 315                 .resolveTemplate("policyId", POLICY_ID)
 316                 .request(MediaType.APPLICATION_JSON)
 317                 .header(Constants.USER_ID_HEADER, USER_ID);
 318     }
 319
 320     @Override
 321     protected ResourceConfig configure() {
 322         return super.configure()
 323                 .register(new PolicyServlet(businessLogic, servletUtils, null, componentsUtils));
 324     }
 325
 326     private static void createMocks() {
 327         businessLogic = Mockito.mock(PolicyBusinessLogic.class);
 328         componentsUtils = Mockito.mock(ComponentsUtils.class);
 329         servletUtils = Mockito.mock(ServletUtils.class);
 330         responseFormat = Mockito.mock(ResponseFormat.class);
 331     }
 332
 333 }