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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Intel. 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.sdc;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertTrue;
  25 import static org.junit.Assert.fail;
  26 import static org.mockito.Matchers.any;
  27
  28 import com.google.gson.Gson;
  29 import com.google.gson.GsonBuilder;
  30
  31 import java.io.FileReader;
  32 import java.io.IOException;
  33 import java.lang.reflect.Field;
  34 import java.util.ArrayList;
  35 import java.util.Arrays;
  36 import java.util.Collection;
  37 import java.util.HashMap;
  38 import java.util.Map;
  39
  40 import org.junit.After;
  41 import org.junit.Before;
  42 import org.junit.Test;
  43 import org.junit.runner.RunWith;
  44 import org.mockito.Mock;
  45 import org.mockito.Mockito;
  46 import org.mockito.runners.MockitoJUnitRunner;
  47 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  48 import org.onap.policy.common.logging.flexlogger.Logger;
  49 import org.onap.policy.common.parameters.ParameterService;
  50 import org.onap.policy.distribution.forwarding.PolicyForwarder;
  51 import org.onap.policy.distribution.forwarding.parameters.PolicyForwarderParameters;
  52 import org.onap.policy.distribution.model.Csar;
  53 import org.onap.policy.distribution.reception.decoding.PluginInitializationException;
  54 import org.onap.policy.distribution.reception.decoding.PluginTerminationException;
  55 import org.onap.policy.distribution.reception.decoding.PolicyDecoder;
  56 import org.onap.policy.distribution.reception.handling.AbstractReceptionHandler;
  57 import org.onap.policy.distribution.reception.handling.PluginHandler;
  58 import org.onap.policy.distribution.reception.parameters.PluginHandlerParameters;
  59 import org.onap.policy.distribution.reception.parameters.PolicyDecoderParameters;
  60 import org.onap.sdc.api.notification.IArtifactInfo;
  61 import org.onap.sdc.api.notification.INotificationData;
  62 import org.onap.sdc.api.results.IDistributionClientDownloadResult;
  63 import org.onap.sdc.api.results.IDistributionClientResult;
  64 import org.onap.sdc.impl.mock.DistributionClientStubImpl;
  65 import org.onap.sdc.utils.DistributionActionResultEnum;
  66
  67 /**
  68  * Class to perform unit test of {@link SdcReceptionHandler}.
  69  *
  70  * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
  71  */
  72 @RunWith(MockitoJUnitRunner.class)
  73 public class TestSdcReceptionHandler {
  74
  75     private static final Logger LOGGER = FlexLogger.getLogger(TestSdcReceptionHandler.class);
  76     private static final String DUMMY_SERVICE_CSAR = "dummyService.csar";
  77
  78     @Mock
  79     private IDistributionClientResult successfulClientInitResult;
  80     @Mock
  81     private IDistributionClientResult failureClientInitResult;
  82     @Mock
  83     private DistributionClientStubImpl distributionClient;
  84     @Mock
  85     private IDistributionClientDownloadResult successfulClientDownloadResult;
  86     @Mock
  87     private INotificationData notificationData;
  88     @Mock
  89     private IArtifactInfo artifactInfo;
  90
  91     private SdcReceptionHandlerConfigurationParameterGroup pssdConfigParameters;
  92     private SdcReceptionHandler sypHandler;
  93
  94
  95     /**
  96      * Setup for the test cases.
  97      *
  98      * @throws IOException if it occurs
  99      */
 100     @Before
 101     public final void init() throws IOException {
 102         final Gson gson = new GsonBuilder().create();
 103         pssdConfigParameters = gson.fromJson(new FileReader("src/test/resources/handling-sdc.json"),
 104                 SdcReceptionHandlerConfigurationParameterGroup.class);
 105         ParameterService.register(pssdConfigParameters);
 106         final SdcReceptionHandler sdcHandler = new SdcReceptionHandler();
 107         sypHandler = Mockito.spy(sdcHandler);
 108
 109         Mockito.when(sypHandler.createSdcDistributionClient()).thenReturn(distributionClient);
 110         Mockito.when(distributionClient.init(any(), any())).thenReturn(successfulClientInitResult);
 111         Mockito.when(distributionClient.start()).thenReturn(successfulClientInitResult);
 112         Mockito.when(distributionClient.stop()).thenReturn(successfulClientInitResult);
 113         Mockito.when(distributionClient.download(any())).thenReturn(successfulClientDownloadResult);
 114         Mockito.when(notificationData.getServiceArtifacts()).thenReturn(Arrays.asList(artifactInfo));
 115         Mockito.when(artifactInfo.getArtifactName()).thenReturn(DUMMY_SERVICE_CSAR);
 116         Mockito.when(successfulClientDownloadResult.getArtifactPayload()).thenReturn(new byte[1]);
 117         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 118                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 119         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 120                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 121
 122     }
 123
 124     @After
 125     public void teardown() {
 126         ParameterService.deregister(pssdConfigParameters);
 127     }
 128
 129     @Test
 130     public final void testInitializeSdcClient() {
 131         try {
 132             sypHandler.initializeReception(pssdConfigParameters.getName());
 133         } catch (final PluginInitializationException exp) {
 134             LOGGER.error(exp);
 135             fail("Test should not throw any exception");
 136         }
 137     }
 138
 139     @Test
 140     public final void testInitializeSdcClient_Again() throws PluginInitializationException {
 141         sypHandler.initializeReception(pssdConfigParameters.getName());
 142         try {
 143             sypHandler.initializeReception(pssdConfigParameters.getName());
 144             fail("Test must throw an exception here");
 145         } catch (final Exception exp) {
 146             assertTrue(exp.getMessage().startsWith("The SDC Client is already initialized"));
 147         }
 148     }
 149
 150     @Test
 151     public final void testInitializeSdcClient_Failure() throws PluginInitializationException {
 152
 153         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 154                 .thenReturn(DistributionActionResultEnum.FAIL);
 155         try {
 156             sypHandler.initializeReception(pssdConfigParameters.getName());
 157             fail("Test must throw an exception here");
 158         } catch (final Exception exp) {
 159             assertTrue(exp.getMessage().startsWith("SDC client initialization failed with reason"));
 160         }
 161     }
 162
 163     @Test
 164     public final void testStartSdcClient_Failure() throws PluginInitializationException {
 165         try {
 166             Mockito.when(distributionClient.start()).thenReturn(failureClientInitResult);
 167             Mockito.when(failureClientInitResult.getDistributionActionResult())
 168                     .thenReturn(DistributionActionResultEnum.FAIL);
 169             sypHandler.initializeReception(pssdConfigParameters.getName());
 170
 171             fail("Test must throw an exception here");
 172         } catch (final Exception exp) {
 173             assertTrue(exp.getMessage().startsWith("SDC client start failed with reason"));
 174         }
 175     }
 176
 177     @Test
 178     public final void testStopSdcClient() {
 179         try {
 180             sypHandler.initializeReception(pssdConfigParameters.getName());
 181             sypHandler.destroy();
 182         } catch (final PluginInitializationException | PluginTerminationException exp) {
 183             LOGGER.error(exp);
 184             fail("Test should not throw any exception");
 185         }
 186
 187     }
 188
 189     @Test
 190     public final void testStopSdcClientWithoutStart() {
 191         try {
 192             sypHandler.destroy();
 193         } catch (final PluginTerminationException exp) {
 194             LOGGER.error(exp);
 195             fail("Test should not throw any exception");
 196         }
 197
 198     }
 199
 200     @Test
 201     public final void testStopSdcClient_Failure() throws PluginInitializationException {
 202
 203         sypHandler.initializeReception(pssdConfigParameters.getName());
 204         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 205                 .thenReturn(DistributionActionResultEnum.FAIL);
 206         try {
 207             sypHandler.destroy();
 208             fail("Test must throw an exception here");
 209         } catch (final Exception exp) {
 210             assertTrue(exp.getMessage().startsWith("SDC client stop failed with reason"));
 211         }
 212     }
 213
 214     @Test
 215     public void testNotificationCallBack() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 216             IllegalAccessException, PluginInitializationException {
 217
 218         final DummyDecoder policyDecoder = new DummyDecoder();
 219         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 220         policyDecoders.add(policyDecoder);
 221
 222         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 223         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 224         policyForwarders.add(policyForwarder);
 225
 226         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 227         sypHandler.initializeReception(pssdConfigParameters.getName());
 228         sypHandler.activateCallback(notificationData);
 229
 230         assertEquals(DummyDecoder.DUMMY_POLICY, policyDecoder.getDecodedPolicy().getPolicyType());
 231         assertTrue(policyDecoder.getDecodedPolicy().getPolicyName().contains(DUMMY_SERVICE_CSAR));
 232         assertEquals(1, policyForwarder.getNumberOfPoliciesReceived());
 233         assertTrue(policyForwarder.receivedPolicyWithGivenType(DummyDecoder.DUMMY_POLICY));
 234     }
 235
 236     @Test
 237     public void testDownloadArtifactFailure() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 238             IllegalAccessException, PluginInitializationException {
 239
 240         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 241                 .thenReturn(DistributionActionResultEnum.FAIL);
 242
 243         final DummyDecoder policyDecoder = new DummyDecoder();
 244         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 245         policyDecoders.add(policyDecoder);
 246
 247         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 248         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 249         policyForwarders.add(policyForwarder);
 250
 251         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 252         sypHandler.initializeReception(pssdConfigParameters.getName());
 253         sypHandler.activateCallback(notificationData);
 254
 255         assertEquals(null, policyDecoder.getDecodedPolicy());
 256         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 257     }
 258
 259     private void setUpPlugins(final AbstractReceptionHandler receptionHandler,
 260             final Collection<PolicyDecoder<Csar, DummyPolicy>> decoders, final Collection<PolicyForwarder> forwarders)
 261             throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException,
 262             PluginInitializationException {
 263         final PluginHandlerParameters pluginParameters = getPluginHandlerParameters();
 264         pluginParameters.setName("DummyDistributionGroup");
 265         ParameterService.register(pluginParameters);
 266         final PluginHandler pluginHandler = new PluginHandler(pluginParameters.getName());
 267
 268         final Field decodersField = pluginHandler.getClass().getDeclaredField("policyDecoders");
 269         decodersField.setAccessible(true);
 270         decodersField.set(pluginHandler, decoders);
 271
 272         final Field forwardersField = pluginHandler.getClass().getDeclaredField("policyForwarders");
 273         forwardersField.setAccessible(true);
 274         forwardersField.set(pluginHandler, forwarders);
 275
 276         final Field pluginHandlerField = AbstractReceptionHandler.class.getDeclaredField("pluginHandler");
 277         pluginHandlerField.setAccessible(true);
 278         pluginHandlerField.set(receptionHandler, pluginHandler);
 279         ParameterService.deregister(pluginParameters.getName());
 280     }
 281
 282     private PluginHandlerParameters getPluginHandlerParameters() {
 283         final Map<String, PolicyDecoderParameters> policyDecoders = getPolicyDecoders();
 284         final Map<String, PolicyForwarderParameters> policyForwarders = getPolicyForwarders();
 285         final PluginHandlerParameters pluginHandlerParameters =
 286                 new PluginHandlerParameters(policyDecoders, policyForwarders);
 287         return pluginHandlerParameters;
 288     }
 289
 290     private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
 291         final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
 292         final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("DummyDecoder",
 293                 "org.onap.policy.distribution.reception.handling.sdc.DummyDecoder");
 294         policyDecoders.put("DummyDecoderKey", pDParameters);
 295         return policyDecoders;
 296     }
 297
 298     private Map<String, PolicyForwarderParameters> getPolicyForwarders() {
 299         final Map<String, PolicyForwarderParameters> policyForwarders =
 300                 new HashMap<String, PolicyForwarderParameters>();
 301         final PolicyForwarderParameters pFParameters = new PolicyForwarderParameters("DummyForwarder",
 302                 "org.onap.policy.distribution.reception.handling.sdc.DummyPolicyForwarder", "DummyConfiguration");
 303         policyForwarders.put("DummyForwarderKey", pFParameters);
 304         return policyForwarders;
 305     }
 306 }