2 * Copyright © 2017-2018 AT&T Intellectual Property.
3 * Modifications Copyright © 2018 IBM.
4 * Modifications Copyright © 2019 Huawei.
5 * Modifications Copyright © 2019 Bell Canada.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 package org.onap.ccsdk.cds.blueprintsprocessor.rest.service
22 import com.fasterxml.jackson.databind.JsonNode
23 import com.fasterxml.jackson.databind.ObjectMapper
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
44 @RunWith(SpringRunner::class)
45 @ContextConfiguration(
47 BluePrintRestLibConfiguration::class, BluePrintPropertyConfiguration::class,
48 BluePrintPropertiesService::class
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"
79 class BluePrintRestLibPropertyServiceTest {
82 lateinit var bluePrintRestLibPropertyService: BluePrintRestLibPropertyService
85 fun testRestClientProperties() {
86 val properties = bluePrintRestLibPropertyService.restClientProperties(
87 "blueprintsprocessor.restclient.sample"
89 assertNotNull(properties, "failed to create property bean")
92 "failed to get url property in" +
98 fun testSSLBasicProperties() {
99 val properties = bluePrintRestLibPropertyService.restClientProperties(
100 "blueprintsprocessor.restclient.sslbasic"
102 assertNotNull(properties, "failed to create property bean")
103 val p: SSLBasicAuthRestClientProperties =
104 properties as SSLBasicAuthRestClientProperties
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")
114 fun testSSLTokenProperties() {
115 val properties = bluePrintRestLibPropertyService.restClientProperties(
116 "blueprintsprocessor.restclient.ssltoken"
118 assertNotNull(properties, "failed to create property bean")
120 val p: SSLTokenAuthRestClientProperties =
121 properties as SSLTokenAuthRestClientProperties
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")
130 fun testSSLNoAuthProperties() {
131 val properties = bluePrintRestLibPropertyService.restClientProperties(
132 "blueprintsprocessor.restclient.ssl"
134 assertNotNull(properties, "failed to create property bean")
136 val p: SSLRestClientProperties =
137 properties as SSLRestClientProperties
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")
147 fun testSSLBasicPropertiesAsJson() {
148 val actualObj: JsonNode = defaultMapper.readTree(sslBasicAuthEndpointWithHeadersField())
149 val properties = bluePrintRestLibPropertyService.restClientProperties(
152 assertNotNull(properties, "failed to create property bean")
153 val p: SSLBasicAuthRestClientProperties = properties as SSLBasicAuthRestClientProperties
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)
165 fun testSSLTokenPropertiesAsJson() {
166 val actualObj: JsonNode = defaultMapper.readTree(sslTokenAuthEndpointWithHeadersField())
168 bluePrintRestLibPropertyService.restClientProperties(actualObj)
169 assertNotNull(properties, "failed to create property bean")
171 val p: SSLTokenAuthRestClientProperties = properties as SSLTokenAuthRestClientProperties
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)
182 fun testSSLNoAuthPropertiesAsJson() {
183 val actualObj: JsonNode = defaultMapper.readTree(sslNoAuthEndpointWithHeadersField())
184 val properties = bluePrintRestLibPropertyService.restClientProperties(
187 assertNotNull(properties, "failed to create property bean")
189 val p: SSLRestClientProperties =
190 properties as SSLRestClientProperties
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)
202 fun testSSLNoDefHeadersPropertiesAsJson() {
203 val actualObj: JsonNode = defaultMapper.readTree(sslNoDefHeadersField())
204 val properties = bluePrintRestLibPropertyService.restClientProperties(
207 assertNotNull(properties, "failed to create property bean")
209 val p: SSLRestClientProperties =
210 properties as SSLRestClientProperties
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"))
223 fun testNoDefHeadersPropertiesAsJson() {
224 val actualObj: JsonNode = defaultMapper.readTree(noDefaultHeadersField())
225 val p = bluePrintRestLibPropertyService.restClientProperties(
228 assertNotNull(p, "failed to create property bean")
230 assertEquals("no-def-headers", p.type)
231 assertEquals("http://127.0.0.1:8000", p.url)
232 assertTrue(p.values.containsKey("type"))
236 fun testBlueprintWebClientService() {
237 val blueprintWebClientService = bluePrintRestLibPropertyService
238 .blueprintWebClientService("sample")
240 blueprintWebClientService,
241 "failed to create blueprintWebClientService"
246 fun testBlueprintWebClientServiceWithJsonNode() {
247 val actualObj: JsonNode = defaultMapper.readTree(sslBasicAuthEndpointWithHeadersField())
248 val blueprintWebClientService = bluePrintRestLibPropertyService
249 .blueprintWebClientService(actualObj)
250 assertNotNull(blueprintWebClientService, "failed to create blueprintWebClientService")
254 fun testNoHeadersForNoDefaultHeaderService() {
255 val actualObj: JsonNode = defaultMapper.readTree(noDefaultHeadersField())
256 val blueprintWebClientService = bluePrintRestLibPropertyService
257 .blueprintWebClientService(actualObj)
258 assertEquals(0, blueprintWebClientService.defaultHeaders().size)
262 fun testNoHeadersForSSLNoDefaultHeaderService() {
263 val actualObj: JsonNode = defaultMapper.readTree(sslNoDefHeadersField())
264 val blueprintWebClientService = bluePrintRestLibPropertyService
265 .blueprintWebClientService(actualObj)
266 assertEquals(0, blueprintWebClientService.defaultHeaders().size)
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())
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)
287 fun `BasicAuth WebClientService with empty additionalHeaders does not modify headers`() {
288 val endPointJson = basicAuthEndpointWithHeadersField()
289 val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(emptyAdditionalHeaders)
290 validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
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())
302 fun `BasicAuth WebClientService accepts one additionalHeaders`() {
303 val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(oneAdditionalParameter)
304 acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
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())
318 fun `BasicAuth WebClientService accepts multiple additionalHeaders`() {
319 val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(threeAdditionalHeaders)
320 acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
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())
329 MediaType.APPLICATION_XML.toString(),
330 extractedHeaders.filter { it.name == HttpHeaders.CONTENT_TYPE }[0].value!!
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)
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())
350 fun `BasicAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
351 assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
352 val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(additionalHeadersWithAuth)
353 attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
355 // spec says headers are case insensitive...
356 assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
357 val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
358 attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
363 fun `TokenAuth WebClientService with empty additionalHeaders does not modify headers`() {
364 val endPointJson = sslTokenAuthEndpointWithHeadersField()
365 val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(emptyAdditionalHeaders)
366 validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
370 fun `TokenAuth WebClientService accepts one additionalHeaders`() {
371 val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(oneAdditionalParameter)
372 acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
376 fun `TokenAuth WebClientService accepts multiple additionalHeaders`() {
377 val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(threeAdditionalHeaders)
378 acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
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)
389 fun `TokenAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
390 assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
391 val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(additionalHeadersWithAuth)
392 attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
394 // spec says headers are case insensitive...
395 assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
396 val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
397 attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
401 // TESTS FOR SSL BASIC AUTH headers
403 fun `SSLBasicAuth WebClientService with empty additionalHeaders does not modify headers`() {
404 val endPointJson = sslBasicAuthEndpointWithHeadersField()
405 val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(emptyAdditionalHeaders)
406 validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
410 fun `SSLBasicAuth WebClientService accepts one additionalHeaders`() {
411 val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(oneAdditionalParameter)
412 acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
416 fun `SSLBasicAuth WebClientService accepts multiple additionalHeaders`() {
417 val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(threeAdditionalHeaders)
418 acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
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)
429 fun `SSLBasicAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
430 assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
431 val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(additionalHeadersWithAuth)
432 attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
434 // spec says headers are case insensitive...
435 assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
436 val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
437 attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
441 // SSL-NO-AUTH headers tests
443 fun `SSLNoAuth WebClientService with empty additionalHeaders does not modify headers`() {
444 val endPointJson = sslNoAuthEndpointWithHeadersField()
445 val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(emptyAdditionalHeaders)
446 validateHeadersDidNotChangeWithEmptyAdditionalHeaders(endPointJson, endPointWithHeadersJson)
450 fun `SSLNoAuth WebClientService accepts one additionalHeaders`() {
451 val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(oneAdditionalParameter)
452 acceptsOneAdditionalHeadersTest(endPointWithHeadersJson)
456 fun `SSLNoAuth WebClientService accepts multiple additionalHeaders`() {
457 val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(threeAdditionalHeaders)
458 acceptsMultipleAdditionalHeaders(endPointWithHeadersJson)
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)
469 fun `SSLNoAuth WebClientService throws BluePrintProcessorException if additionalHeaders contain Authorization`() {
470 assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
471 val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(additionalHeadersWithAuth)
472 attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
474 // spec says headers are case insensitive...
475 assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
476 val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
477 attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
481 companion object BluePrintRestLibPropertyServiceTest {
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"
490 val endPointWithHeadersJsonWithBasicAuthHeader = basicAuthEndpointWithHeadersField(
492 "additionalHeaders" : {
493 "authorization": "Basic aGF2ZTphbmljZWRheQo="
498 private fun sslTokenAuthEndpointWithHeadersField(headers: String = ""): String =
500 "type" : "ssl-token-auth",
501 "url" : "https://localhost:8443",
502 "keyStoreInstance" : "PKCS12",
503 "sslTrust" : "src/test/resources/keystore.p12",
504 "sslTrustPassword" : "changeit",
506 "token" : "72178473kjshdkjgvbsdkjv903274908"
511 private fun sslBasicAuthEndpointWithHeadersField(headers: String = ""): String =
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
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
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"
545 // Don't forget to supply "," as the first char to make valid JSON
546 private fun basicAuthEndpointWithHeadersField(headers: String = ""): String =
548 "type": "basic-auth",
549 "url": "http://127.0.0.1:8000",
551 "password": "pass"$headers
555 private fun noDefaultHeadersField(): String =
557 "type": "no-def-headers",
558 "url": "http://127.0.0.1:8000"
562 private val emptyAdditionalHeaders = """,
563 "additionalHeaders" : {
567 private val oneAdditionalParameter = """,
568 "additionalHeaders" : {
573 private val threeAdditionalHeaders = """,
574 "additionalHeaders" : {
581 private val contentTypeAdditionalHeader = """,
582 "additionalHeaders" : {
583 "${HttpHeaders.CONTENT_TYPE}": "${MediaType.APPLICATION_XML}"
587 private val additionalHeadersWithAuth = """,
588 "additionalHeaders" : {
589 "Authorization": "Basic aGF2ZTphbmljZWRheQo="
593 private val additionalHeadersWithAuthLowercased = """,
594 "additionalHeaders" : {
595 "authorization": "Basic aGF2ZTphbmljZWRheQo="