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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Intel. All rights reserved.
   4  *  Copyright (C) 2019 Nordix Foundation.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.distribution.reception.handling.sdc;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.junit.Assert.fail;
  27 import static org.mockito.Matchers.any;
  28
  29 import com.google.gson.Gson;
  30 import com.google.gson.GsonBuilder;
  31
  32 import java.io.FileReader;
  33 import java.io.IOException;
  34 import java.lang.reflect.Field;
  35 import java.util.ArrayList;
  36 import java.util.Arrays;
  37 import java.util.Collection;
  38 import java.util.HashMap;
  39 import java.util.Map;
  40
  41 import org.junit.After;
  42 import org.junit.Before;
  43 import org.junit.Test;
  44 import org.junit.runner.RunWith;
  45 import org.mockito.Mock;
  46 import org.mockito.Mockito;
  47 import org.mockito.runners.MockitoJUnitRunner;
  48 import org.onap.policy.common.parameters.ParameterService;
  49 import org.onap.policy.distribution.forwarding.PolicyForwarder;
  50 import org.onap.policy.distribution.forwarding.parameters.PolicyForwarderParameters;
  51 import org.onap.policy.distribution.model.Csar;
  52 import org.onap.policy.distribution.reception.decoding.PluginInitializationException;
  53 import org.onap.policy.distribution.reception.decoding.PolicyDecoder;
  54 import org.onap.policy.distribution.reception.handling.AbstractReceptionHandler;
  55 import org.onap.policy.distribution.reception.handling.PluginHandler;
  56 import org.onap.policy.distribution.reception.parameters.PluginHandlerParameters;
  57 import org.onap.policy.distribution.reception.parameters.PolicyDecoderParameters;
  58 import org.onap.policy.distribution.reception.statistics.DistributionStatisticsManager;
  59 import org.onap.sdc.api.IDistributionClient;
  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.utils.DistributionActionResultEnum;
  65 import org.slf4j.Logger;
  66 import org.slf4j.LoggerFactory;
  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 = LoggerFactory.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 IDistributionClient 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      * @throws SecurityException if it occurs
 101      * @throws NoSuchFieldException if it occurs
 102      * @throws IllegalAccessException if it occurs
 103      * @throws IllegalArgumentException if it occurs
 104      */
 105     @Before
 106     public final void init() throws IOException, NoSuchFieldException, SecurityException, IllegalArgumentException,
 107             IllegalAccessException {
 108         DistributionStatisticsManager.resetAllStatistics();
 109         final Gson gson = new GsonBuilder().create();
 110         pssdConfigParameters = gson.fromJson(new FileReader("src/test/resources/handling-sdc.json"),
 111                 SdcReceptionHandlerConfigurationParameterGroup.class);
 112         ParameterService.register(pssdConfigParameters);
 113         final SdcReceptionHandler sdcHandler = new SdcReceptionHandler();
 114         sypHandler = Mockito.spy(sdcHandler);
 115
 116         Mockito.when(sypHandler.createSdcDistributionClient()).thenReturn(distributionClient);
 117         Mockito.when(distributionClient.init(any(), any())).thenReturn(successfulClientInitResult);
 118         Mockito.when(distributionClient.start()).thenReturn(successfulClientInitResult);
 119         Mockito.when(distributionClient.stop()).thenReturn(successfulClientInitResult);
 120         Mockito.when(distributionClient.sendComponentDoneStatus(any())).thenReturn(successfulClientInitResult);
 121         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(successfulClientInitResult);
 122         Mockito.when(distributionClient.sendDownloadStatus(any())).thenReturn(successfulClientInitResult);
 123         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(successfulClientInitResult);
 124         Mockito.when(distributionClient.sendDeploymentStatus(any())).thenReturn(successfulClientInitResult);
 125         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(successfulClientInitResult);
 126         Mockito.when(distributionClient.download(any())).thenReturn(successfulClientDownloadResult);
 127         Mockito.when(notificationData.getServiceArtifacts()).thenReturn(Arrays.asList(artifactInfo));
 128         Mockito.when(artifactInfo.getArtifactName()).thenReturn(DUMMY_SERVICE_CSAR);
 129         Mockito.when(successfulClientDownloadResult.getArtifactPayload()).thenReturn(new byte[1]);
 130         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 131                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 132         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 133                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 134         Mockito.when(failureClientInitResult.getDistributionActionResult())
 135                 .thenReturn(DistributionActionResultEnum.FAIL);
 136
 137     }
 138
 139     @After
 140     public void teardown() {
 141         ParameterService.deregister(pssdConfigParameters);
 142     }
 143
 144     @Test
 145     public final void testInitializeSdcClient() {
 146         try {
 147             sypHandler.initializeReception(pssdConfigParameters.getName());
 148         } catch (final Exception exp) {
 149             LOGGER.error("testInitializeSdcClient failed", exp);
 150             fail("Test should not throw any exception");
 151         }
 152     }
 153
 154     @Test
 155     public final void testInitializeSdcClient_Failure() {
 156
 157         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 158                 .thenReturn(DistributionActionResultEnum.FAIL).thenReturn(DistributionActionResultEnum.SUCCESS);
 159         try {
 160             sypHandler.initializeReception(pssdConfigParameters.getName());
 161         } catch (final Exception exp) {
 162             LOGGER.error("testInitializeSdcClient_Failure failed", exp);
 163             fail("Test should not throw any exception");
 164         }
 165     }
 166
 167     @Test
 168     public final void testStartSdcClient_Failure() {
 169         try {
 170             Mockito.when(distributionClient.start()).thenReturn(failureClientInitResult)
 171                     .thenReturn(successfulClientInitResult);
 172             sypHandler.initializeReception(pssdConfigParameters.getName());
 173         } catch (final Exception exp) {
 174             LOGGER.error("testStartSdcClient_Failure failed", exp);
 175             fail("Test should not throw any exception");
 176         }
 177     }
 178
 179     @Test
 180     public final void testStopSdcClient() {
 181         try {
 182             sypHandler.initializeReception(pssdConfigParameters.getName());
 183             sypHandler.destroy();
 184         } catch (final Exception exp) {
 185             LOGGER.error("testStopSdcClient failed", exp);
 186             fail("Test should not throw any exception");
 187         }
 188
 189     }
 190
 191     @Test
 192     public final void testStopSdcClient_Failure() throws PluginInitializationException {
 193
 194         sypHandler.initializeReception(pssdConfigParameters.getName());
 195         Mockito.when(distributionClient.stop()).thenReturn(failureClientInitResult)
 196                 .thenReturn(successfulClientInitResult);
 197         try {
 198             sypHandler.destroy();
 199         } catch (final Exception exp) {
 200             LOGGER.error("testStopSdcClient_Failure failed", exp);
 201             fail("Test should not throw any exception");
 202         }
 203     }
 204
 205     @Test
 206     public final void testStopSdcClientWithoutStart() {
 207         try {
 208             sypHandler.destroy();
 209         } catch (final Exception exp) {
 210             LOGGER.error("testStopSdcClientWithoutStart", exp);
 211             fail("Test should not throw any exception");
 212         }
 213
 214     }
 215
 216     @Test
 217     public void testNotificationCallBack() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 218             IllegalAccessException, PluginInitializationException {
 219
 220         final DummyDecoder policyDecoder = new DummyDecoder();
 221         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 222         policyDecoders.add(policyDecoder);
 223
 224         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 225         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 226         policyForwarders.add(policyForwarder);
 227
 228         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 229         sypHandler.initializeReception(pssdConfigParameters.getName());
 230         sypHandler.activateCallback(notificationData);
 231
 232         assertTrue(policyDecoder.getDecodedPolicy().getName().contains(DUMMY_SERVICE_CSAR));
 233         assertEquals(1, policyForwarder.getNumberOfPoliciesReceived());
 234         assertTrue(policyForwarder.receivedPolicyWithGivenType(DUMMY_SERVICE_CSAR));
 235         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 236         assertEquals(1, DistributionStatisticsManager.getDistributionSuccessCount());
 237         assertEquals(0, DistributionStatisticsManager.getDistributionFailureCount());
 238         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 239         assertEquals(1, DistributionStatisticsManager.getDownloadSuccessCount());
 240         assertEquals(0, DistributionStatisticsManager.getDownloadFailureCount());
 241     }
 242
 243     @Test
 244     public void testDownloadArtifactFailure() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 245             IllegalAccessException, PluginInitializationException {
 246
 247         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 248                 .thenReturn(DistributionActionResultEnum.FAIL);
 249
 250         final DummyDecoder policyDecoder = new DummyDecoder();
 251         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 252         policyDecoders.add(policyDecoder);
 253
 254         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 255         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 256         policyForwarders.add(policyForwarder);
 257
 258         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 259         sypHandler.initializeReception(pssdConfigParameters.getName());
 260         sypHandler.activateCallback(notificationData);
 261
 262         assertEquals(null, policyDecoder.getDecodedPolicy());
 263         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 264         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 265         assertEquals(0, DistributionStatisticsManager.getDistributionSuccessCount());
 266         assertEquals(1, DistributionStatisticsManager.getDistributionFailureCount());
 267         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 268         assertEquals(0, DistributionStatisticsManager.getDownloadSuccessCount());
 269         assertEquals(1, DistributionStatisticsManager.getDownloadFailureCount());
 270     }
 271
 272     @Test
 273     public void testSendDistributionStatusFailure() throws NoSuchFieldException, SecurityException,
 274             IllegalArgumentException, IllegalAccessException, PluginInitializationException {
 275
 276         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 277                 .thenReturn(DistributionActionResultEnum.FAIL);
 278         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(failureClientInitResult);
 279         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(failureClientInitResult);
 280         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(failureClientInitResult);
 281
 282         final DummyDecoder policyDecoder = new DummyDecoder();
 283         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 284         policyDecoders.add(policyDecoder);
 285
 286         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 287         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 288         policyForwarders.add(policyForwarder);
 289
 290         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 291         sypHandler.initializeReception(pssdConfigParameters.getName());
 292         sypHandler.activateCallback(notificationData);
 293
 294         assertEquals(null, policyDecoder.getDecodedPolicy());
 295         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 296     }
 297
 298     private void setUpPlugins(final AbstractReceptionHandler receptionHandler,
 299             final Collection<PolicyDecoder<Csar, DummyPolicy>> decoders, final Collection<PolicyForwarder> forwarders)
 300             throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException,
 301             PluginInitializationException {
 302         final PluginHandlerParameters pluginParameters = getPluginHandlerParameters();
 303         pluginParameters.setName("DummyDistributionGroup");
 304         ParameterService.register(pluginParameters);
 305         final PluginHandler pluginHandler = new PluginHandler(pluginParameters.getName());
 306
 307         final Field decodersField = pluginHandler.getClass().getDeclaredField("policyDecoders");
 308         decodersField.setAccessible(true);
 309         decodersField.set(pluginHandler, decoders);
 310
 311         final Field forwardersField = pluginHandler.getClass().getDeclaredField("policyForwarders");
 312         forwardersField.setAccessible(true);
 313         forwardersField.set(pluginHandler, forwarders);
 314
 315         final Field pluginHandlerField = AbstractReceptionHandler.class.getDeclaredField("pluginHandler");
 316         pluginHandlerField.setAccessible(true);
 317         pluginHandlerField.set(receptionHandler, pluginHandler);
 318         ParameterService.deregister(pluginParameters.getName());
 319     }
 320
 321     private PluginHandlerParameters getPluginHandlerParameters() {
 322         final Map<String, PolicyDecoderParameters> policyDecoders = getPolicyDecoders();
 323         final Map<String, PolicyForwarderParameters> policyForwarders = getPolicyForwarders();
 324         final PluginHandlerParameters pluginHandlerParameters =
 325                 new PluginHandlerParameters(policyDecoders, policyForwarders);
 326         return pluginHandlerParameters;
 327     }
 328
 329     private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
 330         final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
 331         final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("DummyDecoder",
 332                 "org.onap.policy.distribution.reception.handling.sdc.DummyDecoder", "DummyDecoderConfiguration");
 333         policyDecoders.put("DummyDecoderKey", pDParameters);
 334         return policyDecoders;
 335     }
 336
 337     private Map<String, PolicyForwarderParameters> getPolicyForwarders() {
 338         final Map<String, PolicyForwarderParameters> policyForwarders =
 339                 new HashMap<String, PolicyForwarderParameters>();
 340         final PolicyForwarderParameters pFParameters = new PolicyForwarderParameters("DummyForwarder",
 341                 "org.onap.policy.distribution.reception.handling.sdc.DummyPolicyForwarder", "DummyConfiguration");
 342         policyForwarders.put("DummyForwarderKey", pFParameters);
 343         return policyForwarders;
 344     }
 345 }