Merge branch 'master' into feature/SHIBUI-950

# Conflicts:
#	backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/AbstractAttributeExtensibleXMLObject.java

Jenkinsfile

@@ -48,5 +48,8 @@ pipeline {
     success {
       emailext body: '''${SCRIPT, template="groovy-text.template"}''', recipientProviders: [[$class: 'DevelopersRecipientProvider'], [$class: 'RequesterRecipientProvider']], subject: '[SHIBUI] Build Success'
     }
+    always {
+      cleanWs()
+    }
   }
-}
+}

backend/build.gradle

@@ -46,6 +46,36 @@ configurations {
     }
 }
 
+def generatedSrcDir = new File(buildDir, 'generated/src/main/java')
+
+sourceSets {
+    main {
+        groovy {
+            srcDirs = ['src/main/groovy', 'src/main/java', generatedSrcDir]
+        }
+        java {
+            srcDirs = []
+        }
+    }
+    integrationTest {
+        groovy {
+            srcDirs = ['src/integration/groovy']
+            compileClasspath += main.output + test.output
+            runtimeClasspath += main.output + test.output
+        }
+        resources {
+            srcDir 'src/integration/resources'
+        }
+    }
+
+    enversTest {
+        groovy {
+            srcDir 'src/enversTest/groovy'
+        }
+        resources.srcDir 'src/enversTest/resources'
+    }
+}
+
 processResources.dependsOn(':ui:npm_run_buildProd')
 
 jar {
@@ -174,29 +204,14 @@ dependencies {
 
     // Envers for persistent entities versioning
     compile 'org.hibernate:hibernate-envers'
-}
 
-def generatedSrcDir = new File(buildDir, 'generated/src/main/java')
+    enversTestCompile sourceSets.main.output
+    enversTestCompile sourceSets.test.output
+    enversTestCompile configurations.compile
+    enversTestCompile configurations.testCompile
 
-sourceSets {
-    main {
-        groovy {
-            srcDirs = ['src/main/groovy', 'src/main/java', generatedSrcDir]
-        }
-        java {
-            srcDirs = []
-        }
-    }
-    integrationTest {
-        groovy {
-            srcDirs = ['src/integration/groovy']
-            compileClasspath += main.output + test.output
-            runtimeClasspath += main.output + test.output
-        }
-        resources {
-            srcDir 'src/integration/resources'
-        }
-    }
+    enversTestRuntime configurations.runtime
+    enversTestRuntime configurations.testRuntime
 }
 
 task integrationTest(type: Test) {
@@ -210,6 +225,19 @@ task integrationTest(type: Test) {
     systemProperties['user.dir'] = workingDir
 }
 
+task enversTest(type: Test) {
+    group = 'verification'
+    description = 'Run tests pertaing to envers versioning engine'
+    testClassesDirs = sourceSets.enversTest.output.classesDirs
+    classpath = sourceSets.enversTest.runtimeClasspath
+    systemProperties = System.properties
+    systemProperties['user.dir'] = workingDir
+}
+
+check {
+    dependsOn enversTest
+}
+
 task generateSources {
     inputs.dir('src/main/templates')
     inputs.files fileTree('src/main/resources') {

backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/EntityDescriptorControllerVersionEndpointsIntegrationTests.groovy

@@ -0,0 +1,118 @@
+package edu.internet2.tier.shibboleth.admin.ui.controller
+
+import edu.internet2.tier.shibboleth.admin.ui.domain.EntityDescriptor
+import edu.internet2.tier.shibboleth.admin.ui.domain.frontend.EntityDescriptorRepresentation
+import edu.internet2.tier.shibboleth.admin.ui.repository.EntityDescriptorRepository
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.boot.test.web.client.TestRestTemplate
+import org.springframework.test.context.ActiveProfiles
+import spock.lang.Specification
+
+/**
+ * @author Dmitriy Kopylenko
+ */
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@ActiveProfiles(['no-auth', 'dev'])
+class EntityDescriptorControllerVersionEndpointsIntegrationTests extends Specification {
+
+    @Autowired
+    private TestRestTemplate restTemplate
+
+    @Autowired
+    EntityDescriptorRepository entityDescriptorRepository
+
+    static BASE_URI = '/api/EntityDescriptor'
+
+    static ALL_VERSIONS_URI = "$BASE_URI/%s/Versions"
+
+    static SPECIFIC_VERSION_URI = "$BASE_URI/%s/Versions/%s"
+
+    def "GET /api/EntityDescriptor/{resourceId}/Versions with non-existent entity descriptor"() {
+        when:
+        def result = getAllEntityDescriptorVersions('non-existent-ed-id', String)
+
+        then:
+        result.statusCodeValue == 404
+    }
+
+    def "GET /api/EntityDescriptor{resourceId}/Versions with 1 entity descriptor version"() {
+        given:
+        EntityDescriptor ed = new EntityDescriptor(entityID: 'http://test/controller', createdBy: 'anonymousUser')
+        entityDescriptorRepository.save(ed)
+
+        when:
+        def result = getAllEntityDescriptorVersions(ed.resourceId, List)
+
+        then:
+        result.statusCodeValue == 200
+        result.body.size == 1
+        result.body[0].id && result.body[0].creator && result.body[0].date
+    }
+
+    def "GET /api/EntityDescriptor{resourceId}/Versions with 2 entity descriptor versions"() {
+        given:
+        EntityDescriptor ed = new EntityDescriptor(entityID: 'http://test/controller', createdBy: 'anonymousUser')
+        ed = entityDescriptorRepository.save(ed)
+        //Will created a second version for UPDATE revision
+        ed.serviceEnabled = true
+        entityDescriptorRepository.save(ed)
+
+        when:
+        def result = getAllEntityDescriptorVersions(ed.resourceId, List)
+
+        then:
+        result.statusCodeValue == 200
+        result.body.size == 2
+        result.body[0].id < result.body[1].id
+        result.body[0].date < result.body[1].date
+    }
+
+    def "GET /api/EntityDescriptor{resourceId}/Versions/{version} for non existent version"() {
+        given:
+        EntityDescriptor ed = new EntityDescriptor(entityID: 'http://test/controller', createdBy: 'anonymousUser')
+        ed = entityDescriptorRepository.save(ed)
+
+        when:
+        def result = getEntityDescriptorForVersion(ed.resourceId, '1000', EntityDescriptorRepresentation)
+
+        then:
+        result.statusCodeValue == 404
+    }
+
+    def "GET /api/EntityDescriptor{resourceId}/Versions/{version} with 2 entity descriptor versions returns correct ED for specific versions"() {
+        given:
+        EntityDescriptor ed = new EntityDescriptor(entityID: 'http://test/controller', createdBy: 'anonymousUser', serviceProviderName: 'SP1')
+        ed = entityDescriptorRepository.save(ed)
+        //Will created a second version for UPDATE revision
+        ed.serviceProviderName = 'SP2'
+        entityDescriptorRepository.save(ed)
+
+        when:
+        def allVersions = getAllEntityDescriptorVersions(ed.resourceId, List)
+        def edv1 = getEntityDescriptorForVersion(ed.resourceId, allVersions.body[0].id, EntityDescriptorRepresentation)
+        def edv2 = getEntityDescriptorForVersion(ed.resourceId, allVersions.body[1].id, EntityDescriptorRepresentation)
+
+        then:
+        edv1.statusCodeValue == 200
+        edv1.body.serviceProviderName == 'SP1'
+        edv2.statusCodeValue == 200
+        edv2.body.serviceProviderName == 'SP2'
+    }
+
+    private getAllEntityDescriptorVersions(String resourceId, responseType) {
+        this.restTemplate.getForEntity(resourceUriFor(ALL_VERSIONS_URI, resourceId), responseType)
+    }
+
+    private getEntityDescriptorForVersion(String resourceId, String version, responseType) {
+        this.restTemplate.getForEntity(resourceUriFor(SPECIFIC_VERSION_URI, resourceId, version), responseType)
+    }
+
+    private static resourceUriFor(String uriTemplate, String resourceId, String version) {
+        String.format(uriTemplate, resourceId, version)
+    }
+
+    private static resourceUriFor(String uriTemplate, String resourceId) {
+        String.format(uriTemplate, resourceId)
+    }
+}

backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolverControllerVersionEndpointsIntegrationTests.groovy

@@ -0,0 +1,121 @@
+package edu.internet2.tier.shibboleth.admin.ui.controller
+
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicHttpMetadataResolver
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FileBackedHttpMetadataResolver
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FilesystemMetadataResolver
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.LocalDynamicMetadataResolver
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver
+import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.boot.test.web.client.TestRestTemplate
+import org.springframework.test.context.ActiveProfiles
+import spock.lang.Specification
+
+/**
+ * @author Dmitriy Kopylenko
+ */
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@ActiveProfiles(['no-auth', 'dev'])
+class MetadataResolverControllerVersionEndpointsIntegrationTests extends Specification {
+
+    @Autowired
+    private TestRestTemplate restTemplate
+
+    @Autowired
+    MetadataResolverRepository repository
+
+    static BASE_URI = '/api/MetadataResolvers'
+
+    static ALL_VERSIONS_URI = "$BASE_URI/%s/Versions"
+
+    static SPECIFIC_VERSION_URI = "$BASE_URI/%s/Versions/%s"
+
+    def "GET /api/MetadataResolvers/{resourceId}/Versions with non-existent resolver"() {
+        when:
+        def result = getAllMetadataResolverVersions('non-existent-resolver-id', String)
+
+        then:
+        result.statusCodeValue == 404
+    }
+
+    def "GET /api/MetadataResolvers/{resourceId}/Versions with 1 resolver version"() {
+        given:
+        MetadataResolver mr = new LocalDynamicMetadataResolver(name: 'resolver')
+        repository.save(mr)
+
+        when:
+        def result = getAllMetadataResolverVersions(mr.resourceId, List)
+
+        then:
+        result.statusCodeValue == 200
+        result.body.size == 1
+        result.body[0].id && result.body[0].creator && result.body[0].date
+    }
+
+    def "GET /api/MetadataResolvers/{resourceId}/Versions with 2 resolver versions"() {
+        given:
+        MetadataResolver mr = new FileBackedHttpMetadataResolver(name: 'resolver')
+        mr = repository.save(mr)
+        //Will create a second version for UPDATE revision
+        mr.name = 'resolverUPDATED'
+        repository.save(mr)
+
+        when:
+        def result = getAllMetadataResolverVersions(mr.resourceId, List)
+
+        then:
+        result.statusCodeValue == 200
+        result.body.size == 2
+        result.body[0].id < result.body[1].id
+        result.body[0].date < result.body[1].date
+    }
+
+    def "GET /api/MetadataResolvers/{resourceId}/Versions/{version} for non existent version"() {
+        given:
+        MetadataResolver mr = new DynamicHttpMetadataResolver(name: 'resolver')
+        mr = repository.save(mr)
+
+        when:
+        def result = getMetadataResolverForVersion(mr.resourceId, '1000', MetadataResolver)
+
+        then:
+        result.statusCodeValue == 404
+    }
+
+    def "GET /api/MetadataResolvers/{resourceId}/Versions/{version} with 2 resolver versions returns correct resolver for specific version"() {
+        given:
+        MetadataResolver mr = new FilesystemMetadataResolver(name: 'resolver')
+        mr = repository.save(mr)
+        //Will create a second version for UPDATE revision
+        mr.name = 'resolverUPDATED'
+        repository.save(mr)
+
+        when:
+        def allVersions = getAllMetadataResolverVersions(mr.resourceId, List)
+        def mrv1 = getMetadataResolverForVersion(mr.resourceId, allVersions.body[0].id, MetadataResolver)
+        def mrv2 = getMetadataResolverForVersion(mr.resourceId, allVersions.body[1].id, MetadataResolver)
+
+        then:
+        mrv1.statusCodeValue == 200
+        mrv1.body.name == 'resolver'
+        mrv2.statusCodeValue == 200
+        mrv2.body.name == 'resolverUPDATED'
+    }
+
+    private getAllMetadataResolverVersions(String resourceId, responseType) {
+        this.restTemplate.getForEntity(resourceUriFor(ALL_VERSIONS_URI, resourceId), responseType)
+    }
+
+    private getMetadataResolverForVersion(String resourceId, String version, responseType) {
+        this.restTemplate.getForEntity(resourceUriFor(SPECIFIC_VERSION_URI, resourceId, version), responseType)
+    }
+
+    private static resourceUriFor(String uriTemplate, String resourceId, String version) {
+        String.format(uriTemplate, resourceId, version)
+    }
+
+    private static resourceUriFor(String uriTemplate, String resourceId) {
+        String.format(uriTemplate, resourceId)
+    }
+}