AllureContainer.groovy

 * Added setResultsVolume()

JsmDevDeployment.groovy
 * Now syncs spock reports to allure

Author: farthinder

src/main/groovy/com/eficode/devstack/container/impl/AllureContainer.groovy

@@ -1,7 +1,7 @@
 package com.eficode.devstack.container.impl
 
 import com.eficode.devstack.container.Container
-import de.gesellix.docker.remote.api.ContainerCreateRequest
+import de.gesellix.docker.remote.api.Volume
 
 class AllureContainer implements Container {
 
@@ -10,7 +10,6 @@ class AllureContainer implements Container {
     String containerImage = "frankescobar/allure-docker-service"
     String containerImageTag = "latest"
     String defaultShell = "/bin/bash"
-    String user = "2001:2001"
 
 
     AllureContainer(String dockerHost = "", String dockerCertPath = "") {
@@ -19,5 +18,10 @@ class AllureContainer implements Container {
         }
     }
 
+    void setResultsVolume(String volumeName) {
+        Volume volume = dockerClient.getOrCreateVolume(volumeName)
+        prepareVolumeMount(volume.name, "/app/allure-results", false)
+    }
+
 
 }

src/main/groovy/com/eficode/devstack/deployment/impl/JsmDevDeployment.groovy

@@ -6,8 +6,6 @@ import com.eficode.devstack.container.impl.JsmContainer
 import com.eficode.devstack.deployment.Deployment
 import com.eficode.devstack.util.DirectorySyncer
 import com.eficode.devstack.util.DockerClientDS
-import de.gesellix.docker.client.DockerClient
-import de.gesellix.docker.client.EngineResponseContent
 import de.gesellix.docker.remote.api.Volume
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -27,7 +25,9 @@ class JsmDevDeployment implements Deployment {
     Volume srcCodeVolume
 
     AllureContainer allureContainer
+    Volume jiraReportVolume
     Volume allureReportVolume
+    DirectorySyncer reportSyncer
 
     DockerClientDS dockerClient
 
@@ -42,17 +42,27 @@ class JsmDevDeployment implements Deployment {
         allureContainer.containerName = componentsPrefix + "-reporter"
         dockerClient = allureContainer.dockerClient
 
-        allureReportVolume = getOrCreateVolume( componentsPrefix+ "-reports")
+
+        allureReportVolume = dockerClient.getOrCreateVolume(componentsPrefix + "-allureReports")
+        jiraReportVolume = dockerClient.getOrCreateVolume(componentsPrefix + "-jiraReports")
         allureContainer.prepareCustomEnvVar(["CHECK_RESULTS_EVERY_SECONDS=3", "KEEP_HISTORY=1", "KEEP_HISTORY_LATEST=30"])
-        allureContainer.prepareVolumeMount(allureReportVolume.name, "/app/allure-results", false)
+        allureContainer.setResultsVolume(allureReportVolume.name)
 
 
-        srcCodeVolume = getOrCreateVolume(componentsPrefix + "-code")
+        srcCodeVolume = dockerClient.getOrCreateVolume(componentsPrefix + "-code")
+        srcSyncer = DirectorySyncer.getDuplicateContainer(dockerClient, "SrcSyncer")
         this.srcCodePaths = srcCodePaths
 
+        if (srcSyncer?.created) {
+            log.warn("Old SrcSyncer container exists, removing it before proceeding")
+            srcSyncer.stopAndRemoveContainer()
+            srcSyncer = null
+        }
+
+
         subDeployments.add(new JsmH2Deployment(jiraBaseUrl, dockerHost, dockerCertPath))
         jsmDeployment.jsmContainer.prepareVolumeMount(srcCodeVolume.name, "/var/atlassian/application-data/jira/scripts/", false)
-        jsmDeployment.jsmContainer.prepareVolumeMount(allureReportVolume.name, "/var/atlassian/application-data/jira/allure-results/", false)
+        jsmDeployment.jsmContainer.prepareVolumeMount(jiraReportVolume.name, "/var/atlassian/application-data/jira/allure-results/", false)
 
 
     }
@@ -68,40 +78,65 @@ class JsmDevDeployment implements Deployment {
 
     @Override
     ArrayList<Container> getContainers() {
-        return [srcSyncer, allureContainer, jsmContainer]
+        return [srcSyncer, allureContainer, jsmContainer, reportSyncer]
     }
 
     @Override
     void setContainers(ArrayList<Container> containers) {
         throw new InputMismatchException("Not implemented")
     }
 
-    Volume getOrCreateVolume(String volumeName) {
-        Volume volume = dockerClient.getVolumesWithName(volumeName).find { true }
-
-        if (volume) {
-            log.debug("\tFound existing volume:" + volume.name)
-        } else {
-            log.debug("\tCreating new volume $volumeName")
-            EngineResponseContent<Volume> volumeResponse = dockerClient.createVolume(volumeName)
-            volume = volumeResponse?.content
-            assert volume: "Error creating volume $volumeName, " + volumeResponse?.getStatus()?.text
-            log.debug("\t\tCreated volume:" + volume.name)
+    @Override
+    boolean stopAndRemoveDeployment() {
+
+        Volume jsmSnapshotVolume
+
+        try {
+            jsmSnapshotVolume = jsmContainer.getSnapshotVolume()
+        }catch (ignored){}
+
+
+        Boolean success = Deployment.super.stopAndRemoveDeployment()
+        if (jiraReportVolume) {
+            dockerClient.rmVolume(jiraReportVolume.name)
+        }
+        if (allureReportVolume) {
+            dockerClient.rmVolume(allureReportVolume.name)
         }
 
-        return volume
+        if (srcCodeVolume) {
+            dockerClient.rmVolume(srcCodeVolume.name)
+        }
+
+        if (jsmSnapshotVolume) {
+            dockerClient.rmVolume(jsmSnapshotVolume.name)
+        }
+
+        return success
+
     }
 
     @Override
     boolean setupDeployment() {
 
 
         srcSyncer = DirectorySyncer.createSyncToVolume(srcCodePaths, srcCodeVolume.name, "SrcSyncer", "-avh --chown=2001:2001")
+
+
+        reportSyncer = DirectorySyncer.syncBetweenVolumesAndUsers(jiraReportVolume.name, allureReportVolume.name, "1000:1000", "ReportSyncer")
+
+
         allureContainer.created ?: allureContainer.createContainer()
         allureContainer.startContainer()
 
-        jsmDeployment.setupDeployment(true, false)
 
+        jsmDeployment.setupDeployment(true, true)
+        //Change owner of the mounted volume
+        jsmContainer.runBashCommandInContainer("chown -R jira:jira /var/atlassian/application-data/jira/allure-results", 10, "root")
+
+        if (jsmDeployment.jiraRest.scriptRunnerIsInstalled()) {
+            jsmDeployment.jiraRest.deploySpockEndpoint(['com.riadalabs.jira.plugins.insight' ])
+        }
 
     }
 

src/test/groovy/com/eficode/devstack/deployment/impl/JsmDevDeploymentSpec.groovy

@@ -1,19 +1,19 @@
 package com.eficode.devstack.deployment.impl
 
+import com.eficode.atlassian.jira.remotespock.beans.responses.SpockOutputType
 import com.eficode.atlassian.jiraInstanceManager.JiraInstanceManagerRest
 import com.eficode.atlassian.jiraInstanceManager.beans.MarketplaceApp
 import com.eficode.devstack.DevStackSpec
 import de.gesellix.docker.remote.api.ContainerSummary
 import org.slf4j.LoggerFactory
 import spock.lang.Shared
 
-class JsmDevDeploymentSpec extends DevStackSpec{
+class JsmDevDeploymentSpec extends DevStackSpec {
 
     @Shared
     File srLicenseFile = new File(System.getProperty("user.home") + "/.licenses/jira/sr.license")
     @Shared
-    File jsmLicenseFile = new File(System.getProperty("user.home") +  "/.licenses/jira/jsm.license")
-
+    File jsmLicenseFile = new File(System.getProperty("user.home") + "/.licenses/jira/jsm.license")
 
 
     def setupSpec() {
@@ -36,49 +36,99 @@ class JsmDevDeploymentSpec extends DevStackSpec{
     }
 
 
-    def "Test basics"(){
+    String getSuccessfulSpockBody() {
+        return """
+        package com.eficode.atlassian.jira.jiraLocalScripts
+        
+        
+        import org.slf4j.Logger
+        import org.slf4j.LoggerFactory
+        import spock.lang.Shared
+        import spock.lang.Specification
+        
+        class JiraLocalSpockTest extends Specification {
+        
+            @Shared
+            static Logger log = LoggerFactory.getLogger(JiraLocalSpockTest.class)
+        
+        
+            def "A successful test in JiraLocalSpockTest"() {
+        
+                setup:
+        
+                log.warn("Running spock test:" + this.specificationContext.currentIteration.name)
+                expect:
+                true
+        
+                cleanup:
+                log.warn("\\tTest finished with exception:" + \$spock_feature_throwable)
+        
+            }
+        
+        
+        
+        }
+        """.stripIndent()
+    }
+
+    def "Test basics"() {
 
 
         setup:
 
         File localSrcDir = File.createTempDir()
         localSrcDir.deleteOnExit()
 
-        String baseUrl = "http://spockdev.localhost"
+        String hostName = "spockdev.localhost"
+        String baseUrl = "http://$hostName"
 
         JiraInstanceManagerRest jim = new JiraInstanceManagerRest(baseUrl)
 
 
         when:
-        JsmDevDeployment jsmDevDep= new JsmDevDeployment.Builder(baseUrl ,jsmLicenseFile.text, [localSrcDir.canonicalPath])
+        JsmDevDeployment jsmDevDep = new JsmDevDeployment.Builder(baseUrl, jsmLicenseFile.text, [localSrcDir.canonicalPath])
                 .setJsmJvmDebugPort("5005")
                 .setJsmVersion("latest")
                 .enableJsmDood()
                 .addAppToInstall(MarketplaceApp.getScriptRunnerVersion().downloadUrl, srLicenseFile.text)
                 .build()
 
-        jsmDevDep.stopAndRemoveDeployment()
-
-        ArrayList<ContainerSummary> containersBefore = getContainers()
+        
 
         jsmDevDep.setupDeployment()
         ArrayList<ContainerSummary> containersAfter = getContainers()
 
 
         then:
-        containersAfter.size() - containersBefore.size() == 3
+        containersAfter.find {it.names.toString().contains("spockdev.localhost")}
+        containersAfter.find {it.names.toString().contains("spockdev.localhost-reporter")}
+        containersAfter.find {it.names.toString().contains("ReportSyncer")}
+        containersAfter.find {it.names.toString().contains("SrcSyncer")}
 
 
         when: "Creating a file in the local synced dir"
-        File localTestFile = new File(localSrcDir, "testFile.groovy")
-        localTestFile.text = System.currentTimeMillis()
+
+        File localTestFile =  new File(localSrcDir, "com/eficode/atlassian/jira/jiraLocalScripts/JiraLocalSpockTest.groovy")
+        localTestFile.createParentDirectories()
+        localTestFile.text = getSuccessfulSpockBody()
+        sleep(2000)
 
         then: "It should be available in the container"
-        jim.getScriptrunnerFile("testFile.groovy") == localTestFile.text
+        jim.getScriptrunnerFile("com/eficode/atlassian/jira/jiraLocalScripts/JiraLocalSpockTest.groovy") == getSuccessfulSpockBody()
 
         expect:
         jsmDevDep.jsmContainer.appAppUploadEnabled
         jsmDevDep.jsmContainer.enableJvmDebug() == null
+        assert jim.isSpockEndpointDeployed(true) : "Spock endpoint was not deployed"
+
+        when:"Running spocktest"
+        jim.runSpockTest("com.eficode.atlassian.jira.jiraLocalScripts.JiraLocalSpockTest", "", SpockOutputType.AllureReport, "allure-results/")
+        sleep(2000)
+        then:
+        jsmDevDep.allureContainer.runBashCommandInContainer("ls -l /app/allure-results/")
+        assert jsmDevDep.jsmContainer.runBashCommandInContainer("ls allure-results").first().split("\n").every { reportName ->
+            jsmDevDep.allureContainer.runBashCommandInContainer("ls /app/allure-results/$reportName && echo Status: \$?").toString().contains("Status: 0")
+        } : "All Reports in JIRA container haven't been synced to Allure container"
 
 
         cleanup: