From 3670d579b1bdc26fe044791e7dc5972888f02977 Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Mon, 17 Jun 2019 16:00:01 -0400 Subject: [PATCH 01/11] SHIBUI-1263(1319) wip... --- ...tityDescriptorEnversVersioningTests.groovy | 4 + ...tadataResolverEnversVersioningTests.groovy | 94 +++++++++++++++++++ .../LocalDynamicMetadataResolver.java | 3 + .../envers/EnversTestsSupport.groovy | 15 ++- 4 files changed, 115 insertions(+), 1 deletion(-) create mode 100644 backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/EntityDescriptorEnversVersioningTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/EntityDescriptorEnversVersioningTests.groovy index 05e3ad139..b7f31270a 100644 --- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/EntityDescriptorEnversVersioningTests.groovy +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/EntityDescriptorEnversVersioningTests.groovy @@ -179,6 +179,10 @@ class EntityDescriptorEnversVersioningTests extends Specification { getRevisionEntityForRevisionIndex(entityDescriptorHistory, 0).timestamp > 0L getModifiedEntityNames(entityDescriptorHistory, 0).sort() == expectedModifiedPersistentEntities.sort() + + + + when: representation = new EntityDescriptorRepresentation().with { it.organization = new OrganizationRepresentation(name: 'orgUpdated', displayName: 'display org Updated', url: 'http://org2.edu') diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy new file mode 100644 index 000000000..3a6fe394b --- /dev/null +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy @@ -0,0 +1,94 @@ +package edu.internet2.tier.shibboleth.admin.ui.repository.envers + +import edu.internet2.tier.shibboleth.admin.ui.configuration.CoreShibUiConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.InternationalizationConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.SearchConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.TestConfiguration +import edu.internet2.tier.shibboleth.admin.ui.domain.* +import edu.internet2.tier.shibboleth.admin.ui.domain.frontend.* +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicMetadataResolverAttributes +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.opensaml.OpenSamlObjects +import edu.internet2.tier.shibboleth.admin.ui.repository.EntityDescriptorRepository +import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository +import edu.internet2.tier.shibboleth.admin.ui.service.EntityDescriptorService +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.autoconfigure.domain.EntityScan +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest +import org.springframework.data.jpa.repository.config.EnableJpaRepositories +import org.springframework.test.context.ContextConfiguration +import org.springframework.transaction.PlatformTransactionManager +import spock.lang.Specification + +import javax.persistence.EntityManager + +import static edu.internet2.tier.shibboleth.admin.ui.repository.envers.EnversTestsSupport.* + +/** + * Testing metadata resolver envers versioning + */ +@DataJpaTest +@ContextConfiguration(classes = [CoreShibUiConfiguration, InternationalizationConfiguration, SearchConfiguration, TestConfiguration]) +@EnableJpaRepositories(basePackages = ["edu.internet2.tier.shibboleth.admin.ui"]) +@EntityScan("edu.internet2.tier.shibboleth.admin.ui") +class MetadataResolverEnversVersioningTests extends Specification { + + @Autowired + MetadataResolverRepository metadataResolverRepository + + @Autowired + EntityManager entityManager + + @Autowired + PlatformTransactionManager txMgr + + @Autowired + OpenSamlObjects openSamlObjects + + def "test versioning of LocalDynamicMetadataResolver"() { + setup: + def expectedModifiedPersistentEntities = [LocalDynamicMetadataResolver.name] + + when: + LocalDynamicMetadataResolver resolver = new LocalDynamicMetadataResolver(name: 'ldmr').with { + it.dynamicMetadataResolverAttributes = new DynamicMetadataResolverAttributes() + it + } + def resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + LocalDynamicMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 1 + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'ldmr' + getTargetEntityForRevisionIndex(resolverHistory, 0).dynamicMetadataResolverAttributes.refreshDelayFactor == 0.75 + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + getModifiedEntityNames(resolverHistory, 0).sort() == expectedModifiedPersistentEntities.sort() + + when: + resolver.name = 'ldmr_UPDATED' + resolver.dynamicMetadataResolverAttributes.refreshDelayFactor = 1.00 + resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + LocalDynamicMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 2 + getTargetEntityForRevisionIndex(resolverHistory, 1).name == 'ldmr_UPDATED' + getTargetEntityForRevisionIndex(resolverHistory, 1).dynamicMetadataResolverAttributes.refreshDelayFactor == 1.00 + getRevisionEntityForRevisionIndex(resolverHistory, 1).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 1).timestamp > 0L + + //Check the original revision is intact + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'ldmr' + getTargetEntityForRevisionIndex(resolverHistory, 0).dynamicMetadataResolverAttributes.refreshDelayFactor == 0.75 + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + } +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/LocalDynamicMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/LocalDynamicMetadataResolver.java index 6b722803a..49cc09642 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/LocalDynamicMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/LocalDynamicMetadataResolver.java @@ -8,11 +8,14 @@ import javax.persistence.Embedded; import javax.persistence.Entity; +import org.hibernate.envers.Audited; + @Entity @EqualsAndHashCode(callSuper = true) @Getter @Setter @ToString +@Audited public class LocalDynamicMetadataResolver extends MetadataResolver { public LocalDynamicMetadataResolver() { type = "LocalDynamicMetadataResolver"; diff --git a/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/EnversTestsSupport.groovy b/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/EnversTestsSupport.groovy index ca447e7f0..2052cf9d1 100644 --- a/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/EnversTestsSupport.groovy +++ b/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/EnversTestsSupport.groovy @@ -2,7 +2,9 @@ package edu.internet2.tier.shibboleth.admin.ui.repository.envers 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.domain.resolvers.MetadataResolver import edu.internet2.tier.shibboleth.admin.ui.repository.EntityDescriptorRepository +import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository import edu.internet2.tier.shibboleth.admin.ui.service.EntityDescriptorService import org.hibernate.envers.AuditReaderFactory import org.hibernate.envers.query.AuditEntity @@ -36,10 +38,21 @@ class EnversTestsSupport { doInExplicitTransaction(txMgr) { edr.save(ed) } - getRevisionHistoryForEntityType(em, EntityDescriptor, ed.resourceId) } + static updateAndGetRevisionHistoryOfMetadataResolver(MetadataResolver mr, + MetadataResolverRepository mrr, + Class < ? > type, + PlatformTransactionManager + txMgr, EntityManager em) { + + doInExplicitTransaction(txMgr) { + mrr.save(mr) + } + getRevisionHistoryForEntityType(em, type, mr.resourceId) + } + static getRevisionHistoryForEntityType(EntityManager em, Class entityType, String resourceId) { def auditReader = AuditReaderFactory.get(em) AuditQuery auditQuery = auditReader From 9fd7eca43ca8d39b2a8b0942de86a96c65fa78fe Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Thu, 20 Jun 2019 12:01:17 -0400 Subject: [PATCH 02/11] SHIBUI-1263(1319) --- ...tadataResolverEnversVersioningTests.groovy | 117 +++++++++++++++++- .../DynamicHttpMetadataResolver.java | 1 + .../FileBackedHttpMetadataResolver.java | 4 +- .../MetadataRequestURLConstructionScheme.java | 4 + 4 files changed, 119 insertions(+), 7 deletions(-) diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy index 3a6fe394b..1cea18a62 100644 --- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy @@ -4,15 +4,14 @@ import edu.internet2.tier.shibboleth.admin.ui.configuration.CoreShibUiConfigurat import edu.internet2.tier.shibboleth.admin.ui.configuration.InternationalizationConfiguration import edu.internet2.tier.shibboleth.admin.ui.configuration.SearchConfiguration import edu.internet2.tier.shibboleth.admin.ui.configuration.TestConfiguration -import edu.internet2.tier.shibboleth.admin.ui.domain.* -import edu.internet2.tier.shibboleth.admin.ui.domain.frontend.* +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicHttpMetadataResolver import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicMetadataResolverAttributes +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FileBackedHttpMetadataResolver +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.HttpMetadataResolverAttributes 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.domain.resolvers.ReloadableMetadataResolverAttributes import edu.internet2.tier.shibboleth.admin.ui.opensaml.OpenSamlObjects -import edu.internet2.tier.shibboleth.admin.ui.repository.EntityDescriptorRepository import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository -import edu.internet2.tier.shibboleth.admin.ui.service.EntityDescriptorService import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.autoconfigure.domain.EntityScan import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest @@ -23,6 +22,8 @@ import spock.lang.Specification import javax.persistence.EntityManager +import static edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.HttpMetadataResolverAttributes.HttpCachingType.file +import static edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.HttpMetadataResolverAttributes.HttpCachingType.none import static edu.internet2.tier.shibboleth.admin.ui.repository.envers.EnversTestsSupport.* /** @@ -91,4 +92,110 @@ class MetadataResolverEnversVersioningTests extends Specification { getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L } + + def "test versioning of FileBackedHttpMetadataResolver"() { + setup: + def expectedModifiedPersistentEntities = [FileBackedHttpMetadataResolver.name] + + when: + FileBackedHttpMetadataResolver resolver = new FileBackedHttpMetadataResolver(name: 'fbmr').with { + it.httpMetadataResolverAttributes = new HttpMetadataResolverAttributes(proxyUser: 'proxyUser', + proxyPassword: 'proxyPass', + httpCaching: none) + it.reloadableMetadataResolverAttributes = new ReloadableMetadataResolverAttributes(indexesRef: 'indexRef') + it + } + def resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + FileBackedHttpMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 1 + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'fbmr' + getTargetEntityForRevisionIndex(resolverHistory, 0).httpMetadataResolverAttributes.proxyUser == 'proxyUser' + getTargetEntityForRevisionIndex(resolverHistory, 0).httpMetadataResolverAttributes.proxyPassword == 'proxyPass' + getTargetEntityForRevisionIndex(resolverHistory, 0).httpMetadataResolverAttributes.httpCaching == none + getTargetEntityForRevisionIndex(resolverHistory, 0).reloadableMetadataResolverAttributes.indexesRef == 'indexRef' + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + getModifiedEntityNames(resolverHistory, 0).sort() == expectedModifiedPersistentEntities.sort() + + when: + resolver.name = 'fbmrUPDATED' + resolver.httpMetadataResolverAttributes.proxyUser = 'proxyUserUPDATED' + resolver.httpMetadataResolverAttributes.proxyPassword = 'proxyPassUPDATED' + resolver.httpMetadataResolverAttributes.httpCaching = file + resolver.reloadableMetadataResolverAttributes.indexesRef = 'indexRefUPDATED' + + resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + FileBackedHttpMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 2 + getTargetEntityForRevisionIndex(resolverHistory, 1).name == 'fbmrUPDATED' + getTargetEntityForRevisionIndex(resolverHistory, 1).httpMetadataResolverAttributes.proxyUser == 'proxyUserUPDATED' + getTargetEntityForRevisionIndex(resolverHistory, 1).httpMetadataResolverAttributes.proxyPassword == 'proxyPassUPDATED' + getTargetEntityForRevisionIndex(resolverHistory, 1).httpMetadataResolverAttributes.httpCaching == file + getTargetEntityForRevisionIndex(resolverHistory, 1).reloadableMetadataResolverAttributes.indexesRef == 'indexRefUPDATED' + getRevisionEntityForRevisionIndex(resolverHistory, 1).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 1).timestamp > 0L + getModifiedEntityNames(resolverHistory, 1).sort() == expectedModifiedPersistentEntities.sort() + + //Check the original revision is intact + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'fbmr' + getTargetEntityForRevisionIndex(resolverHistory, 0).httpMetadataResolverAttributes.proxyUser == 'proxyUser' + getTargetEntityForRevisionIndex(resolverHistory, 0).httpMetadataResolverAttributes.proxyPassword == 'proxyPass' + getTargetEntityForRevisionIndex(resolverHistory, 0).httpMetadataResolverAttributes.httpCaching == none + getTargetEntityForRevisionIndex(resolverHistory, 0).reloadableMetadataResolverAttributes.indexesRef == 'indexRef' + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + } + + def "test versioning of DynamicHttpMetadataResolver"() { + setup: + def expectedModifiedPersistentEntities = [DynamicHttpMetadataResolver.name] + + when: + DynamicHttpMetadataResolver resolver = new DynamicHttpMetadataResolver(name: 'dhmr') + + def resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + DynamicHttpMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 1 + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'dhmr' + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + getModifiedEntityNames(resolverHistory, 0).sort() == expectedModifiedPersistentEntities.sort() + + when: + resolver.name = 'dhmrUPDATED' + + resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + DynamicHttpMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 2 + getTargetEntityForRevisionIndex(resolverHistory, 1).name == 'dhmrUPDATED' + getRevisionEntityForRevisionIndex(resolverHistory, 1).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 1).timestamp > 0L + getModifiedEntityNames(resolverHistory, 1).sort() == expectedModifiedPersistentEntities.sort() + + //Check the original revision is intact + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'dhmr' + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + getModifiedEntityNames(resolverHistory, 0).sort() == expectedModifiedPersistentEntities.sort() + } } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/DynamicHttpMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/DynamicHttpMetadataResolver.java index e8deb0e3e..732078747 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/DynamicHttpMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/DynamicHttpMetadataResolver.java @@ -22,6 +22,7 @@ @Getter @Setter @ToString +@Audited public class DynamicHttpMetadataResolver extends MetadataResolver { public static final String DEFAULT_TIMEOUT = "PT5S"; diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FileBackedHttpMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FileBackedHttpMetadataResolver.java index b80b8190f..17fe28ab9 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FileBackedHttpMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FileBackedHttpMetadataResolver.java @@ -1,11 +1,10 @@ package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers; -import edu.internet2.tier.shibboleth.admin.ui.domain.AbstractAuditable; import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; import lombok.ToString; -import org.hibernate.envers.AuditOverride; + import org.hibernate.envers.Audited; import javax.persistence.Embedded; @@ -16,6 +15,7 @@ @Getter @Setter @ToString +@Audited public class FileBackedHttpMetadataResolver extends MetadataResolver { public FileBackedHttpMetadataResolver() { type = "FileBackedHttpMetadataResolver"; diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataRequestURLConstructionScheme.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataRequestURLConstructionScheme.java index adddcc5aa..af3b0eab5 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataRequestURLConstructionScheme.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataRequestURLConstructionScheme.java @@ -7,6 +7,8 @@ import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; +import org.hibernate.envers.AuditOverride; +import org.hibernate.envers.Audited; import javax.persistence.Entity; import javax.persistence.Transient; @@ -24,6 +26,8 @@ @JsonSubTypes({@JsonSubTypes.Type(value=MetadataQueryProtocolScheme.class, name="MetadataQueryProtocol"), @JsonSubTypes.Type(value=TemplateScheme.class, name="Template"), @JsonSubTypes.Type(value=RegexScheme.class, name="Regex")}) +@Audited +@AuditOverride(forClass = AbstractAuditable.class) public abstract class MetadataRequestURLConstructionScheme extends AbstractAuditable { public enum SchemeType { METADATA_QUERY_PROTOCOL("MetadataQueryProtocol"), From 0326701a5f59e9616e35df57855a7d6e56bc88f5 Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Mon, 24 Jun 2019 09:03:26 -0400 Subject: [PATCH 03/11] 1263 wip --- ...tadataResolverEnversVersioningTests.groovy | 124 +++++++++++++++++- .../ui/domain/filters/MetadataFilter.java | 3 +- .../resolvers/FilesystemMetadataResolver.java | 2 + .../MetadataQueryProtocolScheme.java | 2 + .../ui/domain/resolvers/MetadataResolver.java | 2 + .../ui/domain/resolvers/RegexScheme.java | 2 + .../ResourceBackedMetadataResolver.java | 2 + .../ui/domain/resolvers/TemplateScheme.java | 2 + 8 files changed, 135 insertions(+), 4 deletions(-) diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy index 1cea18a62..04b5e9b62 100644 --- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy @@ -4,12 +4,16 @@ import edu.internet2.tier.shibboleth.admin.ui.configuration.CoreShibUiConfigurat import edu.internet2.tier.shibboleth.admin.ui.configuration.InternationalizationConfiguration import edu.internet2.tier.shibboleth.admin.ui.configuration.SearchConfiguration import edu.internet2.tier.shibboleth.admin.ui.configuration.TestConfiguration +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ClasspathMetadataResource import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicHttpMetadataResolver import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicMetadataResolverAttributes 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.HttpMetadataResolverAttributes import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.LocalDynamicMetadataResolver import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ReloadableMetadataResolverAttributes +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ResourceBackedMetadataResolver +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.TemplateScheme import edu.internet2.tier.shibboleth.admin.ui.opensaml.OpenSamlObjects import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository import org.springframework.beans.factory.annotation.Autowired @@ -158,10 +162,17 @@ class MetadataResolverEnversVersioningTests extends Specification { def "test versioning of DynamicHttpMetadataResolver"() { setup: - def expectedModifiedPersistentEntities = [DynamicHttpMetadataResolver.name] + def expectedModifiedPersistentEntities = [DynamicHttpMetadataResolver.name, + TemplateScheme.name] when: - DynamicHttpMetadataResolver resolver = new DynamicHttpMetadataResolver(name: 'dhmr') + DynamicHttpMetadataResolver resolver = new DynamicHttpMetadataResolver(name: 'dhmr').with { + it.metadataRequestURLConstructionScheme = new TemplateScheme().with { + it.content = 'content' + it + } + it + } def resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, metadataResolverRepository, @@ -178,6 +189,7 @@ class MetadataResolverEnversVersioningTests extends Specification { when: resolver.name = 'dhmrUPDATED' + resolver.metadataRequestURLConstructionScheme.content = 'Updated content' resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, metadataResolverRepository, @@ -188,6 +200,7 @@ class MetadataResolverEnversVersioningTests extends Specification { then: resolverHistory.size() == 2 getTargetEntityForRevisionIndex(resolverHistory, 1).name == 'dhmrUPDATED' + getTargetEntityForRevisionIndex(resolverHistory, 1).metadataRequestURLConstructionScheme.content == 'Updated content' getRevisionEntityForRevisionIndex(resolverHistory, 1).principalUserName == 'anonymousUser' getRevisionEntityForRevisionIndex(resolverHistory, 1).timestamp > 0L getModifiedEntityNames(resolverHistory, 1).sort() == expectedModifiedPersistentEntities.sort() @@ -198,4 +211,111 @@ class MetadataResolverEnversVersioningTests extends Specification { getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L getModifiedEntityNames(resolverHistory, 0).sort() == expectedModifiedPersistentEntities.sort() } + + def "test versioning of FilesystemMetadataResolver"() { + setup: + def expectedModifiedPersistentEntities = [FilesystemMetadataResolver.name] + + when: + FilesystemMetadataResolver resolver = new FilesystemMetadataResolver(name: 'fmr', metadataFile: 'metadata.xml').with { + it.reloadableMetadataResolverAttributes = new ReloadableMetadataResolverAttributes(indexesRef: 'indexesRef') + it + } + + def resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + FilesystemMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 1 + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'fmr' + getTargetEntityForRevisionIndex(resolverHistory, 0).metadataFile == 'metadata.xml' + getTargetEntityForRevisionIndex(resolverHistory, 0).reloadableMetadataResolverAttributes.indexesRef == 'indexesRef' + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + getModifiedEntityNames(resolverHistory, 0).sort() == expectedModifiedPersistentEntities.sort() + + when: + resolver.name = 'fmrUPDATED' + resolver.metadataFile = 'metadataUPDATED.xml' + resolver.reloadableMetadataResolverAttributes.indexesRef = 'indexesRefUPDATED' + + resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + FilesystemMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 2 + getTargetEntityForRevisionIndex(resolverHistory, 1).name == 'fmrUPDATED' + getTargetEntityForRevisionIndex(resolverHistory, 1).metadataFile == 'metadataUPDATED.xml' + getTargetEntityForRevisionIndex(resolverHistory, 1).reloadableMetadataResolverAttributes.indexesRef == 'indexesRefUPDATED' + getRevisionEntityForRevisionIndex(resolverHistory, 1).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 1).timestamp > 0L + getModifiedEntityNames(resolverHistory, 1).sort() == expectedModifiedPersistentEntities.sort() + + //Check the original revision is intact + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'fmr' + getTargetEntityForRevisionIndex(resolverHistory, 0).metadataFile == 'metadata.xml' + getTargetEntityForRevisionIndex(resolverHistory, 0).reloadableMetadataResolverAttributes.indexesRef == 'indexesRef' + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + } + + def "test versioning of ResourceBackedMetadataResolver"() { + setup: + def expectedModifiedPersistentEntities = [ResourceBackedMetadataResolver.name] + + when: + ResourceBackedMetadataResolver resolver = new ResourceBackedMetadataResolver(name: 'rbmr').with { + it.reloadableMetadataResolverAttributes = new ReloadableMetadataResolverAttributes(taskTimerRef: 'taskTimerRef') + it.classpathMetadataResource = new ClasspathMetadataResource(file: 'metadata.xml') + it + } + + def resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + ResourceBackedMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 1 + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'rbmr' + getTargetEntityForRevisionIndex(resolverHistory, 0).reloadableMetadataResolverAttributes.taskTimerRef == 'taskTimerRef' + getTargetEntityForRevisionIndex(resolverHistory, 0).classpathMetadataResource.file == 'metadata.xml' + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + getModifiedEntityNames(resolverHistory, 0).sort() == expectedModifiedPersistentEntities.sort() + + when: + resolver.name = 'rbmrUPDATED' + resolver.reloadableMetadataResolverAttributes.taskTimerRef = 'taskTimerRefUPDATED' + resolver.classpathMetadataResource.file = 'metadataUPDATED.xml' + + resolverHistory = updateAndGetRevisionHistoryOfMetadataResolver(resolver, + metadataResolverRepository, + ResourceBackedMetadataResolver, + txMgr, + entityManager) + + then: + resolverHistory.size() == 2 + getTargetEntityForRevisionIndex(resolverHistory, 1).name == 'rbmrUPDATED' + getTargetEntityForRevisionIndex(resolverHistory, 1).reloadableMetadataResolverAttributes.taskTimerRef == 'taskTimerRefUPDATED' + getTargetEntityForRevisionIndex(resolverHistory, 1).classpathMetadataResource.file == 'metadataUPDATED.xml' + getRevisionEntityForRevisionIndex(resolverHistory, 1).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 1).timestamp > 0L + getModifiedEntityNames(resolverHistory, 1).sort() == expectedModifiedPersistentEntities.sort() + + //Check the original revision is intact + getTargetEntityForRevisionIndex(resolverHistory, 0).name == 'rbmr' + getTargetEntityForRevisionIndex(resolverHistory, 0).reloadableMetadataResolverAttributes.taskTimerRef == 'taskTimerRef' + getTargetEntityForRevisionIndex(resolverHistory, 0).classpathMetadataResource.file == 'metadata.xml' + getRevisionEntityForRevisionIndex(resolverHistory, 0).principalUserName == 'anonymousUser' + getRevisionEntityForRevisionIndex(resolverHistory, 0).timestamp > 0L + } } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/MetadataFilter.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/MetadataFilter.java index 5ee500437..d0f5dfb83 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/MetadataFilter.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/MetadataFilter.java @@ -35,7 +35,6 @@ @JsonSubTypes.Type(value=SignatureValidationFilter.class, name="SignatureValidation"), @JsonSubTypes.Type(value=RequiredValidUntilFilter.class, name="RequiredValidUntil"), @JsonSubTypes.Type(value=NameIdFormatFilter.class, name="NameIDFormat")}) -@Audited public class MetadataFilter extends AbstractAuditable { @JsonProperty("@type") @@ -59,4 +58,4 @@ public int getVersion() { } return this.hashCode(); } -} \ No newline at end of file +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FilesystemMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FilesystemMetadataResolver.java index b96a74c14..ce3319d02 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FilesystemMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FilesystemMetadataResolver.java @@ -4,6 +4,7 @@ import lombok.Getter; import lombok.Setter; import lombok.ToString; +import org.hibernate.envers.Audited; import javax.persistence.Embedded; import javax.persistence.Entity; @@ -16,6 +17,7 @@ @Getter @Setter @ToString +@Audited public class FilesystemMetadataResolver extends MetadataResolver { public FilesystemMetadataResolver() { type = "FilesystemMetadataResolver"; diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataQueryProtocolScheme.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataQueryProtocolScheme.java index cc6dffb98..77b7cc733 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataQueryProtocolScheme.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataQueryProtocolScheme.java @@ -3,6 +3,7 @@ import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; +import org.hibernate.envers.Audited; import javax.persistence.Entity; @@ -13,6 +14,7 @@ @Getter @Setter @EqualsAndHashCode(callSuper = true) +@Audited public class MetadataQueryProtocolScheme extends MetadataRequestURLConstructionScheme { public MetadataQueryProtocolScheme() { diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java index 11300c3b7..1fcce6175 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java @@ -13,6 +13,7 @@ import lombok.ToString; import org.hibernate.envers.AuditOverride; import org.hibernate.envers.Audited; +import org.hibernate.envers.NotAudited; import javax.persistence.CascadeType; import javax.persistence.Column; @@ -74,6 +75,7 @@ public class MetadataResolver extends AbstractAuditable { @OneToMany(cascade = CascadeType.ALL) @OrderColumn + @NotAudited private List metadataFilters = new ArrayList<>(); @Transient diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/RegexScheme.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/RegexScheme.java index a8d4fffaa..ce0202b6c 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/RegexScheme.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/RegexScheme.java @@ -3,6 +3,7 @@ import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; +import org.hibernate.envers.Audited; import javax.persistence.Column; import javax.persistence.Entity; @@ -15,6 +16,7 @@ @Getter @Setter @EqualsAndHashCode(callSuper = true) +@Audited public class RegexScheme extends MetadataRequestURLConstructionScheme { public RegexScheme() { diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/ResourceBackedMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/ResourceBackedMetadataResolver.java index 55c833f2d..2b480641f 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/ResourceBackedMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/ResourceBackedMetadataResolver.java @@ -4,6 +4,7 @@ import lombok.Getter; import lombok.Setter; import lombok.ToString; +import org.hibernate.envers.Audited; import javax.persistence.Embedded; import javax.persistence.Entity; @@ -16,6 +17,7 @@ @Getter @Setter @ToString +@Audited public class ResourceBackedMetadataResolver extends MetadataResolver { public ResourceBackedMetadataResolver() { type = "ResourceBackedMetadataResolver"; diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/TemplateScheme.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/TemplateScheme.java index 6cb0c8d90..a176bacd7 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/TemplateScheme.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/TemplateScheme.java @@ -3,6 +3,7 @@ import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; +import org.hibernate.envers.Audited; import javax.persistence.Entity; @@ -13,6 +14,7 @@ @Getter @Setter @EqualsAndHashCode(callSuper = true) +@Audited public class TemplateScheme extends MetadataRequestURLConstructionScheme { public TemplateScheme () { From ee068aad0b25d72574e96eccf42c35877f6445e3 Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Mon, 24 Jun 2019 13:41:19 -0400 Subject: [PATCH 04/11] SHIBUI-1263(1320) --- ...EntityDescriptorVersionServiceTests.groovy | 4 +- ...MetadataResolverVersionServiceTests.groovy | 136 ++++++++++++++++++ .../EntitiesVersioningConfiguration.java | 15 +- .../ui/domain/resolvers/MetadataResolver.java | 1 + .../envers/EnversVersionServiceSupport.java | 62 ++++++++ .../EntityDescriptorVersionService.java | 3 - .../EnversEntityDescriptorVersionService.java | 1 + .../EnversMetadataResolverVersionService.java | 43 ++++++ .../MetadataResolverVersionService.java | 16 +++ 9 files changed, 276 insertions(+), 5 deletions(-) create mode 100644 backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversMetadataResolverVersionServiceTests.groovy create mode 100644 backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java create mode 100644 backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversMetadataResolverVersionService.java create mode 100644 backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverVersionService.java diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversEntityDescriptorVersionServiceTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversEntityDescriptorVersionServiceTests.groovy index d88a604f3..f867ede29 100644 --- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversEntityDescriptorVersionServiceTests.groovy +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversEntityDescriptorVersionServiceTests.groovy @@ -7,6 +7,7 @@ import edu.internet2.tier.shibboleth.admin.ui.configuration.SearchConfiguration import edu.internet2.tier.shibboleth.admin.ui.configuration.TestConfiguration import edu.internet2.tier.shibboleth.admin.ui.domain.EntityDescriptor import edu.internet2.tier.shibboleth.admin.ui.repository.EntityDescriptorRepository +import edu.internet2.tier.shibboleth.admin.ui.repository.envers.EnversTestsSupport import edu.internet2.tier.shibboleth.admin.ui.service.EntityDescriptorService import edu.internet2.tier.shibboleth.admin.ui.service.EntityDescriptorVersionService import org.springframework.beans.factory.annotation.Autowired @@ -19,6 +20,7 @@ import spock.lang.Specification import java.time.LocalDateTime + @DataJpaTest @ContextConfiguration(classes = [CoreShibUiConfiguration, InternationalizationConfiguration, TestConfiguration, SearchConfiguration, EntitiesVersioningConfiguration]) @EnableJpaRepositories(basePackages = ["edu.internet2.tier.shibboleth.admin.ui"]) @@ -40,7 +42,7 @@ class EnversEntityDescriptorVersionServiceTests extends Specification { def "versioning service returns correct number of versions sorted by modified date in natural order"() { when: 'Initial version' EntityDescriptor ed = new EntityDescriptor(entityID: 'ed', serviceProviderName: 'SP1') - ed = edu.internet2.tier.shibboleth.admin.ui.repository.envers.EnversTestsSupport.doInExplicitTransaction(txMgr) { + ed = EnversTestsSupport.doInExplicitTransaction(txMgr) { entityDescriptorRepository.save(ed) } def versions = entityDescriptorVersionService.findVersionsForEntityDescriptor(ed.resourceId) diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversMetadataResolverVersionServiceTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversMetadataResolverVersionServiceTests.groovy new file mode 100644 index 000000000..1ac1dae1f --- /dev/null +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversMetadataResolverVersionServiceTests.groovy @@ -0,0 +1,136 @@ +package edu.internet2.tier.shibboleth.admin.ui.service.envers + + +import edu.internet2.tier.shibboleth.admin.ui.configuration.CoreShibUiConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.EntitiesVersioningConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.InternationalizationConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.SearchConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.TestConfiguration +import edu.internet2.tier.shibboleth.admin.ui.domain.EntityDescriptor +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicHttpMetadataResolver +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.domain.resolvers.ResourceBackedMetadataResolver +import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository +import edu.internet2.tier.shibboleth.admin.ui.repository.envers.EnversTestsSupport +import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverVersionService +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.autoconfigure.domain.EntityScan +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest +import org.springframework.data.jpa.repository.config.EnableJpaRepositories +import org.springframework.test.context.ContextConfiguration +import org.springframework.transaction.PlatformTransactionManager +import spock.lang.Specification + +import java.time.LocalDateTime + + +@DataJpaTest +@ContextConfiguration(classes = [CoreShibUiConfiguration, InternationalizationConfiguration, TestConfiguration, SearchConfiguration, EntitiesVersioningConfiguration]) +@EnableJpaRepositories(basePackages = ["edu.internet2.tier.shibboleth.admin.ui"]) +@EntityScan("edu.internet2.tier.shibboleth.admin.ui") +class EnversMetadataResolverVersionServiceTests extends Specification { + + @Autowired + MetadataResolverVersionService metadataResolverVersionService + + @Autowired + MetadataResolverRepository metadataResolverRepository + + @Autowired + PlatformTransactionManager txMgr + + def "versioning service returns correct number of versions sorted by modified date in natural order"() { + when: 'Initial version' + MetadataResolver mr = new LocalDynamicMetadataResolver(name: 'ldmr') + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + def versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + + then: + versions.size() == 1 + versions[0].id + versions[0].creator + versions[0].date < LocalDateTime.now() + + when: 'Second version' + mr.name = 'ldmr2' + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + + + then: + versions.size() == 2 + versions[0].id && versions[1].id + versions[0].creator && versions[1].creator + versions[0].date < versions[1].date + + when: 'Third version' + mr.name = 'ldmr3' + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + + then: + versions.size() == 3 + versions[0].id && versions[1].id && versions[2].id + versions[0].creator && versions[1].creator && versions[2].creator + (versions[0].date < versions[1].date) && (versions[1].date < versions[2].date) + } + + def "versioning service returns correct metadata resolver for version number"() { + when: 'Initial version' + MetadataResolver mr = new FilesystemMetadataResolver(name: 'fsmr') + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + def versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + def v1Mr = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + + then: + v1Mr.name == 'fsmr' + v1Mr.resourceId == mr.resourceId + + when: 'Update the original' + mr.name = 'fsmr2' + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + def v2Mr = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + + then: + v2Mr.name == 'fsmr2' + v2Mr.resourceId == mr.resourceId + } + + def "versioning service returns null for non existent version number"() { + when: 'Initial version' + MetadataResolver mr = new ResourceBackedMetadataResolver(name: 'rbmr') + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + def nonexitentMrVersion = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, '1000') + + then: + !nonexitentMrVersion + } + + def "versioning service returns null for non existent metadata resolver number"() { + when: 'Initial version' + MetadataResolver mr = new DynamicHttpMetadataResolver(name: 'dhmr') + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + def versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + def nonexitentMr = metadataResolverVersionService.findSpecificVersionOfMetadataResolver('non-existent', versions[0].id) + + then: + !nonexitentMr + } +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/configuration/EntitiesVersioningConfiguration.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/configuration/EntitiesVersioningConfiguration.java index b190f2f5d..ec21d42c4 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/configuration/EntitiesVersioningConfiguration.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/configuration/EntitiesVersioningConfiguration.java @@ -1,8 +1,11 @@ package edu.internet2.tier.shibboleth.admin.ui.configuration; +import edu.internet2.tier.shibboleth.admin.ui.envers.EnversVersionServiceSupport; import edu.internet2.tier.shibboleth.admin.ui.service.EntityDescriptorService; import edu.internet2.tier.shibboleth.admin.ui.service.EntityDescriptorVersionService; import edu.internet2.tier.shibboleth.admin.ui.service.EnversEntityDescriptorVersionService; +import edu.internet2.tier.shibboleth.admin.ui.service.EnversMetadataResolverVersionService; +import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverVersionService; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @@ -16,7 +19,17 @@ public class EntitiesVersioningConfiguration { private EntityManager entityManager; @Bean - EntityDescriptorVersionService entityDescriptorVersionService(EntityDescriptorService entityDescriptorService) { + public EntityDescriptorVersionService entityDescriptorVersionService(EntityDescriptorService entityDescriptorService) { return new EnversEntityDescriptorVersionService(entityManager, entityDescriptorService); } + + @Bean + public MetadataResolverVersionService metadataResolverVersionService() { + return new EnversMetadataResolverVersionService(enversVersionServiceSupport()); + } + + @Bean + public EnversVersionServiceSupport enversVersionServiceSupport() { + return new EnversVersionServiceSupport(entityManager); + } } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java index 1fcce6175..5de02a03b 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java @@ -1,6 +1,7 @@ package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers; import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonSubTypes; import com.fasterxml.jackson.annotation.JsonTypeInfo; diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java new file mode 100644 index 000000000..9b8cc860b --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java @@ -0,0 +1,62 @@ +package edu.internet2.tier.shibboleth.admin.ui.envers; + +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.domain.versioning.Version; +import org.hibernate.envers.AuditReaderFactory; +import org.hibernate.envers.query.AuditEntity; + +import javax.persistence.EntityManager; +import javax.persistence.NoResultException; +import java.time.ZoneId; +import java.util.List; + +import static java.util.Comparator.comparing; +import static java.util.stream.Collectors.toList; + +/** + * Encapsulates common functionality interfacing with Envers AuditReader low level API + * to query for revisions of various persistent entities. + */ +public class EnversVersionServiceSupport { + + private EntityManager entityManager; + + public EnversVersionServiceSupport(EntityManager entityManager) { + this.entityManager = entityManager; + } + + public List findVersionsForPersistentEntity(String resourceId, Class enityClass) { + List revs = AuditReaderFactory.get(entityManager).createQuery() + .forRevisionsOfEntity(enityClass, false, false) + .add(AuditEntity.property("resourceId").eq(resourceId)) + .getResultList(); + + Object listOfVersions = revs.stream() + .map(it -> ((Object[]) it)[1]) + .map(it -> { + return new Version(((PrincipalAwareRevisionEntity) it).idAsString(), + ((PrincipalAwareRevisionEntity) it).getPrincipalUserName(), + ((PrincipalAwareRevisionEntity) it).getRevisionDate() + .toInstant() + .atZone(ZoneId.systemDefault()) + .toLocalDateTime()); + }) + .sorted(comparing(Version::getDate)) + .collect(toList()); + + return (List) listOfVersions; + } + + public Object findSpecificVersionOfPersistentEntity(String resourceId, String versionId, Class entityClass) { + try { + return AuditReaderFactory.get(entityManager).createQuery() + .forEntitiesAtRevision(entityClass, Integer.valueOf(versionId)) + .add(AuditEntity.property("resourceId").eq(resourceId)) + .add(AuditEntity.revisionNumber().eq(Integer.valueOf(versionId))) + .getSingleResult(); + } + catch (NoResultException e) { + return null; + } + } +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EntityDescriptorVersionService.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EntityDescriptorVersionService.java index 6803796fa..5e1542ea2 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EntityDescriptorVersionService.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EntityDescriptorVersionService.java @@ -3,10 +3,7 @@ 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.domain.versioning.Version; -import edu.internet2.tier.shibboleth.admin.ui.repository.EntityDescriptorRepository; -import java.time.LocalDateTime; -import java.util.Arrays; import java.util.List; /** diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversEntityDescriptorVersionService.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversEntityDescriptorVersionService.java index 91dccd5af..795807ce7 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversEntityDescriptorVersionService.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversEntityDescriptorVersionService.java @@ -25,6 +25,7 @@ /** * Hibernate Envers based implementation of {@link EntityDescriptorVersionService}. + * TODO: refactor this implementation using EnversVersionServiceSupport class */ public class EnversEntityDescriptorVersionService implements EntityDescriptorVersionService { diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversMetadataResolverVersionService.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversMetadataResolverVersionService.java new file mode 100644 index 000000000..5a77c2b87 --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversMetadataResolverVersionService.java @@ -0,0 +1,43 @@ +package edu.internet2.tier.shibboleth.admin.ui.service; + +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.domain.resolvers.MetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.domain.versioning.Version; +import edu.internet2.tier.shibboleth.admin.ui.envers.EnversVersionServiceSupport; +import edu.internet2.tier.shibboleth.admin.ui.envers.PrincipalAwareRevisionEntity; +import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository; +import org.hibernate.envers.AuditReaderFactory; +import org.hibernate.envers.query.AuditEntity; + +import javax.persistence.EntityManager; +import javax.persistence.NoResultException; +import java.time.ZoneId; +import java.util.List; + +import static java.util.Comparator.comparing; +import static java.util.stream.Collectors.toList; + +/** + * Hibernate Envers based implementation of {@link MetadataResolverVersionService}. + */ +public class EnversMetadataResolverVersionService implements MetadataResolverVersionService { + + + private EnversVersionServiceSupport enversVersionServiceSupport; + + public EnversMetadataResolverVersionService(EnversVersionServiceSupport enversVersionServiceSupport) { + this.enversVersionServiceSupport = enversVersionServiceSupport; + } + + @Override + public List findVersionsForMetadataResolver(String resourceId) { + return enversVersionServiceSupport.findVersionsForPersistentEntity(resourceId, MetadataResolver.class); + } + + @Override + public MetadataResolver findSpecificVersionOfMetadataResolver(String resourceId, String versionId) { + Object mrObject = enversVersionServiceSupport.findSpecificVersionOfPersistentEntity(resourceId, versionId, MetadataResolver.class); + return mrObject == null ? null : (MetadataResolver) mrObject; + } +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverVersionService.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverVersionService.java new file mode 100644 index 000000000..16f3dd1a3 --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverVersionService.java @@ -0,0 +1,16 @@ +package edu.internet2.tier.shibboleth.admin.ui.service; + +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.domain.versioning.Version; + +import java.util.List; + +/** + * API containing operations pertaining to {@link MetadataResolver} versioning. + */ +public interface MetadataResolverVersionService { + + List findVersionsForMetadataResolver(String resourceId); + + MetadataResolver findSpecificVersionOfMetadataResolver(String resourceId, String versionId); +} From 5ff6ec7aa2162b37e8c7ba8dc365c37107a5d236 Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Mon, 24 Jun 2019 16:16:34 -0400 Subject: [PATCH 05/11] 1263(1336) --- ...MetadataFilterEnversVersioningTests.groovy | 88 +++++++++++++++++++ ...tadataResolverEnversVersioningTests.groovy | 3 - .../filters/EntityAttributesFilter.java | 4 +- .../filters/EntityAttributesFilterTarget.java | 5 +- .../filters/EntityRoleWhiteListFilter.java | 2 + .../ui/domain/filters/MetadataFilter.java | 3 + .../ui/domain/filters/NameIdFormatFilter.java | 2 + .../filters/NameIdFormatFilterTarget.java | 4 + .../filters/RequiredValidUntilFilter.java | 2 + .../filters/SignatureValidationFilter.java | 2 + .../ui/domain/resolvers/MetadataResolver.java | 8 +- 11 files changed, 117 insertions(+), 6 deletions(-) create mode 100644 backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy new file mode 100644 index 000000000..67c7787e2 --- /dev/null +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy @@ -0,0 +1,88 @@ +package edu.internet2.tier.shibboleth.admin.ui.repository.envers + +import edu.internet2.tier.shibboleth.admin.ui.configuration.CoreShibUiConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.EntitiesVersioningConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.InternationalizationConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.SearchConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.TestConfiguration +import edu.internet2.tier.shibboleth.admin.ui.domain.filters.EntityRoleWhiteListFilter +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.FilterRepository +import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository +import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverVersionService +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.autoconfigure.domain.EntityScan +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest +import org.springframework.data.jpa.repository.config.EnableJpaRepositories +import org.springframework.test.context.ContextConfiguration +import org.springframework.transaction.PlatformTransactionManager +import spock.lang.Specification + +import javax.persistence.EntityManager + +/** + * Testing metadata resolver envers versioning + */ +@DataJpaTest +@ContextConfiguration(classes = [CoreShibUiConfiguration, InternationalizationConfiguration, SearchConfiguration, TestConfiguration, EntitiesVersioningConfiguration]) +@EnableJpaRepositories(basePackages = ["edu.internet2.tier.shibboleth.admin.ui"]) +@EntityScan("edu.internet2.tier.shibboleth.admin.ui") +class MetadataFilterEnversVersioningTests extends Specification { + + @Autowired + MetadataResolverRepository metadataResolverRepository + + @Autowired + FilterRepository filterRepository + + @Autowired + MetadataResolverVersionService metadataResolverVersionService + + @Autowired + PlatformTransactionManager txMgr + + + def "test versioning of LocalDynamicMetadataResolver"() { + when: 'Add initial filter' + LocalDynamicMetadataResolver mr = new LocalDynamicMetadataResolver(name: 'ldmr') + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + EntityRoleWhiteListFilter filter = new EntityRoleWhiteListFilter().with { + it.retainedRoles = ['role1'] + it + } + mr.metadataFilters.add(filter) + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + def versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + def mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + def mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + + + then: + versions.size() == 2 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters.size() == 1 + + when: 'Update filter' + filter = filterRepository.findByResourceId(filter.resourceId) + filter.retainedRoles = ['role1', 'role2'] + filter = EnversTestsSupport.doInExplicitTransaction(txMgr) { + filterRepository.save(filter) + } + mr.markAsModified() + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + def mrv3 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[2].id) + + then: + versions.size() == 3 + } +} diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy index 04b5e9b62..2ba81bcdf 100644 --- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataResolverEnversVersioningTests.groovy @@ -48,9 +48,6 @@ class MetadataResolverEnversVersioningTests extends Specification { @Autowired PlatformTransactionManager txMgr - @Autowired - OpenSamlObjects openSamlObjects - def "test versioning of LocalDynamicMetadataResolver"() { setup: def expectedModifiedPersistentEntities = [LocalDynamicMetadataResolver.name] diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilter.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilter.java index 9d68c39b3..5d6d3132a 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilter.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilter.java @@ -6,6 +6,7 @@ import lombok.Getter; import lombok.Setter; import lombok.ToString; +import org.hibernate.envers.Audited; import javax.persistence.CascadeType; import javax.persistence.Entity; @@ -28,6 +29,7 @@ @Getter @Setter @ToString +@Audited public class EntityAttributesFilter extends MetadataFilter { public EntityAttributesFilter() { @@ -70,4 +72,4 @@ public void intoTransientRepresentation() { this.attributeRelease = getAttributeReleaseListFromAttributeList(this.attributes); this.relyingPartyOverrides = getRelyingPartyOverridesRepresentationFromAttributeList(this.attributes); } -} \ No newline at end of file +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilterTarget.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilterTarget.java index 5effdae3d..0abbbd11c 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilterTarget.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilterTarget.java @@ -1,8 +1,9 @@ package edu.internet2.tier.shibboleth.admin.ui.domain.filters; -import com.fasterxml.jackson.annotation.JsonIgnore; import edu.internet2.tier.shibboleth.admin.ui.domain.AbstractAuditable; import lombok.EqualsAndHashCode; +import org.hibernate.envers.AuditOverride; +import org.hibernate.envers.Audited; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -14,6 +15,8 @@ @Entity @EqualsAndHashCode(callSuper = true) +@Audited +@AuditOverride(forClass = AbstractAuditable.class) public class EntityAttributesFilterTarget extends AbstractAuditable { public enum EntityAttributesFilterTargetType { ENTITY, CONDITION_SCRIPT, CONDITION_REF, REGEX diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityRoleWhiteListFilter.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityRoleWhiteListFilter.java index 111b75c2a..26c5e9976 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityRoleWhiteListFilter.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityRoleWhiteListFilter.java @@ -4,6 +4,7 @@ import lombok.Getter; import lombok.Setter; import lombok.ToString; +import org.hibernate.envers.Audited; import javax.persistence.CollectionTable; import javax.persistence.Column; @@ -19,6 +20,7 @@ @Getter @Setter @ToString +@Audited public class EntityRoleWhiteListFilter extends MetadataFilter { public EntityRoleWhiteListFilter() { diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/MetadataFilter.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/MetadataFilter.java index d0f5dfb83..b15058cd0 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/MetadataFilter.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/MetadataFilter.java @@ -10,6 +10,7 @@ import lombok.NoArgsConstructor; import lombok.Setter; import lombok.ToString; +import org.hibernate.envers.AuditOverride; import org.hibernate.envers.Audited; import javax.persistence.Column; @@ -35,6 +36,8 @@ @JsonSubTypes.Type(value=SignatureValidationFilter.class, name="SignatureValidation"), @JsonSubTypes.Type(value=RequiredValidUntilFilter.class, name="RequiredValidUntil"), @JsonSubTypes.Type(value=NameIdFormatFilter.class, name="NameIDFormat")}) +@Audited +@AuditOverride(forClass = AbstractAuditable.class) public class MetadataFilter extends AbstractAuditable { @JsonProperty("@type") diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/NameIdFormatFilter.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/NameIdFormatFilter.java index 608561407..157e5f766 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/NameIdFormatFilter.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/NameIdFormatFilter.java @@ -4,6 +4,7 @@ import lombok.Getter; import lombok.Setter; import lombok.ToString; +import org.hibernate.envers.Audited; import javax.persistence.CascadeType; import javax.persistence.ElementCollection; @@ -17,6 +18,7 @@ @Getter @Setter @ToString +@Audited public class NameIdFormatFilter extends MetadataFilter { public NameIdFormatFilter() { diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/NameIdFormatFilterTarget.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/NameIdFormatFilterTarget.java index a346d983f..c8fd10c90 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/NameIdFormatFilterTarget.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/NameIdFormatFilterTarget.java @@ -3,6 +3,8 @@ import edu.internet2.tier.shibboleth.admin.ui.domain.AbstractAuditable; import lombok.EqualsAndHashCode; import lombok.ToString; +import org.hibernate.envers.AuditOverride; +import org.hibernate.envers.Audited; import javax.persistence.ElementCollection; import javax.persistence.Entity; @@ -13,6 +15,8 @@ @Entity @EqualsAndHashCode(callSuper = true) @ToString +@Audited +@AuditOverride(forClass = AbstractAuditable.class) public class NameIdFormatFilterTarget extends AbstractAuditable { public enum NameIdFormatFilterTargetType { diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/RequiredValidUntilFilter.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/RequiredValidUntilFilter.java index 1aca84d4b..cda431408 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/RequiredValidUntilFilter.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/RequiredValidUntilFilter.java @@ -4,6 +4,7 @@ import lombok.Getter; import lombok.Setter; import lombok.ToString; +import org.hibernate.envers.Audited; import javax.persistence.Entity; @@ -12,6 +13,7 @@ @Getter @Setter @ToString +@Audited public class RequiredValidUntilFilter extends MetadataFilter { public RequiredValidUntilFilter() { diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/SignatureValidationFilter.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/SignatureValidationFilter.java index 7e83ae6d4..5cf71225e 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/SignatureValidationFilter.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/SignatureValidationFilter.java @@ -4,6 +4,7 @@ import lombok.Getter; import lombok.Setter; import lombok.ToString; +import org.hibernate.envers.Audited; import javax.persistence.Entity; @@ -12,6 +13,7 @@ @Getter @Setter @ToString +@Audited public class SignatureValidationFilter extends MetadataFilter { public SignatureValidationFilter() { diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java index 5de02a03b..b41b20ac5 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java @@ -74,9 +74,11 @@ public class MetadataResolver extends AbstractAuditable { private Boolean doInitialization = true; + @JsonIgnore + private Long versionModifiedTimestamp; + @OneToMany(cascade = CascadeType.ALL) @OrderColumn - @NotAudited private List metadataFilters = new ArrayList<>(); @Transient @@ -89,4 +91,8 @@ public int getVersion() { } return this.hashCode(); } + + public void markAsModified() { + this.versionModifiedTimestamp = System.currentTimeMillis(); + } } From 17e995c28d7d4ee225a4e371247b70bd98794a8f Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Tue, 25 Jun 2019 08:29:41 -0400 Subject: [PATCH 06/11] 1263(1336) --- .../shibboleth/admin/ui/domain/resolvers/MetadataResolver.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java index b41b20ac5..dc30d40d8 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolver.java @@ -14,7 +14,6 @@ import lombok.ToString; import org.hibernate.envers.AuditOverride; import org.hibernate.envers.Audited; -import org.hibernate.envers.NotAudited; import javax.persistence.CascadeType; import javax.persistence.Column; @@ -30,7 +29,7 @@ @Entity @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) -@EqualsAndHashCode(callSuper = true, exclude = {"version"}) +@EqualsAndHashCode(callSuper = true, exclude = {"version", "versionModifiedTimestamp"}) @NoArgsConstructor @Getter @Setter From ee3ea921ac4d4870a83436c8434a12d19a1c046b Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Tue, 25 Jun 2019 13:37:54 -0400 Subject: [PATCH 07/11] Fix test --- ...EnversMetadataResolverVersionServiceTests.groovy | 3 ++- .../ui/envers/EnversVersionServiceSupport.java | 7 +++---- .../EnversMetadataResolverVersionService.java | 13 +------------ 3 files changed, 6 insertions(+), 17 deletions(-) diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversMetadataResolverVersionServiceTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversMetadataResolverVersionServiceTests.groovy index 1ac1dae1f..8f68922ed 100644 --- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversMetadataResolverVersionServiceTests.groovy +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversMetadataResolverVersionServiceTests.groovy @@ -24,6 +24,7 @@ import org.springframework.transaction.PlatformTransactionManager import spock.lang.Specification import java.time.LocalDateTime +import java.time.ZonedDateTime @DataJpaTest @@ -53,7 +54,7 @@ class EnversMetadataResolverVersionServiceTests extends Specification { versions.size() == 1 versions[0].id versions[0].creator - versions[0].date < LocalDateTime.now() + versions[0].date < ZonedDateTime.now() when: 'Second version' mr.name = 'ldmr2' diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java index 9b8cc860b..ba1631ade 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java @@ -1,13 +1,12 @@ package edu.internet2.tier.shibboleth.admin.ui.envers; -import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver; import edu.internet2.tier.shibboleth.admin.ui.domain.versioning.Version; import org.hibernate.envers.AuditReaderFactory; import org.hibernate.envers.query.AuditEntity; import javax.persistence.EntityManager; import javax.persistence.NoResultException; -import java.time.ZoneId; +import java.time.ZoneOffset; import java.util.List; import static java.util.Comparator.comparing; @@ -38,8 +37,8 @@ public List findVersionsForPersistentEntity(String resourceId, Class ((PrincipalAwareRevisionEntity) it).getPrincipalUserName(), ((PrincipalAwareRevisionEntity) it).getRevisionDate() .toInstant() - .atZone(ZoneId.systemDefault()) - .toLocalDateTime()); + .atOffset(ZoneOffset.UTC) + .toZonedDateTime()); }) .sorted(comparing(Version::getDate)) .collect(toList()); diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversMetadataResolverVersionService.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversMetadataResolverVersionService.java index 5a77c2b87..c98203eca 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversMetadataResolverVersionService.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/EnversMetadataResolverVersionService.java @@ -1,22 +1,11 @@ package edu.internet2.tier.shibboleth.admin.ui.service; -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.domain.resolvers.MetadataResolver; import edu.internet2.tier.shibboleth.admin.ui.domain.versioning.Version; import edu.internet2.tier.shibboleth.admin.ui.envers.EnversVersionServiceSupport; -import edu.internet2.tier.shibboleth.admin.ui.envers.PrincipalAwareRevisionEntity; -import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository; -import org.hibernate.envers.AuditReaderFactory; -import org.hibernate.envers.query.AuditEntity; - -import javax.persistence.EntityManager; -import javax.persistence.NoResultException; -import java.time.ZoneId; + import java.util.List; -import static java.util.Comparator.comparing; -import static java.util.stream.Collectors.toList; /** * Hibernate Envers based implementation of {@link MetadataResolverVersionService}. From 97df5c06733679c7c66364c3b576ef267cd37e4c Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Tue, 25 Jun 2019 16:51:25 -0400 Subject: [PATCH 08/11] 1263(1336) --- ...MetadataFilterEnversVersioningTests.groovy | 244 +++++++++++++++++- .../controller/MetadataFiltersController.java | 31 ++- 2 files changed, 252 insertions(+), 23 deletions(-) diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy index 67c7787e2..05c8f5ea0 100644 --- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy @@ -5,9 +5,16 @@ import edu.internet2.tier.shibboleth.admin.ui.configuration.EntitiesVersioningCo import edu.internet2.tier.shibboleth.admin.ui.configuration.InternationalizationConfiguration import edu.internet2.tier.shibboleth.admin.ui.configuration.SearchConfiguration import edu.internet2.tier.shibboleth.admin.ui.configuration.TestConfiguration +import edu.internet2.tier.shibboleth.admin.ui.domain.filters.EntityAttributesFilter import edu.internet2.tier.shibboleth.admin.ui.domain.filters.EntityRoleWhiteListFilter +import edu.internet2.tier.shibboleth.admin.ui.domain.filters.NameIdFormatFilter +import edu.internet2.tier.shibboleth.admin.ui.domain.filters.RequiredValidUntilFilter +import edu.internet2.tier.shibboleth.admin.ui.domain.filters.SignatureValidationFilter +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.domain.resolvers.ResourceBackedMetadataResolver import edu.internet2.tier.shibboleth.admin.ui.repository.FilterRepository import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverVersionService @@ -15,14 +22,14 @@ import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.autoconfigure.domain.EntityScan import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest import org.springframework.data.jpa.repository.config.EnableJpaRepositories +import org.springframework.test.annotation.DirtiesContext import org.springframework.test.context.ContextConfiguration import org.springframework.transaction.PlatformTransactionManager import spock.lang.Specification -import javax.persistence.EntityManager /** - * Testing metadata resolver envers versioning + * Testing metadata resolver envers versioning with metadata filters */ @DataJpaTest @ContextConfiguration(classes = [CoreShibUiConfiguration, InternationalizationConfiguration, SearchConfiguration, TestConfiguration, EntitiesVersioningConfiguration]) @@ -43,9 +50,9 @@ class MetadataFilterEnversVersioningTests extends Specification { PlatformTransactionManager txMgr - def "test versioning of LocalDynamicMetadataResolver"() { + def "test versioning of MetadataResolver with EntityRoleWhiteListFilter"() { when: 'Add initial filter' - LocalDynamicMetadataResolver mr = new LocalDynamicMetadataResolver(name: 'ldmr') + def mr = new LocalDynamicMetadataResolver(name: 'resolver') mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { metadataResolverRepository.save(mr) } @@ -61,15 +68,111 @@ class MetadataFilterEnversVersioningTests extends Specification { def mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) def mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) - then: versions.size() == 2 mrv1.metadataFilters.size() == 0 mrv2.metadataFilters.size() == 1 when: 'Update filter' - filter = filterRepository.findByResourceId(filter.resourceId) + filter = mr.metadataFilters[0] filter.retainedRoles = ['role1', 'role2'] + filter.removeEmptyEntitiesDescriptors = false + filter = EnversTestsSupport.doInExplicitTransaction(txMgr) { + filterRepository.save(filter) + } + mr.markAsModified() + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + def mrv3 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[2].id) + + then: + versions.size() == 3 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters[0].retainedRoles.size() == 1 + mrv2.metadataFilters[0].retainedRoles == ['role1'] + mrv3.metadataFilters[0].retainedRoles.size() == 2 + mrv3.metadataFilters[0].retainedRoles == ['role1','role2'] + mrv3.metadataFilters[0].removeEmptyEntitiesDescriptors == false + } + + //@DirtiesContext + def "test versioning of MetadataResolver with EntityAttributesFilter"() { + when: 'Add initial filter' + def mr = new FileBackedHttpMetadataResolver(name: 'resolver') + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + EntityAttributesFilter filter = new EntityAttributesFilter().with { + it.attributeRelease = ['attr1'] + it + } + mr.metadataFilters.add(filter) + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + def versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + def mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + def mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + + then: + versions.size() == 2 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters.size() == 1 + + when: 'Update filter' + filter = mr.metadataFilters[0] + filter.attributeRelease = ['attr1, attr2'] + filter = EnversTestsSupport.doInExplicitTransaction(txMgr) { + filterRepository.save(filter) + } + mr.markAsModified() + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + def mrv3 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[2].id) + + then: + versions.size() == 3 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters[0].attributes[0].attributeValues[0].xsStringvalue == 'attr1' + mrv3.metadataFilters[0].attributes[0].attributeValues[0].xsStringvalue == 'attr1, attr2' + } + + //@DirtiesContext + def "test versioning of MetadataResolver with SignatureValidationFilter"() { + when: 'Add initial filter' + def mr = new DynamicHttpMetadataResolver(name: 'resolver') + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + SignatureValidationFilter filter = new SignatureValidationFilter().with { + it.certificateFile = 'cert1.file' + it + } + mr.metadataFilters.add(filter) + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + def versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + def mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + def mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + + then: + versions.size() == 2 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters.size() == 1 + mrv2.metadataFilters[0].certificateFile == 'cert1.file' + + when: 'Update filter' + filter = mr.metadataFilters[0] + filter.certificateFile = 'cert2.file' filter = EnversTestsSupport.doInExplicitTransaction(txMgr) { filterRepository.save(filter) } @@ -84,5 +187,132 @@ class MetadataFilterEnversVersioningTests extends Specification { then: versions.size() == 3 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters[0].certificateFile == 'cert1.file' + mrv3.metadataFilters[0].certificateFile == 'cert2.file' + } + + def "test versioning of MetadataResolver with RequiredValidUntilFilter"() { + when: 'Add initial filter' + def mr = new FilesystemMetadataResolver(name: 'resolver') + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + RequiredValidUntilFilter filter = new RequiredValidUntilFilter().with { + it.maxValidityInterval = "PT1S" + it + } + mr.metadataFilters.add(filter) + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + def versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + def mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + def mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + + then: + versions.size() == 2 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters.size() == 1 + mrv2.metadataFilters[0].maxValidityInterval == 'PT1S' + + when: 'Update filter' + filter = mr.metadataFilters[0] + filter.maxValidityInterval = 'PT30S' + filter = EnversTestsSupport.doInExplicitTransaction(txMgr) { + filterRepository.save(filter) + } + mr.markAsModified() + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + def mrv3 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[2].id) + + then: + versions.size() == 3 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters[0].maxValidityInterval == 'PT1S' + mrv3.metadataFilters[0].maxValidityInterval == 'PT30S' + } + + @DirtiesContext + def "test versioning of MetadataResolver with NameIdFormatFilter"() { + when: 'Add initial filter' + def mr = new ResourceBackedMetadataResolver(name: 'resolver') + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + NameIdFormatFilter filter = new NameIdFormatFilter().with { + it.formats = ['format1'] + it + } + mr.metadataFilters.add(filter) + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + def versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + def mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + def mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + + then: + versions.size() == 2 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters.size() == 1 + mrv2.metadataFilters[0].formats == ['format1'] + + when: 'Update filter' + filter = mr.metadataFilters[0] + filter.formats = ['format1', 'format2'] + filter.removeExistingFormats = true + filter = EnversTestsSupport.doInExplicitTransaction(txMgr) { + filterRepository.save(filter) + } + mr.markAsModified() + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + def mrv3 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[2].id) + + then: + versions.size() == 3 + mrv1.metadataFilters.size() == 0 + mrv2.metadataFilters[0].formats == ['format1'] + mrv3.metadataFilters[0].formats == ['format1', 'format2'] + mrv3.metadataFilters[0].removeExistingFormats == true + } + + def "test versioning of deleting a filter"() { + when: 'Add initial filter' + def mr = new LocalDynamicMetadataResolver(name: 'resolver') + def filter = new EntityRoleWhiteListFilter() + + mr.metadataFilters.add(filter) + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + //And now remove filter + filter = filterRepository.findByResourceId(filter.resourceId) + mr.metadataFilters = [] + mr = EnversTestsSupport.doInExplicitTransaction(txMgr) { + metadataResolverRepository.save(mr) + } + EnversTestsSupport.doInExplicitTransaction(txMgr) { + filterRepository.delete(filter) + } + + def versions = metadataResolverVersionService.findVersionsForMetadataResolver(mr.resourceId) + def mrv1 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[0].id) + def mrv2 = metadataResolverVersionService.findSpecificVersionOfMetadataResolver(mr.resourceId, versions[1].id) + + then: + versions.size() == 2 + mrv1.metadataFilters.size() == 1 + mrv2.metadataFilters.size() == 0 } } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersController.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersController.java index 57d734f77..cbf5051ba 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersController.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersController.java @@ -7,16 +7,10 @@ import edu.internet2.tier.shibboleth.admin.ui.domain.filters.RequiredValidUntilFilter; import edu.internet2.tier.shibboleth.admin.ui.domain.filters.SignatureValidationFilter; import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver; -import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.OpenSamlFunctionDrivenDynamicHTTPMetadataResolver; -import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.OpenSamlLocalDynamicMetadataResolver; import edu.internet2.tier.shibboleth.admin.ui.repository.FilterRepository; import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository; import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverService; -import net.shibboleth.utilities.java.support.component.ComponentInitializationException; -import net.shibboleth.utilities.java.support.resolver.ResolverException; -import org.opensaml.saml.metadata.resolver.ChainingMetadataResolver; -import org.opensaml.saml.metadata.resolver.RefreshableMetadataResolver; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; @@ -36,6 +30,7 @@ import java.net.URI; import java.util.ArrayList; import java.util.List; +import java.util.Optional; import java.util.function.Supplier; import java.util.stream.Stream; @@ -102,19 +97,19 @@ public ResponseEntity create(@PathVariable String metadataResolverId, @Reques public ResponseEntity update(@PathVariable String metadataResolverId, @PathVariable String resourceId, @RequestBody MetadataFilter updatedFilter) { - MetadataFilter filterTobeUpdated = filterRepository.findByResourceId(resourceId); - if (filterTobeUpdated == null) { - return ResponseEntity.notFound().build(); - } MetadataResolver metadataResolver = findResolverOrThrowHttp404(metadataResolverId); - // check to make sure that the relationship exists - if (!metadataResolver.getMetadataFilters().contains(filterTobeUpdated)) { - // TODO: find a better response - return new ResponseEntity<>(HttpStatus.BAD_REQUEST); + //Now we operate directly on the filter attached to MetadataResolver, + //Instead of fetching filter separately, to accommodate correct envers versioning with uni-directional one-to-many + Optional filterTobeUpdatedOptional = metadataResolver.getMetadataFilters() + .stream() + .filter(it -> it.getResourceId().equals(resourceId)) + .findFirst(); + if(!filterTobeUpdatedOptional.isPresent()) { + return ResponseEntity.notFound().build(); } - + MetadataFilter filterTobeUpdated = filterTobeUpdatedOptional.get(); if (!resourceId.equals(updatedFilter.getResourceId())) { return new ResponseEntity(HttpStatus.CONFLICT); } @@ -130,6 +125,10 @@ public ResponseEntity update(@PathVariable String metadataResolverId, MetadataFilter persistedFilter = filterRepository.save(filterTobeUpdated); + //To support envers versioning from MetadataResolver side + metadataResolver.markAsModified(); + repository.save(metadataResolver); + // TODO: this is wrong metadataResolverService.reloadFilters(metadataResolver.getResourceId()); @@ -244,4 +243,4 @@ private static URI getResourceUriFor(MetadataResolver mr, String filterResourceI .build() .toUri(); } -} \ No newline at end of file +} From 6e2d8a2b101be8cde9e9001facd9112c8f45a2cc Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Wed, 26 Jun 2019 08:43:43 -0400 Subject: [PATCH 09/11] Fix tests --- .../admin/ui/controller/MetadataFiltersControllerTests.groovy | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersControllerTests.groovy b/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersControllerTests.groovy index 802afdb81..16ab5f6e0 100644 --- a/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersControllerTests.groovy +++ b/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersControllerTests.groovy @@ -201,7 +201,6 @@ class MetadataFiltersControllerTests extends Specification { updatedMetadataResolver.getMetadataFilters().add(updatedFilter) 1 * metadataResolverRepository.findByResourceId(_) >> originalMetadataResolver - 1 * metadataFilterRepository.findByResourceId(_) >> originalFilter 1 * metadataFilterRepository.save(_) >> updatedFilter def filterUUID = updatedFilter.getResourceId() @@ -240,7 +239,6 @@ class MetadataFiltersControllerTests extends Specification { originalMetadataResolver.getMetadataFilters().add(randomFilter) 1 * metadataResolverRepository.findByResourceId(_) >> originalMetadataResolver - 1 * metadataFilterRepository.findByResourceId(_) >> randomFilter def filterUUID = randomFilter.getResourceId() @@ -253,4 +251,4 @@ class MetadataFiltersControllerTests extends Specification { then: result.andExpect(status().is(409)) } -} \ No newline at end of file +} From 8321859fae0455f653a5004a03c12f3c9f05135b Mon Sep 17 00:00:00 2001 From: Dmitriy Kopylenko Date: Wed, 26 Jun 2019 15:09:30 -0400 Subject: [PATCH 10/11] 1263(1321) --- ...lerVersionEndpointsIntegrationTests.groovy | 121 ++++++++++++++++++ ...MetadataFilterEnversVersioningTests.groovy | 7 +- .../MetadataResolversController.java | 31 +++++ .../envers/EnversVersionServiceSupport.java | 4 +- 4 files changed, 156 insertions(+), 7 deletions(-) create mode 100644 backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolverControllerVersionEndpointsIntegrationTests.groovy diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolverControllerVersionEndpointsIntegrationTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolverControllerVersionEndpointsIntegrationTests.groovy new file mode 100644 index 000000000..f23ea333d --- /dev/null +++ b/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) + } +} diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy index 05c8f5ea0..fe1e5eee4 100644 --- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy +++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/envers/MetadataFilterEnversVersioningTests.groovy @@ -14,6 +14,7 @@ import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicHttpMetada 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.domain.resolvers.ResourceBackedMetadataResolver import edu.internet2.tier.shibboleth.admin.ui.repository.FilterRepository import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository @@ -22,7 +23,6 @@ import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.autoconfigure.domain.EntityScan import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest import org.springframework.data.jpa.repository.config.EnableJpaRepositories -import org.springframework.test.annotation.DirtiesContext import org.springframework.test.context.ContextConfiguration import org.springframework.transaction.PlatformTransactionManager import spock.lang.Specification @@ -99,7 +99,6 @@ class MetadataFilterEnversVersioningTests extends Specification { mrv3.metadataFilters[0].removeEmptyEntitiesDescriptors == false } - //@DirtiesContext def "test versioning of MetadataResolver with EntityAttributesFilter"() { when: 'Add initial filter' def mr = new FileBackedHttpMetadataResolver(name: 'resolver') @@ -145,7 +144,6 @@ class MetadataFilterEnversVersioningTests extends Specification { mrv3.metadataFilters[0].attributes[0].attributeValues[0].xsStringvalue == 'attr1, attr2' } - //@DirtiesContext def "test versioning of MetadataResolver with SignatureValidationFilter"() { when: 'Add initial filter' def mr = new DynamicHttpMetadataResolver(name: 'resolver') @@ -238,7 +236,6 @@ class MetadataFilterEnversVersioningTests extends Specification { mrv3.metadataFilters[0].maxValidityInterval == 'PT30S' } - @DirtiesContext def "test versioning of MetadataResolver with NameIdFormatFilter"() { when: 'Add initial filter' def mr = new ResourceBackedMetadataResolver(name: 'resolver') @@ -289,7 +286,7 @@ class MetadataFilterEnversVersioningTests extends Specification { def "test versioning of deleting a filter"() { when: 'Add initial filter' - def mr = new LocalDynamicMetadataResolver(name: 'resolver') + def mr = new MetadataResolver(name: 'resolver') def filter = new EntityRoleWhiteListFilter() mr.metadataFilters.add(filter) diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java index 952c118c2..dbdc0ddd1 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java @@ -5,10 +5,12 @@ import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver; import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolverValidationService; import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.OpenSamlChainingMetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.domain.versioning.Version; import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository; import edu.internet2.tier.shibboleth.admin.ui.service.IndexWriterService; import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverConverterService; import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverService; +import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverVersionService; import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolversPositionOrderContainerService; import edu.internet2.tier.shibboleth.admin.util.OpenSamlChainingMetadataResolverUtil; import lombok.extern.slf4j.Slf4j; @@ -69,6 +71,9 @@ public class MetadataResolversController { @Autowired MetadataResolverConverterService metadataResolverConverterService; + @Autowired + MetadataResolverVersionService versionService; + @ExceptionHandler({InvalidTypeIdException.class, IOException.class, HttpMessageNotReadableException.class}) public ResponseEntity unableToParseJson(Exception ex) { return ResponseEntity.badRequest().body(new ErrorResponse(HttpStatus.BAD_REQUEST.toString(), ex.getMessage(), ex.getCause().getMessage())); @@ -149,6 +154,30 @@ public ResponseEntity update(@PathVariable String resourceId, @RequestBody Me return ResponseEntity.ok(persistedResolver); } + //Versioning endpoints + + @GetMapping("/MetadataResolvers/{resourceId}/Versions") + public ResponseEntity getAllVersions(@PathVariable String resourceId) { + MetadataResolver resolver = resolverRepository.findByResourceId(resourceId); + if (resolver == null) { + return ResponseEntity.notFound().build(); + } + List versions = versionService.findVersionsForMetadataResolver(resourceId); + if (versions.isEmpty()) { + return ResponseEntity.notFound().build(); + } + return ResponseEntity.ok(versions); + } + + @GetMapping("/MetadataResolvers/{resourceId}/Versions/{versionId}") + public ResponseEntity getSpecificVersion(@PathVariable String resourceId, @PathVariable String versionId) { + MetadataResolver resolver = versionService.findSpecificVersionOfMetadataResolver(resourceId, versionId); + if (resolver == null) { + return ResponseEntity.notFound().build(); + } + return ResponseEntity.ok(resolver); + } + @SuppressWarnings("Unchecked") private ResponseEntity validate(MetadataResolver metadataResolver) { ValidationResult validationResult = metadataResolverValidationService.validateIfNecessary(metadataResolver); @@ -159,6 +188,8 @@ private ResponseEntity validate(MetadataResolver metadataResolver) { return null; } + //Private methods + private static URI getResourceUriFor(MetadataResolver resolver) { return ServletUriComponentsBuilder .fromCurrentServletMapping().path("/api/MetadataResolvers/") diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java index ba1631ade..964ede86a 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/envers/EnversVersionServiceSupport.java @@ -24,9 +24,9 @@ public EnversVersionServiceSupport(EntityManager entityManager) { this.entityManager = entityManager; } - public List findVersionsForPersistentEntity(String resourceId, Class enityClass) { + public List findVersionsForPersistentEntity(String resourceId, Class entityClass) { List revs = AuditReaderFactory.get(entityManager).createQuery() - .forRevisionsOfEntity(enityClass, false, false) + .forRevisionsOfEntity(entityClass, false, false) .add(AuditEntity.property("resourceId").eq(resourceId)) .getResultList(); From c1eb428c3d689dc1b1b129eea3f3faccbc4ebe73 Mon Sep 17 00:00:00 2001 From: Jj! Date: Fri, 28 Jun 2019 09:20:10 -0500 Subject: [PATCH 11/11] [SHIBUI-1263] remove Filter versioning since it is rolling up into the resolver --- docs/swagger.yaml | 65 ----------------------------------------------- 1 file changed, 65 deletions(-) diff --git a/docs/swagger.yaml b/docs/swagger.yaml index 0022b801c..8b3566fc6 100644 --- a/docs/swagger.yaml +++ b/docs/swagger.yaml @@ -390,71 +390,6 @@ paths: '409': description: Already Exists deprecated: false - '/MetadataResolvers/{metadataResolverId}/Filters/{resourceId}/Versions': - get: - tags: - - metadata-filters-controller - description: Get list of Versions for an entity descriptor - produces: - - application/json - parameters: - - name: metadataResolverId - in: path - description: metadataResolverId - required: true - type: string - - name: resourceId - in: path - description: resourceId - required: true - type: string - responses: - '200': - description: OK. Items returned should be ordered by `date`, ascending (oldest version first). - schema: - type: array - items: - $ref: '#/definitions/Version' - '401': - description: Unauthorized - '403': - description: Forbidden - '404': - description: Not Found - '/MetadataResolvers/{metadataResolverId}/Filters/{resourceId}/Versions/{versionId}': - get: - tags: - - metadata-filters-controller - description: Get a Version of an entity descriptor - produces: - - application/json - parameters: - - name: metadataResolverId - in: path - description: metadataResolverId - required: true - type: string - - name: resourceId - in: path - description: resourceId - required: true - type: string - - name: versionId - in: path - description: versionId of a version of the EntityDescriptor - required: true - type: string - responses: - '200': - description: OK - schema: - $ref: '#/definitions/MetadataFilter' - '401': - description: Unauthorized - '403': - description: Forbidden - '404': - description: Not Found '/MetadataResolvers/{resourceId}': get: tags: