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.reception.handling;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertTrue;
  25
  26 import java.lang.reflect.Field;
  27 import java.util.ArrayList;
  28 import java.util.Collection;
  29 import java.util.Collections;
  30 import java.util.HashMap;
  31 import java.util.Map;
  32 import org.junit.Test;
  33 import org.onap.policy.common.parameters.ParameterService;
  34 import org.onap.policy.distribution.forwarding.PolicyForwarder;
  35 import org.onap.policy.distribution.forwarding.parameters.PolicyForwarderParameters;
  36 import org.onap.policy.distribution.model.Policy;
  37 import org.onap.policy.distribution.model.PolicyInput;
  38 import org.onap.policy.distribution.reception.decoding.PluginInitializationException;
  39 import org.onap.policy.distribution.reception.decoding.PolicyDecoder;
  40 import org.onap.policy.distribution.reception.decoding.PolicyDecodingException;
  41 import org.onap.policy.distribution.reception.parameters.PluginHandlerParameters;
  42 import org.onap.policy.distribution.reception.parameters.PolicyDecoderParameters;
  43
  44 /**
  45  * Class to perform unit test of AbstractReceptionHandler.
  46  *
  47  * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
  48  */
  49 public class AbstractReceptionHandlerTest {
  50
  51     private static final String DISTRIBUTION_GROUP = "DummyDistributionGroup";
  52     private static final String DECODER_TYPE = "DummyDecoder";
  53     private static final String DECODER_CLASS_NAME = "org.onap.policy.distribution.reception.handling.DummyDecoder";
  54     private static final String DECODER_KEY = "DummyDecoderKey";
  55     private static final String FORWARDER_KEY = "DummyForwarderKey";
  56     private static final String FORWARDER_TYPE = "DummyForwarder";
  57     private static final String FORWARDER_CLASS_NAME =
  58             "org.onap.policy.distribution.reception.handling.DummyPolicyForwarder";
  59     private static final String FORWARDER_CONFIGURATION_PARAMETERS = "DummyConfiguration";
  60
  61     @Test
  62     public void testInputReceived() throws PolicyDecodingException, NoSuchFieldException, SecurityException,
  63             IllegalArgumentException, IllegalAccessException, PluginInitializationException {
  64         final AbstractReceptionHandler handler = new DummyReceptionHandler();
  65
  66         final Policy generatedPolicy1 = new DummyPolicy1();
  67         final Policy generatedPolicy2 = new DummyPolicy2();
  68
  69         final PolicyDecoder<PolicyInput, Policy> policyDecoder1 =
  70                 new DummyDecoder(true, Collections.singletonList(generatedPolicy1));
  71         final PolicyDecoder<PolicyInput, Policy> policyDecoder2 =
  72                 new DummyDecoder(true, Collections.singletonList(generatedPolicy2));
  73
  74         final Collection<PolicyDecoder<PolicyInput, Policy>> policyDecoders = new ArrayList<>();
  75         policyDecoders.add(policyDecoder1);
  76         policyDecoders.add(policyDecoder2);
  77
  78         final DummyPolicyForwarder policyForwarder1 = new DummyPolicyForwarder();
  79         final DummyPolicyForwarder policyForwarder2 = new DummyPolicyForwarder();
  80
  81         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
  82         policyForwarders.add(policyForwarder1);
  83         policyForwarders.add(policyForwarder2);
  84
  85         setUpPlugins(handler, policyDecoders, policyForwarders);
  86
  87         handler.inputReceived(new DummyPolicyInput());
  88
  89         assertEquals(2, policyForwarder1.getNumberOfPoliciesReceived());
  90         assertTrue(policyForwarder1.receivedPolicy(generatedPolicy1));
  91         assertTrue(policyForwarder1.receivedPolicy(generatedPolicy2));
  92         assertEquals(2, policyForwarder2.getNumberOfPoliciesReceived());
  93         assertTrue(policyForwarder2.receivedPolicy(generatedPolicy1));
  94         assertTrue(policyForwarder2.receivedPolicy(generatedPolicy2));
  95     }
  96
  97     @Test(expected = PolicyDecodingException.class)
  98     public void testInputReceivedNoSupportingDecoder() throws PolicyDecodingException, NoSuchFieldException,
  99             SecurityException, IllegalArgumentException, IllegalAccessException, PluginInitializationException {
 100         final AbstractReceptionHandler handler = new DummyReceptionHandler();
 101
 102         final PolicyDecoder<PolicyInput, Policy> policyDecoder = new DummyDecoder(false, Collections.emptyList());
 103         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 104         setUpPlugins(handler, Collections.singleton(policyDecoder), Collections.singleton(policyForwarder));
 105
 106         handler.inputReceived(new DummyPolicyInput());
 107     }
 108
 109     @Test(expected = PolicyDecodingException.class)
 110     public void testInputReceivedNoDecoder() throws PolicyDecodingException, NoSuchFieldException, SecurityException,
 111             IllegalArgumentException, IllegalAccessException, PluginInitializationException {
 112         final AbstractReceptionHandler handler = new DummyReceptionHandler();
 113
 114         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 115         setUpPlugins(handler, Collections.emptySet(), Collections.singleton(policyForwarder));
 116
 117         handler.inputReceived(new DummyPolicyInput());
 118     }
 119
 120     class DummyPolicyInput implements PolicyInput {
 121     }
 122
 123     class DummyPolicy1 implements Policy {
 124
 125         @Override
 126         public String getPolicyName() {
 127             return null;
 128         }
 129
 130         @Override
 131         public String getPolicyType() {
 132             return null;
 133         }
 134     }
 135
 136     class DummyPolicy2 implements Policy {
 137
 138         @Override
 139         public String getPolicyName() {
 140             return null;
 141         }
 142
 143         @Override
 144         public String getPolicyType() {
 145             return null;
 146         }
 147     }
 148
 149     private void setUpPlugins(final AbstractReceptionHandler receptionHandler,
 150             final Collection<PolicyDecoder<PolicyInput, Policy>> decoders, final Collection<PolicyForwarder> forwarders)
 151             throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException,
 152             PluginInitializationException {
 153         final PluginHandlerParameters pluginParameters = getPluginHandlerParameters();
 154         pluginParameters.setName(DISTRIBUTION_GROUP);
 155         ParameterService.register(pluginParameters);
 156         final PluginHandler pluginHandler = new PluginHandler(pluginParameters.getName());
 157
 158         final Field decodersField = pluginHandler.getClass().getDeclaredField("policyDecoders");
 159         decodersField.setAccessible(true);
 160         decodersField.set(pluginHandler, decoders);
 161
 162         final Field forwardersField = pluginHandler.getClass().getDeclaredField("policyForwarders");
 163         forwardersField.setAccessible(true);
 164         forwardersField.set(pluginHandler, forwarders);
 165
 166         final Field pluginHandlerField = AbstractReceptionHandler.class.getDeclaredField("pluginHandler");
 167         pluginHandlerField.setAccessible(true);
 168         pluginHandlerField.set(receptionHandler, pluginHandler);
 169         ParameterService.deregister(pluginParameters.getName());
 170     }
 171
 172     private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
 173         final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
 174         final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters(DECODER_TYPE, DECODER_CLASS_NAME);
 175         policyDecoders.put(DECODER_KEY, pDParameters);
 176         return policyDecoders;
 177     }
 178
 179     private Map<String, PolicyForwarderParameters> getPolicyForwarders() {
 180         final Map<String, PolicyForwarderParameters> policyForwarders =
 181                 new HashMap<String, PolicyForwarderParameters>();
 182         final PolicyForwarderParameters pFParameters =
 183                 new PolicyForwarderParameters(FORWARDER_TYPE, FORWARDER_CLASS_NAME, FORWARDER_CONFIGURATION_PARAMETERS);
 184         policyForwarders.put(FORWARDER_KEY, pFParameters);
 185         return policyForwarders;
 186     }
 187
 188     private PluginHandlerParameters getPluginHandlerParameters() {
 189         final Map<String, PolicyDecoderParameters> policyDecoders = getPolicyDecoders();
 190         final Map<String, PolicyForwarderParameters> policyForwarders = getPolicyForwarders();
 191         final PluginHandlerParameters pluginHandlerParameters =
 192                 new PluginHandlerParameters(policyDecoders, policyForwarders);
 193         return pluginHandlerParameters;
 194     }
 195
 196 }