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() throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException,
  83             SecurityException, IllegalArgumentException, IllegalAccessException, PolicyDistributionException {
  84
  85         HttpClient httpClientMock = mock(HttpClient.class);
  86         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
  87         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
  88         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
  89
  90         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
  91         when(httpClientFactoryMock.build(argThat(matcher))).thenReturn(httpClientMock);
  92
  93         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
  94
  95         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
  96         forwarder.configure("xacmlPdpConfiguration");
  97
  98         Collection<Policy> policies = new ArrayList<>();
  99
 100         OptimizationPolicy policy1 = new OptimizationPolicy();
 101         policy1.setPolicyName("policy1");
 102         policy1.setPolicyConfigType("Optimization");
 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         policy3.setPolicyConfigType("Optimization");
 111         policies.add(policy3);
 112
 113         forwarder.forward(policies);
 114
 115         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy1)),
 116                 eq(headers));
 117         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy3)),
 118                 eq(headers));
 119         verify(httpClientMock).put(eq("pushPolicy"), argThat(new PushPolicyParametersEntityMatcher(policy1)),
 120                 eq(headers));
 121         verify(httpClientMock).put(eq("pushPolicy"), argThat(new PushPolicyParametersEntityMatcher(policy3)),
 122                 eq(headers));
 123     }
 124
 125     @Test
 126     public void testForwardPolicy_CreateFailsPushNotInvoked()
 127             throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException, SecurityException,
 128             IllegalArgumentException, IllegalAccessException, PolicyDistributionException {
 129
 130         HttpClient httpClientMock = mock(HttpClient.class);
 131         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
 132         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.status(400).build());
 133         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
 134
 135         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
 136         when(httpClientFactoryMock.build(argThat(matcher))).thenReturn(httpClientMock);
 137
 138         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
 139
 140         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
 141         forwarder.configure("xacmlPdpConfiguration");
 142
 143         Collection<Policy> policies = new ArrayList<>();
 144         OptimizationPolicy policy = new OptimizationPolicy();
 145         policy.setPolicyName("policy");
 146         policy.setPolicyConfigType("Optimization");
 147         policies.add(policy);
 148         forwarder.forward(policies);
 149
 150         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy)), eq(headers));
 151         verify(httpClientMock, times(0)).put(eq("pushPolicy"), anyObject(), anyObject());
 152     }
 153
 154     @Test
 155     public void testForwardPolicy_PushFails()
 156             throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException, SecurityException,
 157             IllegalArgumentException, IllegalAccessException, PolicyDistributionException {
 158
 159         HttpClient httpClientMock = mock(HttpClient.class);
 160         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
 161         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
 162         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.status(400).build());
 163
 164         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
 165         when(httpClientFactoryMock.build(argThat(matcher))).thenReturn(httpClientMock);
 166
 167         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
 168
 169         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
 170         forwarder.configure("xacmlPdpConfiguration");
 171
 172         Collection<Policy> policies = new ArrayList<>();
 173         OptimizationPolicy policy = new OptimizationPolicy();
 174         policy.setPolicyName("policy");
 175         policy.setPolicyConfigType("Optimization");
 176         policies.add(policy);
 177         forwarder.forward(policies);
 178
 179         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy)), eq(headers));
 180         verify(httpClientMock).put(eq("pushPolicy"), argThat(new PushPolicyParametersEntityMatcher(policy)),
 181                 eq(headers));
 182     }
 183
 184     @Test
 185     public void testForwardPolicy_HttpClientInitFailureForPolicyCreate()
 186             throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException, SecurityException,
 187             IllegalArgumentException, IllegalAccessException, PolicyDistributionException {
 188
 189         HttpClient httpClientMock = mock(HttpClient.class);
 190         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
 191         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
 192         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.status(400).build());
 193
 194         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
 195         when(httpClientFactoryMock.build(argThat(matcher))).thenThrow(new KeyManagementException());
 196
 197         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
 198
 199         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
 200         forwarder.configure("xacmlPdpConfiguration");
 201
 202         Collection<Policy> policies = new ArrayList<>();
 203         OptimizationPolicy policy = new OptimizationPolicy();
 204         policy.setPolicyName("policy");
 205         policy.setPolicyConfigType("Optimization");
 206         policies.add(policy);
 207         forwarder.forward(policies);
 208
 209         verify(httpClientMock, times(0)).put(eq("createPolicy"), anyObject(), anyObject());
 210         verify(httpClientMock, times(0)).put(eq("pushPolicy"), anyObject(), anyObject());
 211     }
 212
 213     @Test
 214     public void testForwardPolicy_HttpClientInitFailureForPolicyPush()
 215             throws KeyManagementException, NoSuchAlgorithmException, NoSuchFieldException, SecurityException,
 216             IllegalArgumentException, IllegalAccessException, PolicyDistributionException {
 217
 218         HttpClient httpClientMock = mock(HttpClient.class);
 219         headers.put(CLIENT_AUTH, CLIENT_AUTH_VALUE);
 220         when(httpClientMock.put(eq("createPolicy"), anyObject(), eq(headers))).thenReturn(Response.ok().build());
 221         when(httpClientMock.put(eq("pushPolicy"), anyObject(), eq(headers))).thenReturn(Response.status(400).build());
 222
 223         HttpClientFactory httpClientFactoryMock = mock(HttpClientFactory.class);
 224         when(httpClientFactoryMock.build(argThat(matcher))).thenReturn(httpClientMock)
 225                 .thenThrow(new KeyManagementException());
 226
 227         overwriteField(HttpClient.class, "factory", null, httpClientFactoryMock);
 228
 229         XacmlPdpPolicyForwarder forwarder = new XacmlPdpPolicyForwarder();
 230         forwarder.configure("xacmlPdpConfiguration");
 231
 232         Collection<Policy> policies = new ArrayList<>();
 233         OptimizationPolicy policy = new OptimizationPolicy();
 234         policy.setPolicyName("policy");
 235         policy.setPolicyConfigType("Optimization");
 236         policies.add(policy);
 237         forwarder.forward(policies);
 238
 239         verify(httpClientMock).put(eq("createPolicy"), argThat(new PolicyParametersEntityMatcher(policy)), eq(headers));
 240         verify(httpClientMock, times(0)).put(eq("pushPolicy"), anyObject(), anyObject());
 241     }
 242
 243     private void overwriteField(final Class<?> clazz, final String fieldName, final Object object, final Object value)
 244             throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 245         Field field = clazz.getField(fieldName);
 246         field.setAccessible(true);
 247         Field modifiersField = Field.class.getDeclaredField("modifiers");
 248         modifiersField.setAccessible(true);
 249         modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
 250         field.set(object, value);
 251     }
 252
 253     class BusTopicParamsMatcher extends BaseMatcher<BusTopicParams> {
 254
 255         private BusTopicParams busTopicParams;
 256
 257         BusTopicParamsMatcher(final BusTopicParams busTopicParams) {
 258             this.busTopicParams = busTopicParams;
 259         }
 260
 261         @Override
 262         public boolean matches(Object arg0) {
 263             if (arg0 instanceof BusTopicParams) {
 264                 BusTopicParams toCompareTo = (BusTopicParams) arg0;
 265                 return toCompareTo.isUseHttps() == busTopicParams.isUseHttps()
 266                         && toCompareTo.getHostname().equals(busTopicParams.getHostname())
 267                         && toCompareTo.getPort() == busTopicParams.getPort()
 268                         && toCompareTo.getUserName().equals(busTopicParams.getUserName())
 269                         && toCompareTo.getPassword().equals(busTopicParams.getPassword())
 270                         && toCompareTo.isManaged() == busTopicParams.isManaged();
 271             }
 272             return false;
 273         }
 274
 275         @Override
 276         public void describeTo(Description arg0) {}
 277     }
 278
 279     class PolicyParametersEntityMatcher extends BaseMatcher<Entity<PolicyParameters>> {
 280
 281         private OptimizationPolicy policy;
 282
 283         PolicyParametersEntityMatcher(final OptimizationPolicy policy) {
 284             this.policy = policy;
 285         }
 286
 287         @SuppressWarnings("unchecked")
 288         @Override
 289         public boolean matches(Object arg0) {
 290             if (arg0 instanceof Entity) {
 291                 PolicyParameters toCompareTo = ((Entity<PolicyParameters>) arg0).getEntity();
 292                 return toCompareTo.getPolicyName().equals(policy.getPolicyName())
 293                         && toCompareTo.getPolicyConfigType().toString().equals(policy.getPolicyConfigType());
 294             }
 295             return false;
 296         }
 297
 298         @Override
 299         public void describeTo(Description arg0) {}
 300     }
 301
 302     class PushPolicyParametersEntityMatcher extends BaseMatcher<Entity<PushPolicyParameters>> {
 303
 304         private Policy policy;
 305
 306         PushPolicyParametersEntityMatcher(final Policy policy) {
 307             this.policy = policy;
 308         }
 309
 310         @SuppressWarnings("unchecked")
 311         @Override
 312         public boolean matches(Object arg0) {
 313             if (arg0 instanceof Entity) {
 314                 PushPolicyParameters toCompareTo = ((Entity<PushPolicyParameters>) arg0).getEntity();
 315                 return toCompareTo.getPolicyName().equals(policy.getPolicyName())
 316                         && toCompareTo.getPolicyType().equals(policy.getPolicyType())
 317                         && toCompareTo.getPdpGroup().equals(PDP_GROUP_VALUE);
 318             }
 319             return false;
 320         }
 321
 322         @Override
 323         public void describeTo(Description arg0) {}
 324     }
 325
 326     class UnsupportedPolicy implements Policy {
 327
 328         @Override
 329         public String getPolicyName() {
 330             return "unsupported";
 331         }
 332
 333         @Override
 334         public String getPolicyType() {
 335             return "unsupported";
 336         }
 337     }
 338 }