diff options
Diffstat (limited to 'catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine')
12 files changed, 1417 insertions, 429 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/AaiMockRequestHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/AaiMockRequestHandlerTest.java new file mode 100644 index 0000000000..7df88c1cd9 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/AaiMockRequestHandlerTest.java @@ -0,0 +1,48 @@ +package org.openecomp.sdc.be.components.distribution.engine; + +import org.apache.http.HttpStatus; +import org.junit.Ignore; +import org.junit.Test; +import org.openecomp.sdc.be.components.BeConfDependentTest; +import org.openecomp.sdc.be.info.OperationalEnvInfo; +import org.openecomp.sdc.common.http.client.api.HttpResponse; + +import static org.junit.Assert.assertTrue; + +public class AaiMockRequestHandlerTest extends BeConfDependentTest { + + @Ignore + @Test + public void testGetOperationalEnvJson() { + String id = "OEid4"; + AaiRequestHandler aaiRequestHandler = new AaiRequestHandler(); + aaiRequestHandler.init(); + HttpResponse<String> resp = aaiRequestHandler.getOperationalEnvById(id); + + if (resp.getStatusCode() == HttpStatus.SC_OK) { + try { + String response = resp.getResponse(); + System.out.println("The rest response is:"); + System.out.println(response); + + OperationalEnvInfo operationalEnvInfo = OperationalEnvInfo.createFromJson(response); + + System.out.println(String.format("Get \"%s\" operational environment. %s", id, operationalEnvInfo)); + System.out.println(operationalEnvInfo); + } + catch (Exception e) { + System.out.println(String.format("Json convert to OperationalEnvInfo failed with exception %s", e)); + System.out.println(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + } + else { + System.out.println("The rest response is:"); + String response = resp.getResponse(); + System.out.println(response); + System.out.println(String.format("Get \"%s\" operational environment failed with statusCode: %s, response: %s, description: %s", id, resp.getStatusCode(), resp.getResponse(), resp.getDescription())); + System.out.println(resp.getStatusCode()); + } + + assertTrue(true); + } +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/CambriaHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/CambriaHandlerTest.java new file mode 100644 index 0000000000..d425e6d0f5 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/CambriaHandlerTest.java @@ -0,0 +1,77 @@ +package org.openecomp.sdc.be.components.distribution.engine; + +import com.att.nsa.apiClient.credentials.ApiCredential; +import com.att.nsa.apiClient.http.HttpException; +import com.att.nsa.cambria.client.CambriaClient.CambriaApiException; +import com.att.nsa.cambria.client.CambriaIdentityManager; +import fj.data.Either; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.Spy; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.distribution.api.client.CambriaOperationStatus; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; + +import java.io.IOException; +import java.net.MalformedURLException; +import java.security.GeneralSecurityException; +import java.util.Arrays; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.doReturn; + +@RunWith(MockitoJUnitRunner.class) +public class CambriaHandlerTest { + @Spy + private CambriaHandler handler = new CambriaHandler(); + + @Mock + private CambriaIdentityManager createIdentityManager; + + private ApiCredential apiCredential = new ApiCredential("apiKey", "apiSecret"); + + @BeforeClass + public static void beforeClass() { + String appConfigDir = "src/test/resources/config/catalog-be"; + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir); + new ConfigurationManager(configurationSource); + } + + + @Before + public void startUp() throws MalformedURLException, GeneralSecurityException { + doReturn(createIdentityManager).when(handler).buildCambriaClient(any()); + } + + @Test + public void testCreateUebKeys() throws HttpException, CambriaApiException, IOException { + Mockito.when(createIdentityManager.createApiKey(Mockito.anyString(), Mockito.anyString())).thenReturn(apiCredential); + Either<ApiCredential, CambriaErrorResponse> eitherCreateUebKeys = handler.createUebKeys(Arrays.asList("Myhost:1234") ); + + Mockito.verify(createIdentityManager).setApiCredentials(Mockito.anyString(), Mockito.anyString()); + + assertTrue("Unexpected Operational Status", eitherCreateUebKeys.isLeft()); + + } + + @Test + public void testCreateUebKeys_FAIL() throws HttpException, CambriaApiException, IOException { + Mockito.when(createIdentityManager.createApiKey(Mockito.anyString(), Mockito.anyString())).thenThrow(new CambriaApiException("Error Message")); + Either<ApiCredential, CambriaErrorResponse> eitherCreateUebKeys = handler.createUebKeys(Arrays.asList("Myhost:1234") ); + Mockito.verify(createIdentityManager, Mockito.never()).setApiCredentials(Mockito.anyString(), Mockito.anyString()); + assertTrue("Unexpected Operational Status", eitherCreateUebKeys.isRight()); + CambriaErrorResponse response = eitherCreateUebKeys.right().value(); + assertEquals("Unexpected Operational Status", CambriaOperationStatus.CONNNECTION_ERROR, response.getOperationStatus()); + assertEquals("Unexpected HTTP Code", 500, response.getHttpCode().intValue()); + } + +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/Dev2DevDmaapConsumerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/Dev2DevDmaapConsumerTest.java new file mode 100644 index 0000000000..45906c6f30 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/Dev2DevDmaapConsumerTest.java @@ -0,0 +1,91 @@ +package org.openecomp.sdc.be.components.distribution.engine; + +import com.att.nsa.mr.client.MRConsumer; +import com.google.gson.GsonBuilder; +import org.junit.After; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.config.DmaapConsumerConfiguration; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.util.concurrent.ExecutorService; +import java.util.stream.IntStream; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class Dev2DevDmaapConsumerTest { + @Autowired + private ExecutorFactory executorFactory; + @Autowired + private DmaapClientFactory dmaapClientFactory; + + static ExecutorService notificationExecutor; + + static ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be"); + static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); + + @Test + public void runConsumer() throws Exception{ + boolean isRunConsumer = false ; //change this to true if you wish to run consumer,default should be false + if ( isRunConsumer ){ + consumeDmaapTopic(); + }else{ + System.out.println( "CONSUMER TEST is disabled!!!! "); + } + assert true; + } + //@Ignore + //@Test + public void consumeDmaapTopic() throws Exception { + Thread.UncaughtExceptionHandler handler = new Thread.UncaughtExceptionHandler() { + @Override + public void uncaughtException(Thread t, Throwable e) { + System.out.println("uncaughtException -> "); + } + }; + + DmaapConsumerConfiguration dmaapConsumerParams = configurationManager.getConfiguration().getDmaapConsumerConfiguration(); + String topic = dmaapConsumerParams.getTopic(); + System.out.println(String.format( "Starting to consume topic %s for DMAAP consumer with the next parameters %s. ", topic, dmaapConsumerParams) ); + MRConsumer consumer = dmaapClientFactory.create( dmaapConsumerParams ); + notificationExecutor = executorFactory.create(topic + "Consumer", handler); + final int LIMIT = 2; + IntStream.range(0,LIMIT).forEach( i -> { + System.out.println("Trying to fetch messages from topic: "+ topic); + try { + Iterable<String> messages = consumer.fetch(); + if (messages != null) { + for (String msg : messages) { + System.out.println(String.format( "The DMAAP message %s received. The topic is %s.", msg, topic) ); + handleMessage(msg); + } + } + } + catch (Exception e) { + System.out.println("The exception occured upon fetching DMAAP message "+ e); + } + } + ); + + + } + private void handleMessage(String msg){ + try{ + DmaapNotificationDataImpl notificationData = new GsonBuilder().create().fromJson(msg,DmaapNotificationDataImpl.class); + System.out.println( "successfully parsed notification for environemnt "+notificationData.getOperationalEnvironmentId()); + }catch (Exception e){ + System.out.println( "failed to parse notification"); + } + } + @After + public void after(){ + if (notificationExecutor!=null && !notificationExecutor.isTerminated()) + notificationExecutor.shutdown(); + } +}
\ No newline at end of file diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineConfigTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineConfigTest.java index 8d48a4c320..04aa242b03 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineConfigTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineConfigTest.java @@ -20,13 +20,6 @@ package org.openecomp.sdc.be.components.distribution.engine; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -import java.io.File; -import java.util.ArrayList; -import java.util.List; - import org.junit.Before; import org.junit.Test; import org.openecomp.sdc.be.config.ConfigurationManager; @@ -38,131 +31,138 @@ import org.openecomp.sdc.common.api.ConfigurationSource; import org.openecomp.sdc.common.impl.ExternalConfiguration; import org.openecomp.sdc.common.impl.FSConfigurationSource; +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + public class DistributionEngineConfigTest { - @Before - public void setup() { - ExternalConfiguration.setAppName("catalog-be"); - ExternalConfiguration.setConfigDir("src/test/resources/config"); - ExternalConfiguration.listenForChanges(); + @Before + public void setup() { + ExternalConfiguration.setAppName("catalog-be"); + ExternalConfiguration.setConfigDir("src/test/resources/config"); + ExternalConfiguration.listenForChanges(); - ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), ExternalConfiguration.getConfigDir() + File.separator + ExternalConfiguration.getAppName()); + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), ExternalConfiguration.getConfigDir() + File.separator + ExternalConfiguration.getAppName()); - ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); - } + ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); + } - @Test - public void validateMissingEnvironments() { + @Test + public void validateMissingEnvironments() { - DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); + DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); - String uebPublicKey = "uebPublicKey"; - String uebSecretKey = "uebSecretKey"; + String uebPublicKey = "uebPublicKey"; + String uebSecretKey = "uebSecretKey"; - DistributionEngine distributionEngine = new DistributionEngine(); + DistributionEngine distributionEngine = new DistributionEngine(); - List<String> environments = new ArrayList<String>(); - environments.add("PROD"); - deConfiguration.setEnvironments(environments); + List<String> environments = new ArrayList<String>(); + environments.add("PROD"); + deConfiguration.setEnvironments(environments); - List<String> servers = new ArrayList<String>(); - servers.add("server1:80"); - servers.add("server2:8080"); + List<String> servers = new ArrayList<String>(); + servers.add("server1:80"); + servers.add("server2:8080"); - CreateTopicConfig createTopic = new CreateTopicConfig(); - createTopic.setPartitionCount(1); - createTopic.setReplicationCount(1); - deConfiguration.setCreateTopic(createTopic); + CreateTopicConfig createTopic = new CreateTopicConfig(); + createTopic.setPartitionCount(1); + createTopic.setReplicationCount(1); + deConfiguration.setCreateTopic(createTopic); - ComponentArtifactTypesConfig distribNotifResourceArtifactTypes = new ComponentArtifactTypesConfig(); - deConfiguration.setDistribNotifResourceArtifactTypes(distribNotifResourceArtifactTypes); + ComponentArtifactTypesConfig distribNotifResourceArtifactTypes = new ComponentArtifactTypesConfig(); + deConfiguration.setDistribNotifResourceArtifactTypes(distribNotifResourceArtifactTypes); - ComponentArtifactTypesConfig distribNotifServiceArtifactTypes = new ComponentArtifactTypesConfig(); - deConfiguration.setDistribNotifServiceArtifactTypes(distribNotifServiceArtifactTypes); + ComponentArtifactTypesConfig distribNotifServiceArtifactTypes = new ComponentArtifactTypesConfig(); + deConfiguration.setDistribNotifServiceArtifactTypes(distribNotifServiceArtifactTypes); - deConfiguration.setDistributionNotifTopicName("distributionNotifTopicName"); - deConfiguration.setDistributionStatusTopicName("statusTopic"); + deConfiguration.setDistributionNotifTopicName("distributionNotifTopicName"); + deConfiguration.setDistributionStatusTopicName("statusTopic"); - DistributionStatusTopicConfig distributionStatusTopic = new DistributionStatusTopicConfig(); - distributionStatusTopic.setConsumerGroup("asdc-group"); - distributionStatusTopic.setConsumerId("asdc-id"); - distributionStatusTopic.setFetchTimeSec(20); - distributionStatusTopic.setPollingIntervalSec(20); - deConfiguration.setDistributionStatusTopic(distributionStatusTopic); + DistributionStatusTopicConfig distributionStatusTopic = new DistributionStatusTopicConfig(); + distributionStatusTopic.setConsumerGroup("asdc-group"); + distributionStatusTopic.setConsumerId("asdc-id"); + distributionStatusTopic.setFetchTimeSec(20); + distributionStatusTopic.setPollingIntervalSec(20); + deConfiguration.setDistributionStatusTopic(distributionStatusTopic); - deConfiguration.setUebServers(servers); - deConfiguration.setUebPublicKey(uebPublicKey); - deConfiguration.setUebSecretKey(uebSecretKey); - deConfiguration.setInitMaxIntervalSec(8); - deConfiguration.setInitRetryIntervalSec(3); + deConfiguration.setUebServers(servers); + deConfiguration.setUebPublicKey(uebPublicKey); + deConfiguration.setUebSecretKey(uebSecretKey); + deConfiguration.setInitMaxIntervalSec(8); + deConfiguration.setInitRetryIntervalSec(3); - boolean isValid = distributionEngine.validateConfiguration(deConfiguration); - assertTrue("check empty configuration", isValid); + boolean isValid = distributionEngine.validateConfiguration(deConfiguration); + assertTrue("check empty configuration", isValid); - deConfiguration.setUebServers(null); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertFalse("check empty configuration", isValid); + deConfiguration.setUebServers(null); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertFalse("check empty configuration", isValid); - deConfiguration.setUebServers(servers); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertTrue("check empty configuration", isValid); + deConfiguration.setUebServers(servers); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertTrue("check empty configuration", isValid); - deConfiguration.setEnvironments(null); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertFalse("check empty configuration", isValid); + deConfiguration.setEnvironments(null); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertFalse("check empty configuration", isValid); - deConfiguration.setEnvironments(environments); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertTrue("check empty configuration", isValid); + deConfiguration.setEnvironments(environments); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertTrue("check empty configuration", isValid); - deConfiguration.setUebPublicKey(null); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertFalse("check empty configuration", isValid); + deConfiguration.setUebPublicKey(null); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertFalse("check empty configuration", isValid); - deConfiguration.setUebPublicKey(uebPublicKey); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertTrue("check empty configuration", isValid); + deConfiguration.setUebPublicKey(uebPublicKey); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertTrue("check empty configuration", isValid); - deConfiguration.setUebSecretKey(null); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertFalse("check empty configuration", isValid); + deConfiguration.setUebSecretKey(null); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertFalse("check empty configuration", isValid); - deConfiguration.setUebSecretKey(uebPublicKey); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertTrue("check empty configuration", isValid); + deConfiguration.setUebSecretKey(uebPublicKey); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertTrue("check empty configuration", isValid); - deConfiguration.setDistributionNotifTopicName(null); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertFalse("check empty configuration", isValid); + deConfiguration.setDistributionNotifTopicName(null); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertFalse("check empty configuration", isValid); - deConfiguration.setDistributionNotifTopicName(uebPublicKey); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertTrue("check empty configuration", isValid); + deConfiguration.setDistributionNotifTopicName(uebPublicKey); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertTrue("check empty configuration", isValid); - deConfiguration.setDistributionStatusTopicName(null); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertFalse("check empty configuration", isValid); + deConfiguration.setDistributionStatusTopicName(null); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertFalse("check empty configuration", isValid); - deConfiguration.setDistributionStatusTopicName(uebPublicKey); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertTrue("check empty configuration", isValid); + deConfiguration.setDistributionStatusTopicName(uebPublicKey); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertTrue("check empty configuration", isValid); - deConfiguration.setInitMaxIntervalSec(null); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertFalse("check empty configuration", isValid); + deConfiguration.setInitMaxIntervalSec(null); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertFalse("check empty configuration", isValid); - deConfiguration.setInitMaxIntervalSec(8); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertTrue("check empty configuration", isValid); + deConfiguration.setInitMaxIntervalSec(8); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertTrue("check empty configuration", isValid); - deConfiguration.setInitRetryIntervalSec(null); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertFalse("check empty configuration", isValid); + deConfiguration.setInitRetryIntervalSec(null); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertFalse("check empty configuration", isValid); - deConfiguration.setInitRetryIntervalSec(8); - isValid = distributionEngine.validateConfiguration(deConfiguration); - assertTrue("check empty configuration", isValid); + deConfiguration.setInitRetryIntervalSec(8); + isValid = distributionEngine.validateConfiguration(deConfiguration); + assertTrue("check empty configuration", isValid); - } + } } diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineHealthCheckTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineHealthCheckTest.java index 990ea4f99b..1fa0fc60b7 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineHealthCheckTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineHealthCheckTest.java @@ -20,115 +20,114 @@ package org.openecomp.sdc.be.components.distribution.engine; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.when; - -import java.util.List; - +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; import org.junit.Test; import org.mockito.Mock; import org.mockito.Mockito; -import org.openecomp.sdc.be.components.BaseConfDependentTest; +import org.openecomp.sdc.be.components.BeConfDependentTest; import org.openecomp.sdc.be.config.ConfigurationManager; import org.openecomp.sdc.be.distribution.api.client.CambriaOperationStatus; -import com.google.gson.Gson; -import com.google.gson.GsonBuilder; +import java.util.List; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; -public class DistributionEngineHealthCheckTest extends BaseConfDependentTest { - - @Mock - private CambriaHandler cambriaHandler = Mockito.mock(CambriaHandler.class); - - DistributionEngineClusterHealth distributionEngineClusterHealth = new DistributionEngineClusterHealth(); - - Gson gson = new Gson(); - - Gson prettyGson = new GsonBuilder().setPrettyPrinting().create(); - - // - // @Test - // public void validateDownWhenEnvAreDown() { - // - // Map<String, AtomicBoolean> envNamePerStatus = new HashMap<>(); - // envNamePerStatus.put("PROD1", new AtomicBoolean(false)); - // envNamePerStatus.put("PROD2", new AtomicBoolean(false)); - // - // distributionEngineClusterHealth.startHealthCheckTask(envNamePerStatus); - // - // HealthCheckInfo healthCheckInfo = - // distributionEngineClusterHealth.getHealthCheckInfo(); - // assertEquals("verify down", HealthCheckStatus.DOWN, - // healthCheckInfo.getHealthCheckStatus()); - // assertEquals("verify DE component", HealthCheckComponent.DE, - // healthCheckInfo.getHealthCheckComponent()); - // - // } - - @Test - public void validateUpWhenQuerySucceed() { - - // Map<String, AtomicBoolean> envNamePerStatus = new HashMap<>(); - // envNamePerStatus.put("PROD1", new AtomicBoolean(true)); - // envNamePerStatus.put("PROD2", new AtomicBoolean(false)); - // - // distributionEngineClusterHealth.startHealthCheckTask(envNamePerStatus, - // false); - - CambriaErrorResponse cambriaOkResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, 200); - CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.INTERNAL_SERVER_ERROR, 500); - CambriaErrorResponse cambriaNotErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.AUTHENTICATION_ERROR, 403); - - List<String> uebServers = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getUebServers(); - if (uebServers.size() >= 2) { - when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(0)), Mockito.any(String.class))).thenReturn(cambriaOkResponse); - when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(1)), Mockito.any(String.class))).thenReturn(cambriaOkResponse); - } - - UebHealthCheckCall healthCheckCall1 = new UebHealthCheckCall(uebServers.get(0), "publicKey"); - healthCheckCall1.setCambriaHandler(cambriaHandler); - Boolean call1 = healthCheckCall1.call(); - assertTrue("check response okay", call1); - - UebHealthCheckCall healthCheckCall2 = new UebHealthCheckCall(uebServers.get(1), "publicKey"); - healthCheckCall2.setCambriaHandler(cambriaHandler); - - Boolean call2 = healthCheckCall2.call(); - assertTrue("check response okay", call2); - - if (uebServers.size() >= 2) { - when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(0)), Mockito.any(String.class))).thenReturn(cambriaErrorResponse); - when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(1)), Mockito.any(String.class))).thenReturn(cambriaOkResponse); - } - healthCheckCall1 = new UebHealthCheckCall(uebServers.get(0), "publicKey"); - healthCheckCall1.setCambriaHandler(cambriaHandler); - - call1 = healthCheckCall1.call(); - assertFalse("check response okay", call1); - - healthCheckCall2 = new UebHealthCheckCall(uebServers.get(1), "publicKey"); - healthCheckCall2.setCambriaHandler(cambriaHandler); - - call2 = healthCheckCall2.call(); - assertTrue("check response okay", call2); - - if (uebServers.size() >= 2) { - when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(0)), Mockito.any(String.class))).thenReturn(cambriaErrorResponse); - when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(1)), Mockito.any(String.class))).thenReturn(cambriaNotErrorResponse); - } - healthCheckCall1 = new UebHealthCheckCall(uebServers.get(0), "publicKey"); - healthCheckCall1.setCambriaHandler(cambriaHandler); - - call1 = healthCheckCall1.call(); - assertFalse("check response okay", call1); - - healthCheckCall2 = new UebHealthCheckCall(uebServers.get(1), "publicKey"); - healthCheckCall2.setCambriaHandler(cambriaHandler); - - call2 = healthCheckCall2.call(); - assertTrue("check response okay", call2); - - } +public class DistributionEngineHealthCheckTest extends BeConfDependentTest { + + @Mock + private CambriaHandler cambriaHandler = Mockito.mock(CambriaHandler.class); + + DistributionEngineClusterHealth distributionEngineClusterHealth = new DistributionEngineClusterHealth(); + + Gson gson = new Gson(); + + Gson prettyGson = new GsonBuilder().setPrettyPrinting().create(); + + // + // @Test + // public void validateDownWhenEnvAreDown() { + // + // Map<String, AtomicBoolean> envNamePerStatus = new HashMap<>(); + // envNamePerStatus.put("PROD1", new AtomicBoolean(false)); + // envNamePerStatus.put("PROD2", new AtomicBoolean(false)); + // + // distributionEngineClusterHealth.startHealthCheckTask(envNamePerStatus); + // + // HealthCheckInfo healthCheckInfo = + // distributionEngineClusterHealth.getHealthCheckInfo(); + // assertEquals("verify down", HealthCheckStatus.DOWN, + // healthCheckInfo.getHealthCheckStatus()); + // assertEquals("verify DE component", HealthCheckComponent.DE, + // healthCheckInfo.getHealthCheckComponent()); + // + // } + + @Test + public void validateUpWhenQuerySucceed() { + + // Map<String, AtomicBoolean> envNamePerStatus = new HashMap<>(); + // envNamePerStatus.put("PROD1", new AtomicBoolean(true)); + // envNamePerStatus.put("PROD2", new AtomicBoolean(false)); + // + // distributionEngineClusterHealth.startHealthCheckTask(envNamePerStatus, + // false); + + CambriaErrorResponse cambriaOkResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, 200); + CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.INTERNAL_SERVER_ERROR, 500); + CambriaErrorResponse cambriaNotErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.AUTHENTICATION_ERROR, 403); + + List<String> uebServers = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getUebServers(); + if (uebServers.size() >= 2) { + when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(0)), Mockito.any(String.class))).thenReturn(cambriaOkResponse); + when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(1)), Mockito.any(String.class))).thenReturn(cambriaOkResponse); + } + + UebHealthCheckCall healthCheckCall1 = new UebHealthCheckCall(uebServers.get(0), "publicKey"); + healthCheckCall1.setCambriaHandler(cambriaHandler); + Boolean call1 = healthCheckCall1.call(); + assertTrue("check response okay", call1); + + UebHealthCheckCall healthCheckCall2 = new UebHealthCheckCall(uebServers.get(1), "publicKey"); + healthCheckCall2.setCambriaHandler(cambriaHandler); + + Boolean call2 = healthCheckCall2.call(); + assertTrue("check response okay", call2); + + if (uebServers.size() >= 2) { + when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(0)), Mockito.any(String.class))).thenReturn(cambriaErrorResponse); + when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(1)), Mockito.any(String.class))).thenReturn(cambriaOkResponse); + } + healthCheckCall1 = new UebHealthCheckCall(uebServers.get(0), "publicKey"); + healthCheckCall1.setCambriaHandler(cambriaHandler); + + call1 = healthCheckCall1.call(); + assertFalse("check response okay", call1); + + healthCheckCall2 = new UebHealthCheckCall(uebServers.get(1), "publicKey"); + healthCheckCall2.setCambriaHandler(cambriaHandler); + + call2 = healthCheckCall2.call(); + assertTrue("check response okay", call2); + + if (uebServers.size() >= 2) { + when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(0)), Mockito.any(String.class))).thenReturn(cambriaErrorResponse); + when(cambriaHandler.getApiKey(Mockito.eq(uebServers.get(1)), Mockito.any(String.class))).thenReturn(cambriaNotErrorResponse); + } + healthCheckCall1 = new UebHealthCheckCall(uebServers.get(0), "publicKey"); + healthCheckCall1.setCambriaHandler(cambriaHandler); + + call1 = healthCheckCall1.call(); + assertFalse("check response okay", call1); + + healthCheckCall2 = new UebHealthCheckCall(uebServers.get(1), "publicKey"); + healthCheckCall2.setCambriaHandler(cambriaHandler); + + call2 = healthCheckCall2.call(); + assertTrue("check response okay", call2); + + } } diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineInitTaskTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineInitTaskTest.java index 5bf12d56bc..03a6625cae 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineInitTaskTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineInitTaskTest.java @@ -20,19 +20,9 @@ package org.openecomp.sdc.be.components.distribution.engine; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.when; - -import java.io.File; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import java.util.concurrent.atomic.AtomicBoolean; - -import org.junit.BeforeClass; +import fj.data.Either; +import org.apache.commons.collections.CollectionUtils; +import org.junit.Before; import org.junit.Test; import org.mockito.Mock; import org.mockito.Mockito; @@ -41,224 +31,252 @@ import org.openecomp.sdc.be.config.DistributionEngineConfiguration; import org.openecomp.sdc.be.config.DistributionEngineConfiguration.CreateTopicConfig; import org.openecomp.sdc.be.distribution.api.client.CambriaOperationStatus; import org.openecomp.sdc.be.impl.ComponentsUtils; +import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry; import org.openecomp.sdc.common.api.ConfigurationSource; import org.openecomp.sdc.common.impl.ExternalConfiguration; import org.openecomp.sdc.common.impl.FSConfigurationSource; -import fj.data.Either; - -public class DistributionEngineInitTaskTest { - - @Mock - private ComponentsUtils componentsUtils = Mockito.mock(ComponentsUtils.class); - - @Mock - private CambriaHandler cambriaHandler = Mockito.mock(CambriaHandler.class); - - // public static final IAuditingDao iAuditingDao = - // Mockito.mock(AuditingDao.class); - - @BeforeClass - public static void setup() { - // ExternalConfiguration.setAppName("distribEngine1"); - ExternalConfiguration.setAppName("catalog-be"); - ExternalConfiguration.setConfigDir("src/test/resources/config"); - ExternalConfiguration.listenForChanges(); - - ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), ExternalConfiguration.getConfigDir() + File.separator + ExternalConfiguration.getAppName()); - - ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); - } - - @Test - public void checkIncrement() { - - String envName = "PrOD"; - - DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); - int retry = 2; - int maxRetry = 40; - deConfiguration.setInitRetryIntervalSec(retry); - deConfiguration.setInitMaxIntervalSec(maxRetry); - DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null); - - for (int i = 1; i < 5; i++) { - initTask.incrementRetryInterval(); - assertEquals("check next retry interval", initTask.getCurrentRetryInterval(), retry * (long) Math.pow(2, i)); - } - - initTask.incrementRetryInterval(); - assertEquals("check next retry interval reach max retry interval", initTask.getCurrentRetryInterval(), maxRetry); - - } - - @Test - public void testInitFlowScenarioSuccess() { - - String notifTopic = "notif"; - String statusTopic = "status"; - - List<String> uebServers = new ArrayList<>(); - uebServers.add("server1"); - CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.NOT_FOUND); - Either<Set<String>, CambriaErrorResponse> right = Either.right(cambriaErrorResponse); - when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(right); - - String envName = "PrOD"; - - DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); - deConfiguration.setUebServers(uebServers); - int retry = 2; - int maxRetry = 40; - deConfiguration.setInitRetryIntervalSec(retry); - deConfiguration.setInitMaxIntervalSec(maxRetry); - deConfiguration.setDistributionNotifTopicName(notifTopic); - deConfiguration.setDistributionStatusTopicName(statusTopic); - CreateTopicConfig createTopic = new CreateTopicConfig(); - createTopic.setPartitionCount(1); - createTopic.setReplicationCount(1); - deConfiguration.setCreateTopic(createTopic); - - cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK); - - String realNotifTopic = notifTopic + "-" + envName.toUpperCase(); - String realStatusTopic = statusTopic + "-" + envName.toUpperCase(); - when(cambriaHandler.createTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realNotifTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse); - when(cambriaHandler.createTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realStatusTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse); - - cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK); - when(cambriaHandler.registerToTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())) - .thenReturn(cambriaErrorResponse); - - DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null); - initTask.setCambriaHandler(cambriaHandler); - - boolean initFlow = initTask.initFlow(); - assertTrue("check init flow succeed", initFlow); - - } - - @Test - public void testInitFlowScenarioSuccessTopicsAlreadyExists() { - - String envName = "PrOD"; - String notifTopic = "notif"; - String statusTopic = "status"; - - String realNotifTopic = notifTopic + "-" + envName.toUpperCase(); - String realStatusTopic = statusTopic + "-" + envName.toUpperCase(); +import java.io.File; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.concurrent.atomic.AtomicBoolean; - Set<String> topics = new HashSet<String>(); - topics.add(realNotifTopic); - topics.add(realStatusTopic); +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; - List<String> uebServers = new ArrayList<>(); - uebServers.add("server1"); - Either<Set<String>, CambriaErrorResponse> left = Either.left(topics); - - when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(left); - - DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); - deConfiguration.setUebServers(uebServers); - int retry = 2; - int maxRetry = 40; - deConfiguration.setInitRetryIntervalSec(retry); - deConfiguration.setInitMaxIntervalSec(maxRetry); - deConfiguration.setDistributionNotifTopicName(notifTopic); - deConfiguration.setDistributionStatusTopicName(statusTopic); - CreateTopicConfig createTopic = new CreateTopicConfig(); - createTopic.setPartitionCount(1); - createTopic.setReplicationCount(1); - deConfiguration.setCreateTopic(createTopic); - - CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK); - when(cambriaHandler.registerToTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())) - .thenReturn(cambriaErrorResponse); - - DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null); - initTask.setCambriaHandler(cambriaHandler); - - try { - boolean initFlow = initTask.initFlow(); - assertTrue("check init flow succeed", initFlow); - } catch (Exception e) { - assertTrue("Should not throw exception", false); - } - - } +public class DistributionEngineInitTaskTest { - @Test - public void testInitFlowScenarioFailToRegister() { + @Mock + private ComponentsUtils componentsUtils; - String notifTopic = "notif"; - String statusTopic = "status"; - - List<String> uebServers = new ArrayList<>(); - uebServers.add("server1"); - CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.NOT_FOUND); - Either<Set<String>, CambriaErrorResponse> right = Either.right(cambriaErrorResponse); - when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(right); - - String envName = "PrOD"; - - DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); - deConfiguration.setUebServers(uebServers); - int retry = 2; - int maxRetry = 40; - deConfiguration.setInitRetryIntervalSec(retry); - deConfiguration.setInitMaxIntervalSec(maxRetry); - deConfiguration.setDistributionNotifTopicName(notifTopic); - deConfiguration.setDistributionStatusTopicName(statusTopic); - CreateTopicConfig createTopic = new CreateTopicConfig(); - createTopic.setPartitionCount(1); - createTopic.setReplicationCount(1); - deConfiguration.setCreateTopic(createTopic); + @Mock + private CambriaHandler cambriaHandler; - cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK); + @Before + public void setup() { + ExternalConfiguration.setAppName("catalog-be"); + ExternalConfiguration.setConfigDir("src/test/resources/config"); + ExternalConfiguration.listenForChanges(); - String realNotifTopic = notifTopic + "-" + envName.toUpperCase(); - String realStatusTopic = statusTopic + "-" + envName.toUpperCase(); - when(cambriaHandler.createTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realNotifTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse); - when(cambriaHandler.createTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realStatusTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse); + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), ExternalConfiguration.getConfigDir() + File.separator + ExternalConfiguration.getAppName()); + new ConfigurationManager(configurationSource); - when(cambriaHandler.registerToTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(SubscriberTypeEnum.class))) - .thenReturn(new CambriaErrorResponse(CambriaOperationStatus.OK)); + componentsUtils = Mockito.mock(ComponentsUtils.class); + cambriaHandler = Mockito.mock(CambriaHandler.class); + } + + @Test + public void checkIncrement() { - when(cambriaHandler.registerToTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(SubscriberTypeEnum.class))) - .thenReturn(new CambriaErrorResponse(CambriaOperationStatus.CONNNECTION_ERROR)); + String envName = "PrOD"; + + DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); + int retry = 2; + int maxRetry = 40; + deConfiguration.setInitRetryIntervalSec(retry); + deConfiguration.setInitMaxIntervalSec(maxRetry); + DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null, readEnvFromConfig(deConfiguration)); + + for (int i = 1; i < 5; i++) { + initTask.incrementRetryInterval(); + assertEquals("check next retry interval", initTask.getCurrentRetryInterval(), retry * (long) Math.pow(2, i)); + } + + initTask.incrementRetryInterval(); + assertEquals("check next retry interval reach max retry interval", initTask.getCurrentRetryInterval(), maxRetry); + + } + + @SuppressWarnings("unchecked") + @Test + public void testInitFlowScenarioSuccess() { + String notifTopic = "notif"; + String statusTopic = "status"; + + List<String> uebServers = new ArrayList<>(); + uebServers.add("server1"); + CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.NOT_FOUND); + Either<Set<String>, CambriaErrorResponse> right = Either.right(cambriaErrorResponse); + when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(right); - DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null); - initTask.setCambriaHandler(cambriaHandler); + String envName = "PrOD"; + + DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); + deConfiguration.setUebServers(uebServers); + int retry = 2; + int maxRetry = 40; + deConfiguration.setInitRetryIntervalSec(retry); + deConfiguration.setInitMaxIntervalSec(maxRetry); + deConfiguration.setDistributionNotifTopicName(notifTopic); + deConfiguration.setDistributionStatusTopicName(statusTopic); + CreateTopicConfig createTopic = new CreateTopicConfig(); + createTopic.setPartitionCount(1); + createTopic.setReplicationCount(1); + deConfiguration.setCreateTopic(createTopic); + + cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK); + + String realNotifTopic = notifTopic + "-" + envName.toUpperCase(); + String realStatusTopic = statusTopic + "-" + envName.toUpperCase(); + when(cambriaHandler.createTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realNotifTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse); + when(cambriaHandler.createTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realStatusTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse); + + cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK); + when(cambriaHandler.registerToTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())) + .thenReturn(cambriaErrorResponse); + + DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null, readEnvFromConfig(deConfiguration)); + initTask.setCambriaHandler(cambriaHandler); + + boolean initFlow = initTask.initFlow(); + assertTrue("check init flow succeed", initFlow); - boolean initFlow = initTask.initFlow(); - assertFalse("check init flow failed", initFlow); + } - } + @SuppressWarnings("unchecked") + @Test + public void testInitFlowScenarioSuccessTopicsAlreadyExists() { - @Test - public void testInitFlowScenario1GetTopicsFailed() { - - List<String> uebServers = new ArrayList<>(); - uebServers.add("server1"); - CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.CONNNECTION_ERROR); - Either<Set<String>, CambriaErrorResponse> right = Either.right(cambriaErrorResponse); - when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(right); - - String envName = "PrOD"; - - DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); - deConfiguration.setUebServers(uebServers); - int retry = 2; - int maxRetry = 40; - deConfiguration.setInitRetryIntervalSec(retry); - deConfiguration.setInitMaxIntervalSec(maxRetry); - DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null); - initTask.setCambriaHandler(cambriaHandler); - - boolean initFlow = initTask.initFlow(); - assertFalse("check init flow failed", initFlow); - - } + String envName = "PrOD"; + String notifTopic = "notif"; + String statusTopic = "status"; + + String realNotifTopic = notifTopic + "-" + envName.toUpperCase(); + String realStatusTopic = statusTopic + "-" + envName.toUpperCase(); + + Set<String> topics = new HashSet<String>(); + topics.add(realNotifTopic); + topics.add(realStatusTopic); + + List<String> uebServers = new ArrayList<>(); + uebServers.add("server1"); + Either<Set<String>, CambriaErrorResponse> left = Either.left(topics); + + when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(left); + + DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); + deConfiguration.setUebServers(uebServers); + int retry = 2; + int maxRetry = 40; + deConfiguration.setInitRetryIntervalSec(retry); + deConfiguration.setInitMaxIntervalSec(maxRetry); + deConfiguration.setDistributionNotifTopicName(notifTopic); + deConfiguration.setDistributionStatusTopicName(statusTopic); + CreateTopicConfig createTopic = new CreateTopicConfig(); + createTopic.setPartitionCount(1); + createTopic.setReplicationCount(1); + deConfiguration.setCreateTopic(createTopic); + + CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK); + when(cambriaHandler.registerToTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())) + .thenReturn(cambriaErrorResponse); + + DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null, readEnvFromConfig(deConfiguration)); + initTask.setCambriaHandler(cambriaHandler); + + try { + boolean initFlow = initTask.initFlow(); + assertTrue("check init flow succeed", initFlow); + } catch (Exception e) { + assertTrue("Should not throw exception", false); + } + + } + + @SuppressWarnings("unchecked") + @Test + public void testInitFlowScenarioFailToRegister() { + + String notifTopic = "notif"; + String statusTopic = "status"; + + List<String> uebServers = new ArrayList<>(); + uebServers.add("server1"); + CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.NOT_FOUND); + Either<Set<String>, CambriaErrorResponse> right = Either.right(cambriaErrorResponse); + when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(right); + + String envName = "PrOD"; + + DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); + deConfiguration.setUebServers(uebServers); + int retry = 2; + int maxRetry = 40; + deConfiguration.setInitRetryIntervalSec(retry); + deConfiguration.setInitMaxIntervalSec(maxRetry); + deConfiguration.setDistributionNotifTopicName(notifTopic); + deConfiguration.setDistributionStatusTopicName(statusTopic); + CreateTopicConfig createTopic = new CreateTopicConfig(); + createTopic.setPartitionCount(1); + createTopic.setReplicationCount(1); + deConfiguration.setCreateTopic(createTopic); + + cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK); + + String realNotifTopic = notifTopic + "-" + envName.toUpperCase(); + String realStatusTopic = statusTopic + "-" + envName.toUpperCase(); + when(cambriaHandler.createTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realNotifTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse); + when(cambriaHandler.createTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realStatusTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse); + + when(cambriaHandler.registerToTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realNotifTopic))) + .thenReturn(new CambriaErrorResponse(CambriaOperationStatus.OK)); + + when(cambriaHandler.registerToTopic(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.eq(realStatusTopic))) + .thenReturn(new CambriaErrorResponse(CambriaOperationStatus.CONNNECTION_ERROR)); + + + DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null, readEnvFromConfig(deConfiguration)); + initTask.setCambriaHandler(cambriaHandler); + + boolean initFlow = initTask.initFlow(); + assertFalse("check init flow failed", initFlow); + + } + + @SuppressWarnings("unchecked") + @Test + public void testInitFlowScenario1GetTopicsFailed() { + + List<String> uebServers = new ArrayList<>(); + uebServers.add("server1"); + CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.CONNNECTION_ERROR); + Either<Set<String>, CambriaErrorResponse> right = Either.right(cambriaErrorResponse); + when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(right); + + String envName = "PrOD"; + + DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration(); + deConfiguration.setUebServers(uebServers); + int retry = 2; + int maxRetry = 40; + deConfiguration.setInitRetryIntervalSec(retry); + deConfiguration.setInitMaxIntervalSec(maxRetry); + DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null, readEnvFromConfig(deConfiguration)); + initTask.setCambriaHandler(cambriaHandler); + + boolean initFlow = initTask.initFlow(); + assertFalse("check init flow failed", initFlow); + + } + + private OperationalEnvironmentEntry readEnvFromConfig(DistributionEngineConfiguration distributionEngineConfiguration) { + OperationalEnvironmentEntry entry = new OperationalEnvironmentEntry(); + entry.setUebApikey(distributionEngineConfiguration.getUebPublicKey()); + entry.setUebSecretKey(distributionEngineConfiguration.getUebSecretKey()); + Set<String> puebEndpoints = new HashSet<>(); + if(distributionEngineConfiguration.getUebServers() != null) + puebEndpoints.addAll(distributionEngineConfiguration.getUebServers()); + entry.setDmaapUebAddress(puebEndpoints); + String envName = "UNKNOWN"; + if(CollectionUtils.isNotEmpty(distributionEngineConfiguration.getEnvironments())) + envName = distributionEngineConfiguration.getEnvironments().get(0); + entry.setEnvironmentId(envName); + return entry; + } } diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineTest.java new file mode 100644 index 0000000000..b1a43eaa57 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineTest.java @@ -0,0 +1,95 @@ +package org.openecomp.sdc.be.components.distribution.engine; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.openecomp.sdc.be.components.utils.OperationalEnvironmentBuilder; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.model.Service; +import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry; + +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +public class DistributionEngineTest { + + public static final String DISTRIBUTION_ID = "distId"; + public static final String ENV_ID = "envId"; + public static final String USER_ID = "userId"; + public static final String MODIFIER = "modifier"; + + @InjectMocks + private DistributionEngine testInstance; + + @Mock + private EnvironmentsEngine environmentsEngine; + + @Mock + private DistributionNotificationSender distributionNotificationSender; + + private DummyDistributionConfigurationManager distributionEngineConfigurationMock; + + private Map<String, OperationalEnvironmentEntry> envs; + + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + distributionEngineConfigurationMock = new DummyDistributionConfigurationManager(); + envs = getEnvs(ENV_ID); + } + + @Test + public void notifyService() throws Exception { + NotificationDataImpl notificationData = new NotificationDataImpl(); + Service service = new Service(); + when(environmentsEngine.getEnvironmentById(ENV_ID)).thenReturn(envs.get(ENV_ID)); + when(distributionEngineConfigurationMock.getConfigurationMock().getDistributionNotifTopicName()).thenReturn("topic"); + when(distributionNotificationSender.sendNotification(eq("topic-ENVID"), eq(DISTRIBUTION_ID), any(EnvironmentMessageBusData.class), + any(NotificationDataImpl.class), any(Service.class), eq(USER_ID), eq(MODIFIER))) + .thenReturn(ActionStatus.OK); + ActionStatus actionStatus = testInstance.notifyService(DISTRIBUTION_ID, service, notificationData, ENV_ID, USER_ID, MODIFIER); + assertEquals(ActionStatus.OK, actionStatus); + } + + @Test + public void notifyService_couldNotResolveEnvironment() throws Exception { + when(environmentsEngine.getEnvironments()).thenReturn(envs); + ActionStatus actionStatus = testInstance.notifyService(DISTRIBUTION_ID, new Service(), new NotificationDataImpl(), "someNonExisitngEnv", USER_ID, MODIFIER); + assertEquals(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE, actionStatus); + verifyZeroInteractions(distributionNotificationSender); + } + + @Test + public void notifyService_failedWhileSendingNotification() throws Exception { + NotificationDataImpl notificationData = new NotificationDataImpl(); + Service service = new Service(); + when(environmentsEngine.getEnvironmentById(ENV_ID)).thenReturn(envs.get(ENV_ID)); + when(distributionEngineConfigurationMock.getConfigurationMock().getDistributionNotifTopicName()).thenReturn("topic"); + when(distributionNotificationSender.sendNotification(eq("topic-ENVID"), eq(DISTRIBUTION_ID), any(EnvironmentMessageBusData.class), + any(NotificationDataImpl.class), any(Service.class), eq(USER_ID), eq(MODIFIER))) + .thenReturn(ActionStatus.GENERAL_ERROR); + ActionStatus actionStatus = testInstance.notifyService(DISTRIBUTION_ID, service, notificationData, ENV_ID, USER_ID, MODIFIER); + assertEquals(ActionStatus.GENERAL_ERROR, actionStatus); + } + + private Map<String, OperationalEnvironmentEntry> getEnvs(String ... environmentIds) { + Set<String> uebAddress = new HashSet<>(); + uebAddress.add("someAddress"); + return Stream.of(environmentIds) + .map(id -> new OperationalEnvironmentBuilder().setEnvId(id).setDmaapUebAddress(uebAddress).build()) + .collect(Collectors.toMap(OperationalEnvironmentEntry::getEnvironmentId, Function.identity())); + } +}
\ No newline at end of file diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DummyDistributionConfigurationManager.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DummyDistributionConfigurationManager.java new file mode 100644 index 0000000000..1118385143 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DummyDistributionConfigurationManager.java @@ -0,0 +1,37 @@ +package org.openecomp.sdc.be.components.distribution.engine; + +import org.mockito.Mockito; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.config.DistributionEngineConfiguration; +import org.openecomp.sdc.common.api.ConfigurationListener; +import org.openecomp.sdc.common.api.ConfigurationSource; + +public class DummyDistributionConfigurationManager { + + private DistributionEngineConfiguration configurationMock = Mockito.mock(DistributionEngineConfiguration.class); + + public DummyDistributionConfigurationManager() { + new ConfigurationManager(new DummyConfigurationSource()); + } + + public class DummyConfigurationSource implements ConfigurationSource { + + @SuppressWarnings("unchecked") + @Override + public <T> T getAndWatchConfiguration(Class<T> className, ConfigurationListener configurationListener) { + if (className.equals(DistributionEngineConfiguration.class)) { + return (T)configurationMock; + } + return null; + } + + @Override + public <T> void addWatchConfiguration(Class<T> className, ConfigurationListener configurationListener) { + + } + } + + public DistributionEngineConfiguration getConfigurationMock() { + return configurationMock; + } +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/EnvironmentsEngineTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/EnvironmentsEngineTest.java new file mode 100644 index 0000000000..514618c89a --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/EnvironmentsEngineTest.java @@ -0,0 +1,190 @@ +package org.openecomp.sdc.be.components.distribution.engine; + +import fj.data.Either; +import org.apache.http.HttpStatus; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.config.DistributionEngineConfiguration; +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.info.OperationalEnvInfo; +import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry; +import org.openecomp.sdc.common.http.client.api.HttpResponse; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + +@RunWith(value = MockitoJUnitRunner.class) +public class EnvironmentsEngineTest { + + @InjectMocks + private EnvironmentsEngine envEngine; + @Mock + private DmaapConsumer dmaapConsumer; + @Mock + private OperationalEnvironmentDao operationalEnvironmentDao; + @Mock + private DME2EndpointIteratorCreator epIterCreator; + @Mock + private ConfigurationManager configurationManager; + @Mock + private DistributionEngineConfiguration distributionEngineConfiguration; + @Mock + private AaiRequestHandler aaiRequestHandler; + + @Before + public void preStart() { + when(configurationManager.getDistributionEngineConfiguration()).thenReturn(distributionEngineConfiguration); + envEngine.setConfigurationManager(configurationManager); + } + + @Test + public void testInit() { + List<OperationalEnvironmentEntry> entryList = Arrays.asList(createOpEnvEntry("Env1"), createOpEnvEntry("Env2")); + Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> successEither = Either.left(entryList); + when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.COMPLETED)).thenReturn(successEither); + + when(distributionEngineConfiguration.getEnvironments()).thenReturn(Arrays.asList("Env Loaded From Configuration")); + when(distributionEngineConfiguration.getUebPublicKey()).thenReturn("Dummy Public Key"); + when(distributionEngineConfiguration.getUebSecretKey()).thenReturn("Dummy Private Key"); + when(distributionEngineConfiguration.getUebServers()).thenReturn( + Arrays.asList("uebsb91kcdc.it.att.com:3904", "uebsb92kcdc.it.att.com:3904", "uebsb91kcdc.it.att.com:3904")); + + envEngine.init(); + + Map<String, OperationalEnvironmentEntry> mapEnvs = envEngine.getEnvironments(); + assertEquals("unexpected size of map",3, mapEnvs.size()); + } + + + @Test + public void testGetFullOperationalEnvByIdSuccess() { + String json = getFullOperationalEnvJson(); + + HttpResponse<String> restResponse = new HttpResponse<String>(json, HttpStatus.SC_OK, "Successfully completed"); + when(aaiRequestHandler.getOperationalEnvById(Mockito.anyString())).thenReturn(restResponse); + + Either<OperationalEnvInfo, Integer> response = envEngine.getOperationalEnvById("DummyId"); + assertTrue("The operational environment request ran as not expected", response.isLeft()); + + OperationalEnvInfo operationalEnvInfo = response.left().value(); + + assertEquals("The operational environment json is not as expected", operationalEnvInfo.toString(), json); + } + + @Test + public void testGetPartialOperationalEnvByIdSuccess() { + String json = getPartialOperationalEnvJson(); + + HttpResponse<String> restResponse = new HttpResponse<String>(json, HttpStatus.SC_OK, "Successfully completed"); + when(aaiRequestHandler.getOperationalEnvById(Mockito.anyString())).thenReturn(restResponse); + + Either<OperationalEnvInfo, Integer> response = envEngine.getOperationalEnvById("DummyId"); + assertTrue("The operational environment request ran as not expected", response.isLeft()); + + OperationalEnvInfo operationalEnvInfo = response.left().value(); + + assertEquals("The operational environment json is not as expected", operationalEnvInfo.toString(), json); + } + + + @Test + public void testGetOperationalEnvByIdFailedByJsonConvert() { + String jsonCorrupted = getCorruptedOperationalEnvJson(); + + HttpResponse<String> restResponse = new HttpResponse<String>(jsonCorrupted, HttpStatus.SC_OK, "Successfully Completed"); + when(aaiRequestHandler.getOperationalEnvById(Mockito.anyString())).thenReturn(restResponse); + + Either<OperationalEnvInfo, Integer> response = envEngine.getOperationalEnvById("DummyId"); + assertTrue("The operational environment request ran as not expected", response.isRight()); + assertEquals("The operational environment request status code is not as expected", (Integer)HttpStatus.SC_INTERNAL_SERVER_ERROR, response.right().value()); + } + + @Test + public void testGetOperationalEnvByIdFailed404() { + String json = getFullOperationalEnvJson(); + HttpResponse<String> restResponse = new HttpResponse<String>(json, HttpStatus.SC_NOT_FOUND, "Not Found"); + when(aaiRequestHandler.getOperationalEnvById(Mockito.anyString())).thenReturn(restResponse); + + Either<OperationalEnvInfo, Integer> response = envEngine.getOperationalEnvById("DummyId"); + assertTrue("The operational environment request ran as not expected", response.isRight()); + assertEquals("The operational environment request status code is not as expected", (Integer)HttpStatus.SC_NOT_FOUND, response.right().value()); + } + + + @Test(expected = IOException.class) + public void testCorruptedOperationalEnvJson() throws IOException { + String jsonCorrupted = getCorruptedOperationalEnvJson(); + OperationalEnvInfo.createFromJson(jsonCorrupted); + } + + private String getCorruptedOperationalEnvJson() { + return "{\"OPERATIONAL-environment-name\":\"Op Env Name\"," + + "\"OPERATIONAL-environment-type\":\"VNF\"," + + "\"OPERATIONAL-environment-status\":\"Activate\"," + + "\"tenant-context\":\"Test\"}"; + } + + private String getPartialOperationalEnvJson() { + return "{" + + "\"operational-environment-id\":\"UUID of Operational Environment\"," + + "\"operational-environment-name\":\"Op Env Name\"," + + "\"operational-environment-type\":\"VNF\"," + + "\"operational-environment-status\":\"Activate\"," + + "\"tenant-context\":\"Test\"," + + "\"workload-context\":\"VNF_Development\"," + + "\"resource-version\":\"1505228226913\"," + + "\"relationship-list\":{" + + "\"relationship\":[]" + + "}" + + "}"; + } + + private String getFullOperationalEnvJson() { + return "{" + + "\"operational-environment-id\":\"OEid1\"," + + "\"operational-environment-name\":\"OEname1\"," + + "\"operational-environment-type\":\"OEtype1\"," + + "\"operational-environment-status\":\"OEstatus1\"," + + "\"tenant-context\":\"OEtenantcontext1\"," + + "\"workload-context\":\"OEworkloadcontext1\"," + + "\"resource-version\":\"1511363173278\"," + + "\"relationship-list\":{" + + "\"relationship\":[" + + "{" + + "\"related-to\":\"operational-environment\"," + + "\"relationship-label\":\"managedBy\"," + + "\"related-link\":\"/aai/v12/cloud-infrastructure/operational-environments/operational-environment/OEid3\"," + + "\"relationship-data\":[" + + "{" + + "\"relationship-key\":\"operational-environment.operational-environment-id\"," + + "\"relationship-value\":\"OEid3\"" + + "}" + + "]," + + "\"related-to-property\":[" + + "{" + + "\"property-key\":\"operational-environment.operational-environment-name\"," + + "\"property-value\":\"OEname3\"" + + "}]}]}}"; + } + + private OperationalEnvironmentEntry createOpEnvEntry(String name) { + OperationalEnvironmentEntry entry = new OperationalEnvironmentEntry(); + entry.setEnvironmentId(name); + return entry; + } + +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/StepsTenantIsolation.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/StepsTenantIsolation.java new file mode 100644 index 0000000000..1a2ca4840d --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/StepsTenantIsolation.java @@ -0,0 +1,310 @@ +package org.openecomp.sdc.be.components.distribution.engine; + +import com.att.aft.dme2.api.DME2Exception; +import com.att.aft.dme2.iterator.DME2EndpointIterator; +import com.att.nsa.apiClient.credentials.ApiCredential; +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +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; +import org.apache.commons.lang.NotImplementedException; +import org.apache.commons.lang.math.NumberUtils; +import org.apache.http.HttpStatus; +import org.junit.Assert; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.mockito.Spy; +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.impl.ComponentsUtils; +import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.common.datastructure.Wrapper; +import org.openecomp.sdc.common.http.client.api.HttpResponse; + +import static java.util.Objects.isNull; +import static org.apache.commons.lang3.StringUtils.isEmpty; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +public class StepsTenantIsolation { + + // Notification Fields + private String operationalEnvironmentId = "28122015552391"; + private String operationalEnvironmentName = "Operational Environment Name"; + private String operationalEnvironmentType; + private String tenantContext ; + private String workloadContext; + private String action; + + @Mock + private DmaapConsumer dmaapConsumer; + @Mock + private OperationalEnvironmentDao operationalEnvironmentDao; + @Mock + private DME2EndpointIteratorCreator epIterCreator; + @Mock + private ComponentsUtils componentsUtils; + @Mock + private AaiRequestHandler aaiRequestHandler; + @Mock + private CambriaHandler cambriaHandler; + @InjectMocks + @Spy + private EnvironmentsEngine envEngine; + + private boolean isSuccessful; + private boolean cassandraUp; + + @Before + public void beforeScenario() { + MockitoAnnotations.initMocks(this); + when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.COMPLETED)) + .thenReturn(Either.right(CassandraOperationStatus.NOT_FOUND)); + doNothing().when(envEngine).createUebTopicsForEnvironments(); + envEngine.init(); + } + + // ############################# Given - Start ############################# + @Given("^Dmaap consumer recieved notification with fields (.*)$") + public void dmaap_consumer_recieved_notification_with_fields(String notificationFields) throws Throwable { + Gson gson = new GsonBuilder().create(); + IDmaapNotificationData notification = gson.fromJson(notificationFields, DmaapNotificationDataImpl.class); + if (!isNull(notification.getOperationalEnvironmentType())) { + this.operationalEnvironmentType = notification.getOperationalEnvironmentType().getEventTypenName(); + } + if( !isEmpty(notification.getOperationalEnvironmentId()) ){ + this.operationalEnvironmentId = notification.getOperationalEnvironmentId(); + } + if( !isNull(notification.getAction()) ){ + this.action = notification.getAction().getActionName(); + } + + } + + @Given("^Cassandra service status is (.*)$") + public void cassandra_service_status_is(String status) throws Throwable { + switch (status) { + case "UP": + this.cassandraUp = true; + break; + case "DOWN": + when(operationalEnvironmentDao.get(operationalEnvironmentId)) + .thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR)); + when(operationalEnvironmentDao.save(Mockito.any(OperationalEnvironmentEntry.class))) + .thenReturn(CassandraOperationStatus.GENERAL_ERROR); + break; + default: + throw new NotImplementedException(); + } + } + + @Given("^Record status is (.*)$") + public void record_status_is(String status) throws Throwable { + if (!cassandraUp) { + return; + } + Either<OperationalEnvironmentEntry, CassandraOperationStatus> eitherResult; + final OperationalEnvironmentEntry entryMock = Mockito.mock(OperationalEnvironmentEntry.class); + switch (status) { + case "FOUND_IN_PROGRESS": + when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.IN_PROGRESS.getName()); + eitherResult = Either.left(entryMock); + break; + case "FOUND_COMPLETED": + when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.COMPLETED.getName()); + eitherResult = Either.left(entryMock); + break; + case "FOUND_FAILED": + when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.FAILED.getName()); + eitherResult = Either.left(entryMock); + break; + case "NOT_FOUND": + eitherResult = Either.right(CassandraOperationStatus.NOT_FOUND); + break; + default: + throw new NotImplementedException(); + } + + when(operationalEnvironmentDao.get(operationalEnvironmentId)).thenReturn(eitherResult); + when(operationalEnvironmentDao.save(Mockito.any(OperationalEnvironmentEntry.class))) + .thenReturn(CassandraOperationStatus.OK); + } + + @Given("^AAI service status is (.*) and Tenant returned is (.*) and worload returned is (.*)$") + public void aai_service_status_is(String aaiServiceStatus, String tenant, String workload) throws Throwable { + this.tenantContext = tenant; + this.workloadContext = workload; + HttpResponse<String> resp = Mockito.mock(HttpResponse.class); + when(aaiRequestHandler.getOperationalEnvById(operationalEnvironmentId)).thenReturn(resp); + switch (aaiServiceStatus) { + case "UP": + when(resp.getStatusCode()).thenReturn(HttpStatus.SC_OK); + String aaiResponseTemplate = + //@formatter:off + "{\r\n" + + " \"operational-environment-id\": \"%s\",\r\n" + + " \"operational-environment-name\": \"%s\",\r\n" + + " \"operational-environment-type\": \"%s\",\r\n" + + " \"operational-environment-status\": \"IN-PROGRESS\",\r\n" + + " \"tenant-context\": \"%s\",\r\n" + + " \"workload-context\": \"%s\"\r\n" + + " }"; + //@formatter:on + when(resp.getResponse()).thenReturn(String.format(aaiResponseTemplate, operationalEnvironmentId, + operationalEnvironmentName, operationalEnvironmentType, tenantContext, workloadContext)); + + break; + case "DOWN": + when(resp.getStatusCode()).thenReturn(HttpStatus.SC_REQUEST_TIMEOUT); + break; + default: + throw new NotImplementedException(); + } + } + + @Given("^AFT_DME service status is (.*)$") + public void aft_dme_service_status_is(String aftDmeStatus) throws Throwable { + switch (aftDmeStatus) { + case "UP": + DME2EndpointIterator mockItr = Mockito.mock(DME2EndpointIterator.class); + when(mockItr.hasNext()).thenReturn(false); + when(epIterCreator.create(Mockito.anyString())).thenReturn(mockItr); + break; + case "DOWN": + when(epIterCreator.create(Mockito.anyString())) + .thenThrow(new DME2Exception("dummyCode", new NotImplementedException())); + break; + default: + throw new NotImplementedException(); + } + } + + @SuppressWarnings("unchecked") + @Given("^UEB service status is (.*)$") + public void ueb_service_status_is(String status) throws Throwable { + + Either<ApiCredential, CambriaErrorResponse> response; + switch (status) { + case "UP": + ApiCredential apiCredential = Mockito.mock(ApiCredential.class); + when(apiCredential.getApiKey()).thenReturn("MockAPIKey"); + when(apiCredential.getApiSecret()).thenReturn("MockSecretKey"); + response = Either.left(apiCredential); + break; + case "DOWN": + CambriaErrorResponse cambriaError = Mockito.mock(CambriaErrorResponse.class); + response = Either.right(cambriaError); + break; + default: + throw new NotImplementedException(); + } + when(cambriaHandler.createUebKeys(Mockito.anyList())).thenReturn(response); + } + // ############################# Given - End ############################# + + // ############################# When - Start ############################# + + @When("^handle message is activated$") + public void handle_message_is_activated() throws Throwable { + this.isSuccessful = envEngine.handleMessage(buildNotification()); + } + // ############################# When - End ############################# + + // ############################# Then - Start ############################# + @SuppressWarnings("unchecked") + @Then("^handle message activates validation of eventType (.*)$") + public void handle_message_activates_validation_of_eventType(boolean isValidated) throws Throwable { + verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isValidated))) + .validateEnvironmentType(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class), + Mockito.any(IDmaapAuditNotificationData.class)); + } + + @SuppressWarnings("unchecked") + @Then("^trying to write message to audit log and table (.*)$") + public void trying_to_write_message_to_audit_log_and_table(boolean isUnsupportedTypeEventRecorded) throws Throwable { + int count = isUnsupportedTypeEventRecorded ? 2 : 1; + verify(componentsUtils, Mockito.atLeast(count)) + .auditEnvironmentEngine(Mockito.any(AuditingActionEnum.class), Mockito.eq(operationalEnvironmentId), + Mockito.any(String.class), Mockito.any(String.class), Mockito.eq(operationalEnvironmentName), Mockito.eq(tenantContext)); + } + + @SuppressWarnings("unchecked") + @Then("^handle message activates validation of action (.*)$") + public void handle_message_activates_validation_of_action(boolean isValidated) throws Throwable { + verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isValidated))) + .validateActionType(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class)); + } + + @SuppressWarnings("unchecked") + @Then("^handle message activates validation of state (.*)$") + public void handle_message_activates_validation_of_state(boolean isValidated) throws Throwable { + verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isValidated))) + .validateState(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class)); + } + + @SuppressWarnings("unchecked") + @Then("^trying to save in-progress record (.*)$") + public void trying_to_save_in_progress_record(boolean isActivated) throws Throwable { + verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated))) + .saveEntryWithInProgressStatus(Mockito.any(Wrapper.class), Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class)); + } + + @SuppressWarnings("unchecked") + @Then("^trying to get environment info from A&AI API (.*)$") + public void trying_to_get_environment_info_from_AAI_AP(boolean isActivated) throws Throwable { + verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated))) + .retrieveOpEnvInfoFromAAI(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class)); + } + + @SuppressWarnings("unchecked") + @Then("^trying to retrieve Ueb Addresses From AftDme (.*)$") + public void trying_to_retrieve_ueb_addresses_from_AftDme(boolean isActivated) throws Throwable { + verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated))).discoverUebHosts( + Mockito.anyString(), Mockito.anyString()); + + } + + @SuppressWarnings("unchecked") + @Then("^trying to create Ueb keys (.*)$") + public void trying_to_create_ueb_keys(boolean isActivated) throws Throwable { + verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated))) + .createUebKeys(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class)); + } + + @Then("^trying to create Ueb Topics (.*)$") + public void trying_to_create_ueb_topics(boolean isActivated) throws Throwable { + verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated))) + .createUebTopicsForEnvironment(Mockito.any(OperationalEnvironmentEntry.class)); + } + + @Then("^handle message finished successfully (.*)$") + public void handle_message_finished_successfully(boolean isSuccessfull) throws Throwable { + Assert.assertTrue(this.isSuccessful == isSuccessfull); + } + + // ############################# Then - End ############################# + + private String buildNotification() { + String notificationTemplate = "{ \"operationalEnvironmentId\": \"%s\",\r\n" + + " \"operationalEnvironmentName\": \"%s\",\r\n" + + " \"operationalEnvironmentType\": \"%s\",\r\n" + " \"tenantContext\": \"%s\",\r\n" + + " \"workloadContext\": \"%s\",\r\n" + " \"action\": \"%s\"}"; + + String notification = String.format(notificationTemplate, operationalEnvironmentId, operationalEnvironmentName, + operationalEnvironmentType, tenantContext, workloadContext, action); + return notification; + } + + private int getNumberOfCallsToValidate(boolean isValidated) { + return isValidated ? NumberUtils.INTEGER_ONE : NumberUtils.INTEGER_ZERO; + } + +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/TestSuite.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/TestSuite.java deleted file mode 100644 index 712e16d97a..0000000000 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/TestSuite.java +++ /dev/null @@ -1,12 +0,0 @@ -package org.openecomp.sdc.be.components.distribution.engine; - -import org.junit.runner.RunWith; -import org.junit.runners.Suite; - -@RunWith(Suite.class) -@Suite.SuiteClasses( - -{ DistributionEngineInitTaskTest.class, DistributionEngineConfigTest.class, DistributionEngineHealthCheckTest.class, - VfModuleArtifactPayloadTest.class }) -public class TestSuite { // nothing -} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/rest/MsoRestClientTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/rest/MsoRestClientTest.java new file mode 100644 index 0000000000..9d0e8cd683 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/rest/MsoRestClientTest.java @@ -0,0 +1,135 @@ +package org.openecomp.sdc.be.components.distribution.engine.rest; + +import com.github.tomakehurst.wiremock.client.ResponseDefinitionBuilder; +import com.github.tomakehurst.wiremock.junit.WireMockRule; +import com.github.tomakehurst.wiremock.matching.AnythingPattern; +import com.github.tomakehurst.wiremock.matching.UrlPattern; +import fj.data.Either; +import org.apache.http.HttpHeaders; +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Test; +import org.openecomp.sdc.be.components.distribution.engine.DistributionStatusNotificationEnum; +import org.openecomp.sdc.be.components.distribution.engine.DummyDistributionConfigurationManager; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.common.http.client.api.HttpResponse; +import org.openecomp.sdc.common.http.config.*; +import org.openecomp.sdc.security.SecurityUtil; + +import static com.github.tomakehurst.wiremock.client.WireMock.*; +import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.options; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.when; + +public class MsoRestClientTest { + + private static final String MSO_HOST = "127.0.0.1"; + private static final String MSO_API_URL = "onap/mso/infra/modelDistributions/v1"; + private static final String DISTRIBUTION_ID = "1000"; + + private MSORestClient msoRestClient; + + @ClassRule + public static WireMockRule msoRestServer = new WireMockRule(options() + .dynamicPort() + .bindAddress(MSO_HOST)); + + @Before + public void setupMsoServer() throws Exception { + String encodedPw = ""; + Either<String, String> passkey = SecurityUtil.INSTANCE.decrypt(getPwd()); + if(passkey.isLeft()) { + encodedPw = passkey.left().value(); + } + else { + throw new IllegalArgumentException(passkey.right().value()); + } + + msoRestServer.resetToDefaultMappings(); + msoRestServer.stubFor(patch(urlMatching(String.format("/%s%s/(.*)", MSO_API_URL, getDistributionsUrl()))) + .withBasicAuth(getUserName(), encodedPw) + .withHeader(HttpHeaders.CONTENT_TYPE, containing("application/json")) + .withRequestBody(matchingJsonPath("$.status")) + .withRequestBody(matchingJsonPath("$.errorReason", new AnythingPattern()))//error reason is not mandatory + .willReturn(aResponse().withStatus(200))); + } + + @Before + public void setUp() throws Exception { + DummyDistributionConfigurationManager distributionEngineConfigurationMock = new DummyDistributionConfigurationManager(); + when(distributionEngineConfigurationMock.getConfigurationMock().getMsoConfig()).thenReturn(new MsoDummyConfig(msoRestServer.port())); + msoRestClient = new MSORestClient(); + } + + @Test + public void notifyDistributionComplete_emptyErrReason() throws Exception { + HttpResponse<String> response = msoRestClient.notifyDistributionComplete(DISTRIBUTION_ID, DistributionStatusNotificationEnum.DISTRIBUTION_COMPLETE_OK, ""); + assertThat(response.getStatusCode()).isEqualTo(200); + } + + private int getNumOfRetries() { + return ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getMsoConfig().getHttpClientConfig().getNumOfRetries(); + } + + @Test + public void notifyDistributionComplete_noErrReason() throws Exception { + HttpResponse<String> response = msoRestClient.notifyDistributionComplete(DISTRIBUTION_ID, DistributionStatusNotificationEnum.DISTRIBUTION_COMPLETE_OK, null); + assertThat(response.getStatusCode()).isEqualTo(200); + } + + @Test + public void notifyDistributionComplete_completeWithError() throws Exception { + HttpResponse<String> response = msoRestClient.notifyDistributionComplete(DISTRIBUTION_ID, DistributionStatusNotificationEnum.DISTRIBUTION_COMPLETE_ERROR, "my reason"); + assertThat(response.getStatusCode()).isEqualTo(200); + } + + @Test + public void testRetries() throws Exception { + int readTimeout = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getMsoConfig().getHttpClientConfig().getTimeouts().getReadTimeoutMs(); + int expectedNumOfRetries = getNumOfRetries(); + + UrlPattern msoReqUrlPattern = urlMatching(String.format("/%s%s/(.*)", MSO_API_URL, getDistributionsUrl())); + msoRestServer.stubFor(patch(msoReqUrlPattern) + .willReturn(new ResponseDefinitionBuilder().withFixedDelay(readTimeout + 1))); + HttpResponse<String> response = msoRestClient.notifyDistributionComplete(DISTRIBUTION_ID, DistributionStatusNotificationEnum.DISTRIBUTION_COMPLETE_ERROR, "my reason"); + verify(expectedNumOfRetries + 1, patchRequestedFor(msoReqUrlPattern)); + assertThat(response.getStatusCode()).isEqualTo(500); + } + + private static String getDistributionsUrl() { + return "/distributions"; + } + + private static String getUserName() { + return "asdc"; + } + + private static String getPwd() { + return "OTLEp5lfVhYdyw5EAtTUBQ=="; + } + + private static class MsoDummyConfig extends ExternalServiceConfig { + int port; + + MsoDummyConfig(int port) { + this.port = port; + + BasicAuthorization basicAuthorization = new BasicAuthorization(); + basicAuthorization.setUserName(MsoRestClientTest.getUserName()); + basicAuthorization.setPassword(getPwd()); + HttpClientConfig httpClientConfig = new HttpClientConfig(new Timeouts(500, 2000), basicAuthorization); + httpClientConfig.setNumOfRetries(getNumOfRetries()); + super.setHttpClientConfig(httpClientConfig); + + HttpRequestConfig httpRequestConfig = new HttpRequestConfig(); + httpRequestConfig.setServerRootUrl(String.format("http://%s:%s/%s", MSO_HOST, this.port, MSO_API_URL)); + httpRequestConfig.getResourceNamespaces().put(MSORestClient.DISTRIBUTIONS_RESOURCE_CONFIG_PARAM, getDistributionsUrl()); + super.setHttpRequestConfig(httpRequestConfig); + } + + int getNumOfRetries() { + return 1; + } + } + +} |