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

   1 package org.openecomp.sdc.be.servlets;
   2
   3 import static org.assertj.core.api.Assertions.assertThat;
   4 import static org.junit.Assert.assertEquals;
   5 import static org.mockito.ArgumentMatchers.any;
   6 import static org.mockito.ArgumentMatchers.anyMap;
   7 import static org.mockito.ArgumentMatchers.eq;
   8 import static org.mockito.Mockito.when;
   9 import static org.openecomp.sdc.common.api.Constants.GET_POLICY;
  10
  11 import com.fasterxml.jackson.databind.DeserializationFeature;
  12 import fj.data.Either;
  13 import java.util.Arrays;
  14 import java.util.Collections;
  15 import java.util.HashMap;
  16 import java.util.List;
  17 import java.util.Objects;
  18 import javax.ws.rs.client.ClientBuilder;
  19 import javax.ws.rs.client.Entity;
  20 import javax.ws.rs.client.Invocation;
  21 import javax.ws.rs.core.GenericType;
  22 import javax.ws.rs.core.MediaType;
  23 import javax.ws.rs.core.Response;
  24 import org.glassfish.grizzly.http.util.HttpStatus;
  25 import org.glassfish.jersey.client.ClientConfig;
  26 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider;
  27 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
  28 import org.glassfish.jersey.server.ResourceConfig;
  29 import org.json.simple.JSONObject;
  30 import org.junit.Before;
  31 import org.junit.BeforeClass;
  32 import org.junit.Test;
  33 import org.junit.runner.RunWith;
  34 import org.mockito.ArgumentCaptor;
  35 import org.mockito.Captor;
  36 import org.mockito.Mockito;
  37 import org.mockito.Spy;
  38 import org.mockito.junit.MockitoJUnitRunner;
  39 import org.openecomp.sdc.be.components.impl.BaseBusinessLogic;
  40 import org.openecomp.sdc.be.components.impl.PolicyBusinessLogic;
  41 import org.openecomp.sdc.be.components.property.PropertyDeclarationOrchestrator;
  42 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
  43 import org.openecomp.sdc.be.dao.api.ActionStatus;
  44 import org.openecomp.sdc.be.datatypes.elements.GetPolicyValueDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  47 import org.openecomp.sdc.be.impl.ComponentsUtils;
  48 import org.openecomp.sdc.be.impl.ServletUtils;
  49 import org.openecomp.sdc.be.model.ComponentInstInputsMap;
  50 import org.openecomp.sdc.be.model.ComponentInstancePropInput;
  51 import org.openecomp.sdc.be.model.PolicyDefinition;
  52 import org.openecomp.sdc.be.model.PolicyTargetDTO;
  53 import org.openecomp.sdc.be.model.PropertyDefinition;
  54 import org.openecomp.sdc.be.model.Service;
  55 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  56 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  57 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  58 import org.openecomp.sdc.common.api.Constants;
  59 import org.openecomp.sdc.exception.ResponseFormat;
  60
  61 @RunWith(MockitoJUnitRunner.class)
  62 public class PolicyServletTest extends JerseySpringBaseTest{
  63
  64     private final static String USER_ID = "jh0003";
  65     private static final String COMPONENT_ID = "componentId";
  66     private static PolicyBusinessLogic businessLogic;
  67     private static ComponentsUtils componentsUtils;
  68     private static ServletUtils servletUtils;
  69     private static PropertyDeclarationOrchestrator propertyDeclarationOrchestrator;
  70     private static ToscaOperationFacade toscaOperationFacade;
  71     private static ResponseFormat responseFormat;
  72     @Captor
  73     private static ArgumentCaptor<PolicyDefinition> policyCaptor;
  74     @Spy
  75     private static BaseBusinessLogic baseBusinessLogic;
  76
  77     private static String validComponentType = "resources";
  78     private static String unsupportedComponentType = "unsupported";
  79     private static String componentId = "componentId";
  80     private static String policyTypeName = "policyTypeName";
  81
  82     private static final String PROPS_URL = "/v1/catalog/{componentType}/{serviceId}/policies/{policyId}/properties";
  83     private static final String DECLARE_URL = "v1/catalog/{componentType}/{serviceId}/create/policies";
  84     private static final String DELETE_URL = "v1/catalog/{containerComponentType}/{componentId}/policies/{policyId}";
  85     private static final String SERVICE_ID = "serviceId";
  86     private static final String POLICY_ID = "policyId";
  87     private static final String PROP_1 = "prop1";
  88
  89     private static final String UPDATE_TARGETS_URL = "/v1/catalog/{componentType}/{componentId}/policies/{policyId}/targets";
  90
  91     @BeforeClass
  92     public static void initClass() {
  93         createMocks();
  94         when(servletUtils.getComponentsUtils()).thenReturn(componentsUtils);
  95     }
  96
  97     @Before
  98     public void beforeMethod() {
  99         final JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 100         setClient(ClientBuilder.newClient(new ClientConfig(jacksonJsonProvider)));
 101     }
 102
 103     @Test
 104     public void testGetPolicySuccess(){
 105         String path = "/v1/catalog/" + validComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 106         Either<PolicyDefinition, ResponseFormat> successResponse = Either.left(new PolicyDefinition());
 107         when(businessLogic.getPolicy(eq(ComponentTypeEnum.RESOURCE), eq(componentId), eq(POLICY_ID), eq(USER_ID))).thenReturn(successResponse);
 108         when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200.getStatusCode());
 109         Response response = target()
 110                 .path(path)
 111                 .request(MediaType.APPLICATION_JSON)
 112                 .header("USER_ID", USER_ID)
 113                 .get(Response.class);
 114
 115         assertEquals(response.getStatus(), HttpStatus.OK_200.getStatusCode());
 116     }
 117
 118     @Test
 119     public void testGetPolicyFailure(){
 120         String path = "/v1/catalog/" + unsupportedComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 121         when(responseFormat.getStatus()).thenReturn(HttpStatus.BAD_REQUEST_400.getStatusCode());
 122         when(componentsUtils.getResponseFormat(eq(ActionStatus.UNSUPPORTED_ERROR), eq(unsupportedComponentType))).thenReturn(responseFormat);
 123         Response response = target()
 124                 .path(path)
 125                 .request(MediaType.APPLICATION_JSON)
 126                 .header("USER_ID", USER_ID)
 127                 .get(Response.class);
 128
 129         assertEquals(response.getStatus(), HttpStatus.BAD_REQUEST_400.getStatusCode());
 130     }
 131
 132     @Test
 133     public void testPostPolicySuccess(){
 134         String path = "/v1/catalog/" + validComponentType + "/" + componentId + "/policies/" + policyTypeName;
 135         PolicyDefinition policy = new PolicyDefinition();
 136         Either<PolicyDefinition, ResponseFormat> successResponse = Either.left(policy);
 137         when(businessLogic.createPolicy(eq(ComponentTypeEnum.RESOURCE), eq(componentId), eq(policyTypeName), eq(USER_ID), eq(true))).thenReturn(successResponse);
 138         when(responseFormat.getStatus()).thenReturn(HttpStatus.CREATED_201.getStatusCode());
 139         when(componentsUtils.getResponseFormat(ActionStatus.CREATED)).thenReturn(responseFormat);
 140         Response response = target()
 141                 .path(path)
 142                 .request(MediaType.APPLICATION_JSON)
 143                 .header("USER_ID", USER_ID)
 144                 .post(Entity.entity(policy, MediaType.APPLICATION_JSON),Response.class);
 145
 146         assertEquals(response.getStatus(), HttpStatus.CREATED_201.getStatusCode());
 147     }
 148
 149     @Test
 150     public void testPostPolicyFailure(){
 151         String path = "/v1/catalog/" + unsupportedComponentType + "/" + componentId + "/policies/" + policyTypeName;
 152         PolicyDefinition policy = new PolicyDefinition();
 153         when(responseFormat.getStatus()).thenReturn(HttpStatus.BAD_REQUEST_400.getStatusCode());
 154         when(componentsUtils.getResponseFormat(eq(ActionStatus.UNSUPPORTED_ERROR), eq(unsupportedComponentType))).thenReturn(responseFormat);
 155         Response response = target()
 156                 .path(path)
 157                 .request(MediaType.APPLICATION_JSON)
 158                 .header("USER_ID", USER_ID)
 159                 .post(Entity.entity(policy, MediaType.APPLICATION_JSON),Response.class);
 160
 161         assertEquals(response.getStatus(), HttpStatus.BAD_REQUEST_400.getStatusCode());
 162     }
 163
 164     @Test
 165     public void testPutPolicySuccess(){
 166         String path = "/v1/catalog/" + validComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 167         PolicyDefinition policy = new PolicyDefinition();
 168         policy.setUniqueId(POLICY_ID);
 169         Either<PolicyDefinition, ResponseFormat> successResponse = Either.left(policy);
 170         when(businessLogic.updatePolicy(eq(ComponentTypeEnum.RESOURCE), eq(componentId), any(PolicyDefinition.class), eq(USER_ID), eq(true))).thenReturn(successResponse);
 171         when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200.getStatusCode());
 172         Response response = target()
 173                 .path(path)
 174                 .request(MediaType.APPLICATION_JSON)
 175                 .header("USER_ID", USER_ID)
 176                 .put(Entity.entity(policy, MediaType.APPLICATION_JSON),Response.class);
 177
 178         assertEquals(response.getStatus(), HttpStatus.OK_200.getStatusCode());
 179     }
 180
 181     @Test
 182     public void testPutPolicyFailure(){
 183         String path = "/v1/catalog/" + unsupportedComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 184         PolicyDefinition policy = new PolicyDefinition();
 185         when(responseFormat.getStatus()).thenReturn(HttpStatus.BAD_REQUEST_400.getStatusCode());
 186         when(componentsUtils.getResponseFormat(eq(ActionStatus.UNSUPPORTED_ERROR), eq(unsupportedComponentType))).thenReturn(responseFormat);
 187         Response response = target()
 188                 .path(path)
 189                 .request(MediaType.APPLICATION_JSON)
 190                 .header("USER_ID", USER_ID)
 191                 .put(Entity.entity(policy, MediaType.APPLICATION_JSON),Response.class);
 192
 193         assertEquals(response.getStatus(), HttpStatus.BAD_REQUEST_400.getStatusCode());
 194     }
 195
 196     @Test
 197     public void testDeletePolicySuccess(){
 198         String path = "/v1/catalog/" + validComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 199         Either<PolicyDefinition, ResponseFormat> successResponse = Either.left(new PolicyDefinition());
 200         when(businessLogic.deletePolicy(eq(ComponentTypeEnum.RESOURCE), eq(componentId), eq(POLICY_ID), eq(USER_ID), eq(true))).thenReturn(successResponse);
 201         when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200.getStatusCode());
 202         Response response = target()
 203                 .path(path)
 204                 .request(MediaType.APPLICATION_JSON)
 205                 .header("USER_ID", USER_ID)
 206                 .delete(Response.class);
 207
 208         assertEquals(response.getStatus(), HttpStatus.OK_200.getStatusCode());
 209     }
 210
 211     @Test
 212     public void testDeletePolicyFailure(){
 213         String path = "/v1/catalog/" + unsupportedComponentType + "/" + componentId + "/policies/" + POLICY_ID;
 214         when(responseFormat.getStatus()).thenReturn(HttpStatus.BAD_REQUEST_400.getStatusCode());
 215         when(componentsUtils.getResponseFormat(eq(ActionStatus.UNSUPPORTED_ERROR), eq(unsupportedComponentType))).thenReturn(responseFormat);
 216         Response response = target()
 217                 .path(path)
 218                 .request(MediaType.APPLICATION_JSON)
 219                 .header("USER_ID", USER_ID)
 220                 .delete(Response.class);
 221
 222         assertEquals(response.getStatus(), HttpStatus.BAD_REQUEST_400.getStatusCode());
 223     }
 224
 225     @Test
 226     public void getPolicyProperties_operationForbidden() {
 227         when(businessLogic.getPolicyProperties(ComponentTypeEnum.SERVICE, SERVICE_ID, POLICY_ID, USER_ID)).thenReturn(Either.right(new ResponseFormat(Response.Status.FORBIDDEN.getStatusCode())));
 228         Response response = buildGetPropertiesRequest().get();
 229         assertThat(response.getStatus()).isEqualTo(Response.Status.FORBIDDEN.getStatusCode());
 230     }
 231
 232     @Test
 233     public void getPolicyProperties_unHandledError_returnGeneralError() {
 234         when(businessLogic.getPolicyProperties(ComponentTypeEnum.SERVICE, SERVICE_ID, POLICY_ID, USER_ID)).thenThrow(new RuntimeException());
 235         Response response = buildGetPropertiesRequest().get();
 236         assertThat(response.getStatus()).isEqualTo(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode());
 237     }
 238
 239     @Test
 240     public void getPolicyProperties_wrongComponentType() {
 241         Response response = buildGetPropertiesRequest("unknownType").get();
 242         assertThat(response.getStatus()).isEqualTo(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode());
 243         //verifyZeroInteractions(businessLogic);
 244     }
 245
 246     @Test
 247     public void getPolicyProperties() {
 248         List<PropertyDataDefinition> properties = getPropertiesList();
 249         when(businessLogic.getPolicyProperties(ComponentTypeEnum.SERVICE, SERVICE_ID, POLICY_ID, USER_ID)).thenReturn(Either.left(properties));
 250         List<PropertyDataDefinition> policyProps = buildGetPropertiesRequest().get(new GenericType<List<PropertyDataDefinition>>() {});
 251         assertThat(policyProps)
 252                 .usingElementComparatorOnFields("uniqueId")
 253                 .containsExactlyInAnyOrder(properties.get(0), properties.get(1));
 254     }
 255
 256     @Test
 257     public void updatePolicyPropertiesSuccess() {
 258         List<PropertyDataDefinition> properties = getPropertiesList();
 259         when(businessLogic.updatePolicyProperties(eq(ComponentTypeEnum.SERVICE), eq(SERVICE_ID), eq(POLICY_ID), any(PropertyDataDefinition[].class), eq(USER_ID), eq(true))).thenReturn(Either.left(properties));
 260         List<PropertyDataDefinition> policyProps = buildUpdatePropertiesRequest(ComponentTypeEnum.SERVICE_PARAM_NAME, properties).invoke(new GenericType<List<PropertyDataDefinition>>() {});
 261         assertThat(policyProps)
 262                 .usingElementComparatorOnFields("uniqueId")
 263                 .containsExactlyInAnyOrder(properties.get(0), properties.get(1));
 264     }
 265
 266     @Test
 267     public void updatePolicyTargetsSuccess() {
 268         List<PolicyTargetDTO> targets = getTargetDTOList();
 269         when(businessLogic.updatePolicyTargets(eq(ComponentTypeEnum.RESOURCE), eq(COMPONENT_ID), eq(POLICY_ID), anyMap(), eq(USER_ID))).thenReturn(Either.left(new PolicyDefinition()));
 270         Response policyTargets = buildUpdateTargetsRequest(ComponentTypeEnum.RESOURCE_PARAM_NAME, targets).invoke();
 271         assertThat(policyTargets.getStatus()).isEqualTo(200);
 272     }
 273
 274     @Test
 275     public void updatePolicyPropertiesFailure() {
 276         List<PropertyDataDefinition> properties = getPropertiesList();
 277         ResponseFormat notFoundResponse = new ResponseFormat(HttpStatus.NOT_FOUND_404.getStatusCode());
 278         when(businessLogic.updatePolicyProperties(eq(ComponentTypeEnum.SERVICE), eq(SERVICE_ID), eq(POLICY_ID), any(PropertyDataDefinition[].class), eq(USER_ID), eq(true))).thenReturn(Either.right(notFoundResponse));
 279         Response policyProps = buildUpdatePropertiesRequest(ComponentTypeEnum.SERVICE_PARAM_NAME, properties).invoke();
 280         assertEquals(HttpStatus.NOT_FOUND_404.getStatusCode(), policyProps.getStatus());
 281     }
 282
 283     @Test
 284     public void testDeclarePropertyToPolicySuccess() {
 285         Service service = new Service();
 286         service.setUniqueId(SERVICE_ID);
 287         service.addProperty(new PropertyDataDefinitionBuilder().setUniqueId(PROP_1).build());
 288
 289         PolicyDefinition policyDefinition = new PolicyDefinition();
 290         policyDefinition.setUniqueId(UniqueIdBuilder.buildPolicyUniqueId(SERVICE_ID, PROP_1));
 291
 292         setMocksForPropertyDeclaration(policyDefinition);
 293
 294         when(componentsUtils.getResponseFormat(eq(ActionStatus.OK))).thenReturn(new ResponseFormat(HttpStatus.OK_200.getStatusCode()));
 295
 296         Response declareResponse = buildDeclarePropertiesRequest(PROP_1).invoke();
 297         assertEquals(HttpStatus.OK_200.getStatusCode(), declareResponse.getStatus());
 298     }
 299
 300     @Test
 301     public void testUndeclarePolicySuccess() {
 302         Service service = new Service();
 303         service.setUniqueId(SERVICE_ID);
 304         PropertyDefinition origProperty = new PropertyDataDefinitionBuilder().setUniqueId(PROP_1).build();
 305
 306         service.addProperty(origProperty);
 307
 308         PolicyDefinition policyDefinition = new PolicyDefinition();
 309         policyDefinition.setUniqueId(UniqueIdBuilder.buildPolicyUniqueId(SERVICE_ID, PROP_1));
 310         service.addPolicy(policyDefinition);
 311
 312         addGetPolicyValueToProperty(origProperty, policyDefinition);
 313
 314         when(businessLogic.deletePolicy(eq(ComponentTypeEnum.SERVICE), eq(SERVICE_ID), eq(policyDefinition.getUniqueId()), eq(USER_ID), eq(true))).thenReturn(Either.left(policyDefinition));
 315
 316         Response deleteResponse = buildDeletePolicyRequest(policyDefinition).invoke();
 317         assertEquals(HttpStatus.OK_200.getStatusCode(), deleteResponse.getStatus());
 318     }
 319
 320     private void addGetPolicyValueToProperty(PropertyDefinition propertyDefinition,
 321                                              PolicyDefinition policyDefinition) {
 322         JSONObject jobject = new JSONObject();
 323         String origValue = Objects.isNull(propertyDefinition.getValue()) ? propertyDefinition.getDefaultValue() : propertyDefinition.getValue();
 324         jobject.put(GET_POLICY, null);
 325         propertyDefinition.setValue(jobject.toJSONString());
 326
 327         GetPolicyValueDataDefinition getPolicyValueDataDefinition = new GetPolicyValueDataDefinition();
 328         getPolicyValueDataDefinition.setPolicyId(policyDefinition.getUniqueId());
 329         getPolicyValueDataDefinition.setPropertyName(propertyDefinition.getName());
 330
 331         getPolicyValueDataDefinition.setOrigPropertyValue(origValue);
 332
 333         propertyDefinition.setGetPolicyValues(Collections.singletonList(getPolicyValueDataDefinition));
 334     }
 335
 336     private void setMocksForPropertyDeclaration(PolicyDefinition policyDefinition) {
 337         when(request.getSession()).thenReturn(session);
 338         when(session.getServletContext()).thenReturn(context);
 339         when(context.getAttribute(eq(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR))).thenReturn(contextWrapper);
 340         when(contextWrapper.getWebAppContext(any())).thenReturn(applicationContext);
 341         when(applicationContext.getBean(eq(PolicyBusinessLogic.class))).thenReturn(businessLogic);
 342         when(businessLogic.declareProperties(eq(USER_ID), eq(SERVICE_ID), any(), any())).thenReturn(
 343                 Either.left(Collections.singletonList(policyDefinition)));
 344         when(componentsUtils
 345                      .convertJsonToObjectUsingObjectMapper(any(), any(), eq(ComponentInstInputsMap.class), eq(
 346                              AuditingActionEnum.CREATE_RESOURCE), eq(ComponentTypeEnum.SERVICE)))
 347                         .thenReturn(Either.left(getDeclarationBodyForProperty(PROP_1)));
 348     }
 349
 350     private List<PropertyDataDefinition> getPropertiesList() {
 351         PropertyDefinition prop1 = new PropertyDataDefinitionBuilder()
 352                 .setUniqueId("prop1")
 353                 .build();
 354
 355         PropertyDefinition prop2 = new PropertyDataDefinitionBuilder()
 356                 .setUniqueId("prop2")
 357                 .build();
 358         return Arrays.asList(prop1, prop2);
 359     }
 360
 361     private List<PolicyTargetDTO> getTargetDTOList() {
 362         PolicyTargetDTO target1 = new PolicyTargetDTO();
 363         target1.setUniqueIds(Collections.singletonList("uniqueId"));
 364         target1.setType("GROUPS");
 365
 366         PolicyTargetDTO target2 = new PolicyTargetDTO();
 367         target2.setUniqueIds(Collections.singletonList("uniqueId"));
 368         target2.setType("component_Instances");
 369
 370         return Arrays.asList(target1, target2);
 371     }
 372
 373     private Invocation.Builder buildGetPropertiesRequest(String componentType) {
 374         return target(PROPS_URL)
 375                 .resolveTemplate("componentType", componentType)
 376                 .resolveTemplate("serviceId", SERVICE_ID)
 377                 .resolveTemplate("policyId", POLICY_ID)
 378                 .request(MediaType.APPLICATION_JSON)
 379                 .header(Constants.USER_ID_HEADER, USER_ID);
 380
 381     }
 382
 383     private Invocation buildUpdatePropertiesRequest(String componentType, List<PropertyDataDefinition> properties) {
 384         return target(PROPS_URL)
 385                 .resolveTemplate("componentType", componentType)
 386                 .resolveTemplate("serviceId", SERVICE_ID)
 387                 .resolveTemplate("policyId", POLICY_ID)
 388                 .request(MediaType.APPLICATION_JSON)
 389                 .header(Constants.USER_ID_HEADER, USER_ID)
 390                 .buildPut(Entity.entity(properties, MediaType.APPLICATION_JSON));
 391     }
 392
 393     private Invocation buildUpdateTargetsRequest(String componentType, List<PolicyTargetDTO> targets) {
 394         return target(UPDATE_TARGETS_URL)
 395                 .resolveTemplate("componentType", componentType)
 396                 .resolveTemplate("componentId", COMPONENT_ID)
 397                 .resolveTemplate("policyId", POLICY_ID)
 398                 .request(MediaType.APPLICATION_JSON)
 399                 .header(Constants.USER_ID_HEADER, USER_ID)
 400                 .buildPost(Entity.entity(targets, MediaType.APPLICATION_JSON));
 401     }
 402
 403     private Invocation.Builder buildGetPropertiesRequest() {
 404         return target(PROPS_URL)
 405                 .resolveTemplate("componentType", "services")
 406                 .resolveTemplate("serviceId", SERVICE_ID)
 407                 .resolveTemplate("policyId", POLICY_ID)
 408                 .request(MediaType.APPLICATION_JSON)
 409                 .header(Constants.USER_ID_HEADER, USER_ID);
 410     }
 411
 412     private Invocation buildDeletePolicyRequest(PolicyDefinition policyDefinition) {
 413         return target(DELETE_URL)
 414                        .resolveTemplate("containerComponentType", "services")
 415                        .resolveTemplate("componentId", SERVICE_ID)
 416                        .resolveTemplate("policyId", policyDefinition.getUniqueId())
 417                        .request(MediaType.APPLICATION_JSON)
 418                        .header(Constants.USER_ID_HEADER, USER_ID)
 419                         .buildDelete();
 420     }
 421
 422     private Invocation buildDeclarePropertiesRequest(String propertyId) {
 423         return target(DECLARE_URL)
 424                        .resolveTemplate("componentType", "services")
 425                        .resolveTemplate("serviceId", SERVICE_ID)
 426                        .request(MediaType.APPLICATION_JSON)
 427                        .header(Constants.USER_ID_HEADER, USER_ID)
 428                        .buildPost(Entity.entity(getDeclarationBodyForProperty(propertyId), MediaType.APPLICATION_JSON));
 429     }
 430
 431     private ComponentInstInputsMap getDeclarationBodyForProperty(String propertyId) {
 432         ComponentInstInputsMap componentInstInputsMap = new ComponentInstInputsMap();
 433         ComponentInstancePropInput propInput = new ComponentInstancePropInput();
 434         PropertyDefinition propertyDefinition = new PropertyDefinition();
 435
 436         propertyDefinition.setType("string");
 437         propertyDefinition.setUniqueId(SERVICE_ID + "." + propertyId);
 438         propInput.setInput(propertyDefinition);
 439         propInput.setPropertiesName(propertyId);
 440
 441         componentInstInputsMap.setComponentInstancePropertiesToPolicies(new HashMap<>());
 442         componentInstInputsMap.getComponentInstancePropertiesToPolicies().put("componentInstancePropertiesToPolicies", Collections.singletonList(propInput));
 443
 444         return componentInstInputsMap;
 445     }
 446
 447     @Override
 448     protected ResourceConfig configure() {
 449         return super.configure()
 450                 .register(new PolicyServlet(businessLogic, servletUtils, null, componentsUtils));
 451     }
 452
 453     private static void createMocks() {
 454         propertyDeclarationOrchestrator = Mockito.mock(PropertyDeclarationOrchestrator.class);
 455         toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
 456         businessLogic = Mockito.mock(PolicyBusinessLogic.class);
 457         businessLogic.setPropertyDeclarationOrchestrator(propertyDeclarationOrchestrator);
 458         businessLogic.setToscaOperationFacade(toscaOperationFacade);
 459
 460         baseBusinessLogic = Mockito.spy(BaseBusinessLogic.class);
 461         baseBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 462
 463         componentsUtils = Mockito.mock(ComponentsUtils.class);
 464         servletUtils = Mockito.mock(ServletUtils.class);
 465         responseFormat = Mockito.mock(ResponseFormat.class);
 466     }
 467
 468 }