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.policy.distribution.reception.statistics.DistributionStatisticsManager;
  61 import org.onap.sdc.api.notification.IArtifactInfo;
  62 import org.onap.sdc.api.notification.INotificationData;
  63 import org.onap.sdc.api.results.IDistributionClientDownloadResult;
  64 import org.onap.sdc.api.results.IDistributionClientResult;
  65 import org.onap.sdc.impl.mock.DistributionClientStubImpl;
  66 import org.onap.sdc.utils.DistributionActionResultEnum;
  67
  68 /**
  69  * Class to perform unit test of {@link SdcReceptionHandler}.
  70  *
  71  * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
  72  */
  73 @RunWith(MockitoJUnitRunner.class)
  74 public class TestSdcReceptionHandler {
  75
  76     private static final Logger LOGGER = FlexLogger.getLogger(TestSdcReceptionHandler.class);
  77     private static final String DUMMY_SERVICE_CSAR = "dummyService.csar";
  78
  79     @Mock
  80     private IDistributionClientResult successfulClientInitResult;
  81     @Mock
  82     private IDistributionClientResult failureClientInitResult;
  83     @Mock
  84     private DistributionClientStubImpl distributionClient;
  85     @Mock
  86     private IDistributionClientDownloadResult successfulClientDownloadResult;
  87     @Mock
  88     private INotificationData notificationData;
  89     @Mock
  90     private IArtifactInfo artifactInfo;
  91
  92     private SdcReceptionHandlerConfigurationParameterGroup pssdConfigParameters;
  93     private SdcReceptionHandler sypHandler;
  94
  95
  96     /**
  97      * Setup for the test cases.
  98      *
  99      * @throws IOException if it occurs
 100      */
 101     @Before
 102     public final void init() throws IOException {
 103         DistributionStatisticsManager.resetAllStatistics();
 104         final Gson gson = new GsonBuilder().create();
 105         pssdConfigParameters = gson.fromJson(new FileReader("src/test/resources/handling-sdc.json"),
 106                 SdcReceptionHandlerConfigurationParameterGroup.class);
 107         ParameterService.register(pssdConfigParameters);
 108         final SdcReceptionHandler sdcHandler = new SdcReceptionHandler();
 109         sypHandler = Mockito.spy(sdcHandler);
 110
 111         Mockito.when(sypHandler.createSdcDistributionClient()).thenReturn(distributionClient);
 112         Mockito.when(distributionClient.init(any(), any())).thenReturn(successfulClientInitResult);
 113         Mockito.when(distributionClient.start()).thenReturn(successfulClientInitResult);
 114         Mockito.when(distributionClient.stop()).thenReturn(successfulClientInitResult);
 115         Mockito.when(distributionClient.sendComponentDoneStatus(any())).thenReturn(successfulClientInitResult);
 116         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(successfulClientInitResult);
 117         Mockito.when(distributionClient.sendDownloadStatus(any())).thenReturn(successfulClientInitResult);
 118         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(successfulClientInitResult);
 119         Mockito.when(distributionClient.sendDeploymentStatus(any())).thenReturn(successfulClientInitResult);
 120         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(successfulClientInitResult);
 121         Mockito.when(distributionClient.download(any())).thenReturn(successfulClientDownloadResult);
 122         Mockito.when(notificationData.getServiceArtifacts()).thenReturn(Arrays.asList(artifactInfo));
 123         Mockito.when(artifactInfo.getArtifactName()).thenReturn(DUMMY_SERVICE_CSAR);
 124         Mockito.when(successfulClientDownloadResult.getArtifactPayload()).thenReturn(new byte[1]);
 125         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 126                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 127         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 128                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 129         Mockito.when(failureClientInitResult.getDistributionActionResult())
 130                 .thenReturn(DistributionActionResultEnum.FAIL);
 131
 132     }
 133
 134     @After
 135     public void teardown() {
 136         ParameterService.deregister(pssdConfigParameters);
 137     }
 138
 139     @Test
 140     public final void testInitializeSdcClient() {
 141         try {
 142             sypHandler.initializeReception(pssdConfigParameters.getName());
 143         } catch (final PluginInitializationException exp) {
 144             LOGGER.error(exp);
 145             fail("Test should not throw any exception");
 146         }
 147     }
 148
 149     @Test
 150     public final void testInitializeSdcClient_Again() throws PluginInitializationException {
 151         sypHandler.initializeReception(pssdConfigParameters.getName());
 152         try {
 153             sypHandler.initializeReception(pssdConfigParameters.getName());
 154             fail("Test must throw an exception here");
 155         } catch (final Exception exp) {
 156             assertTrue(exp.getMessage().startsWith("The SDC Client is already initialized"));
 157         }
 158     }
 159
 160     @Test
 161     public final void testInitializeSdcClient_Failure() throws PluginInitializationException {
 162
 163         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 164                 .thenReturn(DistributionActionResultEnum.FAIL);
 165         try {
 166             sypHandler.initializeReception(pssdConfigParameters.getName());
 167             fail("Test must throw an exception here");
 168         } catch (final Exception exp) {
 169             assertTrue(exp.getMessage().startsWith("SDC client initialization failed with reason"));
 170         }
 171     }
 172
 173     @Test
 174     public final void testStartSdcClient_Failure() throws PluginInitializationException {
 175         try {
 176             Mockito.when(distributionClient.start()).thenReturn(failureClientInitResult);
 177             sypHandler.initializeReception(pssdConfigParameters.getName());
 178
 179             fail("Test must throw an exception here");
 180         } catch (final Exception exp) {
 181             assertTrue(exp.getMessage().startsWith("SDC client start failed with reason"));
 182         }
 183     }
 184
 185     @Test
 186     public final void testStopSdcClient() {
 187         try {
 188             sypHandler.initializeReception(pssdConfigParameters.getName());
 189             sypHandler.destroy();
 190         } catch (final PluginInitializationException | PluginTerminationException exp) {
 191             LOGGER.error(exp);
 192             fail("Test should not throw any exception");
 193         }
 194
 195     }
 196
 197     @Test
 198     public final void testStopSdcClientWithoutStart() {
 199         try {
 200             sypHandler.destroy();
 201         } catch (final PluginTerminationException exp) {
 202             LOGGER.error(exp);
 203             fail("Test should not throw any exception");
 204         }
 205
 206     }
 207
 208     @Test
 209     public final void testStopSdcClient_Failure() throws PluginInitializationException {
 210
 211         sypHandler.initializeReception(pssdConfigParameters.getName());
 212         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 213                 .thenReturn(DistributionActionResultEnum.FAIL);
 214         try {
 215             sypHandler.destroy();
 216             fail("Test must throw an exception here");
 217         } catch (final Exception exp) {
 218             assertTrue(exp.getMessage().startsWith("SDC client stop failed with reason"));
 219         }
 220     }
 221
 222     @Test
 223     public void testNotificationCallBack() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 224             IllegalAccessException, PluginInitializationException {
 225
 226         final DummyDecoder policyDecoder = new DummyDecoder();
 227         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 228         policyDecoders.add(policyDecoder);
 229
 230         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 231         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 232         policyForwarders.add(policyForwarder);
 233
 234         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 235         sypHandler.initializeReception(pssdConfigParameters.getName());
 236         sypHandler.activateCallback(notificationData);
 237
 238         assertEquals(DummyDecoder.DUMMY_POLICY, policyDecoder.getDecodedPolicy().getPolicyType());
 239         assertTrue(policyDecoder.getDecodedPolicy().getPolicyName().contains(DUMMY_SERVICE_CSAR));
 240         assertEquals(1, policyForwarder.getNumberOfPoliciesReceived());
 241         assertTrue(policyForwarder.receivedPolicyWithGivenType(DummyDecoder.DUMMY_POLICY));
 242         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 243         assertEquals(1, DistributionStatisticsManager.getDistributionSuccessCount());
 244         assertEquals(0, DistributionStatisticsManager.getDistributionFailureCount());
 245         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 246         assertEquals(1, DistributionStatisticsManager.getDownloadSuccessCount());
 247         assertEquals(0, DistributionStatisticsManager.getDownloadFailureCount());
 248     }
 249
 250     @Test
 251     public void testDownloadArtifactFailure() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 252             IllegalAccessException, PluginInitializationException {
 253
 254         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 255                 .thenReturn(DistributionActionResultEnum.FAIL);
 256
 257         final DummyDecoder policyDecoder = new DummyDecoder();
 258         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 259         policyDecoders.add(policyDecoder);
 260
 261         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 262         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 263         policyForwarders.add(policyForwarder);
 264
 265         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 266         sypHandler.initializeReception(pssdConfigParameters.getName());
 267         sypHandler.activateCallback(notificationData);
 268
 269         assertEquals(null, policyDecoder.getDecodedPolicy());
 270         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 271         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 272         assertEquals(0, DistributionStatisticsManager.getDistributionSuccessCount());
 273         assertEquals(1, DistributionStatisticsManager.getDistributionFailureCount());
 274         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 275         assertEquals(0, DistributionStatisticsManager.getDownloadSuccessCount());
 276         assertEquals(1, DistributionStatisticsManager.getDownloadFailureCount());
 277     }
 278
 279     @Test
 280     public void testSendDistributionStatusFailure() throws NoSuchFieldException, SecurityException,
 281             IllegalArgumentException, IllegalAccessException, PluginInitializationException {
 282
 283         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 284                 .thenReturn(DistributionActionResultEnum.FAIL);
 285         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(failureClientInitResult);
 286         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(failureClientInitResult);
 287         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(failureClientInitResult);
 288
 289         final DummyDecoder policyDecoder = new DummyDecoder();
 290         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 291         policyDecoders.add(policyDecoder);
 292
 293         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 294         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 295         policyForwarders.add(policyForwarder);
 296
 297         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 298         sypHandler.initializeReception(pssdConfigParameters.getName());
 299         sypHandler.activateCallback(notificationData);
 300
 301         assertEquals(null, policyDecoder.getDecodedPolicy());
 302         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 303     }
 304
 305     private void setUpPlugins(final AbstractReceptionHandler receptionHandler,
 306             final Collection<PolicyDecoder<Csar, DummyPolicy>> decoders, final Collection<PolicyForwarder> forwarders)
 307             throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException,
 308             PluginInitializationException {
 309         final PluginHandlerParameters pluginParameters = getPluginHandlerParameters();
 310         pluginParameters.setName("DummyDistributionGroup");
 311         ParameterService.register(pluginParameters);
 312         final PluginHandler pluginHandler = new PluginHandler(pluginParameters.getName());
 313
 314         final Field decodersField = pluginHandler.getClass().getDeclaredField("policyDecoders");
 315         decodersField.setAccessible(true);
 316         decodersField.set(pluginHandler, decoders);
 317
 318         final Field forwardersField = pluginHandler.getClass().getDeclaredField("policyForwarders");
 319         forwardersField.setAccessible(true);
 320         forwardersField.set(pluginHandler, forwarders);
 321
 322         final Field pluginHandlerField = AbstractReceptionHandler.class.getDeclaredField("pluginHandler");
 323         pluginHandlerField.setAccessible(true);
 324         pluginHandlerField.set(receptionHandler, pluginHandler);
 325         ParameterService.deregister(pluginParameters.getName());
 326     }
 327
 328     private PluginHandlerParameters getPluginHandlerParameters() {
 329         final Map<String, PolicyDecoderParameters> policyDecoders = getPolicyDecoders();
 330         final Map<String, PolicyForwarderParameters> policyForwarders = getPolicyForwarders();
 331         final PluginHandlerParameters pluginHandlerParameters =
 332                 new PluginHandlerParameters(policyDecoders, policyForwarders);
 333         return pluginHandlerParameters;
 334     }
 335
 336     private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
 337         final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
 338         final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("DummyDecoder",
 339                 "org.onap.policy.distribution.reception.handling.sdc.DummyDecoder", "DummyDecoderConfiguration");
 340         policyDecoders.put("DummyDecoderKey", pDParameters);
 341         return policyDecoders;
 342     }
 343
 344     private Map<String, PolicyForwarderParameters> getPolicyForwarders() {
 345         final Map<String, PolicyForwarderParameters> policyForwarders =
 346                 new HashMap<String, PolicyForwarderParameters>();
 347         final PolicyForwarderParameters pFParameters = new PolicyForwarderParameters("DummyForwarder",
 348                 "org.onap.policy.distribution.reception.handling.sdc.DummyPolicyForwarder", "DummyConfiguration");
 349         policyForwarders.put("DummyForwarderKey", pFParameters);
 350         return policyForwarders;
 351     }
 352 }