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

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