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.PolicyDecoder;
  55 import org.onap.policy.distribution.reception.handling.AbstractReceptionHandler;
  56 import org.onap.policy.distribution.reception.handling.PluginHandler;
  57 import org.onap.policy.distribution.reception.parameters.PluginHandlerParameters;
  58 import org.onap.policy.distribution.reception.parameters.PolicyDecoderParameters;
  59 import org.onap.policy.distribution.reception.statistics.DistributionStatisticsManager;
  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      * @throws SecurityException if it occurs
 100      * @throws NoSuchFieldException if it occurs
 101      * @throws IllegalAccessException if it occurs
 102      * @throws IllegalArgumentException if it occurs
 103      */
 104     @Before
 105     public final void init() throws IOException, NoSuchFieldException, SecurityException, IllegalArgumentException,
 106             IllegalAccessException {
 107         DistributionStatisticsManager.resetAllStatistics();
 108         final Gson gson = new GsonBuilder().create();
 109         pssdConfigParameters = gson.fromJson(new FileReader("src/test/resources/handling-sdc.json"),
 110                 SdcReceptionHandlerConfigurationParameterGroup.class);
 111         ParameterService.register(pssdConfigParameters);
 112         final SdcReceptionHandler sdcHandler = new SdcReceptionHandler();
 113         sypHandler = Mockito.spy(sdcHandler);
 114
 115         Mockito.when(sypHandler.createSdcDistributionClient()).thenReturn(distributionClient);
 116         Mockito.when(distributionClient.init(any(), any())).thenReturn(successfulClientInitResult);
 117         Mockito.when(distributionClient.start()).thenReturn(successfulClientInitResult);
 118         Mockito.when(distributionClient.stop()).thenReturn(successfulClientInitResult);
 119         Mockito.when(distributionClient.sendComponentDoneStatus(any())).thenReturn(successfulClientInitResult);
 120         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(successfulClientInitResult);
 121         Mockito.when(distributionClient.sendDownloadStatus(any())).thenReturn(successfulClientInitResult);
 122         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(successfulClientInitResult);
 123         Mockito.when(distributionClient.sendDeploymentStatus(any())).thenReturn(successfulClientInitResult);
 124         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(successfulClientInitResult);
 125         Mockito.when(distributionClient.download(any())).thenReturn(successfulClientDownloadResult);
 126         Mockito.when(notificationData.getServiceArtifacts()).thenReturn(Arrays.asList(artifactInfo));
 127         Mockito.when(artifactInfo.getArtifactName()).thenReturn(DUMMY_SERVICE_CSAR);
 128         Mockito.when(successfulClientDownloadResult.getArtifactPayload()).thenReturn(new byte[1]);
 129         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 130                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 131         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 132                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 133         Mockito.when(failureClientInitResult.getDistributionActionResult())
 134                 .thenReturn(DistributionActionResultEnum.FAIL);
 135
 136     }
 137
 138     @After
 139     public void teardown() {
 140         ParameterService.deregister(pssdConfigParameters);
 141     }
 142
 143     @Test
 144     public final void testInitializeSdcClient() {
 145         try {
 146             sypHandler.initializeReception(pssdConfigParameters.getName());
 147         } catch (final Exception exp) {
 148             LOGGER.error(exp);
 149             fail("Test should not throw any exception");
 150         }
 151     }
 152
 153     @Test
 154     public final void testInitializeSdcClient_Failure() {
 155
 156         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 157                 .thenReturn(DistributionActionResultEnum.FAIL).thenReturn(DistributionActionResultEnum.SUCCESS);
 158         try {
 159             sypHandler.initializeReception(pssdConfigParameters.getName());
 160         } catch (final Exception exp) {
 161             LOGGER.error(exp);
 162             fail("Test should not throw any exception");
 163         }
 164     }
 165
 166     @Test
 167     public final void testStartSdcClient_Failure() {
 168         try {
 169             Mockito.when(distributionClient.start()).thenReturn(failureClientInitResult)
 170                     .thenReturn(successfulClientInitResult);
 171             sypHandler.initializeReception(pssdConfigParameters.getName());
 172         } catch (final Exception exp) {
 173             LOGGER.error(exp);
 174             fail("Test should not throw any exception");
 175         }
 176     }
 177
 178     @Test
 179     public final void testStopSdcClient() {
 180         try {
 181             sypHandler.initializeReception(pssdConfigParameters.getName());
 182             sypHandler.destroy();
 183         } catch (final Exception exp) {
 184             LOGGER.error(exp);
 185             fail("Test should not throw any exception");
 186         }
 187
 188     }
 189
 190     @Test
 191     public final void testStopSdcClient_Failure() throws PluginInitializationException {
 192
 193         sypHandler.initializeReception(pssdConfigParameters.getName());
 194         Mockito.when(distributionClient.stop()).thenReturn(failureClientInitResult)
 195                 .thenReturn(successfulClientInitResult);
 196         try {
 197             sypHandler.destroy();
 198         } catch (final Exception exp) {
 199             LOGGER.error(exp);
 200             fail("Test should not throw any exception");
 201         }
 202     }
 203
 204     @Test
 205     public final void testStopSdcClientWithoutStart() {
 206         try {
 207             sypHandler.destroy();
 208         } catch (final Exception exp) {
 209             LOGGER.error(exp);
 210             fail("Test should not throw any exception");
 211         }
 212
 213     }
 214
 215     @Test
 216     public void testNotificationCallBack() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 217             IllegalAccessException, PluginInitializationException {
 218
 219         final DummyDecoder policyDecoder = new DummyDecoder();
 220         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 221         policyDecoders.add(policyDecoder);
 222
 223         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 224         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 225         policyForwarders.add(policyForwarder);
 226
 227         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 228         sypHandler.initializeReception(pssdConfigParameters.getName());
 229         sypHandler.activateCallback(notificationData);
 230
 231         assertEquals(DummyDecoder.DUMMY_POLICY, policyDecoder.getDecodedPolicy().getPolicyType());
 232         assertTrue(policyDecoder.getDecodedPolicy().getPolicyName().contains(DUMMY_SERVICE_CSAR));
 233         assertEquals(1, policyForwarder.getNumberOfPoliciesReceived());
 234         assertTrue(policyForwarder.receivedPolicyWithGivenType(DummyDecoder.DUMMY_POLICY));
 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 }