From 025301d08b061482c1f046d562bf017c8cbcfe8d Mon Sep 17 00:00:00 2001 From: ChrisC Date: Tue, 31 Jan 2017 11:40:03 +0100 Subject: Initial OpenECOMP MSO commit Change-Id: Ia6a7574859480717402cc2f22534d9973a78fa6d Signed-off-by: ChrisC --- .../mso/filesearching/LogFileSearching.java | 112 +++++ .../global_tests/ArquillianPackagerForITCases.java | 57 +++ .../mso/global_tests/IntegrationTestsSuite.java | 25 ++ .../mso/global_tests/asdc/ASDCITCase.java | 497 +++++++++++++++++++++ .../notif_emulator/DistributionClientEmulator.java | 133 ++++++ .../asdc/notif_emulator/JsonArtifactInfo.java | 102 +++++ .../JsonArtifactInfoDeserializer.java | 28 ++ .../asdc/notif_emulator/JsonNotificationData.java | 108 +++++ .../asdc/notif_emulator/JsonResourceInfo.java | 70 +++ .../JsonResourceInfoDeserializer.java | 23 + .../asdc/notif_emulator/JsonVfModuleMetaData.java | 63 +++ .../mso/global_tests/jmeter/JMeterITCase.java | 147 ++++++ .../global_tests/logging/LogsCheckerITCase.java | 88 ++++ .../mso/global_tests/soapui/SoapUiITCase.java | 298 ++++++++++++ 14 files changed, 1751 insertions(+) create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/filesearching/LogFileSearching.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/ArquillianPackagerForITCases.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/IntegrationTestsSuite.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/ASDCITCase.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/DistributionClientEmulator.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonArtifactInfo.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonArtifactInfoDeserializer.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonNotificationData.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonResourceInfo.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonResourceInfoDeserializer.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonVfModuleMetaData.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/jmeter/JMeterITCase.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/logging/LogsCheckerITCase.java create mode 100644 packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/soapui/SoapUiITCase.java (limited to 'packages/arquillian-unit-tests/src/test/java/org') diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/filesearching/LogFileSearching.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/filesearching/LogFileSearching.java new file mode 100644 index 0000000000..2321b3fff0 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/filesearching/LogFileSearching.java @@ -0,0 +1,112 @@ +package org.openecomp.mso.filesearching; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.FileWriter; +import java.io.IOException; +import java.io.PrintWriter; +import java.io.UnsupportedEncodingException; +import java.util.NoSuchElementException; +import java.util.Scanner; + +public class LogFileSearching { + + private static PrintWriter writer; + + public static void initFile(String filePath) { + if (writer == null) { + try { + // This is to reopen an existing file + writer = new PrintWriter(new FileOutputStream(filePath,true)); + } catch ( IOException e) { + System.out.println("Exception caught when trying to open the file /tmp/mso-log-checker.log to dump the result"); + e.printStackTrace(); + } + } + } + + public static void closeFile() { + if (writer != null) { + writer.close(); + writer = null; + } + } + + + public static boolean searchInFile(final String needle, final File file) throws FileNotFoundException { + Scanner logScanner = new Scanner(file); + try { + writer.println("Searching pattern " + needle + " in " + file.getAbsolutePath()); + //System.out.println("Searching pattern " + needle + " in " + file.getAbsolutePath()); + + String filedata = logScanner.useDelimiter("\\Z").next(); + + int occurrences = 0; + int index = 0; + + while (index < filedata.length() && (index = filedata.indexOf(needle, index)) >= 0) { + occurrences++; + + int separatorIndex = filedata.indexOf(System.getProperty("line.separator"), index); + if (separatorIndex >=0){ + writer.println("FOUND:" + filedata.substring(index, separatorIndex)); + //System.out.println("FOUND:" + // + filedata.substring(index, separatorIndex)); + } else { + writer.println("FOUND:" + filedata.substring(index, filedata.length()-1)); + //System.out.println("FOUND:" + // + filedata.substring(index, filedata.length()-1)); + } + index += needle.length(); + } + writer.println("TOTAL:" + occurrences + " FOUND"); + //System.out.println("TOTAL:" + occurrences + " FOUND"); + if (occurrences > 0) { + + return true; + } else { + + return false; + } + } catch (NoSuchElementException e) { + writer.println("TOTAL:0 FOUND"); + //System.out.println("TOTAL:0 FOUND"); + return false; + } finally { + logScanner.close(); + } + } + + public static boolean searchInDirectory(final String needle, final File directory) throws FileNotFoundException { + + boolean res = false; + String[] dirFiles = directory.list(); + + if (dirFiles != null) { + + for (String dir : dirFiles) { + res = res || searchInDirectory(needle, new File(directory.getAbsolutePath() + "/" + dir)); + } + + } else { + return LogFileSearching.searchInFile(needle, directory); + } + return res; + } + + public static boolean searchInDirectoryForCommonIssues(final String[] needles, final File directory) throws FileNotFoundException { + String[] defaultPatternsToUse = {"ClassNotFound","NullPointer","RuntimeException","IllegalStateException","FATAL"}; + + if (needles != null && needles.length>0) { + defaultPatternsToUse=needles; + } + + boolean returnValue=false; + for (String needle:defaultPatternsToUse) { + returnValue |= LogFileSearching.searchInDirectory(needle,directory); + } + + return returnValue; + } +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/ArquillianPackagerForITCases.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/ArquillianPackagerForITCases.java new file mode 100644 index 0000000000..9b80d25e47 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/ArquillianPackagerForITCases.java @@ -0,0 +1,57 @@ +package org.openecomp.mso.global_tests; + +import java.io.File; +import java.io.IOException; +import java.nio.file.DirectoryStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Iterator; + +import org.jboss.shrinkwrap.api.Archive; +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.spec.EnterpriseArchive; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import org.jboss.shrinkwrap.api.spec.WebArchive; + +public class ArquillianPackagerForITCases { + + public static Archive createPackageFromExistingOne(String path, String globPattern, String newPackageName) { + Path dir = Paths.get(path); + + try (DirectoryStream stream = Files.newDirectoryStream(dir, globPattern)) { + Iterator it = stream.iterator(); + if (it.hasNext()) { + + if (newPackageName.endsWith(".war")) { + File archive = it.next().toFile(); + WebArchive webArchive = ShrinkWrap.create(WebArchive.class, newPackageName); + webArchive.merge((ShrinkWrap.createFromZipFile(WebArchive.class, archive))); + return webArchive; + } else if (newPackageName.endsWith(".jar")) { + File archive = it.next().toFile(); + JavaArchive javaArchive = ShrinkWrap.create(JavaArchive.class, newPackageName); + javaArchive.merge((ShrinkWrap.createFromZipFile(JavaArchive.class, archive))); + return javaArchive; + } else if (newPackageName.endsWith(".ear")) { + File archive = it.next().toFile(); + EnterpriseArchive earArchive = ShrinkWrap.create(EnterpriseArchive.class, newPackageName); + earArchive.merge((ShrinkWrap.createFromZipFile(EnterpriseArchive.class, archive))); + return earArchive; + } else { + return null; + } + + } else { + return null; + } + + } catch (IOException e) { + e.printStackTrace(); + return null; + } + + } + + +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/IntegrationTestsSuite.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/IntegrationTestsSuite.java new file mode 100644 index 0000000000..a1fa04dd01 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/IntegrationTestsSuite.java @@ -0,0 +1,25 @@ +package org.openecomp.mso.global_tests; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +//import org.openecomp.mso.global_tests.appc.AppCAdapterITCase; +import org.openecomp.mso.global_tests.asdc.ASDCITCase; +import org.openecomp.mso.global_tests.logging.LogsCheckerITCase; +import org.openecomp.mso.global_tests.soapui.SoapUiITCase; + + +@RunWith(Suite.class) +@SuiteClasses({ + +// MSOUiITCase.class, +// AppCAdapterITCase.class, + SoapUiITCase.class, + ASDCITCase.class, + LogsCheckerITCase.class + +}) +public class IntegrationTestsSuite { + +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/ASDCITCase.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/ASDCITCase.java new file mode 100644 index 0000000000..47b261afd6 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/ASDCITCase.java @@ -0,0 +1,497 @@ +package org.openecomp.mso.global_tests.asdc; + +import static org.junit.Assert.*; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.Method; +import java.net.URISyntaxException; +import java.security.NoSuchAlgorithmException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.jboss.arquillian.container.test.api.Deployment; +import org.jboss.arquillian.container.test.api.OperateOnDeployment; +import org.jboss.arquillian.container.test.api.Testable; +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.shrinkwrap.api.Archive; +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import org.jboss.shrinkwrap.api.spec.WebArchive; +import org.jboss.shrinkwrap.resolver.api.maven.Maven; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.AfterClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +import org.openecomp.sdc.api.consumer.IDistributionStatusMessage; +import org.openecomp.sdc.api.notification.IArtifactInfo; +import org.openecomp.sdc.api.notification.IResourceInstance; +import org.openecomp.sdc.api.notification.IVfModuleMetadata; +import org.openecomp.sdc.utils.DistributionStatusEnum; +import org.openecomp.mso.asdc.client.ASDCConfiguration; +import org.openecomp.mso.asdc.client.ASDCController; +import org.openecomp.mso.asdc.client.exceptions.ASDCControllerException; +import org.openecomp.mso.asdc.client.exceptions.ASDCParametersException; +import org.openecomp.mso.asdc.client.exceptions.ArtifactInstallerException; +import org.openecomp.mso.db.catalog.CatalogDatabase; +import org.openecomp.mso.db.catalog.beans.HeatEnvironment; +import org.openecomp.mso.db.catalog.beans.HeatFiles; +import org.openecomp.mso.db.catalog.beans.HeatTemplate; +import org.openecomp.mso.db.catalog.beans.Service; +import org.openecomp.mso.db.catalog.beans.VfModule; +import org.openecomp.mso.db.catalog.beans.VnfResource; +import org.openecomp.mso.global_tests.ArquillianPackagerForITCases; +import org.openecomp.mso.global_tests.asdc.notif_emulator.DistributionClientEmulator; +import org.openecomp.mso.global_tests.asdc.notif_emulator.JsonNotificationData; + +@RunWith(Arquillian.class) +public class ASDCITCase { + + /** + * Add the resources in the right folder of a jar + * @param jar The jarArchive + * @param dir The main dir containing things that must be added + * @throws Exception In case of issues with the files + */ + private static void addFiles(JavaArchive jar, File dir,String destFolder) throws Exception { + + if (!dir.isDirectory()) { + throw new Exception("not a directory"); + } + for (File f : dir.listFiles()) { + + + if (f.isFile()) { + jar.addAsResource(f, destFolder + "/" + f.getName()); + } else { + + addFiles(jar, f, destFolder+"/"+f.getName()); + } + } + } + + @Deployment(name="asdc-controller",testable=true) + public static Archive createAsdcControllerWarDeployment () throws Exception { + System.out.println("Deploying ASDC Controller WAR with additional resources on default server"); + + WebArchive warArchive = (WebArchive)ArquillianPackagerForITCases.createPackageFromExistingOne("../../asdc-controller/target/", "asdc-controller*.war", "asdc-controller.war"); + + // Add the current test class + JavaArchive testclasses = ShrinkWrap.create (JavaArchive.class, "testClasses.jar"); + + testclasses.addPackage("org.openecomp.mso.global_tests.asdc.notif_emulator"); + + addFiles(testclasses,new File(Thread.currentThread().getContextClassLoader().getResource("resource-examples/asdc").getFile()),"resource-examples/asdc"); + + System.out.println(testclasses.toString(true)); + warArchive.addAsLibraries(testclasses); + + + + // BE CAREFUL a settings.xml file must be located in ${home.user}/.m2/settings.xml + warArchive.addAsLibraries(Maven.resolver() + .resolve("org.mockito:mockito-all:1.10.19") + .withoutTransitivity () + .asFile ()); + + //warArchive.addPackage("org.openecomp.mso.global_tests.asdc.notif_emulator"); + //addFiles(warArchive,new File(ASDCITCase.class.getClassLoader().getResource("resource-examples").getPath()),"resource-examples"); + + // Take one war randomly to make arquilian happy + Testable.archiveToTest(warArchive); + + + System.out.println(warArchive.toString(true)); + + return warArchive; + } + + @BeforeClass + public static final void waitBeforeStart() throws InterruptedException, + IOException, + URISyntaxException, + NoSuchAlgorithmException { + System.out.println("Executing " + ASDCITCase.class.getName()); + } + + @AfterClass + public static final void waitAfterStart() throws InterruptedException, + IOException, + URISyntaxException, + NoSuchAlgorithmException { + System.out.println("Waiting 60000ms " + ASDCITCase.class.getName()); + Thread.sleep(60000); + } + + /** + * Be careful when using that notification fake structure, the UUID of notif artifacts MUST be different. + * There is a static Map behind the scene. + */ + private JsonNotificationData notifDataWithoutModuleInfo; + private DistributionClientEmulator distribClientWithoutModuleInfo; + + private JsonNotificationData notifDataV1, notifDataV2, notifDataV3, notifDataV4, notifDataV5,notifDataDNS,notifDataVFW; + private DistributionClientEmulator distribClientV1, distribClientV2, distribClientV3, distribClientV4, distribClientV5, distribClientV1ForSameNotif, distribClientDNS,distribClientVFW; + + + @Before + public final void beforeEachTest() throws IOException { + + distribClientV1= new DistributionClientEmulator("/resource-examples/asdc/simpleNotif-V1"); + distribClientV1ForSameNotif= new DistributionClientEmulator("/resource-examples/asdc/simpleNotif-V1"); + notifDataV1 = JsonNotificationData.instantiateNotifFromJsonFile("/resource-examples/asdc/simpleNotif-V1"); + + // This is a duplicate in version 2 of the version 1 + distribClientV2= new DistributionClientEmulator("/resource-examples/asdc/simpleNotif-V2"); + notifDataV2 = JsonNotificationData.instantiateNotifFromJsonFile("/resource-examples/asdc/simpleNotif-V2"); + + distribClientV3= new DistributionClientEmulator("/resource-examples/asdc/simpleNotif-V3"); + notifDataV3 = JsonNotificationData.instantiateNotifFromJsonFile("/resource-examples/asdc/simpleNotif-V3"); + + // This is a duplicate in version 4 of the version 3 + distribClientV4= new DistributionClientEmulator("/resource-examples/asdc/simpleNotif-V4"); + notifDataV4 = JsonNotificationData.instantiateNotifFromJsonFile("/resource-examples/asdc/simpleNotif-V4"); + + // This notification is to test the deployment of volume with nested + an artifact not used (should send notification with DEPLOY_ERROR + distribClientV5= new DistributionClientEmulator("/resource-examples/asdc/simpleNotif-V5"); + notifDataV5 = JsonNotificationData.instantiateNotifFromJsonFile("/resource-examples/asdc/simpleNotif-V5"); + + + distribClientWithoutModuleInfo= new DistributionClientEmulator("/resource-examples/asdc/notif-without-modules-metadata"); + notifDataWithoutModuleInfo = JsonNotificationData.instantiateNotifFromJsonFile("/resource-examples/asdc/notif-without-modules-metadata"); + + + distribClientDNS= new DistributionClientEmulator("/resource-examples/asdc/demo-dns-V1"); + notifDataDNS = JsonNotificationData.instantiateNotifFromJsonFile("/resource-examples/asdc/demo-dns-V1"); + + + distribClientVFW= new DistributionClientEmulator("/resource-examples/asdc/demo-vfw-V1"); + notifDataVFW = JsonNotificationData.instantiateNotifFromJsonFile("/resource-examples/asdc/demo-vfw-V1"); + + + } + + @Test + @OperateOnDeployment("asdc-controller") + public void testNotifWithoutModuleInfo () throws NoSuchAlgorithmException, + IOException, + URISyntaxException, + ArtifactInstallerException, ASDCControllerException, ASDCParametersException { + + + + ASDCController asdcController = new ASDCController("asdc-controller1", distribClientWithoutModuleInfo); + asdcController.initASDC(); + asdcController.treatNotification(notifDataWithoutModuleInfo); + + assertTrue(distribClientWithoutModuleInfo.getDistributionMessageReceived().size() > 0); + + int badDeployment=0; + for (IDistributionStatusMessage message:distribClientWithoutModuleInfo.getDistributionMessageReceived()) { + System.out.println("Message received, URL:"+message.getArtifactURL()+", Value:"+message.getStatus().name()); + if(message.getStatus().equals(DistributionStatusEnum.DEPLOY_ERROR)) { + badDeployment++; + } + } + assertTrue(badDeployment == 3); + + // Check if something has been recorder in DB, as it should not + CatalogDatabase catalogDB = new CatalogDatabase(); + + HeatTemplate heatTemplate = catalogDB.getHeatTemplate("Whot-nimbus-oam_v1.0.yaml", "1.0", "resourceName-1"); + assertNull(heatTemplate); + } + + private void validateVnfResource(JsonNotificationData inputNotification,List moduleList) { + + CatalogDatabase catalogDB = new CatalogDatabase(); + + + for (IResourceInstance resource:inputNotification.getResources()) { + VnfResource vnfResourceDB = catalogDB.getVnfResource(inputNotification.getServiceName()+"/"+resource.getResourceInstanceName(), inputNotification.getServiceVersion()); + assertNotNull(vnfResourceDB); + + assertTrue(vnfResourceDB.getAsdcUuid().equals(resource.getResourceUUID())); + assertTrue(vnfResourceDB.getDescription().equals(inputNotification.getServiceDescription())); + assertTrue(vnfResourceDB.getModelInvariantUuid().equals(resource.getResourceInvariantUUID())); + assertTrue(vnfResourceDB.getModelVersion().equals(resource.getResourceVersion())); + assertTrue(vnfResourceDB.getOrchestrationMode().equals("HEAT")); + assertTrue(vnfResourceDB.getVersion().equals(inputNotification.getServiceVersion())); + assertTrue(vnfResourceDB.getVnfType().equals(inputNotification.getServiceName()+"/"+resource.getResourceInstanceName())); + assertTrue(vnfResourceDB.getModelCustomizationName().equals(resource.getResourceInstanceName())); + assertTrue(vnfResourceDB.getModelName().equals(resource.getResourceName())); + assertTrue(vnfResourceDB.getServiceModelInvariantUUID().equals(inputNotification.getServiceInvariantUUID())); + + for (IVfModuleMetadata module:moduleList) { + + VfModule vfModuleDB = catalogDB.getVfModuleModelName(module.getVfModuleModelName(),inputNotification.getServiceVersion()); + assertNotNull(vfModuleDB); + assertTrue(module.getVfModuleModelName().equals(vfModuleDB.getModelName())); + + assertTrue((inputNotification.getServiceName()+"/"+resource.getResourceInstanceName()+"::"+vfModuleDB.getModelName()).equals(vfModuleDB.getType())); + assertTrue(vnfResourceDB.getId()!=0); + assertNotNull(vfModuleDB.getVnfResourceId()); + + assertTrue(vnfResourceDB.getId()==vfModuleDB.getVnfResourceId().intValue()); + + for (String artifactUUID:module.getArtifacts()) { + IArtifactInfo artifact = null; + for (IArtifactInfo artifactTemp:resource.getArtifacts()) { + if (artifactTemp.getArtifactUUID().equals(artifactUUID)) { + artifact = artifactTemp; + break; + } + } + assertNotNull(artifact); + + switch (artifact.getArtifactType()) { + case ASDCConfiguration.HEAT: + HeatTemplate heatTemplateDB= catalogDB.getHeatTemplate(vfModuleDB.getTemplateId()); + assertNotNull(heatTemplateDB); + assertTrue(heatTemplateDB.getAsdcResourceName().equals(resource.getResourceName())); + assertTrue(heatTemplateDB.getAsdcUuid().equals(artifact.getArtifactUUID())); + assertTrue(heatTemplateDB.getDescription().equals(artifact.getArtifactDescription())); + assertTrue(heatTemplateDB.getTemplateBody() != null && !heatTemplateDB.getTemplateBody().isEmpty()); + assertTrue(heatTemplateDB.getParameters().size()>0); + + assertTrue(heatTemplateDB.getTemplateName().equals(artifact.getArtifactName())); + + if (artifact.getArtifactTimeout() != null) { + assertTrue(heatTemplateDB.getTimeoutMinutes()== artifact.getArtifactTimeout().intValue()); + } else { + assertTrue(heatTemplateDB.getTimeoutMinutes()== 240); + } + assertTrue(heatTemplateDB.getVersion().equals(artifact.getArtifactVersion())); + + assertFalse(heatTemplateDB.getTemplateBody().contains("file:///")); + break; + case ASDCConfiguration.HEAT_ENV: + + HeatEnvironment heatEnvironmentDB = catalogDB.getHeatEnvironment(artifact.getArtifactName(), artifact.getArtifactVersion(), inputNotification.getServiceName()+"/"+resource.getResourceInstanceName()); + + assertNotNull(heatEnvironmentDB); + assertTrue((vfModuleDB.getVolEnvironmentId() != null && vfModuleDB.getVolEnvironmentId().intValue() == heatEnvironmentDB.getId()) + || (vfModuleDB.getEnvironmentId() != null && vfModuleDB.getEnvironmentId() == heatEnvironmentDB.getId())); + + assertTrue(heatEnvironmentDB.getAsdcResourceName().equals(inputNotification.getServiceName()+"/"+resource.getResourceInstanceName())); + + assertTrue(heatEnvironmentDB.getAsdcUuid().equals(artifact.getArtifactUUID())); + assertTrue(heatEnvironmentDB.getDescription().equals(artifact.getArtifactDescription())); + assertTrue(heatEnvironmentDB.getVersion().equals(artifact.getArtifactVersion())); + assertTrue(heatEnvironmentDB.getName().equals(artifact.getArtifactName())); + assertTrue(heatEnvironmentDB.getEnvironment() != null); + assertFalse(heatEnvironmentDB.getEnvironment().contains("file:///")); + + break; + case ASDCConfiguration.HEAT_NESTED: + Map listNestedDBMainHeat=new HashMap(); + Map listNestedDBVolHeat=new HashMap(); + + if (vfModuleDB.getTemplateId() != null) { + listNestedDBMainHeat = catalogDB.getNestedTemplates(vfModuleDB.getTemplateId()); + } + if (vfModuleDB.getVolTemplateId() != null) { + listNestedDBVolHeat = catalogDB.getNestedTemplates(vfModuleDB.getVolTemplateId()); + } + + assertTrue(listNestedDBMainHeat.size() > 0 || listNestedDBVolHeat.size() > 0); + + + assertTrue(listNestedDBMainHeat.get(artifact.getArtifactName()) != null + || listNestedDBVolHeat.get(artifact.getArtifactName()) != null); + + HeatTemplate rightNestedTemplateDB = catalogDB.getHeatTemplate(artifact.getArtifactName(), artifact.getArtifactVersion(), resource.getResourceName()); + assertNotNull(rightNestedTemplateDB); + assertTrue(catalogDB.getNestedHeatTemplate(vfModuleDB.getTemplateId(), rightNestedTemplateDB.getId()) != null || catalogDB.getNestedHeatTemplate(vfModuleDB.getVolTemplateId(), rightNestedTemplateDB.getId()) != null); + + assertTrue(rightNestedTemplateDB.getAsdcResourceName().equals(resource.getResourceName())); + assertTrue(rightNestedTemplateDB.getAsdcUuid().equals(artifact.getArtifactUUID())); + assertTrue(rightNestedTemplateDB.getDescription().equals(artifact.getArtifactDescription())); + assertTrue(rightNestedTemplateDB.getTemplateBody() != null && !rightNestedTemplateDB.getTemplateBody().isEmpty()); + assertTrue(rightNestedTemplateDB.getTemplateName().equals(artifact.getArtifactName())); + + if (artifact.getArtifactTimeout() != null) { + assertTrue(rightNestedTemplateDB.getTimeoutMinutes()== artifact.getArtifactTimeout().intValue()); + } else { + assertTrue(rightNestedTemplateDB.getTimeoutMinutes()== 240); + } + assertTrue(rightNestedTemplateDB.getVersion().equals(artifact.getArtifactVersion())); + assertFalse(rightNestedTemplateDB.getTemplateBody().contains("file:///")); + + break; + case ASDCConfiguration.HEAT_VOL: + HeatTemplate heatTemplateVolDB = catalogDB.getHeatTemplate(vfModuleDB.getVolTemplateId()); + assertNotNull(heatTemplateVolDB); + + assertTrue(heatTemplateVolDB.getAsdcResourceName().equals(resource.getResourceName())); + assertTrue(heatTemplateVolDB.getAsdcUuid().equals(artifact.getArtifactUUID())); + assertTrue(heatTemplateVolDB.getDescription().equals(artifact.getArtifactDescription())); + assertTrue(heatTemplateVolDB.getTemplateBody() != null && !heatTemplateVolDB.getTemplateBody().isEmpty()); + assertTrue(heatTemplateVolDB.getTemplateName().equals(artifact.getArtifactName())); + + if (artifact.getArtifactTimeout() != null) { + assertTrue(heatTemplateVolDB.getTimeoutMinutes()== artifact.getArtifactTimeout().intValue()); + } else { + assertTrue(heatTemplateVolDB.getTimeoutMinutes()== 240); + } + assertTrue(heatTemplateVolDB.getVersion().equals(artifact.getArtifactVersion())); + assertFalse(heatTemplateVolDB.getTemplateBody().contains("file:///")); + + break; + case ASDCConfiguration.HEAT_ARTIFACT: + Map heatFilesDB= catalogDB.getHeatFilesForVfModule(vfModuleDB.getId()); + assertTrue(heatFilesDB.size()>0); + HeatFiles rightHeatFilesDB=heatFilesDB.get( artifact.getArtifactName()); + assertNotNull(rightHeatFilesDB); + + assertTrue(rightHeatFilesDB.getAsdcResourceName().equals(resource.getResourceName())); + assertTrue(rightHeatFilesDB.getAsdcUuid().equals(artifact.getArtifactUUID())); + assertTrue(rightHeatFilesDB.getDescription().equals(artifact.getArtifactDescription())); + assertTrue(rightHeatFilesDB.getFileBody() != null && !rightHeatFilesDB.getFileBody().isEmpty()); + assertTrue(rightHeatFilesDB.getFileName().equals( artifact.getArtifactName())); + assertTrue(rightHeatFilesDB.getVersion().equals(artifact.getArtifactVersion())); + + break; + default: + break; + + } + } + + } + + } + + Service service = catalogDB.getServiceByUUID(inputNotification.getServiceUUID()); + assertNotNull(service); + assertTrue(service.getCreated() !=null && service.getCreated().getTime()>0); + assertTrue(service.getDescription().equals(inputNotification.getServiceDescription())); + assertTrue(service.getId()>0); + assertTrue(service.getModelInvariantUUID().equals(inputNotification.getServiceInvariantUUID())); + assertTrue(service.getServiceName().equals(inputNotification.getServiceName())); + assertTrue(service.getServiceNameVersionId().equals(inputNotification.getServiceUUID())); + assertTrue(service.getVersion().equals(inputNotification.getServiceVersion())); + + } + + @Test + @OperateOnDeployment("asdc-controller") + public void testNotifsDeployment () throws NoSuchAlgorithmException, + IOException, + URISyntaxException, + ArtifactInstallerException, ASDCControllerException, ASDCParametersException { + + + + ASDCController asdcControllerV1 = new ASDCController("asdc-controller1", distribClientV1); + asdcControllerV1.initASDC(); + asdcControllerV1.treatNotification(notifDataV1); + + assertTrue(distribClientV1.getDistributionMessageReceived().size() > 0); + for (IDistributionStatusMessage message:distribClientV1.getDistributionMessageReceived()) { + System.out.println("Message received, URL:"+message.getArtifactURL()+", Value:"+message.getStatus().name()); + assertTrue(message.getStatus().equals(DistributionStatusEnum.DEPLOY_OK) || message.getStatus().equals(DistributionStatusEnum.DOWNLOAD_OK)); + } + + this.validateVnfResource(notifDataV1,distribClientV1.getListVFModuleMetaData()); + + + + // Try again to load the same notif + ASDCController asdcControllerNewNotif = new ASDCController("asdc-controller1", distribClientV1ForSameNotif); + asdcControllerNewNotif.initASDC(); + asdcControllerNewNotif.treatNotification(notifDataV1); + + for (IDistributionStatusMessage message:distribClientV1ForSameNotif.getDistributionMessageReceived()) { + System.out.println("Message received, URL:"+message.getArtifactURL()+", Value:"+message.getStatus().name()); + assertTrue(message.getStatus().equals(DistributionStatusEnum.ALREADY_DEPLOYED) || message.getStatus().equals(DistributionStatusEnum.ALREADY_DOWNLOADED)); + } + + + // Try again to load same notif but in V2 + ASDCController asdcControllerV2 = new ASDCController("asdc-controller1", distribClientV2); + asdcControllerV2.initASDC(); + asdcControllerV2.treatNotification(notifDataV2); + + for (IDistributionStatusMessage message:distribClientV2.getDistributionMessageReceived()) { + System.out.println("Message received, URL:"+message.getArtifactURL()+", Value:"+message.getStatus().name()); + assertTrue(message.getStatus().equals(DistributionStatusEnum.DEPLOY_OK) || message.getStatus().equals(DistributionStatusEnum.DOWNLOAD_OK)); + } + + this.validateVnfResource(notifDataV2,distribClientV2.getListVFModuleMetaData()); + + + // Try again to load same notif + Script + Volume artifacts and in service V3 + ASDCController asdcControllerV3 = new ASDCController("asdc-controller1", distribClientV3); + asdcControllerV3.initASDC(); + asdcControllerV3.treatNotification(notifDataV3); + + for (IDistributionStatusMessage message:distribClientV3.getDistributionMessageReceived()) { + System.out.println("Message received, URL:"+message.getArtifactURL()+", Value:"+message.getStatus().name()); + assertTrue(message.getStatus().equals(DistributionStatusEnum.DEPLOY_OK) || message.getStatus().equals(DistributionStatusEnum.DOWNLOAD_OK)); + } + + this.validateVnfResource(notifDataV3,distribClientV3.getListVFModuleMetaData()); + + // Try again to load same notif + Script + Volume artifacts and in service V4 + ASDCController asdcControllerV4 = new ASDCController("asdc-controller1", distribClientV4); + asdcControllerV4.initASDC(); + asdcControllerV4.treatNotification(notifDataV4); + + for (IDistributionStatusMessage message:distribClientV4.getDistributionMessageReceived()) { + System.out.println("Message received, URL:"+message.getArtifactURL()+", Value:"+message.getStatus().name()); + assertTrue(message.getStatus().equals(DistributionStatusEnum.DEPLOY_OK) || message.getStatus().equals(DistributionStatusEnum.DOWNLOAD_OK)); + } + + this.validateVnfResource(notifDataV4,distribClientV4.getListVFModuleMetaData()); + + + // Try again with service V5 (Nested template attached to Volume + HEat artifact not used by module), + //this should force the notification DEPLOY_ERROR to be sent for this artifact + ASDCController asdcControllerV5 = new ASDCController("asdc-controller1", distribClientV5); + asdcControllerV5.initASDC(); + asdcControllerV5.treatNotification(notifDataV5); + + for (IDistributionStatusMessage message:distribClientV5.getDistributionMessageReceived()) { + System.out.println("Message received, URL:"+message.getArtifactURL()+", Value:"+message.getStatus().name()); + if ("cloud-nimbus.sh".equals(message.getArtifactURL())) { + assertTrue(message.getStatus().equals(DistributionStatusEnum.DEPLOY_ERROR) || message.getStatus().equals(DistributionStatusEnum.DOWNLOAD_OK)); + } else { + assertTrue(message.getStatus().equals(DistributionStatusEnum.DEPLOY_OK) || message.getStatus().equals(DistributionStatusEnum.DOWNLOAD_OK)); + } + } + + this.validateVnfResource(notifDataV5,distribClientV5.getListVFModuleMetaData()); + + + // Try again with demo DNS + ASDCController asdcControllerDNS = new ASDCController("asdc-controller1", distribClientDNS); + asdcControllerDNS.initASDC(); + asdcControllerDNS.treatNotification(notifDataDNS); + + for (IDistributionStatusMessage message:distribClientDNS.getDistributionMessageReceived()) { + System.out.println("Message received, URL:"+message.getArtifactURL()+", Value:"+message.getStatus().name()); + assertTrue(message.getStatus().equals(DistributionStatusEnum.DEPLOY_OK) || message.getStatus().equals(DistributionStatusEnum.DOWNLOAD_OK)); + } + + this.validateVnfResource(notifDataDNS,distribClientDNS.getListVFModuleMetaData()); + + // Try again with demo VFW + ASDCController asdcControllerVFW = new ASDCController("asdc-controller1", distribClientVFW); + asdcControllerVFW.initASDC(); + asdcControllerVFW.treatNotification(notifDataVFW); + + for (IDistributionStatusMessage message : distribClientVFW.getDistributionMessageReceived()) { + System.out.println("Message received, URL:" + message.getArtifactURL() + ", Value:" + message.getStatus().name()); + assertTrue(message.getStatus().equals(DistributionStatusEnum.DEPLOY_OK) + || message.getStatus().equals(DistributionStatusEnum.DOWNLOAD_OK)); + } + + this.validateVnfResource(notifDataVFW, distribClientVFW.getListVFModuleMetaData()); + + } +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/DistributionClientEmulator.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/DistributionClientEmulator.java new file mode 100644 index 0000000000..f2fabc09ce --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/DistributionClientEmulator.java @@ -0,0 +1,133 @@ +package org.openecomp.mso.global_tests.asdc.notif_emulator; + +import java.io.IOException; +import java.io.InputStream; +import java.util.LinkedList; +import java.util.List; + +import org.apache.commons.io.IOUtils; +import org.codehaus.jackson.JsonParseException; +import org.codehaus.jackson.map.JsonMappingException; +import org.codehaus.jackson.map.ObjectMapper; +import org.codehaus.jackson.type.TypeReference; +import org.openecomp.sdc.api.IDistributionClient; +import org.openecomp.sdc.api.consumer.IConfiguration; +import org.openecomp.sdc.api.consumer.IDistributionStatusMessage; +import org.openecomp.sdc.api.consumer.INotificationCallback; +import org.openecomp.sdc.api.notification.IArtifactInfo; +import org.openecomp.sdc.api.notification.IVfModuleMetadata; +import org.openecomp.sdc.api.results.IDistributionClientDownloadResult; +import org.openecomp.sdc.api.results.IDistributionClientResult; +import org.openecomp.sdc.impl.DistributionClientDownloadResultImpl; +import org.openecomp.sdc.impl.DistributionClientResultImpl; +import org.openecomp.sdc.utils.DistributionActionResultEnum; + +public class DistributionClientEmulator implements IDistributionClient { + + private String resourcePath; + + private List listVFModuleMetaData; + + private List distributionMessageReceived = new LinkedList<>(); + + public DistributionClientEmulator(String notifFolderInResource) { + + resourcePath = notifFolderInResource; + } + + public List getDistributionMessageReceived() { + return distributionMessageReceived; + } + + @Override + public List decodeVfModuleArtifact(byte[] arg0) { + try { + listVFModuleMetaData = new ObjectMapper().readValue(arg0, new TypeReference>(){}); + return listVFModuleMetaData; + + } catch (JsonParseException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + return null; + } + + public List getListVFModuleMetaData() { + return listVFModuleMetaData; + } + + @Override + public IDistributionClientDownloadResult download (IArtifactInfo arg0) { + + + //String filename = resourcePath+"/artifacts/"+arg0.getArtifactURL(); + String filename = arg0.getArtifactURL(); + System.out.println("Emulating the download from resources files:"+filename); + InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(resourcePath+"/artifacts/"+filename); + + if (inputStream == null) { + System.out.println("InputStream is NULL for:"+filename); + } + try { + return new DistributionClientDownloadResultImpl(DistributionActionResultEnum.SUCCESS, DistributionActionResultEnum.SUCCESS.name(),arg0.getArtifactName(),IOUtils.toByteArray(inputStream)); + } catch (IOException e) { + + e.printStackTrace(); + } + return null; + } + + @Override + public IConfiguration getConfiguration() { + return null; + } + + @Override + public IDistributionClientResult init(IConfiguration arg0, INotificationCallback arg1) { + return new DistributionClientResultImpl(DistributionActionResultEnum.SUCCESS,DistributionActionResultEnum.SUCCESS.name()); + } + + @Override + public IDistributionClientResult sendDeploymentStatus(IDistributionStatusMessage arg0) { + this.distributionMessageReceived.add(arg0); + return new DistributionClientResultImpl(DistributionActionResultEnum.SUCCESS,DistributionActionResultEnum.SUCCESS.name()); + } + + @Override + public IDistributionClientResult sendDeploymentStatus(IDistributionStatusMessage arg0, String arg1) { + this.distributionMessageReceived.add(arg0); + return new DistributionClientResultImpl(DistributionActionResultEnum.SUCCESS,DistributionActionResultEnum.SUCCESS.name()); + } + + @Override + public IDistributionClientResult sendDownloadStatus(IDistributionStatusMessage arg0) { + this.distributionMessageReceived.add(arg0); + return new DistributionClientResultImpl(DistributionActionResultEnum.SUCCESS,DistributionActionResultEnum.SUCCESS.name()); + } + + @Override + public IDistributionClientResult sendDownloadStatus(IDistributionStatusMessage arg0, String arg1) { + this.distributionMessageReceived.add(arg0); + return new DistributionClientResultImpl(DistributionActionResultEnum.SUCCESS,DistributionActionResultEnum.SUCCESS.name()); + } + + @Override + public IDistributionClientResult start() { + return new DistributionClientResultImpl(DistributionActionResultEnum.SUCCESS,DistributionActionResultEnum.SUCCESS.name()); + } + + @Override + public IDistributionClientResult stop() { + return new DistributionClientResultImpl(DistributionActionResultEnum.SUCCESS,DistributionActionResultEnum.SUCCESS.name()); + + } + + @Override + public IDistributionClientResult updateConfiguration(IConfiguration arg0) { + return new DistributionClientResultImpl(DistributionActionResultEnum.SUCCESS,DistributionActionResultEnum.SUCCESS.name()); + } + +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonArtifactInfo.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonArtifactInfo.java new file mode 100644 index 0000000000..f37235bba4 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonArtifactInfo.java @@ -0,0 +1,102 @@ +package org.openecomp.mso.global_tests.asdc.notif_emulator; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import org.codehaus.jackson.annotate.JsonAnySetter; +import org.codehaus.jackson.annotate.JsonIgnore; + +import org.openecomp.sdc.api.notification.IArtifactInfo; + +public class JsonArtifactInfo implements IArtifactInfo { + + @JsonIgnore + private Map artifactsMapByUUID = new HashMap<>(); + + @JsonIgnore + private Map attributesMap = new HashMap<>(); + + public JsonArtifactInfo() { + + } + + public synchronized void addArtifactToUUIDMap (List artifactList) { + for (JsonArtifactInfo artifact:artifactList) { + artifactsMapByUUID.put(artifact.getArtifactUUID(), artifact); + } + + } + + @SuppressWarnings("unused") + @JsonAnySetter + public final void setAttribute(String attrName, Object attrValue) { + if ((null != attrName) && (!attrName.isEmpty()) && (null != attrValue) && (null != attrValue.toString())) { + this.attributesMap.put(attrName,attrValue); + } + } + + + + public Map getArtifactsMapByUUID() { + return artifactsMapByUUID; + } + + @Override + public String getArtifactChecksum() { + return (String)attributesMap.get("artifactCheckSum"); + } + + @Override + public String getArtifactDescription() { + return (String)attributesMap.get("artifactDescription"); + } + + @Override + public String getArtifactName() { + return (String)attributesMap.get("artifactName"); + } + + @Override + public Integer getArtifactTimeout() { + return (Integer)attributesMap.get("artifactTimeout"); + } + + @Override + public String getArtifactType() { + return (String)attributesMap.get("artifactType"); + } + + @Override + public String getArtifactURL() { + return (String)attributesMap.get("artifactURL"); + } + + @Override + public String getArtifactUUID() { + return (String)attributesMap.get("artifactUUID"); + } + + @Override + public String getArtifactVersion() { + return (String)attributesMap.get("artifactVersion"); + } + + @Override + public IArtifactInfo getGeneratedArtifact () { + return artifactsMapByUUID.get(attributesMap.get("generatedArtifact")); + } + + @Override + public List getRelatedArtifacts() { + List listArtifacts = new LinkedList<>(); + List uuidList = (List)attributesMap.get("relatedArtifact"); + if (uuidList != null) { + for(String uuid:uuidList) { + listArtifacts.add(artifactsMapByUUID.get(uuid)); + } + } + return listArtifacts; + } + +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonArtifactInfoDeserializer.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonArtifactInfoDeserializer.java new file mode 100644 index 0000000000..6e24accc14 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonArtifactInfoDeserializer.java @@ -0,0 +1,28 @@ +package org.openecomp.mso.global_tests.asdc.notif_emulator; + +import java.io.IOException; +import java.util.List; + +import org.codehaus.jackson.JsonParser; +import org.codehaus.jackson.JsonProcessingException; +import org.codehaus.jackson.map.DeserializationContext; +import org.codehaus.jackson.map.JsonDeserializer; +import org.codehaus.jackson.map.ObjectMapper; +import org.codehaus.jackson.type.TypeReference; + +public class JsonArtifactInfoDeserializer extends JsonDeserializer>{ + + @Override + public List deserialize(JsonParser jp, DeserializationContext ctxt) + throws IOException, JsonProcessingException { + List jsonArtifactInfoList = new ObjectMapper().readValue(jp, new TypeReference>(){}); + + // For each artifact add the list of artifact retrieved + // This could be used later to index by UUID + for (JsonArtifactInfo artifactInfo:jsonArtifactInfoList) { + artifactInfo.addArtifactToUUIDMap(jsonArtifactInfoList); + } + return jsonArtifactInfoList; + } + +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonNotificationData.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonNotificationData.java new file mode 100644 index 0000000000..02ed01d958 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonNotificationData.java @@ -0,0 +1,108 @@ +package org.openecomp.mso.global_tests.asdc.notif_emulator; + +import java.io.IOException; +import java.io.InputStream; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.codehaus.jackson.annotate.JsonAnySetter; +import org.codehaus.jackson.annotate.JsonIgnore; +import org.codehaus.jackson.annotate.JsonProperty; +import org.codehaus.jackson.map.ObjectMapper; +import org.codehaus.jackson.map.annotate.JsonDeserialize; +import org.jboss.shrinkwrap.api.exporter.FileExistsException; + +import org.openecomp.sdc.api.notification.IArtifactInfo; +import org.openecomp.sdc.api.notification.INotificationData; +import org.openecomp.sdc.api.notification.IResourceInstance; + + +public class JsonNotificationData implements INotificationData { + + @JsonIgnore + private Map attributesMap = new HashMap<>(); + + @JsonProperty("serviceArtifacts") + @JsonDeserialize(using=JsonArtifactInfoDeserializer.class) + private List serviceArtifacts; + + @JsonProperty("resources") + @JsonDeserialize(using=JsonResourceInfoDeserializer.class) + private List resourcesList; + + public JsonNotificationData() { + + } + + /** + * Method instantiate a INotificationData implementation from a JSON file. + * + * @param notifFilePath The file path in String + * @return A JsonNotificationData instance + * @throws IOException in case of the file is not readable or not accessible + */ + public static JsonNotificationData instantiateNotifFromJsonFile(String notifFilePath) throws IOException { + + InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(notifFilePath+"/notif-structure.json"); + + if (is == null) { + throw new FileExistsException("Resource Path does not exist: "+notifFilePath); + } + ObjectMapper mapper = new ObjectMapper(); + return mapper.readValue(is, JsonNotificationData.class); + } + + @SuppressWarnings("unused") + @JsonAnySetter + public final void setAttribute(String attrName, Object attrValue) { + if ((null != attrName) && (!attrName.isEmpty()) && (null != attrValue) && (null != attrValue.toString())) { + this.attributesMap.put(attrName,attrValue); + } + } + + @Override + public IArtifactInfo getArtifactMetadataByUUID(String arg0) { + return null; + } + + @Override + public String getDistributionID() { + return (String)this.attributesMap.get("distributionID"); + } + + @Override + public List getResources() { + return resourcesList; + } + + @Override + public List getServiceArtifacts() { + return this.serviceArtifacts; + } + + @Override + public String getServiceDescription() { + return (String)this.attributesMap.get("serviceDescription"); + } + + @Override + public String getServiceInvariantUUID() { + return (String)this.attributesMap.get("serviceInvariantUUID"); + } + + @Override + public String getServiceName() { + return (String)this.attributesMap.get("serviceName"); + } + + @Override + public String getServiceUUID() { + return (String)this.attributesMap.get("serviceUUID"); + } + + @Override + public String getServiceVersion() { + return (String)this.attributesMap.get("serviceVersion"); + } +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonResourceInfo.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonResourceInfo.java new file mode 100644 index 0000000000..e30bb5fcd0 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonResourceInfo.java @@ -0,0 +1,70 @@ +package org.openecomp.mso.global_tests.asdc.notif_emulator; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.codehaus.jackson.annotate.JsonAnySetter; +import org.codehaus.jackson.annotate.JsonIgnore; +import org.codehaus.jackson.annotate.JsonProperty; +import org.codehaus.jackson.map.annotate.JsonDeserialize; + +import org.openecomp.sdc.api.notification.IArtifactInfo; +import org.openecomp.sdc.api.notification.IResourceInstance; + +public class JsonResourceInfo implements IResourceInstance { + + @JsonIgnore + private Map attributesMap = new HashMap<>(); + + @JsonProperty("artifacts") + @JsonDeserialize(using=JsonArtifactInfoDeserializer.class) + private List artifacts; + + public JsonResourceInfo() { + + } + + @Override + public List getArtifacts() { + return artifacts; + } + + @Override + public String getResourceInstanceName() { + return (String)attributesMap.get("resourceInstanceName"); + } + + @Override + public String getResourceInvariantUUID() { + return (String)attributesMap.get("resourceInvariantUUID"); + } + + @Override + public String getResourceName() { + return (String)attributesMap.get("resourceName"); + } + + @Override + public String getResourceType() { + return (String)attributesMap.get("resourceType"); + } + + @Override + public String getResourceUUID() { + return (String)attributesMap.get("resourceUUID"); + } + + @Override + public String getResourceVersion() { + return (String)attributesMap.get("resourceVersion"); + } + + @SuppressWarnings("unused") + @JsonAnySetter + public final void setAttribute(String attrName, Object attrValue) { + if ((null != attrName) && (!attrName.isEmpty()) && (null != attrValue) && (null != attrValue.toString())) { + this.attributesMap.put(attrName,attrValue); + } + } +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonResourceInfoDeserializer.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonResourceInfoDeserializer.java new file mode 100644 index 0000000000..5ff92f7533 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonResourceInfoDeserializer.java @@ -0,0 +1,23 @@ +package org.openecomp.mso.global_tests.asdc.notif_emulator; + +import java.io.IOException; +import java.util.List; + +import org.codehaus.jackson.JsonParser; +import org.codehaus.jackson.JsonProcessingException; +import org.codehaus.jackson.map.DeserializationContext; +import org.codehaus.jackson.map.JsonDeserializer; +import org.codehaus.jackson.map.ObjectMapper; +import org.codehaus.jackson.type.TypeReference; + +public class JsonResourceInfoDeserializer extends JsonDeserializer>{ + + @Override + public List deserialize(JsonParser jp, DeserializationContext ctxt) + throws IOException, JsonProcessingException { + List jsonResourceInfoList = new ObjectMapper().readValue(jp, new TypeReference>(){}); + + return jsonResourceInfoList; + } + +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonVfModuleMetaData.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonVfModuleMetaData.java new file mode 100644 index 0000000000..dbf953f955 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/asdc/notif_emulator/JsonVfModuleMetaData.java @@ -0,0 +1,63 @@ +package org.openecomp.mso.global_tests.asdc.notif_emulator; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.codehaus.jackson.annotate.JsonAnySetter; +import org.codehaus.jackson.annotate.JsonIgnore; +import org.codehaus.jackson.annotate.JsonProperty; +import org.openecomp.sdc.api.notification.IVfModuleMetadata; + +public class JsonVfModuleMetaData implements IVfModuleMetadata { + + @JsonProperty("artifacts") + private List artifacts; + + @JsonIgnore + private Map attributesMap = new HashMap<>(); + + @Override + public List getArtifacts() { + return artifacts; + } + + @Override + public String getVfModuleModelDescription() { + return (String)attributesMap.get("vfModuleModelDescription"); + } + + @Override + public String getVfModuleModelInvariantUUID() { + return (String)attributesMap.get("vfModuleModelInvariantUUID"); + } + + @Override + public String getVfModuleModelName() { + return (String)attributesMap.get("vfModuleModelName"); + } + + @Override + public String getVfModuleModelUUID() { + return (String)attributesMap.get("vfModuleModelUUID"); + } + + @Override + public String getVfModuleModelVersion() { + return (String)attributesMap.get("vfModuleModelVersion"); + } + + @Override + public boolean isBase() { + return (boolean)attributesMap.get("isBase"); + } + + @SuppressWarnings("unused") + @JsonAnySetter + public final void setAttribute(String attrName, Object attrValue) { + if ((null != attrName) && (!attrName.isEmpty()) && (null != attrValue) && (null != attrValue.toString())) { + this.attributesMap.put(attrName,attrValue); + } + } + +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/jmeter/JMeterITCase.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/jmeter/JMeterITCase.java new file mode 100644 index 0000000000..ebbf657f2d --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/jmeter/JMeterITCase.java @@ -0,0 +1,147 @@ + +package org.openecomp.mso.global_tests.jmeter; + +import java.io.FileInputStream; +import java.io.IOException; +import java.lang.reflect.Method; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.nio.file.StandardCopyOption; + +import org.apache.jmeter.engine.StandardJMeterEngine; +import org.apache.jmeter.save.SaveService; +import org.apache.jmeter.util.JMeterUtils; +import org.apache.jorphan.collections.HashTree; +import org.jboss.arquillian.container.test.api.Deployment; +import org.jboss.arquillian.container.test.api.RunAsClient; +import org.jboss.arquillian.container.test.api.Testable; +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.shrinkwrap.api.Archive; +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import org.jboss.shrinkwrap.api.spec.WebArchive; +import org.jboss.shrinkwrap.resolver.api.maven.Maven; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +import org.openecomp.mso.global_tests.ArquillianPackagerForITCases; + +@RunWith(Arquillian.class) +public class JMeterITCase { + + @Deployment(name="mso-api-handler-infra",testable=false) + public static Archive createMsoApiHandlerInfraWarDeployment () { + System.out.println("Deploying ApiHandler Infra WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../mso-api-handlers/mso-api-handler-infra/target/", "mso-api-handler-infra*.war", "mso-api-handler-infra.war"); + } + + @Deployment(name="mso-vnf-adapter",testable=false) + public static Archive createMsoVnfAdapterWarDeployment () { + System.out.println("Deploying VNF Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-vnf-adapter/target/", "mso-vnf-adapter*.war", "mso-vnf-adapter.war"); + } + + @Deployment(name="mso-tenant-adapter",testable=false) + public static Archive createMsoTenantAdapterWarDeployment () { + System.out.println("Deploying Tenant Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-tenant-adapter/target/", "mso-tenant-adapter*.war", "mso-tenant-adapter.war"); + } + + @Deployment(name="mso-sdnc-adapter",testable=false) + public static Archive createMsoSdncAdapterWarDeployment () { + System.out.println("Deploying SDNC Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-sdnc-adapter/target/", "mso-sdnc-adapter*.war", "mso-sdnc-adapter.war"); + } + + @Deployment(name="mso-network-adapter",testable=false) + public static Archive createMsoNetworkAdapterWarDeployment () { + System.out.println("Deploying Network Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-network-adapter/target/", "mso-network-adapter*.war", "mso-network-adapter.war"); + } + + @Deployment(name="mso-requests-db-adapter",testable=false) + public static Archive createMsoRequestsDbAdapterWarDeployment () { + System.out.println("Deploying Requests DB Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-requests-db-adapter/target/", "mso-requests-db-adapter*.war", "mso-requests-db-adapter.war"); + } + + @Deployment(name="asdc-controller",testable=true) + public static Archive createAsdcControllerWarDeployment () { + System.out.println("Deploying ASDC Controller WAR with additional resources on default server"); + + WebArchive warArchive = (WebArchive)ArquillianPackagerForITCases.createPackageFromExistingOne("../../asdc-controller/target/", "asdc-controller*.war", "asdc-controller.war"); + + // Add the current test class + JavaArchive testclasses = ShrinkWrap.create (JavaArchive.class, "testClasses.jar"); + testclasses.addClasses(JMeterITCase.class); + + warArchive.addAsLibraries(testclasses); + + // BE CAREFUL a settings.xml file must be located in ${home.user}/.m2/settings.xml + warArchive.addAsLibraries(Maven.resolver() + .resolve("org.mockito:mockito-all:1.10.19") + .withoutTransitivity () + .asFile ()); + + // Take one war randomly to make arquilian happy + + Testable.archiveToTest(warArchive); + + + return warArchive; + } + + + @BeforeClass + public static void waitBeforeStart () throws InterruptedException { + System.out.println ("Executing " + JMeterITCase.class.getName ()); + + } + + @Test + @RunAsClient() + public void testJMeter() throws IOException { + // JMeter Engine + StandardJMeterEngine jmeter = new StandardJMeterEngine(); + + + // Initialize Properties, logging, locale, etc. + JMeterUtils.loadJMeterProperties("/tmp/apache-jmeter-2.13/bin/jmeter.properties"); + JMeterUtils.setJMeterHome("/tmp/apache-jmeter-2.13"); + JMeterUtils.initLogging();// you can comment this line out to see extra log messages of i.e. DEBUG level + JMeterUtils.initLocale(); + + // Initialize JMeter SaveService + SaveService.loadProperties(); + + // Load existing .jmx Test Plan + + FileInputStream in = new FileInputStream("./src/test/resources/JMeter/MSO-Perf.jmx"); + HashTree testPlanTree = SaveService.loadTree(in); + testPlanTree.getTree("test variables"); + in.close(); + + // Run JMeter Test + jmeter.configure(testPlanTree); + jmeter.run(); + } + + @AfterClass + public static void afterArquillianTest() { + try { + Files.move (Paths.get ("./jmeter.log"), + Paths.get ("./target/surefire-reports/jmeter.log"), + StandardCopyOption.REPLACE_EXISTING); + + /* Files.move (Paths.get ("./mso-perf.jtl"), + Paths.get ("./target/surefire-reports/mso-perf.log"), + StandardCopyOption.REPLACE_EXISTING);*/ + + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/logging/LogsCheckerITCase.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/logging/LogsCheckerITCase.java new file mode 100644 index 0000000000..68bd22205c --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/logging/LogsCheckerITCase.java @@ -0,0 +1,88 @@ +package org.openecomp.mso.global_tests.logging; + +import static org.junit.Assert.*; + +import java.io.File; +import java.io.IOException; + + +import org.jboss.arquillian.container.test.api.Deployment; +import org.jboss.arquillian.container.test.api.OperateOnDeployment; +import org.jboss.arquillian.container.test.api.RunAsClient; +import org.jboss.arquillian.container.test.api.Testable; +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.shrinkwrap.api.Archive; +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import org.jboss.shrinkwrap.api.spec.WebArchive; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +import org.openecomp.mso.filesearching.LogFileSearching; +import org.openecomp.mso.global_tests.ArquillianPackagerForITCases; + +@RunWith(Arquillian.class) +public class LogsCheckerITCase { + + + @BeforeClass + public static void waitBeforeStart () throws InterruptedException { + System.out.println ("Executing " + LogsCheckerITCase.class.getName ()); + + } + + @Deployment(name="log-check",testable=true) + public static Archive createAsdcControllerWarDeployment () throws Exception { + // Any war could be used here, we just take that one randomly + // Be careful some WAR does not work when being injected in JBOSS, probably due to Servlet conflict + System.out.println("Deploying ASDC Controller WAR for log checker"); + WebArchive warArchive = (WebArchive)ArquillianPackagerForITCases.createPackageFromExistingOne("../../asdc-controller/target/", "asdc-controller*.war", "asdc-controller.war"); + + JavaArchive testclasses = ShrinkWrap.create (JavaArchive.class, "testClasses.jar"); + + testclasses.addPackage("org.openecomp.mso.filesearching"); + + warArchive.addAsLibraries(testclasses); + + Testable.archiveToTest(warArchive); + return warArchive; + } + + @Before + public void beforeEachTest() { + LogFileSearching.initFile("/tmp/mso-log-checker.log"); + } + + @After + public void afterEachTest() { + LogFileSearching.closeFile(); + } + + @Test + @OperateOnDeployment("log-check") + public void testJbossServerLog() throws IOException { + + File serverLogs = new File("/opt/jboss/standalone/log"); + //File serverLogs = new File("/tmp/jbosslogs/server.log"); + + assertFalse(LogFileSearching.searchInDirectoryForCommonIssues(null, serverLogs)); + + } + + @Test + @OperateOnDeployment("log-check") + public void testMSOLog() throws IOException { + //File serverLogs = new File("/opt/app/mso/jboss-eap-6.2/standalone/log/server.log"); + File msoLogs = new File("/var/log/ecomp/MSO"); + + assertFalse(LogFileSearching.searchInDirectoryForCommonIssues(null, msoLogs)); + + } + + + + +} diff --git a/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/soapui/SoapUiITCase.java b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/soapui/SoapUiITCase.java new file mode 100644 index 0000000000..ac730c5787 --- /dev/null +++ b/packages/arquillian-unit-tests/src/test/java/org/openecomp/mso/global_tests/soapui/SoapUiITCase.java @@ -0,0 +1,298 @@ + +package org.openecomp.mso.global_tests.soapui; + +import static org.junit.Assert.*; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.Method; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.nio.file.StandardCopyOption; +import java.util.Map; + +import org.jboss.arquillian.container.test.api.Deployment; +import org.jboss.arquillian.container.test.api.RunAsClient; +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.shrinkwrap.api.Archive; +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.spec.WebArchive; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.FixMethodOrder; +import org.junit.runners.MethodSorters; +import org.junit.Test; +import org.junit.runner.RunWith; + +import org.openecomp.mso.global_tests.ArquillianPackagerForITCases; +import com.eviware.soapui.impl.wsdl.teststeps.WsdlTestStepResult; +import com.eviware.soapui.model.testsuite.TestAssertion; +import com.eviware.soapui.model.testsuite.TestStepResult.TestStepStatus; +import com.eviware.soapui.tools.SoapUITestCaseRunner; + +@RunWith(Arquillian.class) +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class SoapUiITCase { + + private static String jbossHost=System.getProperty("docker.hostname"); + private static String jbossPort="18080"; + + @Deployment(name="mso-api-handler-infra",testable=false) + public static Archive createMsoApiHandlerInfraWarDeployment () { + System.out.println("Deploying ApiHandler Infra WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../mso-api-handlers/mso-api-handler-infra/target/", "mso-api-handler-infra*.war", "mso-api-handler-infra.war"); + } + + @Deployment(name="mso-vnf-adapter",testable=false) + public static Archive createMsoVnfAdapterWarDeployment () { + System.out.println("Deploying VNF Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-vnf-adapter/target/", "mso-vnf-adapter*.war", "mso-vnf-adapter.war"); + } + + @Deployment(name="mso-tenant-adapter",testable=false) + public static Archive createMsoTenantAdapterWarDeployment () { + System.out.println("Deploying Tenant Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-tenant-adapter/target/", "mso-tenant-adapter*.war", "mso-tenant-adapter.war"); + } + + @Deployment(name="mso-sdnc-adapter",testable=false) + public static Archive createMsoSdncAdapterWarDeployment () { + System.out.println("Deploying SDNC Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-sdnc-adapter/target/", "mso-sdnc-adapter*.war", "mso-sdnc-adapter.war"); + } + + @Deployment(name="mso-network-adapter",testable=false) + public static Archive createMsoNetworkAdapterWarDeployment () { + System.out.println("Deploying Network Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-network-adapter/target/", "mso-network-adapter*.war", "mso-network-adapter.war"); + } + + @Deployment(name="mso-requests-db-adapter",testable=false) + public static Archive createMsoRequestsDbAdapterWarDeployment () { + System.out.println("Deploying Requests DB Adapter WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../adapters/mso-requests-db-adapter/target/", "mso-requests-db-adapter*.war", "mso-requests-db-adapter.war"); + } + + @Deployment(name="asdc-controller",testable=true) + public static Archive createAsdcControllerWarDeployment () { + System.out.println("Deploying ASDC Controller WAR with additional resources on default server"); + + WebArchive warArchive = (WebArchive)ArquillianPackagerForITCases.createPackageFromExistingOne("../../asdc-controller/target/", "asdc-controller*.war", "asdc-controller.war"); + + // Take one war randomly to make arquilian happy + + + return warArchive; + } + + @Deployment(name="gammaBPMN",testable=false) + public static Archive createGammaBPMNDeployment () { + System.out.println("Deploying Gamma BPMN WAR on default server"); + return ArquillianPackagerForITCases.createPackageFromExistingOne("../../bpmn/MSOGammaBPMN/target/", "MSOGammaBPMN*.war", "MSOGammaBPMN.war"); + } +/* + @Deployment(name = "SoapUIMocks", testable = false) + public static Archive createSoapUIMocksWarDeployment () { + + File file = new File ("src/test/resources/SoapUIMocks.war"); + + WebArchive archive = ShrinkWrap.create (WebArchive.class, "SoapUIMocks.war"); + + archive.merge ((ShrinkWrap.createFromZipFile (WebArchive.class, file))); + + return archive; + }*/ + + @BeforeClass + public static void waitBeforeStart () throws InterruptedException { + Thread.currentThread().sleep(10000); + System.out.println ("Executing " + SoapUiITCase.class.getName ()); + + } + + @Test + @RunAsClient + public void test01Healthcheck () { + SoapUITestCaseRunner runner = new SoapUITestCaseRunner (); + runner.setSettingsFile("./src/test/resources/SoapUI/soapui-settings.xml"); + runner.setJUnitReport(true); + runner.setProjectFile ("./src/test/resources/SoapUI/Healthcheck-soapui-project.xml"); + runner.setOutputFolder ("./target/surefire-reports"); + String[] properties = new String[7]; + properties[0] = "apihhost="+jbossHost+":"+jbossPort; + properties[1] = "jrahost="+jbossHost+":"+jbossPort; + properties[2] = "userlogin=sitecontrol"; + properties[3] = "userpassword=Domain2.0!"; + properties[4] = "bpmnhost="+jbossHost+":"+jbossPort; + properties[5] = "sitename=mso-docker"; + properties[6] = "enableBpmn=false"; + runner.setProjectProperties (properties); + + try { + runner.setTestSuite ("Healthcheck TestSuite"); + runner.run (); + Map mapResult= runner.getAssertionResults(); + for(Map.Entry entry : mapResult.entrySet()) { + assertTrue(entry.getValue().getStatus().equals(TestStepStatus.OK)); + } + assertTrue (runner.getFailedTests ().size () == 0); + + } catch (Exception e) { + e.printStackTrace (); + fail("Failure in SOAPUI Healthcheck"); + } + } + + @Test + @RunAsClient + public void test03StartNetworkAdapter () { + SoapUITestCaseRunner runner = new SoapUITestCaseRunner (); + runner.setSettingsFile("./src/test/resources/SoapUI/soapui-settings.xml"); + runner.setJUnitReport(true); + runner.setProjectFile ("./src/test/resources/SoapUI/MSONetworkAdapter-soapui-project.xml"); + runner.setOutputFolder ("./target/surefire-reports"); + String[] properties = new String[1]; + properties[0] = "host="+jbossHost+":"+jbossPort; + runner.setProjectProperties (properties); + + + try { + runner.setTestSuite ("MsoNetworkAdapter TestSuite"); + runner.run (); + + Map mapResult= runner.getAssertionResults(); + for(Map.Entry entry : mapResult.entrySet()) { + assertTrue(entry.getValue().getStatus().equals(TestStepStatus.OK)); + } + assertTrue (runner.getFailedTests ().size () == 0); + + } catch (Exception e) { + e.printStackTrace (); + fail("Failure in SOAPUI NetworkAdapter"); + } + } + + + @Test + @RunAsClient + public void test04StartVnfAdapter () { + SoapUITestCaseRunner runner = new SoapUITestCaseRunner (); + runner.setSettingsFile("./src/test/resources/SoapUI/soapui-settings.xml"); + runner.setJUnitReport(true); + runner.setProjectFile ("./src/test/resources/SoapUI/MSOVnfAdapter-soapui-project.xml"); + runner.setOutputFolder ("./target/surefire-reports"); + String[] properties = new String[1]; + properties[0] = "host="+jbossHost+":"+jbossPort; + runner.setProjectProperties (properties); + + try { + runner.setTestSuite ("MsoVnfAdapter TestSuite"); + runner.run (); + + Map mapResult= runner.getAssertionResults(); + for(Map.Entry entry : mapResult.entrySet()) { + assertTrue(entry.getValue().getStatus().equals(TestStepStatus.OK)); + } + assertTrue (runner.getFailedTests ().size () == 0); + + } catch (Exception e) { + e.printStackTrace (); + fail("Failure in SOAPUI VnfAdapter"); + } + } + + + @Test + @RunAsClient + public void test05StartTenantAdapter () { + SoapUITestCaseRunner runner = new SoapUITestCaseRunner (); + runner.setSettingsFile("./src/test/resources/SoapUI/soapui-settings.xml"); + runner.setJUnitReport(true); + runner.setProjectFile ("./src/test/resources/SoapUI/MSOTenantAdapter-soapui-project.xml"); + runner.setOutputFolder ("./target/surefire-reports"); + String[] properties = new String[3]; + properties[0] = "host="+jbossHost+":"+jbossPort; + properties[1] = "user-bpel=BPELClient"; + properties[2] = "password-bpel=password1$"; + runner.setProjectProperties (properties); + + try { + runner.setTestSuite ("MsoTenantAdapter TestSuite"); + runner.run (); + + Map mapResult= runner.getAssertionResults(); + for(Map.Entry entry : mapResult.entrySet()) { + assertTrue(entry.getValue().getStatus().equals(TestStepStatus.OK)); + } + assertTrue (runner.getFailedTests ().size () == 0); + + } catch (Exception e) { + e.printStackTrace (); + fail("Failure in SOAPUI TenantAdapter"); + } + } + + + @Test + @RunAsClient + public void test06StartRequestDBAdapter () { + SoapUITestCaseRunner runner = new SoapUITestCaseRunner (); + runner.setSettingsFile("./src/test/resources/SoapUI/soapui-settings.xml"); + runner.setJUnitReport(true); + runner.setProjectFile ("./src/test/resources/SoapUI/MsoRequestDB-soapui-project.xml"); + runner.setOutputFolder ("./target/surefire-reports"); + String[] properties = new String[3]; + properties[0] = "host="+jbossHost+":"+jbossPort; + properties[1] = "user-infraportal=InfraPortalClient"; + properties[2] = "password-infraportal=password1$"; + runner.setProjectProperties (properties); + + + try { + runner.setTestSuite ("MsoRequestsDbAdapterImplPortBinding TestSuite"); + runner.run (); + + Map mapResult= runner.getAssertionResults(); + for(Map.Entry entry : mapResult.entrySet()) { + assertTrue(entry.getValue().getStatus().equals(TestStepStatus.OK)); + } + assertTrue (runner.getFailedTests ().size () == 0); + + } catch (Exception e) { + e.printStackTrace (); + fail("Failure in SOAPUI RequestDB adapter"); + } + } + + @Test + @RunAsClient + public void test07MsoConfigEndpoints () { + SoapUITestCaseRunner runner = new SoapUITestCaseRunner (); + runner.setSettingsFile("./src/test/resources/SoapUI/soapui-settings.xml"); + runner.setJUnitReport(true); + runner.setProjectFile ("./src/test/resources/SoapUI/MSOConfig-soapui-project.xml"); + runner.setOutputFolder ("./target/surefire-reports"); + String[] properties = new String[3]; + properties[0] = "host="+jbossHost+":"+jbossPort; + properties[1] = "user-infraportal=InfraPortalClient"; + properties[2] = "password-infraportal=password1$"; + runner.setProjectProperties (properties); + + + try { + runner.setTestSuite ("test_config_endpoints TestSuite"); + runner.run (); + + Map mapResult= runner.getAssertionResults(); + for(Map.Entry entry : mapResult.entrySet()) { + assertTrue(entry.getValue().getStatus().equals(TestStepStatus.OK)); + } + assertTrue (runner.getFailedTests ().size () == 0); + + } catch (Exception e) { + e.printStackTrace (); + fail("Failure in SOAPUI MSOConfig Endpoints"); + } + } +} -- cgit 1.2.3-korg