From fb9eb6a6564a572d8222660c77f83188ae31ea4e Mon Sep 17 00:00:00 2001 From: Bill Smith Date: Fri, 25 May 2018 11:53:46 -0700 Subject: [PATCH] [SHIBUI-517] Added unit tests for all controller operations. --- ...eBackedHttpMetadataProviderController.java | 3 +- ...HttpMetadataProviderControllerTests.groovy | 594 ++++++++++++++++++ ...HttpMetadataResolverRepositoryTests.groovy | 5 +- 3 files changed, 599 insertions(+), 3 deletions(-) create mode 100644 backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/FileBackedHttpMetadataProviderControllerTests.groovy diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/FileBackedHttpMetadataProviderController.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/FileBackedHttpMetadataProviderController.java index 572c728ae..5b8000482 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/FileBackedHttpMetadataProviderController.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/FileBackedHttpMetadataProviderController.java @@ -43,7 +43,7 @@ public ResponseEntity deleteByResourceId(@PathVariable String resourceId) { @GetMapping("/name/{metadataProviderName}") @Transactional(readOnly = true) public ResponseEntity getOneByName(@PathVariable String metadataProviderName) { - FileBackedHttpMetadataResolver resolver = repository.findByResourceId(metadataProviderName); + FileBackedHttpMetadataResolver resolver = repository.findByName(metadataProviderName); if (resolver == null) { return ResponseEntity.notFound().build(); } else { @@ -95,6 +95,7 @@ public ResponseEntity update(@RequestBody FileBackedHttpMetadataResolver reso //TODO: Do we need to set anything else? dates? FileBackedHttpMetadataResolver updatedResolver = repository.save(resolver); + updatedResolver.setVersion(updatedResolver.hashCode()); return ResponseEntity.ok(updatedResolver); } diff --git a/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/FileBackedHttpMetadataProviderControllerTests.groovy b/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/FileBackedHttpMetadataProviderControllerTests.groovy new file mode 100644 index 000000000..377722b5d --- /dev/null +++ b/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/FileBackedHttpMetadataProviderControllerTests.groovy @@ -0,0 +1,594 @@ +package edu.internet2.tier.shibboleth.admin.ui.controller + +import com.fasterxml.jackson.databind.ObjectMapper +import edu.internet2.tier.shibboleth.admin.ui.configuration.CoreShibUiConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.MetadataResolverConfiguration +import edu.internet2.tier.shibboleth.admin.ui.configuration.SearchConfiguration +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FileBackedHttpMetadataResolver +import edu.internet2.tier.shibboleth.admin.ui.repository.FileBackedHttpMetadataResolverRepository +import edu.internet2.tier.shibboleth.admin.ui.util.RandomGenerator +import edu.internet2.tier.shibboleth.admin.ui.util.TestObjectGenerator +import groovy.json.JsonOutput +import groovy.json.JsonSlurper +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.test.web.servlet.setup.MockMvcBuilders +import spock.lang.Specification + +import static org.hamcrest.CoreMatchers.containsString +import static org.springframework.http.MediaType.APPLICATION_JSON_UTF8 +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.* +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.* + +/** + * @author Bill Smith (wsmith@unicon.net) + */ +@DataJpaTest +@ContextConfiguration(classes=[CoreShibUiConfiguration, SearchConfiguration, MetadataResolverConfiguration]) +@EnableJpaRepositories(basePackages = ["edu.internet2.tier.shibboleth.admin.ui"]) +@EntityScan("edu.internet2.tier.shibboleth.admin.ui") +class FileBackedHttpMetadataProviderControllerTests extends Specification { + TestObjectGenerator testObjectGenerator + RandomGenerator randomGenerator + ObjectMapper mapper + + def repository = Mock(FileBackedHttpMetadataResolverRepository) + def controller + def mockMvc + + def setup() { + randomGenerator = new RandomGenerator() + //testObjectGenerator = new TestObjectGenerator(attributeUtility) + mapper = new ObjectMapper() + + controller = new FileBackedHttpMetadataProviderController ( + repository: repository + ) + + mockMvc = MockMvcBuilders.standaloneSetup(controller).build() + } + + def "DELETE deletes the desired resolver"() { + given: + def randomResourceId = randomGenerator.randomId() + + 1 * repository.deleteByResourceId(randomResourceId) >> true + + when: + def result = mockMvc.perform( + delete("/api/MetadataProvider/FileBackedHttp/$randomResourceId")) + + then: + result.andExpect(status().isAccepted()) + } + + def "DELETE returns error when desired resolver is not found"() { + given: + def randomResourceId = randomGenerator.randomId() + + 1 * repository.deleteByResourceId(randomResourceId) >> false + + when: + def result = mockMvc.perform( + delete("/api/MetadataProvider/FileBackedHttp/$randomResourceId")) + + then: + result.andExpect(status().isNotFound()) + } + + def "POST a new resolver properly persists and returns the new persisted resolver"() { + given: + def postedJsonBody = '''{ + "name": "name", + "requireValidMetadata": true, + "failFastInitialization": true, + "sortKey": 7, + "criterionPredicateRegistryRef": "criterionPredicateRegistryRef", + "useDefaultPredicateRegistry": true, + "satisfyAnyPredicates": true, + "metadataFilters": [], + "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef", + "taskTimerRef": "taskTimerRef", + "minRefreshDelay": "minRefreshDelay", + "maxRefreshDelay": "maxRefreshDelay", + "refreshDelayFactor": 1.0, + "indexesRef": "indexesRef", + "resolveViaPredicatesOnly": true, + "expirationWarningThreshold": "expirationWarningThreshold" + }, + "httpMetadataResolverAttributes": { + "httpClientRef": "httpClientRef", + "connectionRequestTimeout": "connectionRequestTimeout", + "requestTimeout": "requestTimeout", + "socketTimeout": "socketTimeout", + "disregardTLSCertificate": true, + "tlsTrustEngineRef": "tlsTrustEngineRef", + "httpClientSecurityParametersRef": "httpClientSecurityParametersRef", + "proxyHost": "proxyHost", + "proxyPort": "proxyPort", + "proxyUser": "proxyUser", + "proxyPassword": "proxyPassword", + "httpCaching": "none", + "httpCacheDirectory": "httpCacheDirectory", + "httpMaxCacheEntries": 1, + "httpMaxCacheEntrySize": 2 + } +}''' + def resolver = new ObjectMapper().readValue(postedJsonBody.bytes, FileBackedHttpMetadataResolver) + 1 * repository.findByName(resolver.getName()) >> null + 1 * repository.save(_) >> resolver + + def expectedResolverUUID = resolver.getResourceId() + def expectedResponseHeader = 'Location' + def expectedResponseHeaderValue = "/api/MetadataProvider/FileBackedHttp/$expectedResolverUUID" + + when: + def result = mockMvc.perform( + post('/api/MetadataProvider/FileBackedHttp') + .contentType(APPLICATION_JSON_UTF8) + .content(postedJsonBody)) + + then: + result.andExpect(status().isCreated()) + .andExpect(content().json(postedJsonBody, false)) + .andExpect(header().string(expectedResponseHeader, containsString(expectedResponseHeaderValue))) + + } + + def "POST a new resolver that has a name of a persisted resolver returns conflict"() { + given: + def randomResolverName = randomGenerator.randomString(10) + def postedJsonBody = """{ + "name": "$randomResolverName", + "requireValidMetadata": true, + "failFastInitialization": true, + "sortKey": 7, + "criterionPredicateRegistryRef": "criterionPredicateRegistryRef", + "useDefaultPredicateRegistry": true, + "satisfyAnyPredicates": true, + "metadataFilters": [], + "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef", + "taskTimerRef": "taskTimerRef", + "minRefreshDelay": "minRefreshDelay", + "maxRefreshDelay": "maxRefreshDelay", + "refreshDelayFactor": 1.0, + "indexesRef": "indexesRef", + "resolveViaPredicatesOnly": true, + "expirationWarningThreshold": "expirationWarningThreshold" + }, + "httpMetadataResolverAttributes": { + "httpClientRef": "httpClientRef", + "connectionRequestTimeout": "connectionRequestTimeout", + "requestTimeout": "requestTimeout", + "socketTimeout": "socketTimeout", + "disregardTLSCertificate": true, + "tlsTrustEngineRef": "tlsTrustEngineRef", + "httpClientSecurityParametersRef": "httpClientSecurityParametersRef", + "proxyHost": "proxyHost", + "proxyPort": "proxyPort", + "proxyUser": "proxyUser", + "proxyPassword": "proxyPassword", + "httpCaching": "none", + "httpCacheDirectory": "httpCacheDirectory", + "httpMaxCacheEntries": 1, + "httpMaxCacheEntrySize": 2 + } +}""" + def resolver = new ObjectMapper().readValue(postedJsonBody.bytes, FileBackedHttpMetadataResolver) + 1 * repository.findByName(randomResolverName) >> resolver + 0 * repository.save(_) + + when: + def result = mockMvc.perform( + post('/api/MetadataProvider/FileBackedHttp') + .contentType(APPLICATION_JSON_UTF8) + .content(postedJsonBody)) + + then: + result.andExpect(status().isConflict()) + } + + def "GET by resourceId returns the desired persisted resolver"() { + given: + def randomUUID = randomGenerator.randomId() + def resolverJson = """{ + "name": "name", + "resourceId": "$randomUUID", + "requireValidMetadata": true, + "failFastInitialization": true, + "sortKey": 7, + "criterionPredicateRegistryRef": "criterionPredicateRegistryRef", + "useDefaultPredicateRegistry": true, + "satisfyAnyPredicates": true, + "metadataFilters": [], + "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef", + "taskTimerRef": "taskTimerRef", + "minRefreshDelay": "minRefreshDelay", + "maxRefreshDelay": "maxRefreshDelay", + "refreshDelayFactor": 1.0, + "indexesRef": "indexesRef", + "resolveViaPredicatesOnly": true, + "expirationWarningThreshold": "expirationWarningThreshold" + }, + "httpMetadataResolverAttributes": { + "httpClientRef": "httpClientRef", + "connectionRequestTimeout": "connectionRequestTimeout", + "requestTimeout": "requestTimeout", + "socketTimeout": "socketTimeout", + "disregardTLSCertificate": true, + "tlsTrustEngineRef": "tlsTrustEngineRef", + "httpClientSecurityParametersRef": "httpClientSecurityParametersRef", + "proxyHost": "proxyHost", + "proxyPort": "proxyPort", + "proxyUser": "proxyUser", + "proxyPassword": "proxyPassword", + "httpCaching": "none", + "httpCacheDirectory": "httpCacheDirectory", + "httpMaxCacheEntries": 1, + "httpMaxCacheEntrySize": 2 + } +}""" + + def resolver = new ObjectMapper().readValue(resolverJson.bytes, FileBackedHttpMetadataResolver) + resolver.setResourceId(randomUUID) + + 1 * repository.findByResourceId(randomUUID) >> resolver + + def expectedResponseContentType = APPLICATION_JSON_UTF8 + + when: + def result = mockMvc.perform( + get("/api/MetadataProvider/FileBackedHttp/$randomUUID")) + + then: + result.andExpect(status().isOk()) + .andExpect(content().contentType(expectedResponseContentType)) + .andExpect(content().json(resolverJson, false)) + } + + def "GET by unknown resource id returns not found"() { + given: + def randomResourceId = randomGenerator.randomId() + + 1 * repository.findByResourceId(randomResourceId) >> null + + when: + def result = mockMvc.perform( + get("/api/MetadataProvider/FileBackedHttp/$randomResourceId")) + + then: + result.andExpect(status().isNotFound()) + } + + def "GET by resolver name returns the desired persisted resolver"() { + given: + def randomResolverName = randomGenerator.randomString(10) + def resolverJson = """{ + "name": "$randomResolverName", + "requireValidMetadata": true, + "failFastInitialization": true, + "sortKey": 7, + "criterionPredicateRegistryRef": "criterionPredicateRegistryRef", + "useDefaultPredicateRegistry": true, + "satisfyAnyPredicates": true, + "metadataFilters": [], + "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef", + "taskTimerRef": "taskTimerRef", + "minRefreshDelay": "minRefreshDelay", + "maxRefreshDelay": "maxRefreshDelay", + "refreshDelayFactor": 1.0, + "indexesRef": "indexesRef", + "resolveViaPredicatesOnly": true, + "expirationWarningThreshold": "expirationWarningThreshold" + }, + "httpMetadataResolverAttributes": { + "httpClientRef": "httpClientRef", + "connectionRequestTimeout": "connectionRequestTimeout", + "requestTimeout": "requestTimeout", + "socketTimeout": "socketTimeout", + "disregardTLSCertificate": true, + "tlsTrustEngineRef": "tlsTrustEngineRef", + "httpClientSecurityParametersRef": "httpClientSecurityParametersRef", + "proxyHost": "proxyHost", + "proxyPort": "proxyPort", + "proxyUser": "proxyUser", + "proxyPassword": "proxyPassword", + "httpCaching": "none", + "httpCacheDirectory": "httpCacheDirectory", + "httpMaxCacheEntries": 1, + "httpMaxCacheEntrySize": 2 + } +}""" + + def resolver = new ObjectMapper().readValue(resolverJson.bytes, FileBackedHttpMetadataResolver) + + 1 * repository.findByName(randomResolverName) >> resolver + + def expectedResponseContentType = APPLICATION_JSON_UTF8 + + when: + def result = mockMvc.perform( + get("/api/MetadataProvider/FileBackedHttp/name/$randomResolverName")) + + then: + result.andExpect(status().isOk()) + .andExpect(content().contentType(expectedResponseContentType)) + .andExpect(content().json(resolverJson, false)) + } + + def "GET by unknown resolver name returns not found"() { + given: + def randomResolverName = randomGenerator.randomString(10) + + 1 * repository.findByName(randomResolverName) >> null + + when: + def result = mockMvc.perform( + get("/api/MetadataProvider/FileBackedHttp/name/$randomResolverName")) + + then: + result.andExpect(status().isNotFound()) + } + + def "PUT allows for a successful update of an already-persisted resolver"() { + given: + def randomResourceId = "resourceId" + def existingResolverJson = """{ + "name": "name", + "resourceId": "$randomResourceId", + "requireValidMetadata": true, + "failFastInitialization": true, + "sortKey": 7, + "criterionPredicateRegistryRef": "criterionPredicateRegistryRef", + "useDefaultPredicateRegistry": true, + "satisfyAnyPredicates": true, + "metadataFilters": [], + "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef", + "taskTimerRef": "taskTimerRef", + "minRefreshDelay": "minRefreshDelay", + "maxRefreshDelay": "maxRefreshDelay", + "refreshDelayFactor": 1.0, + "indexesRef": "indexesRef", + "resolveViaPredicatesOnly": true, + "expirationWarningThreshold": "expirationWarningThreshold" + }, + "httpMetadataResolverAttributes": { + "httpClientRef": "httpClientRef", + "connectionRequestTimeout": "connectionRequestTimeout", + "requestTimeout": "requestTimeout", + "socketTimeout": "socketTimeout", + "disregardTLSCertificate": true, + "tlsTrustEngineRef": "tlsTrustEngineRef", + "httpClientSecurityParametersRef": "httpClientSecurityParametersRef", + "proxyHost": "proxyHost", + "proxyPort": "proxyPort", + "proxyUser": "proxyUser", + "proxyPassword": "proxyPassword", + "httpCaching": "none", + "httpCacheDirectory": "httpCacheDirectory", + "httpMaxCacheEntries": 1, + "httpMaxCacheEntrySize": 2 + } +}""" + def existingResolver = new ObjectMapper().readValue(existingResolverJson.bytes, FileBackedHttpMetadataResolver) + def existingResolverVersion = existingResolver.hashCode() + + def randomName = randomGenerator.randomString(10) + def postedJsonBody = """{ + "name": "$randomName", + "resourceId": "$randomResourceId", + "version": "$existingResolverVersion", + "requireValidMetadata": true, + "failFastInitialization": true, + "sortKey": 7, + "criterionPredicateRegistryRef": "criterionPredicateRegistryRef", + "useDefaultPredicateRegistry": true, + "satisfyAnyPredicates": true, + "metadataFilters": [], + "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef", + "taskTimerRef": "taskTimerRef", + "minRefreshDelay": "minRefreshDelay", + "maxRefreshDelay": "maxRefreshDelay", + "refreshDelayFactor": 1.0, + "indexesRef": "indexesRef", + "resolveViaPredicatesOnly": true, + "expirationWarningThreshold": "expirationWarningThreshold" + }, + "httpMetadataResolverAttributes": { + "httpClientRef": "httpClientRef", + "connectionRequestTimeout": "connectionRequestTimeout", + "requestTimeout": "requestTimeout", + "socketTimeout": "socketTimeout", + "disregardTLSCertificate": true, + "tlsTrustEngineRef": "tlsTrustEngineRef", + "httpClientSecurityParametersRef": "httpClientSecurityParametersRef", + "proxyHost": "proxyHost", + "proxyPort": "proxyPort", + "proxyUser": "proxyUser", + "proxyPassword": "proxyPassword", + "httpCaching": "none", + "httpCacheDirectory": "httpCacheDirectory", + "httpMaxCacheEntries": 1, + "httpMaxCacheEntrySize": 2 + } +}""" + def updatedResolver = new ObjectMapper().readValue(postedJsonBody.bytes, FileBackedHttpMetadataResolver) + 1 * repository.findByResourceId(randomResourceId) >> existingResolver + 1 * repository.save(_) >> updatedResolver + + def expectedResponseContentType = APPLICATION_JSON_UTF8 + + when: + def result = mockMvc.perform( + put('/api/MetadataProvider/FileBackedHttp') + .contentType(APPLICATION_JSON_UTF8) + .content(postedJsonBody)) + + then: + def expectedJson = new JsonSlurper().parseText(postedJsonBody) + expectedJson << [version: updatedResolver.hashCode()] + result.andExpect(status().isOk()) + .andExpect(content().contentType(expectedResponseContentType)) + .andExpect(content().json(JsonOutput.toJson(expectedJson), false)) + } + + def "PUT of an updated resolver with an incorrect version returns a conflict"() { + given: + def randomResourceId = "resourceId" + def existingResolverJson = """{ + "name": "name", + "resourceId": "$randomResourceId", + "requireValidMetadata": true, + "failFastInitialization": true, + "sortKey": 7, + "criterionPredicateRegistryRef": "criterionPredicateRegistryRef", + "useDefaultPredicateRegistry": true, + "satisfyAnyPredicates": true, + "metadataFilters": [], + "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef", + "taskTimerRef": "taskTimerRef", + "minRefreshDelay": "minRefreshDelay", + "maxRefreshDelay": "maxRefreshDelay", + "refreshDelayFactor": 1.0, + "indexesRef": "indexesRef", + "resolveViaPredicatesOnly": true, + "expirationWarningThreshold": "expirationWarningThreshold" + }, + "httpMetadataResolverAttributes": { + "httpClientRef": "httpClientRef", + "connectionRequestTimeout": "connectionRequestTimeout", + "requestTimeout": "requestTimeout", + "socketTimeout": "socketTimeout", + "disregardTLSCertificate": true, + "tlsTrustEngineRef": "tlsTrustEngineRef", + "httpClientSecurityParametersRef": "httpClientSecurityParametersRef", + "proxyHost": "proxyHost", + "proxyPort": "proxyPort", + "proxyUser": "proxyUser", + "proxyPassword": "proxyPassword", + "httpCaching": "none", + "httpCacheDirectory": "httpCacheDirectory", + "httpMaxCacheEntries": 1, + "httpMaxCacheEntrySize": 2 + } +}""" + def existingResolver = new ObjectMapper().readValue(existingResolverJson.bytes, FileBackedHttpMetadataResolver) + def existingResolverVersion = existingResolver.hashCode() + + def randomName = randomGenerator.randomString(10) + def randomVersion = randomGenerator.randomInt() + def postedJsonBody = """{ + "name": "$randomName", + "resourceId": "$randomResourceId", + "version": "$randomVersion", + "requireValidMetadata": true, + "failFastInitialization": true, + "sortKey": 7, + "criterionPredicateRegistryRef": "criterionPredicateRegistryRef", + "useDefaultPredicateRegistry": true, + "satisfyAnyPredicates": true, + "metadataFilters": [], + "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef", + "taskTimerRef": "taskTimerRef", + "minRefreshDelay": "minRefreshDelay", + "maxRefreshDelay": "maxRefreshDelay", + "refreshDelayFactor": 1.0, + "indexesRef": "indexesRef", + "resolveViaPredicatesOnly": true, + "expirationWarningThreshold": "expirationWarningThreshold" + }, + "httpMetadataResolverAttributes": { + "httpClientRef": "httpClientRef", + "connectionRequestTimeout": "connectionRequestTimeout", + "requestTimeout": "requestTimeout", + "socketTimeout": "socketTimeout", + "disregardTLSCertificate": true, + "tlsTrustEngineRef": "tlsTrustEngineRef", + "httpClientSecurityParametersRef": "httpClientSecurityParametersRef", + "proxyHost": "proxyHost", + "proxyPort": "proxyPort", + "proxyUser": "proxyUser", + "proxyPassword": "proxyPassword", + "httpCaching": "none", + "httpCacheDirectory": "httpCacheDirectory", + "httpMaxCacheEntries": 1, + "httpMaxCacheEntrySize": 2 + } +}""" + 1 * repository.findByResourceId(randomResourceId) >> existingResolver + 0 * repository.save(_) + + when: + def result = mockMvc.perform( + put('/api/MetadataProvider/FileBackedHttp') + .contentType(APPLICATION_JSON_UTF8) + .content(postedJsonBody)) + + then: + result.andExpect(status().isConflict()) + } + + def "PUT of a resolver that is not persisted returns not found"() { + given: + def randomResourceId = randomGenerator.randomId() + def postedJsonBody = """{ + "name": "name", + "resourceId": "$randomResourceId", + "requireValidMetadata": true, + "failFastInitialization": true, + "sortKey": 7, + "criterionPredicateRegistryRef": "criterionPredicateRegistryRef", + "useDefaultPredicateRegistry": true, + "satisfyAnyPredicates": true, + "metadataFilters": [], + "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef", + "taskTimerRef": "taskTimerRef", + "minRefreshDelay": "minRefreshDelay", + "maxRefreshDelay": "maxRefreshDelay", + "refreshDelayFactor": 1.0, + "indexesRef": "indexesRef", + "resolveViaPredicatesOnly": true, + "expirationWarningThreshold": "expirationWarningThreshold" + }, + "httpMetadataResolverAttributes": { + "httpClientRef": "httpClientRef", + "connectionRequestTimeout": "connectionRequestTimeout", + "requestTimeout": "requestTimeout", + "socketTimeout": "socketTimeout", + "disregardTLSCertificate": true, + "tlsTrustEngineRef": "tlsTrustEngineRef", + "httpClientSecurityParametersRef": "httpClientSecurityParametersRef", + "proxyHost": "proxyHost", + "proxyPort": "proxyPort", + "proxyUser": "proxyUser", + "proxyPassword": "proxyPassword", + "httpCaching": "none", + "httpCacheDirectory": "httpCacheDirectory", + "httpMaxCacheEntries": 1, + "httpMaxCacheEntrySize": 2 + } +}""" + 1 * repository.findByResourceId(randomResourceId) >> null + 0 * repository.save(_) + + when: + def result = mockMvc.perform( + put('/api/MetadataProvider/FileBackedHttp') + .contentType(APPLICATION_JSON_UTF8) + .content(postedJsonBody)) + + then: + result.andExpect(status().isNotFound()) + } +} diff --git a/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/FileBackedHttpMetadataResolverRepositoryTests.groovy b/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/FileBackedHttpMetadataResolverRepositoryTests.groovy index d4aea60ba..d0beb24d2 100644 --- a/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/FileBackedHttpMetadataResolverRepositoryTests.groovy +++ b/backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/repository/FileBackedHttpMetadataResolverRepositoryTests.groovy @@ -80,7 +80,8 @@ class FileBackedHttpMetadataResolverRepositoryTests extends Specification { def "FileBackedHttpMetadataResolver hashcode works as desired"() { given: - // TODO: Ask JJ why an empty reloadableMetadataResolverAttributes object results in a null object for item2 below + // TODO: There is weirdness here if reloadableMetadataResolverAttributes is empty. + // I suspect similar weirdness if httpMetadataResolverAttributes is an empty object, too. def resolverJson = '''{ "name": "name", "requireValidMetadata": true, @@ -91,6 +92,7 @@ class FileBackedHttpMetadataResolverRepositoryTests extends Specification { "satisfyAnyPredicates": true, "metadataFilters": [], "reloadableMetadataResolverAttributes": { + "parserPoolRef": "parserPoolRef" }, "httpMetadataResolverAttributes": { "httpClientRef": "httpClientRef", @@ -117,7 +119,6 @@ class FileBackedHttpMetadataResolverRepositoryTests extends Specification { entityManager.flush() then: - entityManager.clear() def item1 = repositoryUnderTest.findByResourceId(persistedResolver.resourceId) entityManager.clear() def item2 = repositoryUnderTest.findByResourceId(persistedResolver.resourceId)