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

   1 package org.openecomp.sdc.be.components.distribution.engine;
   2
   3 import mockit.Deencapsulation;
   4 import java.util.LinkedList;
   5 import org.junit.Assert;
   6 import org.junit.Before;
   7 import org.junit.Test;
   8 import org.mockito.ArgumentMatchers;
   9 import org.mockito.InjectMocks;
  10 import org.mockito.Mock;
  11 import org.mockito.Mockito;
  12 import org.mockito.MockitoAnnotations;
  13 import org.openecomp.sdc.be.components.BeConfDependentTest;
  14 import org.openecomp.sdc.be.components.utils.OperationalEnvironmentBuilder;
  15 import org.openecomp.sdc.be.config.DistributionEngineConfiguration;
  16 import org.openecomp.sdc.be.config.DistributionEngineConfiguration.CreateTopicConfig;
  17 import org.openecomp.sdc.be.config.DistributionEngineConfiguration.DistributionStatusTopicConfig;
  18 import org.openecomp.sdc.be.dao.api.ActionStatus;
  19 import org.openecomp.sdc.be.model.Service;
  20 import org.openecomp.sdc.be.model.User;
  21 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  22 import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry;
  23
  24 import java.util.HashSet;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Set;
  28 import java.util.function.Function;
  29 import java.util.stream.Collectors;
  30 import java.util.stream.Stream;
  31
  32 import static org.junit.Assert.assertEquals;
  33 import static org.mockito.ArgumentMatchers.any;
  34 import static org.mockito.ArgumentMatchers.eq;
  35 import static org.mockito.Mockito.verifyZeroInteractions;
  36 import static org.mockito.Mockito.when;
  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     private User modifier = new User();
  65
  66         @Before
  67         public void setUpMock() throws Exception {
  68                 MockitoAnnotations.initMocks(this);
  69                 distributionEngineConfigurationMock = new DummyDistributionConfigurationManager();
  70                 envs = getEnvs(ENV_ID);
  71         modifier.setUserId(USER_ID);
  72         modifier.setFirstName(MODIFIER);
  73         modifier.setLastName(MODIFIER);
  74         }
  75
  76     @Test
  77     public void notifyService() throws Exception {
  78         NotificationDataImpl notificationData = new NotificationDataImpl();
  79         Service service = new Service();
  80         when(environmentsEngine.getEnvironmentById(ENV_ID)).thenReturn(envs.get(ENV_ID));
  81         when(distributionEngineConfigurationMock.getConfigurationMock().getDistributionNotifTopicName()).thenReturn("topic");
  82         when(distributionNotificationSender.sendNotification(eq("topic-ENVID"), eq(DISTRIBUTION_ID), any(EnvironmentMessageBusData.class),
  83                 any(NotificationDataImpl.class), any(Service.class), any(User.class)))
  84         .thenReturn(ActionStatus.OK);
  85         ActionStatus actionStatus = testInstance.notifyService(DISTRIBUTION_ID, service, notificationData, ENV_ID, modifier);
  86         assertEquals(ActionStatus.OK, actionStatus);
  87     }
  88
  89     @Test
  90     public void notifyService_couldNotResolveEnvironment() throws Exception {
  91         when(environmentsEngine.getEnvironments()).thenReturn(envs);
  92         ActionStatus actionStatus = testInstance.notifyService(DISTRIBUTION_ID, new Service(), new NotificationDataImpl(), "someNonExisitngEnv", modifier);
  93         assertEquals(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE, actionStatus);
  94         verifyZeroInteractions(distributionNotificationSender);
  95     }
  96
  97     @Test
  98     public void notifyService_failedWhileSendingNotification() throws Exception {
  99         NotificationDataImpl notificationData = new NotificationDataImpl();
 100         Service service = new Service();
 101         when(environmentsEngine.getEnvironmentById(ENV_ID)).thenReturn(envs.get(ENV_ID));
 102         when(distributionEngineConfigurationMock.getConfigurationMock().getDistributionNotifTopicName()).thenReturn("topic");
 103         when(distributionNotificationSender.sendNotification(eq("topic-ENVID"), eq(DISTRIBUTION_ID), any(EnvironmentMessageBusData.class),
 104                 any(NotificationDataImpl.class), any(Service.class), any(User.class)))
 105                 .thenReturn(ActionStatus.GENERAL_ERROR);
 106         ActionStatus actionStatus = testInstance.notifyService(DISTRIBUTION_ID, service, notificationData, ENV_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
 305
 306         @Test
 307         public void testGetEnvironmentById() throws Exception {
 308                 DistributionEngine testSubject;
 309                 String opEnvId = "";
 310                 OperationalEnvironmentEntry result;
 311
 312                 // default test
 313                 when(environmentsEngine.getEnvironmentById(ArgumentMatchers.anyString()))
 314                                 .thenReturn(new OperationalEnvironmentEntry());
 315                 result = testInstance.getEnvironmentById(opEnvId);
 316         }
 317
 318         @Test
 319         public void testBuildServiceForDistribution() throws Exception {
 320                 Service service = new Service();
 321                 String distributionId = "";
 322                 String workloadContext = "";
 323                 INotificationData result;
 324
 325                 // default test
 326                 // testSubject = createTestSubject();
 327                 when(serviceDistributionArtifactsBuilder.buildResourceInstanceForDistribution(ArgumentMatchers.any(),
 328                                 ArgumentMatchers.any(), ArgumentMatchers.any())).thenReturn(new NotificationDataImpl());
 329                 result = testInstance.buildServiceForDistribution(service, distributionId, workloadContext);
 330         }
 331 }