ms/blueprintsprocessor/modules/commons/rest-lib/src/test/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/rest/service/BluePrintRestLibPropertyServiceTest.kt

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  * Modifications Copyright © 2018 IBM.
   4  * Modifications Copyright © 2019 Huawei.
   5  * Modifications Copyright © 2019 Bell Canada.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 package org.onap.ccsdk.cds.blueprintsprocessor.rest.service
  21
  22 import com.fasterxml.jackson.databind.JsonNode
  23 import com.fasterxml.jackson.databind.ObjectMapper
  24 import org.junit.Test
  25 import org.junit.runner.RunWith
  26 import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
  27 import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
  28 import org.onap.ccsdk.cds.blueprintsprocessor.rest.BluePrintRestLibConfiguration
  29 import org.onap.ccsdk.cds.blueprintsprocessor.rest.SSLBasicAuthRestClientProperties
  30 import org.onap.ccsdk.cds.blueprintsprocessor.rest.SSLRestClientProperties
  31 import org.onap.ccsdk.cds.blueprintsprocessor.rest.SSLTokenAuthRestClientProperties
  32 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
  33 import org.springframework.beans.factory.annotation.Autowired
  34 import org.springframework.http.HttpHeaders
  35 import org.springframework.http.MediaType
  36 import org.springframework.test.context.ContextConfiguration
  37 import org.springframework.test.context.TestPropertySource
  38 import org.springframework.test.context.junit4.SpringRunner
  39 import kotlin.test.assertEquals
  40 import kotlin.test.assertFailsWith
  41 import kotlin.test.assertNotNull
  42 import kotlin.test.assertTrue
  43
  44 @RunWith(SpringRunner::class)
  45 @ContextConfiguration(
  46     classes = [
  47         BluePrintRestLibConfiguration::class, BluePrintPropertyConfiguration::class,
  48         BluePrintPropertiesService::class
  49     ]
  50 )
  51 @TestPropertySource(
  52     properties =
  53         [
  54             "blueprintsprocessor.restclient.sample.type=basic-auth",
  55             "blueprintsprocessor.restclient.sample.url=http://localhost:8080",
  56             "blueprintsprocessor.restclient.sample.userId=sampleuser",
  57             "blueprintsprocessor.restclient.sslbasic.type=ssl-basic-auth",
  58             "blueprintsprocessor.restclient.sslbasic.url=https://localhost:8443",
  59             "blueprintsprocessor.restclient.sslbasic.username=admin",
  60             "blueprintsprocessor.restclient.sslbasic.password=cds",
  61             "blueprintsprocessor.restclient.sslbasic.keyStoreInstance=PKCS12",
  62             "blueprintsprocessor.restclient.sslbasic.sslTrust=src/test/resources/keystore.p12",
  63             "blueprintsprocessor.restclient.sslbasic.sslTrustPassword=changeit",
  64             "blueprintsprocessor.restclient.ssltoken.type=ssl-token-auth",
  65             "blueprintsprocessor.restclient.ssltoken.url=https://localhost:8443",
  66             "blueprintsprocessor.restclient.ssltoken.token=72178473kjshdkjgvbsdkjv903274908",
  67             "blueprintsprocessor.restclient.ssltoken.keyStoreInstance=PKCS12",
  68             "blueprintsprocessor.restclient.ssltoken.sslTrust=src/test/resources/keystore.p12",
  69             "blueprintsprocessor.restclient.ssltoken.sslTrustPassword=changeit",
  70             "blueprintsprocessor.restclient.ssl.type=ssl-no-auth",
  71             "blueprintsprocessor.restclient.ssl.url=https://localhost:8443",
  72             "blueprintsprocessor.restclient.ssl.keyStoreInstance=PKCS12",
  73             "blueprintsprocessor.restclient.ssl.sslTrust=src/test/resources/keystore.p12",
  74             "blueprintsprocessor.restclient.ssl.sslTrustPassword=changeit",
  75             "blueprintsprocessor.restclient.ssl.sslKey=src/test/resources/keystore.p12",
  76             "blueprintsprocessor.restclient.ssl.sslKeyPassword=changeit"
  77         ]
  78 )
  79 class BluePrintRestLibPropertyServiceTest {
  80
  81     @Autowired
  82     lateinit var bluePrintRestLibPropertyService: BluePrintRestLibPropertyService
  83
  84     @Test
  85     fun testRestClientProperties() {
  86         val properties = bluePrintRestLibPropertyService.restClientProperties(
  87             "blueprintsprocessor.restclient.sample"
  88         )
  89         assertNotNull(properties, "failed to create property bean")
  90         assertNotNull(
  91             properties.url,
  92             "failed to get url property in" +
  93                 " property bean"
  94         )
  95     }
  96
  97     @Test
  98     fun testSSLBasicProperties() {
  99         val properties = bluePrintRestLibPropertyService.restClientProperties(
 100             "blueprintsprocessor.restclient.sslbasic"
 101         )
 102         assertNotNull(properties, "failed to create property bean")
 103         val p: SSLBasicAuthRestClientProperties =
 104             properties as SSLBasicAuthRestClientProperties
 105
 106         assertEquals(p.username, "admin")
 107         assertEquals(p.password, "cds")
 108         assertEquals(p.sslTrust, "src/test/resources/keystore.p12")
 109         assertEquals(p.sslTrustPassword, "changeit")
 110         assertEquals(p.keyStoreInstance, "PKCS12")
 111     }
 112
 113     @Test
 114     fun testSSLTokenProperties() {
 115         val properties = bluePrintRestLibPropertyService.restClientProperties(
 116             "blueprintsprocessor.restclient.ssltoken"
 117         )
 118         assertNotNull(properties, "failed to create property bean")
 119
 120         val p: SSLTokenAuthRestClientProperties =
 121             properties as SSLTokenAuthRestClientProperties
 122
 123         assertEquals(p.tokenAuth!!.token!!, "72178473kjshdkjgvbsdkjv903274908")
 124         assertEquals(p.sslTrust, "src/test/resources/keystore.p12")
 125         assertEquals(p.sslTrustPassword, "changeit")
 126         assertEquals(p.keyStoreInstance, "PKCS12")
 127     }
 128
 129     @Test
 130     fun testSSLNoAuthProperties() {
 131         val properties = bluePrintRestLibPropertyService.restClientProperties(
 132             "blueprintsprocessor.restclient.ssl"
 133         )
 134         assertNotNull(properties, "failed to create property bean")
 135
 136         val p: SSLRestClientProperties =
 137             properties as SSLRestClientProperties
 138
 139         assertEquals(p.sslTrust, "src/test/resources/keystore.p12")
 140         assertEquals(p.sslTrustPassword, "changeit")
 141         assertEquals(p.keyStoreInstance, "PKCS12")
 142         assertEquals(p.sslKey, "src/test/resources/keystore.p12")
 143         assertEquals(p.sslKeyPassword, "changeit")
 144     }
 145
 146     @Test
 147     fun testSSLBasicPropertiesAsJson() {
 148         val actualObj: JsonNode = defaultMapper.readTree(sslBasicAuthEndpointWithHeadersField())
 149         val properties = bluePrintRestLibPropertyService.restClientProperties(
 150             actualObj
 151         )
 152         assertNotNull(properties, "failed to create property bean")
 153         val p: SSLBasicAuthRestClientProperties = properties as SSLBasicAuthRestClientProperties
 154
 155         assertEquals("admin", p.username)
 156         assertEquals("cds", p.password)
 157         assertEquals("src/test/resources/keystore.p12", p.sslTrust)
 158         assertEquals("changeit", p.sslTrustPassword)
 159         assertEquals("PKCS12", p.keyStoreInstance)
 160         assertEquals("ssl-basic-auth", p.type)
 161         assertEquals("https://localhost:8443", p.url)
 162     }
 163
 164     @Test
 165     fun testSSLTokenPropertiesAsJson() {
 166         val actualObj: JsonNode = defaultMapper.readTree(sslTokenAuthEndpointWithHeadersField())
 167         val properties =
 168             bluePrintRestLibPropertyService.restClientProperties(actualObj)
 169         assertNotNull(properties, "failed to create property bean")
 170
 171         val p: SSLTokenAuthRestClientProperties = properties as SSLTokenAuthRestClientProperties
 172
 173         assertEquals("72178473kjshdkjgvbsdkjv903274908", p.tokenAuth!!.token!!)
 174         assertEquals("src/test/resources/keystore.p12", p.sslTrust)
 175         assertEquals("changeit", p.sslTrustPassword)
 176         assertEquals("PKCS12", p.keyStoreInstance)
 177         assertEquals("ssl-token-auth", p.type)
 178         assertEquals("https://localhost:8443", p.url)
 179     }
 180
 181     @Test
 182     fun testSSLNoAuthPropertiesAsJson() {
 183         val actualObj: JsonNode = defaultMapper.readTree(sslNoAuthEndpointWithHeadersField())
 184         val properties = bluePrintRestLibPropertyService.restClientProperties(
 185             actualObj
 186         )
 187         assertNotNull(properties, "failed to create property bean")
 188
 189         val p: SSLRestClientProperties =
 190             properties as SSLRestClientProperties
 191
 192         assertEquals("src/test/resources/keystore.p12", p.sslTrust)
 193         assertEquals("changeit", p.sslTrustPassword)
 194         assertEquals("PKCS12", p.keyStoreInstance)
 195         assertEquals("src/test/resources/keystore.p12", p.sslKey)
 196         assertEquals("changeit", p.sslKeyPassword)
 197         assertEquals("ssl-no-auth", p.type)
 198         assertEquals("https://localhost:8443", p.url)
 199     }
 200
 201     @Test
 202     fun testSSLNoDefHeadersPropertiesAsJson() {
 203         val actualObj: JsonNode = defaultMapper.readTree(sslNoDefHeadersField())
 204         val properties = bluePrintRestLibPropertyService.restClientProperties(
 205             actualObj
 206         )
 207         assertNotNull(properties, "failed to create property bean")
 208
 209         val p: SSLRestClientProperties =
 210             properties as SSLRestClientProperties
 211
 212         assertEquals("src/test/resources/keystore.p12", p.sslTrust)
 213         assertEquals("changeit", p.sslTrustPassword)
 214         assertEquals("PKCS12", p.keyStoreInstance)
 215         assertEquals("src/test/resources/keystore.p12", p.sslKey)
 216         assertEquals("changeit", p.sslKeyPassword)
 217         assertEquals("ssl-no-def-headers", p.type)
 218         assertEquals("https://localhost:8443", p.url)
 219         assertTrue(p.values.containsKey("type"))
 220     }
 221
 222     @Test
 223     fun testNoDefHeadersPropertiesAsJson() {
 224         val actualObj: JsonNode = defaultMapper.readTree(noDefaultHeadersField())
 225         val p = bluePrintRestLibPropertyService.restClientProperties(
 226             actualObj
 227         )
 228         assertNotNull(p, "failed to create property bean")
 229
 230         assertEquals("no-def-headers", p.type)
 231         assertEquals("http://127.0.0.1:8000", p.url)
 232         assertTrue(p.values.containsKey("type"))
 233     }
 234
 235     @Test
 236     fun testBlueprintWebClientService() {
 237         val blueprintWebClientService = bluePrintRestLibPropertyService
 238             .blueprintWebClientService("sample")
 239         assertNotNull(
 240             blueprintWebClientService,
 241             "failed to create blueprintWebClientService"
 242         )
 243     }
 244
 245     @Test
 246     fun testBlueprintWebClientServiceWithJsonNode() {
 247         val actualObj: JsonNode = defaultMapper.readTree(sslBasicAuthEndpointWithHeadersField())
 248         val blueprintWebClientService = bluePrintRestLibPropertyService
 249             .blueprintWebClientService(actualObj)
 250         assertNotNull(blueprintWebClientService, "failed to create blueprintWebClientService")
 251     }
 252
 253     @Test
 254     fun testNoHeadersForNoDefaultHeaderService() {
 255         val actualObj: JsonNode = defaultMapper.readTree(noDefaultHeadersField())
 256         val blueprintWebClientService = bluePrintRestLibPropertyService
 257             .blueprintWebClientService(actualObj)
 258         assertEquals(0, blueprintWebClientService.defaultHeaders().size)
 259     }
 260
 261     @Test
 262     fun testNoHeadersForSSLNoDefaultHeaderService() {
 263         val actualObj: JsonNode = defaultMapper.readTree(sslNoDefHeadersField())
 264         val blueprintWebClientService = bluePrintRestLibPropertyService
 265             .blueprintWebClientService(actualObj)
 266         assertEquals(0, blueprintWebClientService.defaultHeaders().size)
 267     }
 268
 269     // pass the result of $typeEndpointWithHeadersField() output with and without headers to compare.
 270     private fun validateHeadersDidNotChangeWithEmptyAdditionalHeaders(noHeaders: String, withHeaders: String) {
 271         val parsedObj: JsonNode = defaultMapper.readTree(noHeaders)
 272         val bpWebClientService =
 273             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 274         val extractedHeaders = bpWebClientService.convertToBasicHeaders(mapOf())
 275
 276         val parsedObjWithHeaders: JsonNode = defaultMapper.readTree(withHeaders)
 277         val bpWebClientServiceWithHeaders =
 278             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObjWithHeaders)
 279         val extractedHeadersWithAdditionalHeaders = bpWebClientServiceWithHeaders.convertToBasicHeaders(mapOf())
 280         // Array<BasicHeader<>> -> Map<String,String>
 281         val headersMap = extractedHeaders.map { it.name to it.value }.toMap()
 282         val additionalHeadersMap = extractedHeadersWithAdditionalHeaders.map { it.name to it.value }.toMap()
 283         assertEquals(headersMap, additionalHeadersMap)
 284     }
 285
 286     @Test
 287     fun `BasicAuth WebClientService with empty additionalHeaders does not modify headers`() {
 288         val endPointJson = basicAuthEndpointWithHeadersField()
 289         val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(emptyAdditionalHeaders)
 290         validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
 291     }
 292
 293     private fun acceptsOneAdditionalHeadersTest(endPointWithHeadersJson: String) {
 294         val parsedObj: JsonNode = defaultMapper.readTree(endPointWithHeadersJson)
 295         val bpWebClientService =
 296             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 297         val extractedHeaders = bpWebClientService.convertToBasicHeaders(mapOf())
 298         assertEquals(1, extractedHeaders.filter { it.name == "key1" }.count())
 299     }
 300
 301     @Test
 302     fun `BasicAuth WebClientService accepts one additionalHeaders`() {
 303         val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(oneAdditionalParameter)
 304         acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
 305     }
 306
 307     private fun acceptsMultipleAdditionalHeaders(endPointWithHeadersJson: String) {
 308         val parsedObj: JsonNode = defaultMapper.readTree(endPointWithHeadersJson)
 309         val bpWebClientService =
 310             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 311         val extractedHeaders = bpWebClientService.convertToBasicHeaders(mapOf())
 312         assertEquals(1, extractedHeaders.filter { it.name == "key1" }.count())
 313         assertEquals(1, extractedHeaders.filter { it.name == "key2" }.count())
 314         assertEquals(1, extractedHeaders.filter { it.name == "key3" }.count())
 315     }
 316
 317     @Test
 318     fun `BasicAuth WebClientService accepts multiple additionalHeaders`() {
 319         val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(threeAdditionalHeaders)
 320         acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
 321     }
 322
 323     private fun additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson: String) {
 324         val parsedObj: JsonNode = defaultMapper.readTree(endPointWithHeadersJson)
 325         val bpWebClientService =
 326             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 327         val extractedHeaders = bpWebClientService.convertToBasicHeaders(mapOf())
 328         assertEquals(
 329             MediaType.APPLICATION_XML.toString(),
 330             extractedHeaders.filter { it.name == HttpHeaders.CONTENT_TYPE }[0].value!!
 331         )
 332     }
 333
 334     @Test
 335     fun `BasicAuth WebClientService additionalHeaders can overwrite default Content-Type`() {
 336         // default content type is application/json
 337         val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(contentTypeAdditionalHeader)
 338         additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson)
 339     }
 340
 341     // called from within "assertFailsWith(exceptionClass = BluePrintProcessorException::class) {"
 342     private fun attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson: String) {
 343         val parsedObj: JsonNode = defaultMapper.readTree(endPointWithHeadersJson)
 344         val bpWebClientService =
 345             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 346         bpWebClientService.convertToBasicHeaders(mapOf())
 347     }
 348
 349     @Test
 350     fun `BasicAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
 351         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 352             val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(additionalHeadersWithAuth)
 353             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 354         }
 355         // spec says headers are case insensitive...
 356         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 357             val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
 358             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 359         }
 360     }
 361
 362     @Test
 363     fun `TokenAuth WebClientService with empty additionalHeaders does not modify headers`() {
 364         val endPointJson = sslTokenAuthEndpointWithHeadersField()
 365         val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(emptyAdditionalHeaders)
 366         validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
 367     }
 368
 369     @Test
 370     fun `TokenAuth WebClientService accepts one additionalHeaders`() {
 371         val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(oneAdditionalParameter)
 372         acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
 373     }
 374
 375     @Test
 376     fun `TokenAuth WebClientService accepts multiple additionalHeaders`() {
 377         val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(threeAdditionalHeaders)
 378         acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
 379     }
 380
 381     @Test
 382     fun `TokenAuth WebClientService additionalHeaders can overwrite default Content-Type`() {
 383         // default content type is application/json
 384         val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(contentTypeAdditionalHeader)
 385         additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson)
 386     }
 387
 388     @Test
 389     fun `TokenAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
 390         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 391             val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(additionalHeadersWithAuth)
 392             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 393         }
 394         // spec says headers are case insensitive...
 395         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 396             val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
 397             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 398         }
 399     }
 400
 401     // TESTS FOR SSL BASIC AUTH headers
 402     @Test
 403     fun `SSLBasicAuth WebClientService with empty additionalHeaders does not modify headers`() {
 404         val endPointJson = sslBasicAuthEndpointWithHeadersField()
 405         val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(emptyAdditionalHeaders)
 406         validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
 407     }
 408
 409     @Test
 410     fun `SSLBasicAuth WebClientService accepts one additionalHeaders`() {
 411         val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(oneAdditionalParameter)
 412         acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
 413     }
 414
 415     @Test
 416     fun `SSLBasicAuth WebClientService accepts multiple additionalHeaders`() {
 417         val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(threeAdditionalHeaders)
 418         acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
 419     }
 420
 421     @Test
 422     fun `SSLBasicAuth WebClientService additionalHeaders can overwrite default Content-Type`() {
 423         // default content type is application/json
 424         val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(contentTypeAdditionalHeader)
 425         additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson)
 426     }
 427
 428     @Test
 429     fun `SSLBasicAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
 430         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 431             val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(additionalHeadersWithAuth)
 432             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 433         }
 434         // spec says headers are case insensitive...
 435         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 436             val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
 437             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 438         }
 439     }
 440
 441     // SSL-NO-AUTH headers tests
 442     @Test
 443     fun `SSLNoAuth WebClientService with empty additionalHeaders does not modify headers`() {
 444         val endPointJson = sslNoAuthEndpointWithHeadersField()
 445         val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(emptyAdditionalHeaders)
 446         validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
 447     }
 448
 449     @Test
 450     fun `SSLNoAuth WebClientService accepts one additionalHeaders`() {
 451         val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(oneAdditionalParameter)
 452         acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
 453     }
 454
 455     @Test
 456     fun `SSLNoAuth WebClientService accepts multiple additionalHeaders`() {
 457         val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(threeAdditionalHeaders)
 458         acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
 459     }
 460
 461     @Test
 462     fun `SSLNoAuth WebClientService additionalHeaders can overwrite default Content-Type`() {
 463         // default content type is application/json
 464         val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(contentTypeAdditionalHeader)
 465         additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson)
 466     }
 467
 468     @Test
 469     fun `SSLNoAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
 470         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 471             val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(additionalHeadersWithAuth)
 472             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 473         }
 474         // spec says headers are case insensitive...
 475         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 476             val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
 477             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 478         }
 479     }
 480
 481     companion object BluePrintRestLibPropertyServiceTest {
 482
 483         val defaultMapper = ObjectMapper()
 484         val expectedTokenAuthDefaultHeaders = mapOf<String, String>(
 485             "Content-Type" to "application/json",
 486             "Accept" to "application/json",
 487             "Authorization" to "72178473kjshdkjgvbsdkjv903274908"
 488         )
 489
 490         val endPointWithHeadersJsonWithBasicAuthHeader = basicAuthEndpointWithHeadersField(
 491             """,
 492               "additionalHeaders" : {
 493                  "authorization": "Basic aGF2ZTphbmljZWRheQo="
 494               }
 495             """.trimIndent()
 496         )
 497
 498         private fun sslTokenAuthEndpointWithHeadersField(headers: String = ""): String =
 499             """{
 500             "type" : "ssl-token-auth",
 501             "url" : "https://localhost:8443",
 502             "keyStoreInstance" : "PKCS12",
 503             "sslTrust" : "src/test/resources/keystore.p12",
 504             "sslTrustPassword" : "changeit",
 505               "tokenAuth" : {
 506                 "token" : "72178473kjshdkjgvbsdkjv903274908"
 507               }$headers
 508             }
 509             """.trimIndent()
 510
 511         private fun sslBasicAuthEndpointWithHeadersField(headers: String = ""): String =
 512             """{
 513           "type" : "ssl-basic-auth",
 514           "url" : "https://localhost:8443",
 515           "keyStoreInstance" : "PKCS12",
 516           "sslTrust" : "src/test/resources/keystore.p12",
 517           "sslTrustPassword" : "changeit",
 518           "username" : "admin",
 519           "password" : "cds"$headers
 520         }
 521             """.trimIndent()
 522
 523         private fun sslNoAuthEndpointWithHeadersField(headers: String = ""): String = """{
 524           "type" : "ssl-no-auth",
 525           "url" : "https://localhost:8443",
 526           "keyStoreInstance" : "PKCS12",
 527           "sslTrust" : "src/test/resources/keystore.p12",
 528           "sslTrustPassword" : "changeit",
 529           "sslKey" : "src/test/resources/keystore.p12",
 530           "sslKeyPassword" : "changeit"$headers
 531         }
 532         """.trimIndent()
 533
 534         private fun sslNoDefHeadersField(): String = """{
 535           "type" : "ssl-no-def-headers",
 536           "url" : "https://localhost:8443",
 537           "keyStoreInstance" : "PKCS12",
 538           "sslTrust" : "src/test/resources/keystore.p12",
 539           "sslTrustPassword" : "changeit",
 540           "sslKey" : "src/test/resources/keystore.p12",
 541           "sslKeyPassword" : "changeit"
 542         }
 543         """.trimIndent()
 544
 545         // Don't forget to supply "," as the first char to make valid JSON
 546         private fun basicAuthEndpointWithHeadersField(headers: String = ""): String =
 547             """{
 548               "type": "basic-auth",
 549               "url": "http://127.0.0.1:8000",
 550               "username": "user",
 551               "password": "pass"$headers
 552             }
 553             """.trimIndent()
 554
 555         private fun noDefaultHeadersField(): String =
 556             """{
 557               "type": "no-def-headers",
 558               "url": "http://127.0.0.1:8000"
 559             }
 560             """.trimIndent()
 561
 562         private val emptyAdditionalHeaders = """,
 563           "additionalHeaders" : {
 564           }
 565         """.trimIndent()
 566
 567         private val oneAdditionalParameter = """,
 568           "additionalHeaders" : {
 569             "key1": "value1"
 570           }
 571         """.trimIndent()
 572
 573         private val threeAdditionalHeaders = """,
 574           "additionalHeaders" : {
 575             "key1": "value1",
 576             "key2": "value2",
 577             "key3": "value3"
 578           }
 579         """.trimIndent()
 580
 581         private val contentTypeAdditionalHeader = """,
 582           "additionalHeaders" : {
 583             "${HttpHeaders.CONTENT_TYPE}": "${MediaType.APPLICATION_XML}"
 584           }
 585         """.trimIndent()
 586
 587         private val additionalHeadersWithAuth = """,
 588           "additionalHeaders" : {
 589              "Authorization": "Basic aGF2ZTphbmljZWRheQo="
 590           }
 591         """.trimIndent()
 592
 593         private val additionalHeadersWithAuthLowercased = """,
 594           "additionalHeaders" : {
 595              "authorization": "Basic aGF2ZTphbmljZWRheQo="
 596           }
 597         """.trimIndent()
 598     }
 599 }