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  *  Modifications Copyright (C) 2020 Nordix Foundation
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  * SPDX-License-Identifier: Apache-2.0
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.distribution.reception.handling.sdc;
  24
  25 import static org.assertj.core.api.Assertions.assertThatCode;
  26 import static org.junit.Assert.assertEquals;
  27 import static org.junit.Assert.assertTrue;
  28 import static org.mockito.Matchers.any;
  29
  30 import com.google.gson.Gson;
  31 import com.google.gson.GsonBuilder;
  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 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.parameters.ParameterService;
  48 import org.onap.policy.distribution.forwarding.PolicyForwarder;
  49 import org.onap.policy.distribution.forwarding.parameters.PolicyForwarderParameters;
  50 import org.onap.policy.distribution.model.Csar;
  51 import org.onap.policy.distribution.reception.decoding.PluginInitializationException;
  52 import org.onap.policy.distribution.reception.decoding.PolicyDecoder;
  53 import org.onap.policy.distribution.reception.handling.AbstractReceptionHandler;
  54 import org.onap.policy.distribution.reception.handling.PluginHandler;
  55 import org.onap.policy.distribution.reception.parameters.PluginHandlerParameters;
  56 import org.onap.policy.distribution.reception.parameters.PolicyDecoderParameters;
  57 import org.onap.policy.distribution.reception.statistics.DistributionStatisticsManager;
  58 import org.onap.sdc.api.IDistributionClient;
  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.utils.DistributionActionResultEnum;
  64
  65 /**
  66  * Class to perform unit test of {@link SdcReceptionHandler}.
  67  *
  68  * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
  69  */
  70 @RunWith(MockitoJUnitRunner.class)
  71 public class TestSdcReceptionHandler {
  72
  73     private static final String DUMMY_SERVICE_CSAR = "dummyService.csar";
  74
  75     @Mock
  76     private IDistributionClientResult successfulClientInitResult;
  77     @Mock
  78     private IDistributionClientResult failureClientInitResult;
  79     @Mock
  80     private IDistributionClient distributionClient;
  81     @Mock
  82     private IDistributionClientDownloadResult successfulClientDownloadResult;
  83     @Mock
  84     private INotificationData notificationData;
  85     @Mock
  86     private IArtifactInfo artifactInfo;
  87
  88     private SdcReceptionHandlerConfigurationParameterGroup pssdConfigParameters;
  89     private SdcReceptionHandler sypHandler;
  90
  91
  92     /**
  93      * Setup for the test cases.
  94      *
  95      * @throws IOException if it occurs
  96      * @throws SecurityException if it occurs
  97      * @throws NoSuchFieldException if it occurs
  98      * @throws IllegalAccessException if it occurs
  99      * @throws IllegalArgumentException if it occurs
 100      */
 101     @Before
 102     public final void init() throws IOException, NoSuchFieldException, SecurityException, IllegalArgumentException,
 103             IllegalAccessException {
 104         DistributionStatisticsManager.resetAllStatistics();
 105         final Gson gson = new GsonBuilder().create();
 106         pssdConfigParameters = gson.fromJson(new FileReader("src/test/resources/handling-sdc.json"),
 107                 SdcReceptionHandlerConfigurationParameterGroup.class);
 108         ParameterService.register(pssdConfigParameters);
 109         final SdcReceptionHandler sdcHandler = new SdcReceptionHandler();
 110         sypHandler = Mockito.spy(sdcHandler);
 111
 112         Mockito.when(sypHandler.createSdcDistributionClient()).thenReturn(distributionClient);
 113         Mockito.when(distributionClient.init(any(), any())).thenReturn(successfulClientInitResult);
 114         Mockito.when(distributionClient.start()).thenReturn(successfulClientInitResult);
 115         Mockito.when(distributionClient.stop()).thenReturn(successfulClientInitResult);
 116         Mockito.when(distributionClient.sendComponentDoneStatus(any())).thenReturn(successfulClientInitResult);
 117         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(successfulClientInitResult);
 118         Mockito.when(distributionClient.sendDownloadStatus(any())).thenReturn(successfulClientInitResult);
 119         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(successfulClientInitResult);
 120         Mockito.when(distributionClient.sendDeploymentStatus(any())).thenReturn(successfulClientInitResult);
 121         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(successfulClientInitResult);
 122         Mockito.when(distributionClient.download(any())).thenReturn(successfulClientDownloadResult);
 123         Mockito.when(notificationData.getServiceArtifacts()).thenReturn(Arrays.asList(artifactInfo));
 124         Mockito.when(artifactInfo.getArtifactName()).thenReturn(DUMMY_SERVICE_CSAR);
 125         Mockito.when(successfulClientDownloadResult.getArtifactPayload()).thenReturn(new byte[1]);
 126         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 127                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 128         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 129                 .thenReturn(DistributionActionResultEnum.SUCCESS);
 130         Mockito.when(failureClientInitResult.getDistributionActionResult())
 131                 .thenReturn(DistributionActionResultEnum.FAIL);
 132
 133     }
 134
 135     @After
 136     public void teardown() {
 137         ParameterService.deregister(pssdConfigParameters);
 138     }
 139
 140     @Test
 141     public final void testInitializeSdcClient() {
 142         assertThatCode(() ->  sypHandler.initializeReception(pssdConfigParameters.getName()))
 143             .doesNotThrowAnyException();
 144     }
 145
 146     @Test
 147     public final void testInitializeSdcClient_Failure() {
 148
 149         Mockito.when(successfulClientInitResult.getDistributionActionResult())
 150                 .thenReturn(DistributionActionResultEnum.FAIL).thenReturn(DistributionActionResultEnum.SUCCESS);
 151         assertThatCode(() -> sypHandler.initializeReception(pssdConfigParameters.getName()))
 152             .doesNotThrowAnyException();
 153     }
 154
 155     @Test
 156     public final void testStartSdcClient_Failure() {
 157         assertThatCode(() -> {
 158             Mockito.when(distributionClient.start()).thenReturn(failureClientInitResult)
 159             .thenReturn(successfulClientInitResult);
 160             sypHandler.initializeReception(pssdConfigParameters.getName());
 161         }).doesNotThrowAnyException();
 162     }
 163
 164     @Test
 165     public final void testStopSdcClient() {
 166         assertThatCode(() -> {
 167             sypHandler.initializeReception(pssdConfigParameters.getName());
 168             sypHandler.destroy();
 169         }).doesNotThrowAnyException();
 170     }
 171
 172     @Test
 173     public final void testStopSdcClient_Failure() throws PluginInitializationException {
 174         sypHandler.initializeReception(pssdConfigParameters.getName());
 175         Mockito.when(distributionClient.stop()).thenReturn(failureClientInitResult)
 176                 .thenReturn(successfulClientInitResult);
 177         assertThatCode(() -> sypHandler.destroy()).doesNotThrowAnyException();
 178     }
 179
 180     @Test
 181     public final void testStopSdcClientWithoutStart() {
 182         assertThatCode(() -> sypHandler.destroy()).doesNotThrowAnyException();
 183     }
 184
 185     @Test
 186     public void testNotificationCallBack() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 187             IllegalAccessException, PluginInitializationException {
 188
 189         final DummyDecoder policyDecoder = new DummyDecoder();
 190         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 191         policyDecoders.add(policyDecoder);
 192
 193         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 194         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 195         policyForwarders.add(policyForwarder);
 196
 197         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 198         sypHandler.initializeReception(pssdConfigParameters.getName());
 199         sypHandler.activateCallback(notificationData);
 200
 201         assertTrue(policyDecoder.getDecodedPolicy().getName().contains(DUMMY_SERVICE_CSAR));
 202         assertEquals(1, policyForwarder.getNumberOfPoliciesReceived());
 203         assertTrue(policyForwarder.receivedPolicyWithGivenType(DUMMY_SERVICE_CSAR));
 204         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 205         assertEquals(1, DistributionStatisticsManager.getDistributionSuccessCount());
 206         assertEquals(0, DistributionStatisticsManager.getDistributionFailureCount());
 207         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 208         assertEquals(1, DistributionStatisticsManager.getDownloadSuccessCount());
 209         assertEquals(0, DistributionStatisticsManager.getDownloadFailureCount());
 210     }
 211
 212     @Test
 213     public void testDownloadArtifactFailure() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 214             IllegalAccessException, PluginInitializationException {
 215
 216         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 217                 .thenReturn(DistributionActionResultEnum.FAIL);
 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(null, policyDecoder.getDecodedPolicy());
 232         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 233         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 234         assertEquals(0, DistributionStatisticsManager.getDistributionSuccessCount());
 235         assertEquals(1, DistributionStatisticsManager.getDistributionFailureCount());
 236         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 237         assertEquals(0, DistributionStatisticsManager.getDownloadSuccessCount());
 238         assertEquals(1, DistributionStatisticsManager.getDownloadFailureCount());
 239     }
 240
 241     @Test
 242     public void testSendDistributionStatusFailure() throws NoSuchFieldException, SecurityException,
 243             IllegalArgumentException, IllegalAccessException, PluginInitializationException {
 244
 245         Mockito.when(successfulClientDownloadResult.getDistributionActionResult())
 246                 .thenReturn(DistributionActionResultEnum.FAIL);
 247         Mockito.when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(failureClientInitResult);
 248         Mockito.when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(failureClientInitResult);
 249         Mockito.when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(failureClientInitResult);
 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     }
 266
 267     private void setUpPlugins(final AbstractReceptionHandler receptionHandler,
 268             final Collection<PolicyDecoder<Csar, DummyPolicy>> decoders, final Collection<PolicyForwarder> forwarders)
 269             throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException,
 270             PluginInitializationException {
 271         final PluginHandlerParameters pluginParameters = getPluginHandlerParameters();
 272         pluginParameters.setName("DummyDistributionGroup");
 273         ParameterService.register(pluginParameters);
 274         final PluginHandler pluginHandler = new PluginHandler(pluginParameters.getName());
 275
 276         final Field decodersField = pluginHandler.getClass().getDeclaredField("policyDecoders");
 277         decodersField.setAccessible(true);
 278         decodersField.set(pluginHandler, decoders);
 279
 280         final Field forwardersField = pluginHandler.getClass().getDeclaredField("policyForwarders");
 281         forwardersField.setAccessible(true);
 282         forwardersField.set(pluginHandler, forwarders);
 283
 284         final Field pluginHandlerField = AbstractReceptionHandler.class.getDeclaredField("pluginHandler");
 285         pluginHandlerField.setAccessible(true);
 286         pluginHandlerField.set(receptionHandler, pluginHandler);
 287         ParameterService.deregister(pluginParameters.getName());
 288     }
 289
 290     private PluginHandlerParameters getPluginHandlerParameters() {
 291         final Map<String, PolicyDecoderParameters> policyDecoders = getPolicyDecoders();
 292         final Map<String, PolicyForwarderParameters> policyForwarders = getPolicyForwarders();
 293         final PluginHandlerParameters pluginHandlerParameters =
 294                 new PluginHandlerParameters(policyDecoders, policyForwarders);
 295         return pluginHandlerParameters;
 296     }
 297
 298     private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
 299         final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
 300         final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("DummyDecoder",
 301                 "org.onap.policy.distribution.reception.handling.sdc.DummyDecoder", "DummyDecoderConfiguration");
 302         policyDecoders.put("DummyDecoderKey", pDParameters);
 303         return policyDecoders;
 304     }
 305
 306     private Map<String, PolicyForwarderParameters> getPolicyForwarders() {
 307         final Map<String, PolicyForwarderParameters> policyForwarders =
 308                 new HashMap<String, PolicyForwarderParameters>();
 309         final PolicyForwarderParameters pFParameters = new PolicyForwarderParameters("DummyForwarder",
 310                 "org.onap.policy.distribution.reception.handling.sdc.DummyPolicyForwarder", "DummyConfiguration");
 311         policyForwarders.put("DummyForwarderKey", pFParameters);
 312         return policyForwarders;
 313     }
 314 }