catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   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  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.distribution.engine;
  22
  23 import mockit.Deencapsulation;
  24 import java.util.LinkedList;
  25 import org.junit.Assert;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28 import org.mockito.ArgumentMatchers;
  29 import org.mockito.InjectMocks;
  30 import org.mockito.Mock;
  31 import org.mockito.Mockito;
  32 import org.mockito.MockitoAnnotations;
  33 import org.openecomp.sdc.be.components.BeConfDependentTest;
  34 import org.openecomp.sdc.be.components.utils.OperationalEnvironmentBuilder;
  35 import org.openecomp.sdc.be.config.DistributionEngineConfiguration;
  36 import org.openecomp.sdc.be.config.DistributionEngineConfiguration.CreateTopicConfig;
  37 import org.openecomp.sdc.be.config.DistributionEngineConfiguration.DistributionStatusTopicConfig;
  38 import org.openecomp.sdc.be.dao.api.ActionStatus;
  39 import org.openecomp.sdc.be.model.Service;
  40 import org.openecomp.sdc.be.model.User;
  41 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  42 import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry;
  43
  44 import java.util.HashSet;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.Set;
  48 import java.util.function.Function;
  49 import java.util.stream.Collectors;
  50 import java.util.stream.Stream;
  51
  52 import static org.junit.Assert.assertEquals;
  53 import static org.mockito.ArgumentMatchers.any;
  54 import static org.mockito.ArgumentMatchers.eq;
  55 import static org.mockito.Mockito.verifyZeroInteractions;
  56 import static org.mockito.Mockito.when;
  57
  58 public class DistributionEngineTest extends BeConfDependentTest{
  59
  60         public static final String DISTRIBUTION_ID = "distId";
  61         public static final String ENV_ID = "envId";
  62         public static final String USER_ID = "userId";
  63         public static final String MODIFIER = "modifier";
  64
  65         @InjectMocks
  66         private DistributionEngine testInstance;
  67
  68         @Mock
  69         private EnvironmentsEngine environmentsEngine;
  70
  71         @Mock
  72         private DistributionNotificationSender distributionNotificationSender;
  73
  74         @Mock
  75         private ServiceDistributionArtifactsBuilder serviceDistributionArtifactsBuilder;
  76
  77         @Mock
  78         private DistributionEngineClusterHealth distributionEngineClusterHealth;
  79
  80         private DummyDistributionConfigurationManager distributionEngineConfigurationMock;
  81
  82         private Map<String, OperationalEnvironmentEntry> envs;
  83
  84     private User modifier = new User();
  85
  86         @Before
  87         public void setUpMock() throws Exception {
  88                 MockitoAnnotations.initMocks(this);
  89                 distributionEngineConfigurationMock = new DummyDistributionConfigurationManager();
  90                 envs = getEnvs(ENV_ID);
  91         modifier.setUserId(USER_ID);
  92         modifier.setFirstName(MODIFIER);
  93         modifier.setLastName(MODIFIER);
  94         }
  95
  96     @Test
  97     public void notifyService() throws Exception {
  98         NotificationDataImpl notificationData = new NotificationDataImpl();
  99         Service service = new Service();
 100         when(environmentsEngine.getEnvironmentById(ENV_ID)).thenReturn(envs.get(ENV_ID));
 101         when(distributionEngineConfigurationMock.getConfigurationMock().getDistributionNotifTopicName()).thenReturn("topic");
 102         when(distributionNotificationSender.sendNotification(eq("topic-ENVID"), eq(DISTRIBUTION_ID), any(EnvironmentMessageBusData.class),
 103                 any(NotificationDataImpl.class), any(Service.class), any(User.class)))
 104         .thenReturn(ActionStatus.OK);
 105         ActionStatus actionStatus = testInstance.notifyService(DISTRIBUTION_ID, service, notificationData, ENV_ID, modifier);
 106         assertEquals(ActionStatus.OK, actionStatus);
 107     }
 108
 109     @Test
 110     public void notifyService_couldNotResolveEnvironment() throws Exception {
 111         when(environmentsEngine.getEnvironments()).thenReturn(envs);
 112         ActionStatus actionStatus = testInstance.notifyService(DISTRIBUTION_ID, new Service(), new NotificationDataImpl(), "someNonExisitngEnv", modifier);
 113         assertEquals(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE, actionStatus);
 114         verifyZeroInteractions(distributionNotificationSender);
 115     }
 116
 117     @Test
 118     public void notifyService_failedWhileSendingNotification() throws Exception {
 119         NotificationDataImpl notificationData = new NotificationDataImpl();
 120         Service service = new Service();
 121         when(environmentsEngine.getEnvironmentById(ENV_ID)).thenReturn(envs.get(ENV_ID));
 122         when(distributionEngineConfigurationMock.getConfigurationMock().getDistributionNotifTopicName()).thenReturn("topic");
 123         when(distributionNotificationSender.sendNotification(eq("topic-ENVID"), eq(DISTRIBUTION_ID), any(EnvironmentMessageBusData.class),
 124                 any(NotificationDataImpl.class), any(Service.class), any(User.class)))
 125                 .thenReturn(ActionStatus.GENERAL_ERROR);
 126         ActionStatus actionStatus = testInstance.notifyService(DISTRIBUTION_ID, service, notificationData, ENV_ID, modifier);
 127         assertEquals(ActionStatus.GENERAL_ERROR, actionStatus);
 128     }
 129
 130         private Map<String, OperationalEnvironmentEntry> getEnvs(String... environmentIds) {
 131                 Set<String> uebAddress = new HashSet<>();
 132                 uebAddress.add("someAddress");
 133                 return Stream.of(environmentIds)
 134                                 .map(id -> new OperationalEnvironmentBuilder().setEnvId(id).setDmaapUebAddress(uebAddress).build())
 135                                 .collect(Collectors.toMap(OperationalEnvironmentEntry::getEnvironmentId, Function.identity()));
 136         }
 137
 138         @Test
 139         public void testIsActive() throws Exception {
 140                 // default test
 141                 testInstance.isActive();
 142         }
 143
 144         @Test
 145         public void testInitDisabled() throws Exception {
 146                 // default test
 147                 Deencapsulation.invoke(testInstance, "init");
 148         }
 149
 150         @Test
 151         public void testInitNotValidConfig() throws Exception {
 152                 DistributionEngine testSubject;
 153
 154                 // default test
 155                 Mockito.when(distributionEngineConfigurationMock.getConfigurationMock().isStartDistributionEngine())
 156                                 .thenReturn(true);
 157                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getDistributionStatusTopic())
 158                                 .thenReturn(new DistributionStatusTopicConfig());
 159                 Deencapsulation.invoke(testInstance, "init");
 160         }
 161
 162         @Test
 163         public void testInit() throws Exception {
 164                 DistributionEngine testSubject;
 165
 166                 // default test
 167                 Mockito.when(distributionEngineConfigurationMock.getConfigurationMock().isStartDistributionEngine())
 168                                 .thenReturn(true);
 169                 DistributionStatusTopicConfig value = new DistributionStatusTopicConfig();
 170                 value.setConsumerId("mock");
 171                 value.setConsumerGroup("mock");
 172                 value.setFetchTimeSec(0);
 173                 value.setPollingIntervalSec(0);
 174                 LinkedList<String> value2 = new LinkedList<>();
 175                 value2.add("uebsb91kcdc.it.att.com:3904");
 176                 value2.add("uebsb92kcdc.it.att.com:3904");
 177                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getUebServers()).thenReturn(value2);
 178                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getEnvironments()).thenReturn(value2);
 179                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getUebPublicKey()).thenReturn("mock");
 180                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getUebSecretKey()).thenReturn("mock");
 181                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getDistributionNotifTopicName())
 182                                 .thenReturn("mock");
 183                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getDistributionStatusTopicName())
 184                                 .thenReturn("mock");
 185                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getCreateTopic())
 186                                 .thenReturn(new CreateTopicConfig());
 187                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getDistributionStatusTopic())
 188                                 .thenReturn(value);
 189                 Deencapsulation.invoke(testInstance, "init");
 190         }
 191
 192         @Test
 193         public void testShutdown() throws Exception {
 194                 DistributionEngine testSubject;
 195
 196                 // default test
 197                 testInstance.shutdown();
 198         }
 199
 200         @Test
 201         public void testValidateConfiguration() throws Exception {
 202                 DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration();
 203                 deConfiguration.setDistributionStatusTopic((new DistributionStatusTopicConfig()));
 204                 boolean result;
 205
 206                 // default test
 207                 result = Deencapsulation.invoke(testInstance, "validateConfiguration", deConfiguration);
 208         }
 209
 210         @Test
 211         public void testIsValidServers() throws Exception {
 212                 List<String> uebServers = null;
 213                 String methodName = "";
 214                 String paramName = "";
 215                 boolean result;
 216
 217                 // test 1
 218                 uebServers = null;
 219                 result = Deencapsulation.invoke(testInstance, "isValidServers",
 220                                 new Object[] { List.class, methodName, paramName });
 221                 Assert.assertEquals(false, result);
 222         }
 223
 224         @Test
 225         public void testIsValidFqdn() throws Exception {
 226                 String serverFqdn = "";
 227                 boolean result;
 228
 229                 // default test
 230                 result = Deencapsulation.invoke(testInstance, "isValidFqdn", new Object[] { serverFqdn });
 231         }
 232
 233         @Test
 234         public void testIsValidParam() throws Exception {
 235                 String paramValue = "";
 236                 String methodName = "";
 237                 String paramName = "";
 238                 boolean result;
 239
 240                 // default test
 241                 result = Deencapsulation.invoke(testInstance, "isValidParam",
 242                                 new Object[] { paramValue, methodName, paramName });
 243         }
 244
 245         @Test
 246         public void testIsValidParam_1() throws Exception {
 247                 List<String> paramValue = null;
 248                 String methodName = "";
 249                 String paramName = "";
 250                 boolean result;
 251
 252                 // default test
 253                 result = Deencapsulation.invoke(testInstance, "isValidParam",
 254                                 new Object[] { List.class, methodName, paramName });
 255         }
 256
 257         @Test
 258         public void testIsValidObject() throws Exception {
 259                 Object paramValue = null;
 260                 String methodName = "";
 261                 String paramName = "";
 262                 boolean result;
 263
 264                 // test 1
 265                 paramValue = null;
 266                 result = Deencapsulation.invoke(testInstance, "isValidObject",
 267                                 new Object[] { Object.class, methodName, paramName });
 268                 Assert.assertEquals(false, result);
 269         }
 270
 271         @Test
 272         public void testGetEnvironmentErrorDescription() throws Exception {
 273                 StorageOperationStatus status = null;
 274                 String result;
 275
 276                 // default test
 277                 result = Deencapsulation.invoke(testInstance, "getEnvironmentErrorDescription",
 278                                 StorageOperationStatus.DISTR_ENVIRONMENT_NOT_AVAILABLE);
 279                 result = Deencapsulation.invoke(testInstance, "getEnvironmentErrorDescription",
 280                                 StorageOperationStatus.DISTR_ENVIRONMENT_NOT_FOUND);
 281                 result = Deencapsulation.invoke(testInstance, "getEnvironmentErrorDescription",
 282                                 StorageOperationStatus.DISTR_ENVIRONMENT_SENT_IS_INVALID);
 283                 result = Deencapsulation.invoke(testInstance, "getEnvironmentErrorDescription",
 284                                 StorageOperationStatus.ARTIFACT_NOT_FOUND);
 285         }
 286
 287         @Test
 288         public void testIsEnvironmentAvailable() throws Exception {
 289                 DistributionEngine testSubject;
 290                 String envName = "";
 291                 StorageOperationStatus result;
 292
 293                 // test 1
 294                 envName = null;
 295                 result = testInstance.isEnvironmentAvailable(envName);
 296                 Assert.assertEquals(StorageOperationStatus.DISTR_ENVIRONMENT_SENT_IS_INVALID, result);
 297
 298                 // test 2
 299                 envName = "mock";
 300                 result = testInstance.isEnvironmentAvailable(envName);
 301                 Assert.assertEquals(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_FOUND, result);
 302         }
 303
 304         @Test
 305         public void testIsEnvironmentAvailable_1() throws Exception {
 306                 DistributionEngine testSubject;
 307                 StorageOperationStatus result;
 308
 309                 LinkedList<String> value = new LinkedList<>();
 310                 value.add("mock");
 311                 Mockito.when(distributionEngineConfigurationMock.configurationMock.getEnvironments()).thenReturn(value);
 312                 testInstance.isEnvironmentAvailable();
 313         }
 314
 315         @Test
 316         public void testBuildTopicName() throws Exception {
 317                 String envName = "";
 318                 String result;
 319
 320                 // default test
 321                 result = Deencapsulation.invoke(testInstance, "buildTopicName", new Object[] { envName });
 322         }
 323
 324
 325
 326         @Test
 327         public void testGetEnvironmentById() throws Exception {
 328                 DistributionEngine testSubject;
 329                 String opEnvId = "";
 330                 OperationalEnvironmentEntry result;
 331
 332                 // default test
 333                 when(environmentsEngine.getEnvironmentById(ArgumentMatchers.anyString()))
 334                                 .thenReturn(new OperationalEnvironmentEntry());
 335                 result = testInstance.getEnvironmentById(opEnvId);
 336         }
 337
 338         @Test
 339         public void testBuildServiceForDistribution() throws Exception {
 340                 Service service = new Service();
 341                 String distributionId = "";
 342                 String workloadContext = "";
 343                 INotificationData result;
 344
 345                 // default test
 346                 // testSubject = createTestSubject();
 347                 when(serviceDistributionArtifactsBuilder.buildResourceInstanceForDistribution(ArgumentMatchers.any(),
 348                                 ArgumentMatchers.any(), ArgumentMatchers.any())).thenReturn(new NotificationDataImpl());
 349                 result = testInstance.buildServiceForDistribution(service, distributionId, workloadContext);
 350         }
 351 }