gerrit.onap Code Review - policy/distribution.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Ericsson. All rights reserved.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.distribution.forwarding.xacml.pdp.engine;
  22
  23 import static org.mockito.Matchers.anyObject;
  24 import static org.mockito.Matchers.argThat;
  25 import static org.mockito.Matchers.eq;
  26 import static org.mockito.Mockito.mock;
  27 import static org.mockito.Mockito.times;
  28 import static org.mockito.Mockito.verify;
  29 import static org.mockito.Mockito.when;
  30
  31 import java.lang.reflect.Field;
  32 import java.lang.reflect.Modifier;
  33 import java.security.KeyManagementException;
  34 import java.security.NoSuchAlgorithmException;
  35 import java.util.ArrayList;
  36 import java.util.Collection;
  37 import java.util.HashMap;
  38 import javax.ws.rs.client.Entity;
  39 import javax.ws.rs.core.Response;
  40 import org.hamcrest.BaseMatcher;
  41 import org.hamcrest.Description;
  42 import org.junit.BeforeClass;
  43 import org.junit.Test;
  44 import org.onap.policy.api.PolicyParameters;
  45 import org.onap.policy.api.PushPolicyParameters;
  46 import org.onap.policy.common.endpoints.event.comm.bus.internal.BusTopicParams;
  47 import org.onap.policy.common.endpoints.http.client.HttpClient;
  48 import org.onap.policy.common.endpoints.http.client.HttpClientFactory;
  49 import org.onap.policy.common.parameters.ParameterGroup;
  50 import org.onap.policy.common.parameters.ParameterService;
  51 import org.onap.policy.distribution.forwarding.xacml.pdp.XacmlPdpPolicyForwarder;
  52 import org.onap.policy.distribution.forwarding.xacml.pdp.XacmlPdpPolicyForwarderParameterGroup.XacmlPdpPolicyForwarderParameterGroupBuilder;
  53 import org.onap.policy.distribution.main.PolicyDistributionException;
  54 import org.onap.policy.distribution.model.OptimizationPolicy;
  55 import org.onap.policy.distribution.model.Policy;
  56
  57 public class XacmlPdpPolicyForwarderTest {
  58
  59     private static final BusTopicParams BUS_TOPIC_PARAMS = BusTopicParams.builder().useHttps(false).hostname("myHost")
  60             .port(1234).userName("myUser").password("myPassword").managed(true).build();
  61     private static final String CLIENT_AUTH = "ClientAuth";
  62     private static final String CLIENT_AUTH_VALUE = "myClientAuth";
  63     private static final String PDP_GROUP_VALUE = "myPdpGroup";
  64     private HashMap<String, Object> headers = new HashMap<>();
  65     private BusTopicParamsMatcher matcher = new BusTopicParamsMatcher(BUS_TOPIC_PARAMS);
  66
  67     /**
  68      * Set up.
  69      */
  70     @BeforeClass
  71     public static void setUp() {
  72         ParameterGroup parameterGroup = new XacmlPdpPolicyForwarderParameterGroupBuilder()
  73                 .setUseHttps(BUS_TOPIC_PARAMS.isUseHttps()).setHostname(BUS_TOPIC_PARAMS.getHostname())
  74                 .setPort(BUS_TOPIC_PARAMS.getPort()).setUserName(BUS_TOPIC_PARAMS.getUserName())
  75                 .setPassword(BUS_TOPIC_PARAMS.getPassword()).setClientAuth(CLIENT_AUTH_VALUE)
  76                 .setIsManaged(BUS_TOPIC_PARAMS.isManaged()).setPdpGroup(PDP_GROUP_VALUE).build();
  77         parameterGroup.setName("xacmlPdpConfiguration");
  78         ParameterService.register(parameterGroup);
  79     }
  80
  81     @Test
  82     public void testForwardPolicy()
  83             throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException,SecurityException,
  84             IllegalArgumentException, IllegalAccessException, PolicyDistributionException, ClassNotFoundException {
  85
  86         HttpClient httpClientMock = mock(HttpClient.class);
  87         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
  88         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
  89         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
  90
  91         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
  92         when(httpClientFactoryMock.build(argThat(matcher))).thenReturn(httpClientMock);
  93
  94         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
  95
  96         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
  97         forwarder.configure("xacmlPdpConfiguration");
  98
  99         Collection<Policy> policies = new ArrayList<>();
 100
 101         OptimizationPolicy policy1 = new OptimizationPolicy();
 102         policy1.setPolicyName("policy1");
 103         policies.add(policy1);
 104
 105         Policy policy2 = new UnsupportedPolicy();
 106         policies.add(policy2);
 107
 108         OptimizationPolicy policy3 = new OptimizationPolicy();
 109         policy3.setPolicyName("policy3");
 110         policies.add(policy3);
 111
 112         forwarder.forward(policies);
 113
 114         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy1)),
 115                 eq(headers));
 116         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy3)),
 117                 eq(headers));
 118         verify(httpClientMock).put(eq("pushPolicy"), argThat(new PushPolicyParametersEntityMatcher(policy1)),
 119                 eq(headers));
 120         verify(httpClientMock).put(eq("pushPolicy"), argThat(new PushPolicyParametersEntityMatcher(policy3)),
 121                 eq(headers));
 122     }
 123
 124     @Test
 125     public void testForwardPolicy_CreateFailsPushNotInvoked()
 126             throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException, SecurityException,
 127             IllegalArgumentException, IllegalAccessException, PolicyDistributionException, ClassNotFoundException {
 128
 129         HttpClient httpClientMock = mock(HttpClient.class);
 130         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
 131         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.status(400).build());
 132         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
 133
 134         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
 135         when(httpClientFactoryMock.build(argThat(matcher))).thenReturn(httpClientMock);
 136
 137         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
 138
 139         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
 140         forwarder.configure("xacmlPdpConfiguration");
 141
 142         Collection<Policy> policies = new ArrayList<>();
 143         OptimizationPolicy policy = new OptimizationPolicy();
 144         policy.setPolicyName("policy");
 145         policies.add(policy);
 146         forwarder.forward(policies);
 147
 148         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy)), eq(headers));
 149         verify(httpClientMock, times(0)).put(eq("pushPolicy"), anyObject(), anyObject());
 150     }
 151
 152     @Test
 153     public void testForwardPolicy_PushFails()
 154             throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException, SecurityException,
 155             IllegalArgumentException, IllegalAccessException, PolicyDistributionException, ClassNotFoundException {
 156
 157         HttpClient httpClientMock = mock(HttpClient.class);
 158         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
 159         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
 160         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.status(400).build());
 161
 162         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
 163         when(httpClientFactoryMock.build(argThat(matcher))).thenReturn(httpClientMock);
 164
 165         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
 166
 167         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
 168         forwarder.configure("xacmlPdpConfiguration");
 169
 170         Collection<Policy> policies = new ArrayList<>();
 171         OptimizationPolicy policy = new OptimizationPolicy();
 172         policy.setPolicyName("policy");
 173         policies.add(policy);
 174         forwarder.forward(policies);
 175
 176         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy)), eq(headers));
 177         verify(httpClientMock).put(eq("pushPolicy"), argThat(new PushPolicyParametersEntityMatcher(policy)),
 178                 eq(headers));
 179     }
 180
 181     @Test
 182     public void testForwardPolicy_HttpClientInitFailureForPolicyCreate()
 183             throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException, SecurityException,
 184             IllegalArgumentException, IllegalAccessException, PolicyDistributionException, ClassNotFoundException {
 185
 186         HttpClient httpClientMock = mock(HttpClient.class);
 187         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
 188         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
 189         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.status(400).build());
 190
 191         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
 192         when(httpClientFactoryMock.build(argThat(matcher))).thenThrow(new KeyManagementException());
 193
 194         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
 195
 196         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
 197         forwarder.configure("xacmlPdpConfiguration");
 198
 199         Collection<Policy> policies = new ArrayList<>();
 200         OptimizationPolicy policy = new OptimizationPolicy();
 201         policy.setPolicyName("policy");
 202         policies.add(policy);
 203         forwarder.forward(policies);
 204
 205         verify(httpClientMock, times(0)).put(eq("createPolicy"), anyObject(), anyObject());
 206         verify(httpClientMock, times(0)).put(eq("pushPolicy"), anyObject(), anyObject());
 207     }
 208
 209     @Test
 210     public void testForwardPolicy_HttpClientInitFailureForPolicyPush()
 211             throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException, SecurityException,
 212             IllegalArgumentException, IllegalAccessException, PolicyDistributionException, ClassNotFoundException {
 213
 214         HttpClient httpClientMock = mock(HttpClient.class);
 215         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
 216         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
 217         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.status(400).build());
 218
 219         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
 220         when(httpClientFactoryMock.build(argThat(matcher))).thenReturn(httpClientMock)
 221                 .thenThrow(new KeyManagementException());
 222
 223         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
 224
 225         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
 226         forwarder.configure("xacmlPdpConfiguration");
 227
 228         Collection<Policy> policies = new ArrayList<>();
 229         OptimizationPolicy policy = new OptimizationPolicy();
 230         policy.setPolicyName("policy");
 231         policies.add(policy);
 232         forwarder.forward(policies);
 233
 234         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy)), eq(headers));
 235         verify(httpClientMock, times(0)).put(eq("pushPolicy"), anyObject(), anyObject());
 236     }
 237
 238     private void overwriteField(final Class<?> clazz, final String fieldName, final Object object, final Object value)
 239             throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 240         Field field = clazz.getField(fieldName);
 241         field.setAccessible(true);
 242         Field modifiersField = Field.class.getDeclaredField("modifiers");
 243         modifiersField.setAccessible(true);
 244         modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
 245         field.set(object, value);
 246     }
 247
 248     class BusTopicParamsMatcher extends BaseMatcher<BusTopicParams> {
 249
 250         private BusTopicParams busTopicParams;
 251
 252         BusTopicParamsMatcher(final BusTopicParams busTopicParams) {
 253             this.busTopicParams = busTopicParams;
 254         }
 255
 256         @Override
 257         public boolean matches(Object arg0) {
 258             if (arg0 instanceof BusTopicParams) {
 259                 BusTopicParams toCompareTo = (BusTopicParams) arg0;
 260                 return toCompareTo.isUseHttps() == busTopicParams.isUseHttps()
 261                         && toCompareTo.getHostname().equals(busTopicParams.getHostname())
 262                         && toCompareTo.getPort() == busTopicParams.getPort()
 263                         && toCompareTo.getUserName().equals(busTopicParams.getUserName())
 264                         && toCompareTo.getPassword().equals(busTopicParams.getPassword())
 265                         && toCompareTo.isManaged() == busTopicParams.isManaged();
 266             }
 267             return false;
 268         }
 269
 270         @Override
 271         public void describeTo(Description arg0) {}
 272     }
 273
 274     class PolicyParametersEntityMatcher extends BaseMatcher<Entity<PolicyParameters>> {
 275
 276         private OptimizationPolicy policy;
 277
 278         PolicyParametersEntityMatcher(final OptimizationPolicy policy) {
 279             this.policy = policy;
 280         }
 281
 282         @SuppressWarnings("unchecked")
 283         @Override
 284         public boolean matches(Object arg0) {
 285             if (arg0 instanceof Entity) {
 286                 PolicyParameters toCompareTo = ((Entity<PolicyParameters>) arg0).getEntity();
 287                 return toCompareTo.getPolicyName().equals(policy.getPolicyName())
 288                         && toCompareTo.getPolicyConfigType().toString().equals(policy.getPolicyConfigType());
 289             }
 290             return false;
 291         }
 292
 293         @Override
 294         public void describeTo(Description arg0) {}
 295     }
 296
 297     class PushPolicyParametersEntityMatcher extends BaseMatcher<Entity<PushPolicyParameters>> {
 298
 299         private Policy policy;
 300
 301         PushPolicyParametersEntityMatcher(final Policy policy) {
 302             this.policy = policy;
 303         }
 304
 305         @SuppressWarnings("unchecked")
 306         @Override
 307         public boolean matches(Object arg0) {
 308             if (arg0 instanceof Entity) {
 309                 PushPolicyParameters toCompareTo = ((Entity<PushPolicyParameters>) arg0).getEntity();
 310                 return toCompareTo.getPolicyName().equals(policy.getPolicyName())
 311                         && toCompareTo.getPolicyType().equals(policy.getPolicyType())
 312                         && toCompareTo.getPdpGroup().equals(PDP_GROUP_VALUE);
 313             }
 314             return false;
 315         }
 316
 317         @Override
 318         public void describeTo(Description arg0) {}
 319     }
 320
 321     class UnsupportedPolicy implements Policy {
 322
 323         @Override
 324         public String getPolicyName() {
 325             return "unsupported";
 326         }
 327
 328         @Override
 329         public String getPolicyType() {
 330             return "unsupported";
 331         }
 332     }
 333 }