gerrit.onap Code Review - sdc.git/blob

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