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=NullPointerException.class)
 116         public void testInit() throws Exception {
 117                 DistributionEngine testSubject;
 118
 119                 // default test
 120                 testSubject = createTestSubject();
 121                 Deencapsulation.invoke(testSubject, "init");
 122         }
 123
 124         @Test
 125         public void testShutdown() throws Exception {
 126                 DistributionEngine testSubject;
 127
 128                 // default test
 129                 testSubject = createTestSubject();
 130                 testSubject.shutdown();
 131         }
 132
 133         @Test
 134         public void testValidateConfiguration() throws Exception {
 135                 DistributionEngine testSubject;
 136                 DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration();
 137                 deConfiguration.setDistributionStatusTopic((new DistributionStatusTopicConfig()));
 138                 boolean result;
 139
 140                 // default test
 141                 testSubject = createTestSubject();
 142                 result = Deencapsulation.invoke(testSubject, "validateConfiguration", deConfiguration);
 143         }
 144
 145         @Test
 146         public void testIsValidServers() throws Exception {
 147                 DistributionEngine testSubject;
 148                 List<String> uebServers = null;
 149                 String methodName = "";
 150                 String paramName = "";
 151                 boolean result;
 152
 153                 // test 1
 154                 testSubject = createTestSubject();
 155                 uebServers = null;
 156                 result = Deencapsulation.invoke(testSubject, "isValidServers",
 157                                 new Object[] { List.class, methodName, paramName });
 158                 Assert.assertEquals(false, result);
 159         }
 160
 161         @Test
 162         public void testIsValidFqdn() throws Exception {
 163                 DistributionEngine testSubject;
 164                 String serverFqdn = "";
 165                 boolean result;
 166
 167                 // default test
 168                 testSubject = createTestSubject();
 169                 result = Deencapsulation.invoke(testSubject, "isValidFqdn", new Object[] { serverFqdn });
 170         }
 171
 172         @Test
 173         public void testIsValidParam() throws Exception {
 174                 DistributionEngine testSubject;
 175                 String paramValue = "";
 176                 String methodName = "";
 177                 String paramName = "";
 178                 boolean result;
 179
 180                 // default test
 181                 testSubject = createTestSubject();
 182                 result = Deencapsulation.invoke(testSubject, "isValidParam",
 183                                 new Object[] { paramValue, methodName, paramName });
 184         }
 185
 186         @Test
 187         public void testIsValidParam_1() throws Exception {
 188                 DistributionEngine testSubject;
 189                 List<String> paramValue = null;
 190                 String methodName = "";
 191                 String paramName = "";
 192                 boolean result;
 193
 194                 // default test
 195                 testSubject = createTestSubject();
 196                 result = Deencapsulation.invoke(testSubject, "isValidParam",
 197                                 new Object[] { List.class, methodName, paramName });
 198         }
 199
 200         @Test
 201         public void testIsValidObject() throws Exception {
 202                 DistributionEngine testSubject;
 203                 Object paramValue = null;
 204                 String methodName = "";
 205                 String paramName = "";
 206                 boolean result;
 207
 208                 // test 1
 209                 testSubject = createTestSubject();
 210                 paramValue = null;
 211                 result = Deencapsulation.invoke(testSubject, "isValidObject",
 212                                 new Object[] { Object.class, methodName, paramName });
 213                 Assert.assertEquals(false, result);
 214         }
 215
 216         @Test
 217         public void testGetEnvironmentErrorDescription() throws Exception {
 218                 DistributionEngine testSubject;
 219                 StorageOperationStatus status = null;
 220                 String result;
 221
 222                 // default test
 223                 testSubject = createTestSubject();
 224                 result = Deencapsulation.invoke(testSubject, "getEnvironmentErrorDescription",
 225                                  StorageOperationStatus.DISTR_ENVIRONMENT_NOT_AVAILABLE);
 226                 result = Deencapsulation.invoke(testSubject, "getEnvironmentErrorDescription",
 227                                  StorageOperationStatus.DISTR_ENVIRONMENT_NOT_FOUND);
 228                 result = Deencapsulation.invoke(testSubject, "getEnvironmentErrorDescription",
 229                                  StorageOperationStatus.DISTR_ENVIRONMENT_SENT_IS_INVALID);
 230                 result = Deencapsulation.invoke(testSubject, "getEnvironmentErrorDescription",
 231                                  StorageOperationStatus.ARTIFACT_NOT_FOUND);
 232         }
 233
 234         @Test
 235         public void testIsEnvironmentAvailable() throws Exception {
 236                 DistributionEngine testSubject;
 237                 String envName = "";
 238                 StorageOperationStatus result;
 239
 240                 // test 1
 241                 testSubject = createTestSubject();
 242                 envName = null;
 243                 result = testSubject.isEnvironmentAvailable(envName);
 244                 Assert.assertEquals(StorageOperationStatus.DISTR_ENVIRONMENT_SENT_IS_INVALID, result);
 245
 246                 // test 2
 247                 testSubject = createTestSubject();
 248                 envName = "mock";
 249                 result = testSubject.isEnvironmentAvailable(envName);
 250                 Assert.assertEquals(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_FOUND, result);
 251         }
 252
 253         //TODO Create test coverage for this method
 254         /*@Test
 255         public void testIsEnvironmentAvailable_1() throws Exception {
 256                 DistributionEngine testSubject;
 257                 StorageOperationStatus result;
 258
 259                 // default test
 260                 testSubject = createTestSubject();
 261                 result = testInstance.isEnvironmentAvailable();
 262         }*/
 263
 264         @Test(expected=NullPointerException.class)
 265         public void testDisableEnvironment() throws Exception {
 266                 DistributionEngine testSubject;
 267                 String envName = "";
 268
 269                 // default test
 270                 testSubject = createTestSubject();
 271                 testSubject.disableEnvironment(envName);
 272         }
 273
 274         @Test
 275         public void testBuildTopicName() throws Exception {
 276                 DistributionEngine testSubject;
 277                 String envName = "";
 278                 String result;
 279
 280                 // default test
 281                 testSubject = createTestSubject();
 282                 result = Deencapsulation.invoke(testSubject, "buildTopicName", new Object[] { envName });
 283         }
 284
 285         @Test
 286         public void testIsReadyForDistribution() throws Exception {
 287                 DistributionEngine testSubject;
 288                 Service service = null;
 289                 String envName = "";
 290                 StorageOperationStatus result;
 291
 292                 // default test
 293                 testSubject = createTestSubject();
 294                 result = testSubject.isReadyForDistribution(service, envName);
 295         }
 296
 297         @Test
 298         public void testVerifyServiceHasDeploymentArtifactsTrue() throws Exception {
 299                 Service service = new Service();
 300                 StorageOperationStatus result;
 301
 302                 // default test
 303                 when(serviceDistributionArtifactsBuilder.verifyServiceContainsDeploymentArtifacts(ArgumentMatchers.any(Service.class))).thenReturn(true);
 304                 result = testInstance.verifyServiceHasDeploymentArtifacts(service);
 305         }
 306
 307         @Test
 308         public void testVerifyServiceHasDeploymentArtifactsFalse() throws Exception {
 309                 Service service = new Service();
 310                 StorageOperationStatus result;
 311
 312                 // default test
 313                 when(serviceDistributionArtifactsBuilder.verifyServiceContainsDeploymentArtifacts(ArgumentMatchers.any(Service.class))).thenReturn(false);
 314                 result = testInstance.verifyServiceHasDeploymentArtifacts(service);
 315         }
 316
 317         @Test
 318         public void testGetEnvironmentById() throws Exception {
 319                 DistributionEngine testSubject;
 320                 String opEnvId = "";
 321                 OperationalEnvironmentEntry result;
 322
 323                 // default test
 324                 when(environmentsEngine.getEnvironmentById(ArgumentMatchers.anyString())).thenReturn(new OperationalEnvironmentEntry());
 325                 result = testInstance.getEnvironmentById(opEnvId);
 326         }
 327
 328         @Test
 329         public void testBuildServiceForDistribution() throws Exception {
 330                 Service service = new Service();
 331                 String distributionId = "";
 332                 String workloadContext = "";
 333                 INotificationData result;
 334
 335                 // default test
 336                 //testSubject = createTestSubject();
 337                 when(serviceDistributionArtifactsBuilder.buildResourceInstanceForDistribution(ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any())).thenReturn(new NotificationDataImpl());
 338                 result = testInstance.buildServiceForDistribution(service, distributionId, workloadContext);
 339         }
 340 }