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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Intel. All rights reserved.
   4  *  Copyright (C) 2019, 2022 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.assertNull;
  28 import static org.junit.Assert.assertTrue;
  29 import static  org.mockito.Mockito.any;
  30 import static  org.mockito.Mockito.mock;
  31 import static  org.mockito.Mockito.spy;
  32 import static  org.mockito.Mockito.when;
  33
  34 import com.google.gson.Gson;
  35 import com.google.gson.GsonBuilder;
  36 import java.io.FileReader;
  37 import java.io.IOException;
  38 import java.lang.reflect.Field;
  39 import java.util.ArrayList;
  40 import java.util.Collection;
  41 import java.util.HashMap;
  42 import java.util.List;
  43 import java.util.Map;
  44 import org.junit.After;
  45 import org.junit.Before;
  46 import org.junit.Test;
  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 public class TestSdcReceptionHandler {
  71
  72     private static final String DUMMY_SERVICE_CSAR = "dummyService.csar";
  73
  74     private IDistributionClientResult successfulClientInitResult = mock(IDistributionClientResult.class);
  75     private IDistributionClientResult failureClientInitResult = mock(IDistributionClientResult.class);
  76     private IDistributionClient distributionClient = mock(IDistributionClient.class);
  77     private IDistributionClientDownloadResult successfulClientDownloadResult
  78         = mock(IDistributionClientDownloadResult.class);
  79     private INotificationData notificationData = mock(INotificationData.class);
  80     private IArtifactInfo artifactInfo = mock(IArtifactInfo.class);
  81
  82     private SdcReceptionHandlerConfigurationParameterGroup pssdConfigParameters;
  83     private SdcReceptionHandler sypHandler;
  84
  85
  86     /**
  87      * Setup for the test cases.
  88      *
  89      * @throws IOException              if it occurs
  90      * @throws SecurityException        if it occurs
  91      * @throws IllegalArgumentException if it occurs
  92      */
  93     @Before
  94     public final void init() throws IOException, SecurityException, IllegalArgumentException {
  95         DistributionStatisticsManager.resetAllStatistics();
  96         final Gson gson = new GsonBuilder().create();
  97         pssdConfigParameters = gson.fromJson(new FileReader("src/test/resources/handling-sdc.json"),
  98             SdcReceptionHandlerConfigurationParameterGroup.class);
  99         ParameterService.register(pssdConfigParameters);
 100         final SdcReceptionHandler sdcHandler = new SdcReceptionHandler();
 101         sypHandler = spy(sdcHandler);
 102
 103         when(sypHandler.createSdcDistributionClient()).thenReturn(distributionClient);
 104         when(distributionClient.init(any(), any())).thenReturn(successfulClientInitResult);
 105         when(distributionClient.start()).thenReturn(successfulClientInitResult);
 106         when(distributionClient.stop()).thenReturn(successfulClientInitResult);
 107         when(distributionClient.sendComponentDoneStatus(any())).thenReturn(successfulClientInitResult);
 108         when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(successfulClientInitResult);
 109         when(distributionClient.sendDownloadStatus(any())).thenReturn(successfulClientInitResult);
 110         when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(successfulClientInitResult);
 111         when(distributionClient.sendDeploymentStatus(any())).thenReturn(successfulClientInitResult);
 112         when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(successfulClientInitResult);
 113         when(distributionClient.download(any())).thenReturn(successfulClientDownloadResult);
 114         when(notificationData.getServiceArtifacts()).thenReturn(List.of(artifactInfo));
 115         when(artifactInfo.getArtifactName()).thenReturn(DUMMY_SERVICE_CSAR);
 116         when(successfulClientDownloadResult.getArtifactPayload()).thenReturn(new byte[1]);
 117         when(successfulClientInitResult.getDistributionActionResult())
 118             .thenReturn(DistributionActionResultEnum.SUCCESS);
 119         when(successfulClientDownloadResult.getDistributionActionResult())
 120             .thenReturn(DistributionActionResultEnum.SUCCESS);
 121         when(failureClientInitResult.getDistributionActionResult())
 122             .thenReturn(DistributionActionResultEnum.FAIL);
 123
 124     }
 125
 126     @After
 127     public void teardown() {
 128         ParameterService.deregister(pssdConfigParameters);
 129     }
 130
 131     @Test
 132     public final void testInitializeSdcClient() {
 133         assertThatCode(() -> sypHandler.initializeReception(pssdConfigParameters.getName()))
 134             .doesNotThrowAnyException();
 135     }
 136
 137     @Test
 138     public final void testInitializeSdcClient_Failure() {
 139
 140         when(successfulClientInitResult.getDistributionActionResult())
 141             .thenReturn(DistributionActionResultEnum.FAIL).thenReturn(DistributionActionResultEnum.SUCCESS);
 142         assertThatCode(() -> sypHandler.initializeReception(pssdConfigParameters.getName()))
 143             .doesNotThrowAnyException();
 144     }
 145
 146     @Test
 147     public final void testStartSdcClient_Failure() {
 148         assertThatCode(() -> {
 149             when(distributionClient.start()).thenReturn(failureClientInitResult)
 150                 .thenReturn(successfulClientInitResult);
 151             sypHandler.initializeReception(pssdConfigParameters.getName());
 152         }).doesNotThrowAnyException();
 153     }
 154
 155     @Test
 156     public final void testStopSdcClient() {
 157         assertThatCode(() -> {
 158             sypHandler.initializeReception(pssdConfigParameters.getName());
 159             sypHandler.destroy();
 160         }).doesNotThrowAnyException();
 161     }
 162
 163     @Test
 164     public final void testStopSdcClient_Failure() {
 165         sypHandler.initializeReception(pssdConfigParameters.getName());
 166         when(distributionClient.stop()).thenReturn(failureClientInitResult)
 167             .thenReturn(successfulClientInitResult);
 168         assertThatCode(() -> sypHandler.destroy()).doesNotThrowAnyException();
 169     }
 170
 171     @Test
 172     public final void testStopSdcClientWithoutStart() {
 173         assertThatCode(() -> sypHandler.destroy()).doesNotThrowAnyException();
 174     }
 175
 176     @Test
 177     public void testNotificationCallBack() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 178         IllegalAccessException, PluginInitializationException {
 179
 180         final DummyDecoder policyDecoder = new DummyDecoder();
 181         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 182         policyDecoders.add(policyDecoder);
 183
 184         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 185         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 186         policyForwarders.add(policyForwarder);
 187
 188         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 189         sypHandler.initializeReception(pssdConfigParameters.getName());
 190         sypHandler.activateCallback(notificationData);
 191
 192         assertTrue(policyDecoder.getDecodedPolicy().getName().contains(DUMMY_SERVICE_CSAR));
 193         assertEquals(1, policyForwarder.getNumberOfPoliciesReceived());
 194         assertTrue(policyForwarder.receivedPolicyWithGivenType(DUMMY_SERVICE_CSAR));
 195         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 196         assertEquals(1, DistributionStatisticsManager.getDistributionSuccessCount());
 197         assertEquals(0, DistributionStatisticsManager.getDistributionFailureCount());
 198         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 199         assertEquals(1, DistributionStatisticsManager.getDownloadSuccessCount());
 200         assertEquals(0, DistributionStatisticsManager.getDownloadFailureCount());
 201     }
 202
 203     @Test
 204     public void testDownloadArtifactFailure() throws NoSuchFieldException, SecurityException, IllegalArgumentException,
 205         IllegalAccessException, PluginInitializationException {
 206
 207         when(successfulClientDownloadResult.getDistributionActionResult())
 208             .thenReturn(DistributionActionResultEnum.FAIL);
 209
 210         final DummyDecoder policyDecoder = new DummyDecoder();
 211         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 212         policyDecoders.add(policyDecoder);
 213
 214         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 215         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 216         policyForwarders.add(policyForwarder);
 217
 218         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 219         sypHandler.initializeReception(pssdConfigParameters.getName());
 220         sypHandler.activateCallback(notificationData);
 221
 222         assertNull(policyDecoder.getDecodedPolicy());
 223         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 224         assertEquals(1, DistributionStatisticsManager.getTotalDistributionCount());
 225         assertEquals(0, DistributionStatisticsManager.getDistributionSuccessCount());
 226         assertEquals(1, DistributionStatisticsManager.getDistributionFailureCount());
 227         assertEquals(1, DistributionStatisticsManager.getTotalDownloadCount());
 228         assertEquals(0, DistributionStatisticsManager.getDownloadSuccessCount());
 229         assertEquals(1, DistributionStatisticsManager.getDownloadFailureCount());
 230     }
 231
 232     @Test
 233     public void testSendDistributionStatusFailure() throws NoSuchFieldException, SecurityException,
 234         IllegalArgumentException, IllegalAccessException, PluginInitializationException {
 235
 236         when(successfulClientDownloadResult.getDistributionActionResult())
 237             .thenReturn(DistributionActionResultEnum.FAIL);
 238         when(distributionClient.sendDownloadStatus(any(), any())).thenReturn(failureClientInitResult);
 239         when(distributionClient.sendDeploymentStatus(any(), any())).thenReturn(failureClientInitResult);
 240         when(distributionClient.sendComponentDoneStatus(any(), any())).thenReturn(failureClientInitResult);
 241
 242         final DummyDecoder policyDecoder = new DummyDecoder();
 243         final Collection<PolicyDecoder<Csar, DummyPolicy>> policyDecoders = new ArrayList<>();
 244         policyDecoders.add(policyDecoder);
 245
 246         final DummyPolicyForwarder policyForwarder = new DummyPolicyForwarder();
 247         final Collection<PolicyForwarder> policyForwarders = new ArrayList<>();
 248         policyForwarders.add(policyForwarder);
 249
 250         setUpPlugins(sypHandler, policyDecoders, policyForwarders);
 251         sypHandler.initializeReception(pssdConfigParameters.getName());
 252         sypHandler.activateCallback(notificationData);
 253
 254         assertNull(policyDecoder.getDecodedPolicy());
 255         assertEquals(0, policyForwarder.getNumberOfPoliciesReceived());
 256     }
 257
 258     private void setUpPlugins(final AbstractReceptionHandler receptionHandler,
 259                               final Collection<PolicyDecoder<Csar, DummyPolicy>> decoders,
 260                               final Collection<PolicyForwarder> forwarders)
 261         throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException,
 262         PluginInitializationException {
 263         final PluginHandlerParameters pluginParameters = getPluginHandlerParameters();
 264         pluginParameters.setName("DummyDistributionGroup");
 265         ParameterService.register(pluginParameters);
 266         final PluginHandler pluginHandler = new PluginHandler(pluginParameters.getName());
 267
 268         final Field decodersField = pluginHandler.getClass().getDeclaredField("policyDecoders");
 269         decodersField.setAccessible(true);
 270         decodersField.set(pluginHandler, decoders);
 271
 272         final Field forwardersField = pluginHandler.getClass().getDeclaredField("policyForwarders");
 273         forwardersField.setAccessible(true);
 274         forwardersField.set(pluginHandler, forwarders);
 275
 276         final Field pluginHandlerField = AbstractReceptionHandler.class.getDeclaredField("pluginHandler");
 277         pluginHandlerField.setAccessible(true);
 278         pluginHandlerField.set(receptionHandler, pluginHandler);
 279         ParameterService.deregister(pluginParameters.getName());
 280     }
 281
 282     private PluginHandlerParameters getPluginHandlerParameters() {
 283         final Map<String, PolicyDecoderParameters> policyDecoders = getPolicyDecoders();
 284         final Map<String, PolicyForwarderParameters> policyForwarders = getPolicyForwarders();
 285         return new PluginHandlerParameters(policyDecoders, policyForwarders);
 286     }
 287
 288     private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
 289         final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<>();
 290         final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("DummyDecoder",
 291             "org.onap.policy.distribution.reception.handling.sdc.DummyDecoder", "DummyDecoderConfiguration");
 292         policyDecoders.put("DummyDecoderKey", pDParameters);
 293         return policyDecoders;
 294     }
 295
 296     private Map<String, PolicyForwarderParameters> getPolicyForwarders() {
 297         final Map<String, PolicyForwarderParameters> policyForwarders = new HashMap<>();
 298         final PolicyForwarderParameters pFParameters = new PolicyForwarderParameters("DummyForwarder",
 299             "org.onap.policy.distribution.reception.handling.sdc.DummyPolicyForwarder", "DummyConfiguration");
 300         policyForwarders.put("DummyForwarderKey", pFParameters);
 301         return policyForwarders;
 302     }
 303 }