diff options
Diffstat (limited to 'test-apis-ci/src/test/java/org/openecomp')
6 files changed, 752 insertions, 0 deletions
diff --git a/test-apis-ci/src/test/java/org/openecomp/sdc/conf/TestAPIConfDependentTest.java b/test-apis-ci/src/test/java/org/openecomp/sdc/conf/TestAPIConfDependentTest.java new file mode 100644 index 0000000000..99b6888211 --- /dev/null +++ b/test-apis-ci/src/test/java/org/openecomp/sdc/conf/TestAPIConfDependentTest.java @@ -0,0 +1,13 @@ +package org.openecomp.sdc.conf; + +import org.junit.BeforeClass; +import org.openecomp.sdc.common.test.BaseConfDependent; + +public class TestAPIConfDependentTest extends BaseConfDependent{ + @BeforeClass + public static void setupBeforeClass() { + componentName = "test-apis-ci"; + confPath = "src/test/resources/config"; + setUp(); + } +} diff --git a/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/runners/RunTenantIsolationCucumberCI.java b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/runners/RunTenantIsolationCucumberCI.java new file mode 100644 index 0000000000..d9183fc5c4 --- /dev/null +++ b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/runners/RunTenantIsolationCucumberCI.java @@ -0,0 +1,31 @@ +package org.openecomp.sdc.cucumber.runners; + +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.runner.RunWith; +import org.openecomp.sdc.conf.TestAPIConfDependentTest; + +import cucumber.api.CucumberOptions; +import cucumber.api.junit.Cucumber; + +@RunWith(Cucumber.class) +@CucumberOptions(features = "classpath:cucumber/tenantIsolation.feature", glue = "org.openecomp.sdc.cucumber.steps") + +public class RunTenantIsolationCucumberCI extends TestAPIConfDependentTest { + + @BeforeClass + public static void beforeClass() { + } + + @AfterClass + public static void afterClassJUnit() { + } + + @org.testng.annotations.BeforeClass + public static void beforeClassTestNg() { + } + + @org.testng.annotations.AfterClass + public static void afterClassTestNG() { + } +}
\ No newline at end of file diff --git a/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/spring/ImportTableConfig.java b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/spring/ImportTableConfig.java new file mode 100644 index 0000000000..f0c7610513 --- /dev/null +++ b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/spring/ImportTableConfig.java @@ -0,0 +1,19 @@ +package org.openecomp.sdc.cucumber.spring; + +import org.openecomp.sdc.be.dao.cassandra.CassandraClient; +import org.openecomp.sdc.be.dao.cassandra.OperationalEnvironmentDao; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +@Configuration +public class ImportTableConfig { + @Bean(name = "cassandra-client") + public CassandraClient cassandraClient() { + return new CassandraClient(); + } + + @Bean(name = "operational-environment-dao") + public OperationalEnvironmentDao operationalEnvironmentDao() { + return new OperationalEnvironmentDao(); + } +} diff --git a/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/steps/PrecannedTestExpectationCallback.java b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/steps/PrecannedTestExpectationCallback.java new file mode 100644 index 0000000000..56802ec7d4 --- /dev/null +++ b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/steps/PrecannedTestExpectationCallback.java @@ -0,0 +1,31 @@ +package org.openecomp.sdc.cucumber.steps; + +import static org.mockserver.model.HttpResponse.response; + +import org.apache.http.entity.ContentType; +import org.mockserver.mock.action.ExpectationCallback; +import org.mockserver.model.Header; +import org.mockserver.model.HttpRequest; +import org.mockserver.model.HttpResponse; + +import com.google.common.net.HttpHeaders; + +public class PrecannedTestExpectationCallback implements ExpectationCallback { + private static volatile int countRequests; + + static HttpResponse httpResponse = response() + .withStatusCode(200) + .withHeaders(new Header(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType())); + + @Override + public HttpResponse handle(HttpRequest httpRequest) { + countRequests++; + + System.out.println( + String.format("MSO Server Simulator Recieved %s Final Distribution Complete Rest Reports From ASDC", + countRequests)); + + return httpResponse; + } + +}
\ No newline at end of file diff --git a/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/steps/StepsTenantIsolationCI.java b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/steps/StepsTenantIsolationCI.java new file mode 100644 index 0000000000..490b3e0c84 --- /dev/null +++ b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/steps/StepsTenantIsolationCI.java @@ -0,0 +1,597 @@ +package org.openecomp.sdc.cucumber.steps; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.is; +import static org.mockserver.model.HttpCallback.callback; +import static org.mockserver.model.HttpRequest.request; +import static org.mockserver.model.HttpResponse.response; +import static org.openecomp.sdc.common.datastructure.FunctionalInterfaces.retryMethodOnResult; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertNotNull; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.UUID; +import java.util.function.Function; +import java.util.stream.Collectors; + +import org.apache.commons.collections.CollectionUtils; +//import org.openecomp.sdc.dmaap.DmaapPublisher; +import org.apache.commons.lang3.StringUtils; +import org.apache.http.HttpStatus; +import org.apache.http.entity.ContentType; +import org.apache.http.entity.StringEntity; +import org.mockserver.integration.ClientAndServer; +import org.mockserver.model.Header; +import org.mockserver.model.HttpRequest; +import org.openecomp.sdc.api.IDistributionClient; +import org.openecomp.sdc.api.consumer.IConfiguration; +import org.openecomp.sdc.api.consumer.IFinalDistrStatusMessage; +import org.openecomp.sdc.api.consumer.INotificationCallback; +import org.openecomp.sdc.api.notification.IArtifactInfo; +import org.openecomp.sdc.api.notification.INotificationData; +import org.openecomp.sdc.api.results.IDistributionClientDownloadResult; +import org.openecomp.sdc.api.results.IDistributionClientResult; +import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; +import org.openecomp.sdc.be.dao.cassandra.OperationalEnvironmentDao; +import org.openecomp.sdc.be.datatypes.enums.EnvironmentStatusEnum; +import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry; +import org.openecomp.sdc.common.datastructure.FunctionalInterfaces; +import org.openecomp.sdc.common.datastructure.Wrapper; +import org.openecomp.sdc.cucumber.spring.ImportTableConfig; +import org.openecomp.sdc.http.HttpAsdcClient; +import org.openecomp.sdc.http.HttpAsdcResponse; +import org.openecomp.sdc.http.IHttpAsdcClient; +import org.openecomp.sdc.impl.DistributionClientFactory; +import org.openecomp.sdc.utils.ArtifactTypeEnum; +import org.openecomp.sdc.utils.DistributionActionResultEnum; +import org.openecomp.sdc.utils.DistributionStatusEnum; +import org.springframework.context.annotation.AnnotationConfigApplicationContext; + +import com.google.common.base.Strings; +import com.google.common.net.HttpHeaders; +import com.google.gson.JsonElement; +import com.google.gson.JsonParser; + +import cucumber.api.java.After; +import cucumber.api.java.Before; +import cucumber.api.java.en.Given; +import cucumber.api.java.en.Then; +import cucumber.api.java.en.When; +import fj.data.Either; + +public class StepsTenantIsolationCI { + + private Map<String, OperationalEnvironmentEntry> recordMap = new HashMap<>(); + private OperationalEnvironmentDao operationalEnvironmentDao; + private ClientAndServer aaiMockServer; + private ClientAndServer msoMockServer; + private List<IDistributionClient> distributionClients = new ArrayList<>(); + + private List<String> wdFinalStatusSent = new ArrayList<>(); + + private HttpRequest msoHttpRequest; + private List<String> uuidServicesList; + private boolean cleanFlag = true; + private int maxStepWaitTimeMs; + + private List<String> envIds = new ArrayList<>(); + private List<OperationalEnvironmentEntry> envList = new ArrayList<>(); + private String asdcAddress; + private volatile int numberOfFinalDistributionsSentByASDC; + private int numOfArtifactsToDownload; + private volatile int totalNumOfArtifactsToDownload; + private List<String> envNames = new ArrayList<>(Arrays.asList("Apple", "Orange", "Grape", "Pear", "Watermelon", "Bannana", "Cherry", "Coconut", "Fig", "Mango", "Peach", "Pineapple", "Plum", "Strawberries", "Apricot")); + + private static final String AAI_RESPONSE_BODY_FMT = "{\"operational-environment-id\":\"UUID of Operational Environment\"," + + "\"operational-environment-name\":\"Op Env Name\"," + "\"operational-environment-type\":\"ECOMP\"," + + "\"operational-environment-status\":\"Activate\"," + "\"tenant-context\":\"%s\"," + + "\"workload-context\":\"%s\"," + "\"resource-version\":\"1505228226913\"," + "\"relationship-list\":{}}"; + + private static final String AAI_PATH_REGEX = "/aai/v12/cloud-infrastructure/operational-environments/.*"; + + private static final String MSO_PATH_REGEX = "/onap/mso/infra/modelDistributions/v1/distributions/.*"; + + @Before + public void beforeScenario() { + Collections.shuffle(envNames); + aaiMockServer = ClientAndServer.startClientAndServer(1111); + msoMockServer = ClientAndServer.startClientAndServer(1112); + + this.operationalEnvironmentDao = createDaoObj(); + } + + @After + public void afterScenario() { + System.out.println("Cleaning Up After Scenario..."); + aaiMockServer.stop(); + msoMockServer.stop(); + if (cleanFlag) { + envIds.stream().forEach(operationalEnvironmentDao::delete); + } + distributionClients.stream().forEach(IDistributionClient::stop); + System.out.println("Cleaning Up After Scenario Done"); + } + + // ############################# Given - Start ############################# + + @Given("^clean db after test is (.*)$") + public void clean_db_after_test_is(boolean cleanFlag) { + this.cleanFlag = cleanFlag; + } + + @Given("^AAI returns (.*) and aai_body contains (.*) and (.*)$") + public void aai_returns(int retCode, String tenant, String workload) throws Throwable { + String aaiResponseBody = String.format(AAI_RESPONSE_BODY_FMT, tenant, workload); + + setAaiMockServer(aaiResponseBody); + + System.out.println(aaiMockServer.getClass()); + } + + @Given("^MSO-WD Simulators Started with topic name (.*)$") + public void notification_listner_simulators_started(String topicName) throws Throwable { + envList.forEach(env -> { + final IDistributionClient distClientSim = simulateDistributionClientWD(topicName, env); + distributionClients.add(distClientSim); + }); + + } + + @Given("^MSO Final Distribution Simulator is UP$") + public void mso_Final_Distribution_Simulator_is_UP() throws Throwable { + msoHttpRequest = request().withPath(MSO_PATH_REGEX); + msoMockServer.when(msoHttpRequest).callback( + callback().withCallbackClass("org.openecomp.sdc.cucumber.steps.PrecannedTestExpectationCallback")); + } + + @Given("^ASDC Address is (.*)$") + public void asdc_Address_is(String asdcAddress) throws Throwable { + this.asdcAddress = asdcAddress; + + } + + @Given("^ASDC Contains the following services (.*)$") + public void asdc_Contains_the_following_services(String listOfServicesUUID) throws Throwable { + uuidServicesList = Arrays.asList(listOfServicesUUID.split(",")).stream().map(String::trim) + .collect(Collectors.toList()); + + int maxMinWait = uuidServicesList.size() * envIds.size(); + this.maxStepWaitTimeMs = 60000 * maxMinWait; + System.out.println(String.format("Set Max Step Wait Time To: %s Minutes", maxMinWait)); + } + + @Given("^The number of complete environments is (.*)$") + public void the_number_of_complete_environments_is(int envNum) throws Throwable { + + int counter = 1; + while( envNum > envNames.size()){ + envNames.add(String.valueOf(counter)); + counter++; + } + + + for (int i = 0; i < envNum; i++) { + OperationalEnvironmentEntry preSaveEntry = new OperationalEnvironmentEntry(); + + preSaveEntry.setStatus(EnvironmentStatusEnum.COMPLETED); + preSaveEntry.setLastModified(new Date(System.currentTimeMillis())); + + Set<String> uebAdresses = new HashSet<>(); + uebAdresses.add("uebsb92sfdc.it.att.com"); + preSaveEntry.setDmaapUebAddress(uebAdresses); + preSaveEntry.setIsProduction(false); + preSaveEntry.setUebApikey("sSJc5qiBnKy2qrlc"); + preSaveEntry.setUebSecretKey("4ZRPzNJfEUK0sSNBvccd2m7X"); + preSaveEntry.setTenant("TEST"); + preSaveEntry.setEcompWorkloadContext("ECOMP_E2E-IST"); + + // String envId = UUID.randomUUID().toString(); + String envId = envNames.get(i); + preSaveEntry.setEnvironmentId(envId); + envIds.add(envId); + envList.add(preSaveEntry); + operationalEnvironmentDao.save(preSaveEntry); + } + } + + @Given("^The number of artifacts each Simulator downloads from a service is (.*)$") + public void number_of_artifacts_each_simulator_downloads(int numOfArtifactsToDownload) throws Throwable { + this.numOfArtifactsToDownload = numOfArtifactsToDownload; + } + + // ############################# Given - End ############################# + + // ############################# When - Start ############################# + @When("^Distribution Requests are Sent By MSO$") + public void distribution_Requests_are_Sent_By_MSO() throws Throwable { + envList.stream().forEach(this::distributeServiceInEnv); + + } + + @When("^The Number Of Operational Envrinoments that created is (.*) and Records are added with data (.*)$") + public void operational_envrinoments_records_are_added_with_data(int numOfRecords, String recordData) + throws Throwable { + for (int i = 0; i < numOfRecords; i++) { + OperationalEnvironmentEntry preSaveEntry = new OperationalEnvironmentEntry(); + JsonElement root = new JsonParser().parse(recordData); + + String originalStatus = root.getAsJsonObject().get("status").getAsString(); + int delta = root.getAsJsonObject().get("last_modified_delta").getAsInt(); + preSaveEntry.setStatus(EnvironmentStatusEnum.getByName(originalStatus)); + long last_modified = System.currentTimeMillis() + delta * 1000; + preSaveEntry.setLastModified(new Date(last_modified)); + String envId = UUID.randomUUID().toString(); + preSaveEntry.setEnvironmentId(envId); + envIds.add(envId); + // envrionmentIds.add(envId); + operationalEnvironmentDao.save(preSaveEntry); + + } + + } + + // ############################# When - End ############################# + + // ############################# Then - Start ############################# + @Then("^Operational Environment record contains tenant field (.*$)") + public void operational_environment_record_contains_tenant(boolean tenantExist) throws Throwable { + envIds.forEach(envId -> { + validateStringFieldPresent(tenantExist, OperationalEnvironmentEntry::getTenant, envId, + "Tenant is not as expected"); + }); + } + + @Then("^Operational Environment record contains workload field (.*$)") + public void operational_environment_record_contains_workload(boolean workloadExist) throws Throwable { + envIds.forEach(envId -> { + validateStringFieldPresent(workloadExist, OperationalEnvironmentEntry::getEcompWorkloadContext, envId, + "Workload is not as expected"); + }); + } + + @Then("^Operational Environment record contains UEB Address field (.*$)") + public void operational_environment_record_contains_ueb_address(boolean uebAddresExist) throws Throwable { + envIds.forEach(envId -> { + validateStringFieldPresent(uebAddresExist, this::convertUebAddressToList, envId, + "UEB Address is not as expected"); + }); + } + + @Then("^The Number Of Environment is (.*) with status (.*)$") + public void the_Number_Of_Environment_Created_is(int numberOfEnvsCreated, String status) throws Throwable { + // Write code here that turns the phrase above into concrete actions + + retryMethodOnResult(() -> getCurrentEnvironmets(status), envList -> envList.size() == numberOfEnvsCreated, + 40000, 500); + + List<OperationalEnvironmentEntry> environmentsFound = getCurrentEnvironmets(status); + + assertThat(environmentsFound.size(), is(numberOfEnvsCreated)); + + environmentsFound.forEach(env -> recordMap.put(env.getEnvironmentId(), env)); + envList.addAll(environmentsFound); + } + + @Then("^MSO Final Distribution Recieved Correct Number Of Request$") + public void mso_final_distribution_recieved_request() throws Throwable { + int expectedNumberOfRequestsSentByASDC = calculateExcpectedNumberOfDistributionRequets(); + Function<Integer, Boolean> resultVerifier = actualStatusList -> actualStatusList >= expectedNumberOfRequestsSentByASDC; + retryMethodOnResult(() -> numberOfFinalDistributionsSentByASDC(expectedNumberOfRequestsSentByASDC), + resultVerifier, maxStepWaitTimeMs, 500); + int actualNumberOfRequestsSentByASDC = numberOfFinalDistributionsSentByASDC(expectedNumberOfRequestsSentByASDC); + assertThat(actualNumberOfRequestsSentByASDC, is(expectedNumberOfRequestsSentByASDC)); + } + + @Then("^All MSO-WD Simulators Sent The Distribution Complete Notifications$") + public void all_mso_wd_simulators_sent_the_distribution_complete_notifications() { + // Wait Watch Dogs To Send Final Distribution + int excpectedNumberOfDistributionCompleteNotifications = calculateExcpectedNumberOfDistributionRequets(); + final Function<List<String>, Boolean> resultVerifier = actualStatusList -> actualStatusList + .size() == excpectedNumberOfDistributionCompleteNotifications; + retryMethodOnResult(() -> wdFinalStatusSent, resultVerifier, maxStepWaitTimeMs, 500); + assertThat(wdFinalStatusSent.size(), is(excpectedNumberOfDistributionCompleteNotifications)); + } + @Then("^All Artifacts were downloaded by Simulators$") + public void all_artifacts_downloaded() { + // Wait Watch Dogs To Send Final Distribution + int excpectedNumberOfArtifactsToDownload = numOfArtifactsToDownload * envIds.size() * uuidServicesList.size(); + assertThat(totalNumOfArtifactsToDownload, is(excpectedNumberOfArtifactsToDownload)); + } + // ############################# Then - End ############################# + + private List<OperationalEnvironmentEntry> getCurrentEnvironmets(String status) { + Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> eitherStatus = operationalEnvironmentDao + .getByEnvironmentsStatus(EnvironmentStatusEnum.getByName(status)); + assertThat(eitherStatus.isLeft(), is(true)); + + List<OperationalEnvironmentEntry> environmentsRetrieved = eitherStatus.left().value(); + + List<OperationalEnvironmentEntry> environmentsFound = environmentsRetrieved.stream() + .filter(env -> envIds.contains(env.getEnvironmentId())).collect(Collectors.toList()); + return environmentsFound; + } + + private int numberOfFinalDistributionsSentByASDC(int expectedNumberOfRequestsSentByASDC) { + final int newVal = msoMockServer.retrieveRecordedRequests(msoHttpRequest).length; + if (newVal != numberOfFinalDistributionsSentByASDC) { + System.out.println(String.format( + "MSO Server Simulator Recieved %s/%s Final Distribution Complete Rest Reports From ASDC", newVal, + expectedNumberOfRequestsSentByASDC)); + numberOfFinalDistributionsSentByASDC = newVal; + } + + return newVal; + } + + private int calculateExcpectedNumberOfDistributionRequets() { + int numberOfDistributionRequests = envList.size() * uuidServicesList.size(); + return numberOfDistributionRequests; + } + + private static OperationalEnvironmentDao createDaoObj() { + AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ImportTableConfig.class); + final OperationalEnvironmentDao openvDao = (OperationalEnvironmentDao) context + .getBean("operational-environment-dao"); + return openvDao; + } + + private OperationalEnvironmentEntry getRecord(String environmentId) { + Either<OperationalEnvironmentEntry, CassandraOperationStatus> result = operationalEnvironmentDao + .get(environmentId); + return result.isLeft() ? result.left().value() : null; + } + + private void validateStringFieldPresent(boolean fieldExist, + Function<OperationalEnvironmentEntry, String> getFieldFunc, String envId, String msg) { + OperationalEnvironmentEntry record = recordMap.computeIfAbsent(envId, this::getRecord); + + assertNotNull(record, "Expected DB record was not found"); + + String actualValue = getFieldFunc.apply(record); + + assertEquals(fieldExist, !Strings.isNullOrEmpty(actualValue), msg); + } + + private void setAaiMockServer(String aaiResponseBody) { + HttpRequest httpRequest = request().withMethod("GET").withPath(AAI_PATH_REGEX) + .withHeaders(new Header(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType())); + + aaiMockServer.when(httpRequest) + .respond(response() + .withHeaders(new Header(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType())) + .withBody(aaiResponseBody)); + } + + private IDistributionClient simulateDistributionClientWD(String topicName, OperationalEnvironmentEntry opEnv) { + + IDistributionClient client = DistributionClientFactory.createDistributionClient(); + final IConfiguration buildDistributionClientConfiguration = buildDistributionClientConfiguration(topicName, + opEnv); + IDistributionClientResult initResult = client.init(buildDistributionClientConfiguration, + new INotificationCallback() { + + @Override + public void activateCallback(INotificationData data) { + buildWdSimulatorCallback(opEnv, client, buildDistributionClientConfiguration, data); + + } + + }); + assertThat(initResult.getDistributionActionResult(), is(DistributionActionResultEnum.SUCCESS)); + IDistributionClientResult startResult = client.start(); + assertThat(startResult.getDistributionActionResult(), is(DistributionActionResultEnum.SUCCESS)); + System.out.println(String.format("WD Simulator On Environment:\"%s\" Started Successfully", + buildDistributionClientConfiguration.getConsumerID())); + return client; + } + + private IFinalDistrStatusMessage buildFinalDistribution() { + return new IFinalDistrStatusMessage() { + + @Override + public long getTimestamp() { + return System.currentTimeMillis(); + } + + @Override + public DistributionStatusEnum getStatus() { + return DistributionStatusEnum.DISTRIBUTION_COMPLETE_OK; + } + + @Override + public String getDistributionID() { + return "FakeDistributionId"; + } + }; + } + + private IConfiguration buildDistributionClientConfiguration(String topicName, OperationalEnvironmentEntry opEnv) { + return new IConfiguration() { + + public String getUser() { + return "ci"; + } + + public int getPollingTimeout() { + return 20; + } + + public int getPollingInterval() { + return 20; + } + + public String getPassword() { + return "123456"; + } + + public String getEnvironmentName() { + return topicName; + } + + public String getConsumerID() { + return opEnv.getEnvironmentId(); + } + + public String getConsumerGroup() { + return String.format("BenchMarkDistributionClientConsumerGroup%s", opEnv.getEnvironmentId()); + } + + public String getAsdcAddress() { + return String.format("%s:8443", asdcAddress); + } + + @Override + public String getKeyStorePath() { + // TODO Auto-generated method stub + return null; + } + + @Override + public String getKeyStorePassword() { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean activateServerTLSAuth() { + // TODO Auto-generated method stub + return false; + } + + @Override + public List<String> getRelevantArtifactTypes() { + return Arrays.asList(ArtifactTypeEnum.values()).stream() + .map(artifactTypeEnum -> artifactTypeEnum.name()).collect(Collectors.toList()); + } + + @Override + public boolean isFilterInEmptyResources() { + // TODO Auto-generated method stub + return false; + } + + @Override + public Boolean isUseHttpsWithDmaap() { + return null; + } + + @Override + public List<String> getMsgBusAddress() { + return opEnv.getDmaapUebAddress().stream().map(this::extractHost).collect(Collectors.toList()); + } + + private String extractHost(String url) { + return url.split(":")[0]; + } + }; + } + + private void distributeServiceInEnv(OperationalEnvironmentEntry env) { + uuidServicesList.stream().forEach(serviceUUID -> distributeSingleService(env, serviceUUID)); + } + + private void distributeSingleService(OperationalEnvironmentEntry env, String serviceUUID) { + IHttpAsdcClient client = new HttpAsdcClient(buildDistributionClientConfiguration(StringUtils.EMPTY, env)); + String pattern = "/sdc/v1/catalog/services/%s/distribution/%s/activate"; + String requestUrl = String.format(pattern, serviceUUID, env.getEnvironmentId()); + String requestBody = String.format("{\"workloadContext\":\"%s\"}", env.getEnvironmentId()); + StringEntity body = new StringEntity(requestBody, ContentType.APPLICATION_JSON); + Map<String, String> headersMap = new HashMap<>(); + headersMap.put("USER_ID", "cs0008"); + headersMap.put("X-ECOMP-InstanceID", "test"); + headersMap.put("Content-Type", "application/json"); + + HttpAsdcResponse postRequest = FunctionalInterfaces.retryMethodOnResult( + () -> distributeMethod(client, requestUrl, serviceUUID, body, headersMap, env.getEnvironmentId()), + resp -> resp.getStatus() == HttpStatus.SC_ACCEPTED); + assertThat(postRequest.getStatus(), is(HttpStatus.SC_ACCEPTED)); + + } + + private HttpAsdcResponse distributeMethod(IHttpAsdcClient client, String requestUrl, String serviceUUID, + StringEntity body, Map<String, String> headersMap, String envId) { + + final HttpAsdcResponse postRequest = client.postRequest(requestUrl, body, headersMap); + final String message = String.format( + "MSO Client Simulator Distributes Service:%s On Environment:\"%s\" - Recieved Response: %s", serviceUUID, envId, + postRequest.getStatus()); + if (postRequest.getStatus() != HttpStatus.SC_ACCEPTED) { + System.err.println(message); + } else { + System.out.println(message); + } + + return postRequest; + } + + private String convertUebAddressToList(OperationalEnvironmentEntry op) { + Set<String> dmaapUebAddress = op.getDmaapUebAddress(); + Wrapper<String> resultWrapper = new Wrapper<>(StringUtils.EMPTY); + if (!CollectionUtils.isEmpty(dmaapUebAddress)) { + dmaapUebAddress.stream() + .forEach(uebAddress -> resultWrapper.setInnerElement(resultWrapper.getInnerElement() + uebAddress)); + } + + return resultWrapper.getInnerElement(); + } + + private void buildWdSimulatorCallback(OperationalEnvironmentEntry opEnv, IDistributionClient client, + final IConfiguration buildDistributionClientConfiguration, INotificationData data) { + if (StringUtils.equals(data.getWorkloadContext(), opEnv.getEnvironmentId())) { + + final String expectedArtifactType = org.openecomp.sdc.common.api.ArtifactTypeEnum.MODEL_INVENTORY_PROFILE.name(); + Optional<IArtifactInfo> optional = data.getServiceArtifacts().stream().filter( artifact -> { + return StringUtils.equals(artifact.getArtifactType(), expectedArtifactType); + }).findAny(); + + for (int i = 0; i < numOfArtifactsToDownload; i++) { + optional.ifPresent( artifactInfo -> simulateDownload(client , artifactInfo, data) ); + optional.orElseThrow( () -> handleArtifactNotFound(expectedArtifactType, data)); + + } + if( numOfArtifactsToDownload > 0 ){ + System.out.println(String.format( + "ASDC Consumer Simulator On Environment:\"%s\" Downloaded %s Artifacts From ASDC Service with UUID:%s Total Artifacts Downloaded from ASDC is: %s", + data.getWorkloadContext(), numOfArtifactsToDownload, + data.getServiceUUID(), totalNumOfArtifactsToDownload)); + } + + IDistributionClientResult finalDistrStatus = client.sendFinalDistrStatus(buildFinalDistribution()); + assertThat(finalDistrStatus.getDistributionActionResult(), is(DistributionActionResultEnum.SUCCESS)); + wdFinalStatusSent.add(data.getWorkloadContext()); + + System.out.println(String.format( + "WD Simulator On Environment:\"%s\" Recieved Notification From ASDC On WorkLoad: %s And Service UUID:%s And Sends Distribution Complete Notification", + buildDistributionClientConfiguration.getConsumerID(), data.getWorkloadContext(), + data.getServiceUUID())); + } + } + + private IllegalStateException handleArtifactNotFound(String expectedArtifactType, INotificationData data ){ + final String stringMessage = String.format("Did Not Find Artifact of type: %s to download from service with UUID:%s", expectedArtifactType, data.getServiceUUID()); + System.err.println(stringMessage); + return new IllegalStateException(stringMessage); + + } + + private void simulateDownload(IDistributionClient client, IArtifactInfo info, INotificationData data){ + IDistributionClientDownloadResult downloadResult = client.download(info); + if( downloadResult.getDistributionActionResult() != DistributionActionResultEnum.SUCCESS ){ + System.err.println(String.format("Client Simulator %s Failed to download artifact from service : %s", client.getConfiguration().getConsumerID(), data.getServiceUUID())); + assertThat(downloadResult.getDistributionActionResult(), is(DistributionActionResultEnum.SUCCESS)); + } + else{ + totalNumOfArtifactsToDownload++; + + } + } +} diff --git a/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/utils/RunnerSession.java b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/utils/RunnerSession.java new file mode 100644 index 0000000000..c93b3d2f0c --- /dev/null +++ b/test-apis-ci/src/test/java/org/openecomp/sdc/cucumber/utils/RunnerSession.java @@ -0,0 +1,61 @@ +package org.openecomp.sdc.cucumber.utils; + +import java.util.HashMap; +import java.util.Map; + +/** + * Store Data here that is relevant for the whole runner and not just a single scenario. + * @author ms172g + * + */ +public class RunnerSession { + private static final RunnerSession instance = new RunnerSession(); + private Map<String, String> stringElements; + private Map<String, Integer> intElements; + private Map<String, Object> elements; + private RunnerSession(){ + stringElements = new HashMap<>(); + intElements = new HashMap<>(); + elements = new HashMap<>(); + } + public static RunnerSession getSession(){ + return instance; + } + + public void putInSession(String key, String value){ + stringElements.put(key, value); + } + + public String getString(String key){ + return stringElements.get(key); + + } + + public void putInSession(String key, Integer value){ + intElements.put(key, value); + } + + + public Integer getInt(String key){ + return intElements.get(key); + } + + public void putInSession(String key, Object value) { + elements.put(key, value); + + } + + public Object get(String key){ + return elements.get(key); + } + + public void clean(){ + intElements.clear(); + stringElements.clear(); + } + + + + + +} |