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