gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.be.components.distribution.engine;
   2
   3 import static java.util.Objects.isNull;
   4 import static org.apache.commons.lang3.StringUtils.isEmpty;
   5 import static org.mockito.Mockito.doNothing;
   6 import static org.mockito.Mockito.verify;
   7 import static org.mockito.Mockito.when;
   8
   9 import org.apache.commons.lang.NotImplementedException;
  10 import org.apache.commons.lang.math.NumberUtils;
  11 import org.apache.http.HttpStatus;
  12 import org.junit.Assert;
  13 import org.mockito.InjectMocks;
  14 import org.mockito.Mock;
  15 import org.mockito.Mockito;
  16 import org.mockito.MockitoAnnotations;
  17 import org.mockito.Spy;
  18 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  19 import org.openecomp.sdc.be.dao.cassandra.OperationalEnvironmentDao;
  20 import org.openecomp.sdc.be.datatypes.enums.EnvironmentStatusEnum;
  21 import org.openecomp.sdc.be.impl.ComponentsUtils;
  22 import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry;
  23 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  24 import org.openecomp.sdc.common.datastructure.Wrapper;
  25 import org.openecomp.sdc.common.http.client.api.HttpResponse;
  26
  27 import com.att.aft.dme2.api.DME2Exception;
  28 import com.att.aft.dme2.iterator.DME2EndpointIterator;
  29 import com.att.nsa.apiClient.credentials.ApiCredential;
  30 import com.google.gson.Gson;
  31 import com.google.gson.GsonBuilder;
  32
  33 import cucumber.api.java.Before;
  34 import cucumber.api.java.en.Given;
  35 import cucumber.api.java.en.Then;
  36 import cucumber.api.java.en.When;
  37 import fj.data.Either;
  38
  39 public class StepsTenantIsolation {
  40
  41     // Notification Fields
  42     private String operationalEnvironmentId = "28122015552391";
  43     private String operationalEnvironmentName = "Operational Environment Name";
  44     private String operationalEnvironmentType;
  45     private String tenantContext ;
  46     private String workloadContext;
  47     private String action;
  48
  49     @Mock
  50     private DmaapConsumer dmaapConsumer;
  51     @Mock
  52     private OperationalEnvironmentDao operationalEnvironmentDao;
  53     @Mock
  54     private DME2EndpointIteratorCreator epIterCreator;
  55     @Mock
  56     private ComponentsUtils componentsUtils;
  57     @Mock
  58     private AaiRequestHandler aaiRequestHandler;
  59     @Mock
  60     private CambriaHandler cambriaHandler;
  61     @InjectMocks
  62     @Spy
  63     private EnvironmentsEngine envEngine;
  64
  65     private boolean isSuccessful;
  66     private boolean cassandraUp;
  67
  68     @Before
  69     public void beforeScenario() {
  70         MockitoAnnotations.initMocks(this);
  71         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.COMPLETED))
  72                 .thenReturn(Either.right(CassandraOperationStatus.NOT_FOUND));
  73         doNothing().when(envEngine).createUebTopicsForEnvironments();
  74         envEngine.init();
  75     }
  76
  77     // ############################# Given - Start #############################
  78     @Given("^Dmaap consumer recieved notification with fields (.*)$")
  79     public void dmaap_consumer_recieved_notification_with_fields(String notificationFields) throws Throwable {
  80         Gson gson = new GsonBuilder().create();
  81         IDmaapNotificationData notification = gson.fromJson(notificationFields, DmaapNotificationDataImpl.class);
  82         if (!isNull(notification.getOperationalEnvironmentType())) {
  83             this.operationalEnvironmentType = notification.getOperationalEnvironmentType().getEventTypenName();
  84         }
  85         if( !isEmpty(notification.getOperationalEnvironmentId()) ){
  86             this.operationalEnvironmentId = notification.getOperationalEnvironmentId();
  87         }
  88         if( !isNull(notification.getAction()) ){
  89             this.action = notification.getAction().getActionName();
  90         }
  91
  92     }
  93
  94     @Given("^Cassandra service status is (.*)$")
  95     public void cassandra_service_status_is(String status) throws Throwable {
  96         switch (status) {
  97         case "UP":
  98             this.cassandraUp = true;
  99             break;
 100         case "DOWN":
 101             when(operationalEnvironmentDao.get(operationalEnvironmentId))
 102                     .thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
 103             when(operationalEnvironmentDao.save(Mockito.any(OperationalEnvironmentEntry.class)))
 104                     .thenReturn(CassandraOperationStatus.GENERAL_ERROR);
 105             break;
 106         default:
 107             throw new NotImplementedException();
 108         }
 109     }
 110
 111     @Given("^Record status is (.*)$")
 112     public void record_status_is(String status) throws Throwable {
 113         if (!cassandraUp) {
 114             return;
 115         }
 116         Either<OperationalEnvironmentEntry, CassandraOperationStatus> eitherResult;
 117         final OperationalEnvironmentEntry entryMock = Mockito.mock(OperationalEnvironmentEntry.class);
 118         switch (status) {
 119         case "FOUND_IN_PROGRESS":
 120             when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.IN_PROGRESS.getName());
 121             eitherResult = Either.left(entryMock);
 122             break;
 123         case "FOUND_COMPLETED":
 124             when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.COMPLETED.getName());
 125             eitherResult = Either.left(entryMock);
 126             break;
 127         case "FOUND_FAILED":
 128             when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.FAILED.getName());
 129             eitherResult = Either.left(entryMock);
 130             break;
 131         case "NOT_FOUND":
 132             eitherResult = Either.right(CassandraOperationStatus.NOT_FOUND);
 133             break;
 134         default:
 135             throw new NotImplementedException();
 136         }
 137
 138         when(operationalEnvironmentDao.get(operationalEnvironmentId)).thenReturn(eitherResult);
 139         when(operationalEnvironmentDao.save(Mockito.any(OperationalEnvironmentEntry.class)))
 140                 .thenReturn(CassandraOperationStatus.OK);
 141     }
 142
 143     @Given("^AAI service status is (.*) and Tenant returned is (.*) and worload returned is (.*)$")
 144     public void aai_service_status_is(String aaiServiceStatus, String tenant, String workload) throws Throwable {
 145         this.tenantContext = tenant;
 146         this.workloadContext = workload;
 147         HttpResponse<String> resp = Mockito.mock(HttpResponse.class);
 148         when(aaiRequestHandler.getOperationalEnvById(operationalEnvironmentId)).thenReturn(resp);
 149         switch (aaiServiceStatus) {
 150         case "UP":
 151             when(resp.getStatusCode()).thenReturn(HttpStatus.SC_OK);
 152             String aaiResponseTemplate =
 153                     //@formatter:off
 154                     "{\r\n"
 155                     + "     \"operational-environment-id\": \"%s\",\r\n"
 156                     + "     \"operational-environment-name\": \"%s\",\r\n"
 157                     + "     \"operational-environment-type\": \"%s\",\r\n"
 158                     + "     \"operational-environment-status\": \"IN-PROGRESS\",\r\n"
 159                     + "     \"tenant-context\": \"%s\",\r\n"
 160                     + "     \"workload-context\": \"%s\"\r\n"
 161                     + "    }";
 162                     //@formatter:on
 163             when(resp.getResponse()).thenReturn(String.format(aaiResponseTemplate, operationalEnvironmentId,
 164                     operationalEnvironmentName, operationalEnvironmentType, tenantContext, workloadContext));
 165
 166             break;
 167         case "DOWN":
 168             when(resp.getStatusCode()).thenReturn(HttpStatus.SC_REQUEST_TIMEOUT);
 169             break;
 170         default:
 171             throw new NotImplementedException();
 172         }
 173     }
 174
 175     @Given("^AFT_DME service status is (.*)$")
 176     public void aft_dme_service_status_is(String aftDmeStatus) throws Throwable {
 177         switch (aftDmeStatus) {
 178         case "UP":
 179             DME2EndpointIterator mockItr = Mockito.mock(DME2EndpointIterator.class);
 180             when(mockItr.hasNext()).thenReturn(false);
 181             when(epIterCreator.create(Mockito.anyString())).thenReturn(mockItr);
 182             break;
 183         case "DOWN":
 184             when(epIterCreator.create(Mockito.anyString()))
 185                     .thenThrow(new DME2Exception("dummyCode", new NotImplementedException()));
 186             break;
 187         default:
 188             throw new NotImplementedException();
 189         }
 190     }
 191
 192     @SuppressWarnings("unchecked")
 193     @Given("^UEB service status is (.*)$")
 194     public void ueb_service_status_is(String status) throws Throwable {
 195
 196         Either<ApiCredential, CambriaErrorResponse> response;
 197         switch (status) {
 198         case "UP":
 199             ApiCredential apiCredential = Mockito.mock(ApiCredential.class);
 200             when(apiCredential.getApiKey()).thenReturn("MockAPIKey");
 201             when(apiCredential.getApiSecret()).thenReturn("MockSecretKey");
 202             response = Either.left(apiCredential);
 203             break;
 204         case "DOWN":
 205             CambriaErrorResponse cambriaError = Mockito.mock(CambriaErrorResponse.class);
 206             response = Either.right(cambriaError);
 207             break;
 208         default:
 209             throw new NotImplementedException();
 210         }
 211         when(cambriaHandler.createUebKeys(Mockito.anyList())).thenReturn(response);
 212     }
 213     // ############################# Given - End #############################
 214
 215     // ############################# When - Start #############################
 216
 217     @When("^handle message is activated$")
 218     public void handle_message_is_activated() throws Throwable {
 219         this.isSuccessful = envEngine.handleMessage(buildNotification());
 220     }
 221     // ############################# When - End #############################
 222
 223     // ############################# Then - Start #############################
 224     @SuppressWarnings("unchecked")
 225     @Then("^handle message activates validation of eventType (.*)$")
 226     public void handle_message_activates_validation_of_eventType(boolean isValidated) throws Throwable {
 227         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isValidated)))
 228                 .validateEnvironmentType(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class),
 229                         Mockito.any(IDmaapAuditNotificationData.class));
 230     }
 231
 232     @SuppressWarnings("unchecked")
 233     @Then("^trying to write message to audit log and table (.*)$")
 234     public void trying_to_write_message_to_audit_log_and_table(boolean isUnsupportedTypeEventRecorded) throws Throwable {
 235         int count = isUnsupportedTypeEventRecorded ? 2 : 1;
 236         verify(componentsUtils, Mockito.atLeast(count))
 237                 .auditEnvironmentEngine(Mockito.any(AuditingActionEnum.class), Mockito.eq(operationalEnvironmentId),
 238                         Mockito.any(String.class), Mockito.any(String.class), Mockito.eq(operationalEnvironmentName), Mockito.eq(tenantContext));
 239     }
 240
 241     @SuppressWarnings("unchecked")
 242     @Then("^handle message activates validation of action (.*)$")
 243     public void handle_message_activates_validation_of_action(boolean isValidated) throws Throwable {
 244         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isValidated)))
 245                 .validateActionType(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class));
 246     }
 247
 248     @SuppressWarnings("unchecked")
 249     @Then("^handle message activates validation of state (.*)$")
 250     public void handle_message_activates_validation_of_state(boolean isValidated) throws Throwable {
 251         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isValidated)))
 252                 .validateState(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class));
 253     }
 254
 255     @SuppressWarnings("unchecked")
 256     @Then("^trying to save in-progress record (.*)$")
 257     public void trying_to_save_in_progress_record(boolean isActivated) throws Throwable {
 258         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated)))
 259                 .saveEntryWithInProgressStatus(Mockito.any(Wrapper.class), Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class));
 260     }
 261
 262     @SuppressWarnings("unchecked")
 263     @Then("^trying to get environment info from A&AI API (.*)$")
 264     public void trying_to_get_environment_info_from_AAI_AP(boolean isActivated) throws Throwable {
 265         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated)))
 266                 .retrieveOpEnvInfoFromAAI(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
 267     }
 268
 269     @SuppressWarnings("unchecked")
 270     @Then("^trying to retrieve Ueb Addresses From AftDme (.*)$")
 271     public void trying_to_retrieve_ueb_addresses_from_AftDme(boolean isActivated) throws Throwable {
 272         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated))).discoverUebHosts(
 273                 Mockito.anyString(), Mockito.anyString());
 274
 275     }
 276
 277     @SuppressWarnings("unchecked")
 278     @Then("^trying to create Ueb keys (.*)$")
 279     public void trying_to_create_ueb_keys(boolean isActivated) throws Throwable {
 280         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated)))
 281                 .createUebKeys(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
 282     }
 283
 284     @Then("^trying to create Ueb Topics (.*)$")
 285     public void trying_to_create_ueb_topics(boolean isActivated) throws Throwable {
 286         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated)))
 287                 .createUebTopicsForEnvironment(Mockito.any(OperationalEnvironmentEntry.class));
 288     }
 289
 290     @Then("^handle message finished successfully (.*)$")
 291     public void handle_message_finished_successfully(boolean isSuccessfull) throws Throwable {
 292         Assert.assertTrue(this.isSuccessful == isSuccessfull);
 293     }
 294
 295     // ############################# Then - End #############################
 296
 297     private String buildNotification() {
 298         String notificationTemplate = "{ \"operationalEnvironmentId\": \"%s\",\r\n"
 299                 + "             \"operationalEnvironmentName\": \"%s\",\r\n"
 300                 + "             \"operationalEnvironmentType\": \"%s\",\r\n" + "             \"tenantContext\": \"%s\",\r\n"
 301                 + "             \"workloadContext\": \"%s\",\r\n" + "             \"action\": \"%s\"}";
 302
 303         String notification = String.format(notificationTemplate, operationalEnvironmentId, operationalEnvironmentName,
 304                 operationalEnvironmentType, tenantContext, workloadContext, action);
 305         return notification;
 306     }
 307
 308     private int getNumberOfCallsToValidate(boolean isValidated) {
 309         return isValidated ? NumberUtils.INTEGER_ONE : NumberUtils.INTEGER_ZERO;
 310     }
 311
 312 }