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.notification.IArtifactInfo;
  60 import org.onap.sdc.api.notification.INotificationData;
  61 import org.onap.sdc.api.results.IDistributionClientDownloadResult;
  62 import org.onap.sdc.api.results.IDistributionClientResult;
  63 import org.onap.sdc.impl.mock.DistributionClientStubImpl;
  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 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      * @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         assertEquals(DummyDecoder.DUMMY_POLICY, policyDecoder.getDecodedPolicy().getPolicyType());
 233         assertTrue(policyDecoder.getDecodedPolicy().getPolicyName().contains(DUMMY_SERVICE_CSAR));
 234         assertEquals(1, policyForwarder.getNumberOfPoliciesReceived());
 235         assertTrue(policyForwarder.receivedPolicyWithGivenType(DummyDecoder.DUMMY_POLICY));
 236         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 237         assertEquals(1, DistributionStatisticsManager.getDistributionSuccessCount());
 238         assertEquals(0, DistributionStatisticsManager.getDistributionFailureCount());
 239         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 240         assertEquals(1, DistributionStatisticsManager.getDownloadSuccessCount());
 241         assertEquals(0, DistributionStatisticsManager.getDownloadFailureCount());
 242     }
 243
 244     @Test
 245     public void testDownloadArtifactFailure() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 246             IllegalAccessException, PluginInitializationException {
 247
 248         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 249                 .thenReturn(DistributionActionResultEnum.FAIL);
 250
 251         final DummyDecoder policyDecoder = new DummyDecoder();
 252         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 253         policyDecoders.add(policyDecoder);
 254
 255         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 256         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 257         policyForwarders.add(policyForwarder);
 258
 259         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 260         sypHandler.initializeReception(pssdConfigParameters.getName());
 261         sypHandler.activateCallback(notificationData);
 262
 263         assertEquals(null, policyDecoder.getDecodedPolicy());
 264         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 265         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 266         assertEquals(0, DistributionStatisticsManager.getDistributionSuccessCount());
 267         assertEquals(1, DistributionStatisticsManager.getDistributionFailureCount());
 268         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 269         assertEquals(0, DistributionStatisticsManager.getDownloadSuccessCount());
 270         assertEquals(1, DistributionStatisticsManager.getDownloadFailureCount());
 271     }
 272
 273     @Test
 274     public void testSendDistributionStatusFailure() throws NoSuchFieldException, SecurityException,
 275             IllegalArgumentException, IllegalAccessException, PluginInitializationException {
 276
 277         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 278                 .thenReturn(DistributionActionResultEnum.FAIL);
 279         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(failureClientInitResult);
 280         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(failureClientInitResult);
 281         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(failureClientInitResult);
 282
 283         final DummyDecoder policyDecoder = new DummyDecoder();
 284         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 285         policyDecoders.add(policyDecoder);
 286
 287         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 288         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 289         policyForwarders.add(policyForwarder);
 290
 291         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 292         sypHandler.initializeReception(pssdConfigParameters.getName());
 293         sypHandler.activateCallback(notificationData);
 294
 295         assertEquals(null, policyDecoder.getDecodedPolicy());
 296         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 297     }
 298
 299     private void setUpPlugins(final AbstractReceptionHandler receptionHandler,
 300             final Collection<PolicyDecoder<Csar, DummyPolicy>> decoders, final Collection<PolicyForwarder> forwarders)
 301             throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException,
 302             PluginInitializationException {
 303         final PluginHandlerParameters pluginParameters = getPluginHandlerParameters();
 304         pluginParameters.setName("DummyDistributionGroup");
 305         ParameterService.register(pluginParameters);
 306         final PluginHandler pluginHandler = new PluginHandler(pluginParameters.getName());
 307
 308         final Field decodersField = pluginHandler.getClass().getDeclaredField("policyDecoders");
 309         decodersField.setAccessible(true);
 310         decodersField.set(pluginHandler, decoders);
 311
 312         final Field forwardersField = pluginHandler.getClass().getDeclaredField("policyForwarders");
 313         forwardersField.setAccessible(true);
 314         forwardersField.set(pluginHandler, forwarders);
 315
 316         final Field pluginHandlerField = AbstractReceptionHandler.class.getDeclaredField("pluginHandler");
 317         pluginHandlerField.setAccessible(true);
 318         pluginHandlerField.set(receptionHandler, pluginHandler);
 319         ParameterService.deregister(pluginParameters.getName());
 320     }
 321
 322     private PluginHandlerParameters getPluginHandlerParameters() {
 323         final Map<String, PolicyDecoderParameters> policyDecoders = getPolicyDecoders();
 324         final Map<String, PolicyForwarderParameters> policyForwarders = getPolicyForwarders();
 325         final PluginHandlerParameters pluginHandlerParameters =
 326                 new PluginHandlerParameters(policyDecoders, policyForwarders);
 327         return pluginHandlerParameters;
 328     }
 329
 330     private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
 331         final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
 332         final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("DummyDecoder",
 333                 "org.onap.policy.distribution.reception.handling.sdc.DummyDecoder", "DummyDecoderConfiguration");
 334         policyDecoders.put("DummyDecoderKey", pDParameters);
 335         return policyDecoders;
 336     }
 337
 338     private Map<String, PolicyForwarderParameters> getPolicyForwarders() {
 339         final Map<String, PolicyForwarderParameters> policyForwarders =
 340                 new HashMap<String, PolicyForwarderParameters>();
 341         final PolicyForwarderParameters pFParameters = new PolicyForwarderParameters("DummyForwarder",
 342                 "org.onap.policy.distribution.reception.handling.sdc.DummyPolicyForwarder", "DummyConfiguration");
 343         policyForwarders.put("DummyForwarderKey", pFParameters);
 344         return policyForwarders;
 345     }
 346 }