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
  43 @RunWith(SpringRunner::class)
  44 @ContextConfiguration(
  45     classes = [
  46         BluePrintRestLibConfiguration::class, BluePrintPropertyConfiguration::class,
  47         BluePrintPropertiesService::class
  48     ]
  49 )
  50 @TestPropertySource(
  51     properties =
  52         [
  53             "blueprintsprocessor.restclient.sample.type=basic-auth",
  54             "blueprintsprocessor.restclient.sample.url=http://localhost:8080",
  55             "blueprintsprocessor.restclient.sample.userId=sampleuser",
  56             "blueprintsprocessor.restclient.sslbasic.type=ssl-basic-auth",
  57             "blueprintsprocessor.restclient.sslbasic.url=https://localhost:8443",
  58             "blueprintsprocessor.restclient.sslbasic.username=admin",
  59             "blueprintsprocessor.restclient.sslbasic.password=cds",
  60             "blueprintsprocessor.restclient.sslbasic.keyStoreInstance=PKCS12",
  61             "blueprintsprocessor.restclient.sslbasic.sslTrust=src/test/resources/keystore.p12",
  62             "blueprintsprocessor.restclient.sslbasic.sslTrustPassword=changeit",
  63             "blueprintsprocessor.restclient.ssltoken.type=ssl-token-auth",
  64             "blueprintsprocessor.restclient.ssltoken.url=https://localhost:8443",
  65             "blueprintsprocessor.restclient.ssltoken.token=72178473kjshdkjgvbsdkjv903274908",
  66             "blueprintsprocessor.restclient.ssltoken.keyStoreInstance=PKCS12",
  67             "blueprintsprocessor.restclient.ssltoken.sslTrust=src/test/resources/keystore.p12",
  68             "blueprintsprocessor.restclient.ssltoken.sslTrustPassword=changeit",
  69             "blueprintsprocessor.restclient.ssl.type=ssl-no-auth",
  70             "blueprintsprocessor.restclient.ssl.url=https://localhost:8443",
  71             "blueprintsprocessor.restclient.ssl.keyStoreInstance=PKCS12",
  72             "blueprintsprocessor.restclient.ssl.sslTrust=src/test/resources/keystore.p12",
  73             "blueprintsprocessor.restclient.ssl.sslTrustPassword=changeit",
  74             "blueprintsprocessor.restclient.ssl.sslKey=src/test/resources/keystore.p12",
  75             "blueprintsprocessor.restclient.ssl.sslKeyPassword=changeit"
  76         ]
  77 )
  78 class BluePrintRestLibPropertyServiceTest {
  79
  80     @Autowired
  81     lateinit var bluePrintRestLibPropertyService: BluePrintRestLibPropertyService
  82
  83     @Test
  84     fun testRestClientProperties() {
  85         val properties = bluePrintRestLibPropertyService.restClientProperties(
  86             "blueprintsprocessor.restclient.sample"
  87         )
  88         assertNotNull(properties, "failed to create property bean")
  89         assertNotNull(
  90             properties.url,
  91             "failed to get url property in" +
  92                 " property bean"
  93         )
  94     }
  95
  96     @Test
  97     fun testSSLBasicProperties() {
  98         val properties = bluePrintRestLibPropertyService.restClientProperties(
  99             "blueprintsprocessor.restclient.sslbasic"
 100         )
 101         assertNotNull(properties, "failed to create property bean")
 102         val p: SSLBasicAuthRestClientProperties =
 103             properties as SSLBasicAuthRestClientProperties
 104
 105         assertEquals(p.username, "admin")
 106         assertEquals(p.password, "cds")
 107         assertEquals(p.sslTrust, "src/test/resources/keystore.p12")
 108         assertEquals(p.sslTrustPassword, "changeit")
 109         assertEquals(p.keyStoreInstance, "PKCS12")
 110     }
 111
 112     @Test
 113     fun testSSLTokenProperties() {
 114         val properties = bluePrintRestLibPropertyService.restClientProperties(
 115             "blueprintsprocessor.restclient.ssltoken"
 116         )
 117         assertNotNull(properties, "failed to create property bean")
 118
 119         val p: SSLTokenAuthRestClientProperties =
 120             properties as SSLTokenAuthRestClientProperties
 121
 122         assertEquals(p.tokenAuth!!.token!!, "72178473kjshdkjgvbsdkjv903274908")
 123         assertEquals(p.sslTrust, "src/test/resources/keystore.p12")
 124         assertEquals(p.sslTrustPassword, "changeit")
 125         assertEquals(p.keyStoreInstance, "PKCS12")
 126     }
 127
 128     @Test
 129     fun testSSLNoAuthProperties() {
 130         val properties = bluePrintRestLibPropertyService.restClientProperties(
 131             "blueprintsprocessor.restclient.ssl"
 132         )
 133         assertNotNull(properties, "failed to create property bean")
 134
 135         val p: SSLRestClientProperties =
 136             properties as SSLRestClientProperties
 137
 138         assertEquals(p.sslTrust, "src/test/resources/keystore.p12")
 139         assertEquals(p.sslTrustPassword, "changeit")
 140         assertEquals(p.keyStoreInstance, "PKCS12")
 141         assertEquals(p.sslKey, "src/test/resources/keystore.p12")
 142         assertEquals(p.sslKeyPassword, "changeit")
 143     }
 144
 145     @Test
 146     fun testSSLBasicPropertiesAsJson() {
 147         val actualObj: JsonNode = defaultMapper.readTree(sslBasicAuthEndpointWithHeadersField())
 148         val properties = bluePrintRestLibPropertyService.restClientProperties(
 149             actualObj
 150         )
 151         assertNotNull(properties, "failed to create property bean")
 152         val p: SSLBasicAuthRestClientProperties = properties as SSLBasicAuthRestClientProperties
 153
 154         assertEquals("admin", p.username)
 155         assertEquals("cds", p.password)
 156         assertEquals("src/test/resources/keystore.p12", p.sslTrust)
 157         assertEquals("changeit", p.sslTrustPassword)
 158         assertEquals("PKCS12", p.keyStoreInstance)
 159         assertEquals("ssl-basic-auth", p.type)
 160         assertEquals("https://localhost:8443", p.url)
 161     }
 162
 163     @Test
 164     fun testSSLTokenPropertiesAsJson() {
 165         val actualObj: JsonNode = defaultMapper.readTree(sslTokenAuthEndpointWithHeadersField())
 166         val properties =
 167             bluePrintRestLibPropertyService.restClientProperties(actualObj)
 168         assertNotNull(properties, "failed to create property bean")
 169
 170         val p: SSLTokenAuthRestClientProperties = properties as SSLTokenAuthRestClientProperties
 171
 172         assertEquals("72178473kjshdkjgvbsdkjv903274908", p.tokenAuth!!.token!!)
 173         assertEquals("src/test/resources/keystore.p12", p.sslTrust)
 174         assertEquals("changeit", p.sslTrustPassword)
 175         assertEquals("PKCS12", p.keyStoreInstance)
 176         assertEquals("ssl-token-auth", p.type)
 177         assertEquals("https://localhost:8443", p.url)
 178     }
 179
 180     @Test
 181     fun testSSLNoAuthPropertiesAsJson() {
 182         val actualObj: JsonNode = defaultMapper.readTree(sslNoAuthEndpointWithHeadersField())
 183         val properties = bluePrintRestLibPropertyService.restClientProperties(
 184             actualObj
 185         )
 186         assertNotNull(properties, "failed to create property bean")
 187
 188         val p: SSLRestClientProperties =
 189             properties as SSLRestClientProperties
 190
 191         assertEquals("src/test/resources/keystore.p12", p.sslTrust)
 192         assertEquals("changeit", p.sslTrustPassword)
 193         assertEquals("PKCS12", p.keyStoreInstance)
 194         assertEquals("src/test/resources/keystore.p12", p.sslKey)
 195         assertEquals("changeit", p.sslKeyPassword)
 196         assertEquals("ssl-no-auth", p.type)
 197         assertEquals("https://localhost:8443", p.url)
 198     }
 199
 200     @Test
 201     fun testBlueprintWebClientService() {
 202         val blueprintWebClientService = bluePrintRestLibPropertyService
 203             .blueprintWebClientService("sample")
 204         assertNotNull(
 205             blueprintWebClientService,
 206             "failed to create blueprintWebClientService"
 207         )
 208     }
 209
 210     @Test
 211     fun testBlueprintWebClientServiceWithJsonNode() {
 212         val actualObj: JsonNode = defaultMapper.readTree(sslBasicAuthEndpointWithHeadersField())
 213         val blueprintWebClientService = bluePrintRestLibPropertyService
 214             .blueprintWebClientService(actualObj)
 215         assertNotNull(blueprintWebClientService, "failed to create blueprintWebClientService")
 216     }
 217
 218     // pass the result of $typeEndpointWithHeadersField() output with and without headers to compare.
 219     private fun validateHeadersDidNotChangeWithEmptyAdditionalHeaders(noHeaders: String, withHeaders: String) {
 220         val parsedObj: JsonNode = defaultMapper.readTree(noHeaders)
 221         val bpWebClientService =
 222             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 223         val extractedHeaders = bpWebClientService.convertToBasicHeaders(mapOf())
 224
 225         val parsedObjWithHeaders: JsonNode = defaultMapper.readTree(withHeaders)
 226         val bpWebClientServiceWithHeaders =
 227             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObjWithHeaders)
 228         val extractedHeadersWithAdditionalHeaders = bpWebClientServiceWithHeaders.convertToBasicHeaders(mapOf())
 229         // Array<BasicHeader<>> -> Map<String,String>
 230         val headersMap = extractedHeaders.map { it.name to it.value }.toMap()
 231         val additionalHeadersMap = extractedHeadersWithAdditionalHeaders.map { it.name to it.value }.toMap()
 232         assertEquals(headersMap, additionalHeadersMap)
 233     }
 234
 235     @Test
 236     fun `BasicAuth WebClientService with empty additionalHeaders does not modify headers`() {
 237         val endPointJson = basicAuthEndpointWithHeadersField()
 238         val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(emptyAdditionalHeaders)
 239         validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
 240     }
 241
 242     private fun acceptsOneAdditionalHeadersTest(endPointWithHeadersJson: String) {
 243         val parsedObj: JsonNode = defaultMapper.readTree(endPointWithHeadersJson)
 244         val bpWebClientService =
 245             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 246         val extractedHeaders = bpWebClientService.convertToBasicHeaders(mapOf())
 247         assertEquals(1, extractedHeaders.filter { it.name == "key1" }.count())
 248     }
 249
 250     @Test
 251     fun `BasicAuth WebClientService accepts one additionalHeaders`() {
 252         val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(oneAdditionalParameter)
 253         acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
 254     }
 255
 256     private fun acceptsMultipleAdditionalHeaders(endPointWithHeadersJson: String) {
 257         val parsedObj: JsonNode = defaultMapper.readTree(endPointWithHeadersJson)
 258         val bpWebClientService =
 259             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 260         val extractedHeaders = bpWebClientService.convertToBasicHeaders(mapOf())
 261         assertEquals(1, extractedHeaders.filter { it.name == "key1" }.count())
 262         assertEquals(1, extractedHeaders.filter { it.name == "key2" }.count())
 263         assertEquals(1, extractedHeaders.filter { it.name == "key3" }.count())
 264     }
 265
 266     @Test
 267     fun `BasicAuth WebClientService accepts multiple additionalHeaders`() {
 268         val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(threeAdditionalHeaders)
 269         acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
 270     }
 271
 272     private fun additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson: String) {
 273         val parsedObj: JsonNode = defaultMapper.readTree(endPointWithHeadersJson)
 274         val bpWebClientService =
 275             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 276         val extractedHeaders = bpWebClientService.convertToBasicHeaders(mapOf())
 277         assertEquals(
 278             MediaType.APPLICATION_XML.toString(),
 279             extractedHeaders.filter { it.name == HttpHeaders.CONTENT_TYPE }[0].value!!
 280         )
 281     }
 282
 283     @Test
 284     fun `BasicAuth WebClientService additionalHeaders can overwrite default Content-Type`() {
 285         // default content type is application/json
 286         val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(contentTypeAdditionalHeader)
 287         additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson)
 288     }
 289
 290     // called from within "assertFailsWith(exceptionClass = BluePrintProcessorException::class) {"
 291     private fun attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson: String) {
 292         val parsedObj: JsonNode = defaultMapper.readTree(endPointWithHeadersJson)
 293         val bpWebClientService =
 294             bluePrintRestLibPropertyService.blueprintWebClientService(parsedObj)
 295         bpWebClientService.convertToBasicHeaders(mapOf())
 296     }
 297
 298     @Test
 299     fun `BasicAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
 300         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 301             val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(additionalHeadersWithAuth)
 302             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 303         }
 304         // spec says headers are case insensitive...
 305         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 306             val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
 307             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 308         }
 309     }
 310
 311     @Test
 312     fun `TokenAuth WebClientService with empty additionalHeaders does not modify headers`() {
 313         val endPointJson = sslTokenAuthEndpointWithHeadersField()
 314         val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(emptyAdditionalHeaders)
 315         validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
 316     }
 317
 318     @Test
 319     fun `TokenAuth WebClientService accepts one additionalHeaders`() {
 320         val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(oneAdditionalParameter)
 321         acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
 322     }
 323
 324     @Test
 325     fun `TokenAuth WebClientService accepts multiple additionalHeaders`() {
 326         val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(threeAdditionalHeaders)
 327         acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
 328     }
 329
 330     @Test
 331     fun `TokenAuth WebClientService additionalHeaders can overwrite default Content-Type`() {
 332         // default content type is application/json
 333         val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(contentTypeAdditionalHeader)
 334         additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson)
 335     }
 336
 337     @Test
 338     fun `TokenAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
 339         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 340             val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(additionalHeadersWithAuth)
 341             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 342         }
 343         // spec says headers are case insensitive...
 344         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 345             val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
 346             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 347         }
 348     }
 349
 350     // TESTS FOR SSL BASIC AUTH headers
 351     @Test
 352     fun `SSLBasicAuth WebClientService with empty additionalHeaders does not modify headers`() {
 353         val endPointJson = sslBasicAuthEndpointWithHeadersField()
 354         val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(emptyAdditionalHeaders)
 355         validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
 356     }
 357
 358     @Test
 359     fun `SSLBasicAuth WebClientService accepts one additionalHeaders`() {
 360         val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(oneAdditionalParameter)
 361         acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
 362     }
 363
 364     @Test
 365     fun `SSLBasicAuth WebClientService accepts multiple additionalHeaders`() {
 366         val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(threeAdditionalHeaders)
 367         acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
 368     }
 369
 370     @Test
 371     fun `SSLBasicAuth WebClientService additionalHeaders can overwrite default Content-Type`() {
 372         // default content type is application/json
 373         val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(contentTypeAdditionalHeader)
 374         additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson)
 375     }
 376
 377     @Test
 378     fun `SSLBasicAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
 379         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 380             val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(additionalHeadersWithAuth)
 381             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 382         }
 383         // spec says headers are case insensitive...
 384         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 385             val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
 386             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 387         }
 388     }
 389
 390     // SSL-NO-AUTH headers tests
 391     @Test
 392     fun `SSLNoAuth WebClientService with empty additionalHeaders does not modify headers`() {
 393         val endPointJson = sslNoAuthEndpointWithHeadersField()
 394         val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(emptyAdditionalHeaders)
 395         validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
 396     }
 397
 398     @Test
 399     fun `SSLNoAuth WebClientService accepts one additionalHeaders`() {
 400         val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(oneAdditionalParameter)
 401         acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
 402     }
 403
 404     @Test
 405     fun `SSLNoAuth WebClientService accepts multiple additionalHeaders`() {
 406         val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(threeAdditionalHeaders)
 407         acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
 408     }
 409
 410     @Test
 411     fun `SSLNoAuth WebClientService additionalHeaders can overwrite default Content-Type`() {
 412         // default content type is application/json
 413         val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(contentTypeAdditionalHeader)
 414         additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson)
 415     }
 416
 417     @Test
 418     fun `SSLNoAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
 419         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 420             val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(additionalHeadersWithAuth)
 421             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 422         }
 423         // spec says headers are case insensitive...
 424         assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
 425             val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
 426             attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
 427         }
 428     }
 429
 430     companion object BluePrintRestLibPropertyServiceTest {
 431
 432         val defaultMapper = ObjectMapper()
 433         val expectedTokenAuthDefaultHeaders = mapOf<String, String>(
 434             "Content-Type" to "application/json",
 435             "Accept" to "application/json",
 436             "Authorization" to "72178473kjshdkjgvbsdkjv903274908"
 437         )
 438
 439         val endPointWithHeadersJsonWithBasicAuthHeader = basicAuthEndpointWithHeadersField(
 440             """,
 441               "additionalHeaders" : {
 442                  "authorization": "Basic aGF2ZTphbmljZWRheQo="
 443               }
 444             """.trimIndent()
 445         )
 446
 447         private fun sslTokenAuthEndpointWithHeadersField(headers: String = ""): String =
 448             """{
 449             "type" : "ssl-token-auth",
 450             "url" : "https://localhost:8443",
 451             "keyStoreInstance" : "PKCS12",
 452             "sslTrust" : "src/test/resources/keystore.p12",
 453             "sslTrustPassword" : "changeit",
 454               "tokenAuth" : {
 455                 "token" : "72178473kjshdkjgvbsdkjv903274908"
 456               }$headers
 457             }
 458             """.trimIndent()
 459
 460         private fun sslBasicAuthEndpointWithHeadersField(headers: String = ""): String =
 461             """{
 462           "type" : "ssl-basic-auth",
 463           "url" : "https://localhost:8443",
 464           "keyStoreInstance" : "PKCS12",
 465           "sslTrust" : "src/test/resources/keystore.p12",
 466           "sslTrustPassword" : "changeit",
 467           "username" : "admin",
 468           "password" : "cds"$headers
 469         }
 470             """.trimIndent()
 471
 472         private fun sslNoAuthEndpointWithHeadersField(headers: String = ""): String = """{
 473           "type" : "ssl-no-auth",
 474           "url" : "https://localhost:8443",
 475           "keyStoreInstance" : "PKCS12",
 476           "sslTrust" : "src/test/resources/keystore.p12",
 477           "sslTrustPassword" : "changeit",
 478           "sslKey" : "src/test/resources/keystore.p12",
 479           "sslKeyPassword" : "changeit"$headers
 480         }
 481         """.trimIndent()
 482
 483         // Don't forget to supply "," as the first char to make valid JSON
 484         private fun basicAuthEndpointWithHeadersField(headers: String = ""): String =
 485             """{
 486               "type": "basic-auth",
 487               "url": "http://127.0.0.1:8000",
 488               "username": "user",
 489               "password": "pass"$headers
 490             }
 491             """.trimIndent()
 492
 493         private val emptyAdditionalHeaders = """,
 494           "additionalHeaders" : {
 495           }
 496         """.trimIndent()
 497
 498         private val oneAdditionalParameter = """,
 499           "additionalHeaders" : {
 500             "key1": "value1"
 501           }
 502         """.trimIndent()
 503
 504         private val threeAdditionalHeaders = """,
 505           "additionalHeaders" : {
 506             "key1": "value1",
 507             "key2": "value2",
 508             "key3": "value3"
 509           }
 510         """.trimIndent()
 511
 512         private val contentTypeAdditionalHeader = """,
 513           "additionalHeaders" : {
 514             "${HttpHeaders.CONTENT_TYPE}": "${MediaType.APPLICATION_XML}"
 515           }
 516         """.trimIndent()
 517
 518         private val additionalHeadersWithAuth = """,
 519           "additionalHeaders" : {
 520              "Authorization": "Basic aGF2ZTphbmljZWRheQo="
 521           }
 522         """.trimIndent()
 523
 524         private val additionalHeadersWithAuthLowercased = """,
 525           "additionalHeaders" : {
 526              "authorization": "Basic aGF2ZTphbmljZWRheQo="
 527           }
 528         """.trimIndent()
 529     }
 530 }