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.sendComponentDoneStatus(any())).thenReturn(successfulClientInitResult);
 114         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(successfulClientInitResult);
 115         Mockito.when(distributionClient.sendDownloadStatus(any())).thenReturn(successfulClientInitResult);
 116         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(successfulClientInitResult);
 117         Mockito.when(distributionClient.sendDeploymentStatus(any())).thenReturn(successfulClientInitResult);
 118         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(successfulClientInitResult);
 119         Mockito.when(distributionClient.download(any())).thenReturn(successfulClientDownloadResult);
 120         Mockito.when(notificationData.getServiceArtifacts()).thenReturn(Arrays.asList(artifactInfo));
 121         Mockito.when(artifactInfo.getArtifactName()).thenReturn(DUMMY_SERVICE_CSAR);
 122         Mockito.when(successfulClientDownloadResult.getArtifactPayload()).thenReturn(new byte[1]);
 123         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 124                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 125         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 126                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 127         Mockito.when(failureClientInitResult.getDistributionActionResult())
 128                 .thenReturn(DistributionActionResultEnum.FAIL);
 129
 130     }
 131
 132     @After
 133     public void teardown() {
 134         ParameterService.deregister(pssdConfigParameters);
 135     }
 136
 137     @Test
 138     public final void testInitializeSdcClient() {
 139         try {
 140             sypHandler.initializeReception(pssdConfigParameters.getName());
 141         } catch (final PluginInitializationException exp) {
 142             LOGGER.error(exp);
 143             fail("Test should not throw any exception");
 144         }
 145     }
 146
 147     @Test
 148     public final void testInitializeSdcClient_Again() throws PluginInitializationException {
 149         sypHandler.initializeReception(pssdConfigParameters.getName());
 150         try {
 151             sypHandler.initializeReception(pssdConfigParameters.getName());
 152             fail("Test must throw an exception here");
 153         } catch (final Exception exp) {
 154             assertTrue(exp.getMessage().startsWith("The SDC Client is already initialized"));
 155         }
 156     }
 157
 158     @Test
 159     public final void testInitializeSdcClient_Failure() throws PluginInitializationException {
 160
 161         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 162                 .thenReturn(DistributionActionResultEnum.FAIL);
 163         try {
 164             sypHandler.initializeReception(pssdConfigParameters.getName());
 165             fail("Test must throw an exception here");
 166         } catch (final Exception exp) {
 167             assertTrue(exp.getMessage().startsWith("SDC client initialization failed with reason"));
 168         }
 169     }
 170
 171     @Test
 172     public final void testStartSdcClient_Failure() throws PluginInitializationException {
 173         try {
 174             Mockito.when(distributionClient.start()).thenReturn(failureClientInitResult);
 175             sypHandler.initializeReception(pssdConfigParameters.getName());
 176
 177             fail("Test must throw an exception here");
 178         } catch (final Exception exp) {
 179             assertTrue(exp.getMessage().startsWith("SDC client start failed with reason"));
 180         }
 181     }
 182
 183     @Test
 184     public final void testStopSdcClient() {
 185         try {
 186             sypHandler.initializeReception(pssdConfigParameters.getName());
 187             sypHandler.destroy();
 188         } catch (final PluginInitializationException | PluginTerminationException exp) {
 189             LOGGER.error(exp);
 190             fail("Test should not throw any exception");
 191         }
 192
 193     }
 194
 195     @Test
 196     public final void testStopSdcClientWithoutStart() {
 197         try {
 198             sypHandler.destroy();
 199         } catch (final PluginTerminationException exp) {
 200             LOGGER.error(exp);
 201             fail("Test should not throw any exception");
 202         }
 203
 204     }
 205
 206     @Test
 207     public final void testStopSdcClient_Failure() throws PluginInitializationException {
 208
 209         sypHandler.initializeReception(pssdConfigParameters.getName());
 210         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 211                 .thenReturn(DistributionActionResultEnum.FAIL);
 212         try {
 213             sypHandler.destroy();
 214             fail("Test must throw an exception here");
 215         } catch (final Exception exp) {
 216             assertTrue(exp.getMessage().startsWith("SDC client stop failed with reason"));
 217         }
 218     }
 219
 220     @Test
 221     public void testNotificationCallBack() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 222             IllegalAccessException, PluginInitializationException {
 223
 224         final DummyDecoder policyDecoder = new DummyDecoder();
 225         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 226         policyDecoders.add(policyDecoder);
 227
 228         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 229         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 230         policyForwarders.add(policyForwarder);
 231
 232         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 233         sypHandler.initializeReception(pssdConfigParameters.getName());
 234         sypHandler.activateCallback(notificationData);
 235
 236         assertEquals(DummyDecoder.DUMMY_POLICY, policyDecoder.getDecodedPolicy().getPolicyType());
 237         assertTrue(policyDecoder.getDecodedPolicy().getPolicyName().contains(DUMMY_SERVICE_CSAR));
 238         assertEquals(1, policyForwarder.getNumberOfPoliciesReceived());
 239         assertTrue(policyForwarder.receivedPolicyWithGivenType(DummyDecoder.DUMMY_POLICY));
 240     }
 241
 242     @Test
 243     public void testDownloadArtifactFailure() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 244             IllegalAccessException, PluginInitializationException {
 245
 246         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 247                 .thenReturn(DistributionActionResultEnum.FAIL);
 248
 249         final DummyDecoder policyDecoder = new DummyDecoder();
 250         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 251         policyDecoders.add(policyDecoder);
 252
 253         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 254         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 255         policyForwarders.add(policyForwarder);
 256
 257         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 258         sypHandler.initializeReception(pssdConfigParameters.getName());
 259         sypHandler.activateCallback(notificationData);
 260
 261         assertEquals(null, policyDecoder.getDecodedPolicy());
 262         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 263     }
 264
 265     @Test
 266     public void testSendDistributionStatusFailure() throws NoSuchFieldException, SecurityException,
 267             IllegalArgumentException, IllegalAccessException, PluginInitializationException {
 268
 269         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 270                 .thenReturn(DistributionActionResultEnum.FAIL);
 271         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(failureClientInitResult);
 272         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(failureClientInitResult);
 273         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(failureClientInitResult);
 274
 275         final DummyDecoder policyDecoder = new DummyDecoder();
 276         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 277         policyDecoders.add(policyDecoder);
 278
 279         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 280         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 281         policyForwarders.add(policyForwarder);
 282
 283         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 284         sypHandler.initializeReception(pssdConfigParameters.getName());
 285         sypHandler.activateCallback(notificationData);
 286
 287         assertEquals(null, policyDecoder.getDecodedPolicy());
 288         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 289     }
 290
 291     private void setUpPlugins(final AbstractReceptionHandler receptionHandler,
 292             final Collection<PolicyDecoder<Csar, DummyPolicy>> decoders, final Collection<PolicyForwarder> forwarders)
 293             throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException,
 294             PluginInitializationException {
 295         final PluginHandlerParameters pluginParameters = getPluginHandlerParameters();
 296         pluginParameters.setName("DummyDistributionGroup");
 297         ParameterService.register(pluginParameters);
 298         final PluginHandler pluginHandler = new PluginHandler(pluginParameters.getName());
 299
 300         final Field decodersField = pluginHandler.getClass().getDeclaredField("policyDecoders");
 301         decodersField.setAccessible(true);
 302         decodersField.set(pluginHandler, decoders);
 303
 304         final Field forwardersField = pluginHandler.getClass().getDeclaredField("policyForwarders");
 305         forwardersField.setAccessible(true);
 306         forwardersField.set(pluginHandler, forwarders);
 307
 308         final Field pluginHandlerField = AbstractReceptionHandler.class.getDeclaredField("pluginHandler");
 309         pluginHandlerField.setAccessible(true);
 310         pluginHandlerField.set(receptionHandler, pluginHandler);
 311         ParameterService.deregister(pluginParameters.getName());
 312     }
 313
 314     private PluginHandlerParameters getPluginHandlerParameters() {
 315         final Map<String, PolicyDecoderParameters> policyDecoders = getPolicyDecoders();
 316         final Map<String, PolicyForwarderParameters> policyForwarders = getPolicyForwarders();
 317         final PluginHandlerParameters pluginHandlerParameters =
 318                 new PluginHandlerParameters(policyDecoders, policyForwarders);
 319         return pluginHandlerParameters;
 320     }
 321
 322     private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
 323         final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
 324         final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("DummyDecoder",
 325                 "org.onap.policy.distribution.reception.handling.sdc.DummyDecoder");
 326         policyDecoders.put("DummyDecoderKey", pDParameters);
 327         return policyDecoders;
 328     }
 329
 330     private Map<String, PolicyForwarderParameters> getPolicyForwarders() {
 331         final Map<String, PolicyForwarderParameters> policyForwarders =
 332                 new HashMap<String, PolicyForwarderParameters>();
 333         final PolicyForwarderParameters pFParameters = new PolicyForwarderParameters("DummyForwarder",
 334                 "org.onap.policy.distribution.reception.handling.sdc.DummyPolicyForwarder", "DummyConfiguration");
 335         policyForwarders.put("DummyForwarderKey", pFParameters);
 336         return policyForwarders;
 337     }
 338 }