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