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