1181 lines
54 KiB
Groovy
1181 lines
54 KiB
Groovy
package eu.ztsh.mockserver.tests
|
|
|
|
import groovy.xml.slurpersupport.GPathResult
|
|
import org.apache.http.client.methods.CloseableHttpResponse
|
|
import org.apache.http.client.methods.HttpDelete
|
|
import org.apache.http.client.methods.HttpGet
|
|
import org.apache.http.client.methods.HttpHead
|
|
import org.apache.http.client.methods.HttpOptions
|
|
import org.apache.http.client.methods.HttpPatch
|
|
import org.apache.http.client.methods.HttpPost
|
|
import org.apache.http.client.methods.HttpPut
|
|
import org.apache.http.client.methods.HttpTrace
|
|
import org.apache.http.entity.ContentType
|
|
import org.apache.http.entity.StringEntity
|
|
import org.apache.http.impl.client.CloseableHttpClient
|
|
import org.apache.http.impl.client.HttpClients
|
|
import org.apache.http.util.EntityUtils
|
|
import eu.ztsh.mockserver.api.common.ImportAlias
|
|
import eu.ztsh.mockserver.api.common.Method
|
|
import eu.ztsh.mockserver.api.request.AddMock
|
|
import eu.ztsh.mockserver.api.response.MockEventReport
|
|
import eu.ztsh.mockserver.api.response.MockReport
|
|
import eu.ztsh.mockserver.client.InvalidMockDefinition
|
|
import eu.ztsh.mockserver.client.InvalidMockRequestSchema
|
|
import eu.ztsh.mockserver.client.MockAlreadyExists
|
|
import eu.ztsh.mockserver.client.MockDoesNotExist
|
|
import eu.ztsh.mockserver.client.RemoteMockServer
|
|
import eu.ztsh.mockserver.client.Util
|
|
import eu.ztsh.mockserver.server.HttpMockServer
|
|
import spock.lang.AutoCleanup
|
|
import spock.lang.Specification
|
|
|
|
class MockServerIntegrationTest extends Specification {
|
|
|
|
RemoteMockServer remoteMockServer
|
|
|
|
@AutoCleanup('stop')
|
|
HttpMockServer httpMockServer
|
|
|
|
CloseableHttpClient client = HttpClients.createDefault()
|
|
|
|
def setup() {
|
|
httpMockServer = new HttpMockServer(9000)
|
|
remoteMockServer = new RemoteMockServer('localhost', 9000)
|
|
}
|
|
|
|
def "should add working rest mock on endpoint"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseRest-${req.xml.name()}/>"}''',
|
|
soap: false
|
|
))
|
|
when:
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'goodResponseRest-request'
|
|
expect:
|
|
remoteMockServer.removeMock('testRest')?.size() == 1
|
|
}
|
|
|
|
def "should add working rest mock on endpoint with utf"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRestUtf',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request' && req.xml.@test == 'łżźćąś'}''',
|
|
response: '''{req -> "<goodResponseRest-${req.xml.name()} ans='łżźćąś'/>"}''',
|
|
soap: false
|
|
))
|
|
when:
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('<request test="łżźćąś"/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'goodResponseRest-request'
|
|
restPostResponse.@ans == 'łżźćąś'
|
|
expect:
|
|
remoteMockServer.removeMock('testRestUtf')?.size() == 1
|
|
}
|
|
|
|
def "should add soap mock on endpoint"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.soap.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseSoap-${req.soap.name()}/>"}''',
|
|
soap: true
|
|
))
|
|
when:
|
|
HttpPost soapPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
soapPost.entity = new StringEntity(Util.soap('<request/>'), ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response = client.execute(soapPost)
|
|
then:
|
|
GPathResult soapPostResponse = Util.extractXmlResponse(response)
|
|
soapPostResponse.name() == 'Envelope'
|
|
soapPostResponse.Body.'goodResponseSoap-request'.size() == 1
|
|
expect:
|
|
remoteMockServer.removeMock('testSoap')?.size() == 1
|
|
}
|
|
|
|
def "should throw exception when try to remove mock when it does not exist"() {
|
|
when:
|
|
remoteMockServer.removeMock('testSoap')
|
|
then:
|
|
thrown(MockDoesNotExist)
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseSoap-${req.xml.name()}/>"}''',
|
|
soap: true
|
|
))
|
|
and:
|
|
remoteMockServer.removeMock('testSoap') == []
|
|
when:
|
|
remoteMockServer.removeMock('testSoap')
|
|
then:
|
|
thrown(MockDoesNotExist)
|
|
}
|
|
|
|
def "should not add mock with existing name"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseSoap-${req.xml.name()}/>"}''',
|
|
soap: true
|
|
))
|
|
when:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint2',
|
|
port: 9998,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseSoap-${req.xml.name()}/>"}''',
|
|
soap: true
|
|
))
|
|
then:
|
|
thrown(MockAlreadyExists)
|
|
}
|
|
|
|
def "should not add mock when schema does not exist"() {
|
|
when:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'test',
|
|
path: 'testEndpoint2',
|
|
port: 9998,
|
|
response: '''{req -> "<goodResponse/>"}''',
|
|
soap: false,
|
|
schema: 'ble.xsd'
|
|
))
|
|
then:
|
|
thrown(InvalidMockRequestSchema)
|
|
}
|
|
|
|
def "should not add mock with empty name"() {
|
|
when:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: '',
|
|
path: 'testEndpoint2',
|
|
port: 9998,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseSoap-${req.xml.name()}/>"}''',
|
|
soap: true
|
|
))
|
|
then:
|
|
thrown(InvalidMockDefinition)
|
|
}
|
|
|
|
def "should add mock after deleting old mock with the same name"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseSoap-${req.name()}/>"}''',
|
|
soap: true
|
|
))
|
|
and:
|
|
remoteMockServer.removeMock('testSoap') == []
|
|
and:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request2'}''',
|
|
response: '''{req -> "<goodResponseSoap2-${req.xml.name()}/>"}''',
|
|
soap: true
|
|
))
|
|
}
|
|
|
|
def "should add simultaneously working post and rest mocks with the same predicate and endpoint nad port"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseRest-${req.xml.name()}/>"}'''
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.soap.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseSoap-${req.soap.name()}/>"}''',
|
|
soap: true
|
|
))
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
HttpPost soapPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
soapPost.entity = new StringEntity(Util.soap('<request/>'), ContentType.create("text/xml", "UTF-8"))
|
|
when:
|
|
CloseableHttpResponse restResponse = client.execute(restPost)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(restResponse)
|
|
restPostResponse.name() == 'goodResponseRest-request'
|
|
when:
|
|
CloseableHttpResponse soapResponse = client.execute(soapPost)
|
|
then:
|
|
GPathResult soapPostResponse = Util.extractXmlResponse(soapResponse)
|
|
soapPostResponse.name() == 'Envelope'
|
|
soapPostResponse.Body.'goodResponseSoap-request'.size() == 1
|
|
}
|
|
|
|
def "should dispatch rest mocks when second on #name"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest1',
|
|
path: 'test1',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request1'}''',
|
|
response: '''{req -> "<goodResponseRest1/>"}'''
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: secondPath,
|
|
port: secondPort,
|
|
predicate: '''{req -> req.xml.name() == 'request2'}''',
|
|
response: '''{req -> "<goodResponseRest2/>"}'''
|
|
))
|
|
HttpPost firstRequest = new HttpPost('http://localhost:9999/test1')
|
|
firstRequest.entity = new StringEntity('<request1/>', ContentType.create("text/xml", "UTF-8"))
|
|
HttpPost secondRequest = new HttpPost("http://localhost:${secondPort}/${secondPath}")
|
|
secondRequest.entity = new StringEntity('<request2/>', ContentType.create("text/xml", "UTF-8"))
|
|
when:
|
|
CloseableHttpResponse firstResponse = client.execute(firstRequest)
|
|
then:
|
|
GPathResult firstXmlResponse = Util.extractXmlResponse(firstResponse)
|
|
firstXmlResponse.name() == 'goodResponseRest1'
|
|
when:
|
|
CloseableHttpResponse secondResponse = client.execute(secondRequest)
|
|
then:
|
|
GPathResult secondXmlResponse = Util.extractXmlResponse(secondResponse)
|
|
secondXmlResponse.name() == 'goodResponseRest2'
|
|
where:
|
|
secondPort | secondPath | name
|
|
9999 | 'test1' | 'the same port and path'
|
|
9998 | 'test1' | 'the same path and another port'
|
|
9999 | 'test2' | 'the same port and another path'
|
|
9998 | 'test2' | 'another port and path'
|
|
}
|
|
|
|
def "should dispatch rest mock with response code"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest1',
|
|
path: 'test1',
|
|
port: 9999,
|
|
statusCode: statusCode
|
|
))
|
|
HttpPost request = new HttpPost('http://localhost:9999/test1')
|
|
request.entity = new StringEntity('<request1/>', ContentType.create("text/xml", "UTF-8"))
|
|
when:
|
|
CloseableHttpResponse response = client.execute(request)
|
|
then:
|
|
response.statusLine.statusCode == expectedStatusCode
|
|
EntityUtils.consumeQuietly(response.entity)
|
|
where:
|
|
statusCode | expectedStatusCode
|
|
null | 200
|
|
300 | 300
|
|
204 | 204
|
|
}
|
|
|
|
def "should return response code 404 and error body the same as request body when mocks does not apply"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest1',
|
|
path: 'test1',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request2'}''',
|
|
response: '''{req -> "<goodResponseRest2/>"}'''
|
|
))
|
|
HttpPost request = new HttpPost('http://localhost:9999/test1')
|
|
request.entity = new StringEntity('<request1/>', ContentType.create("text/xml", "UTF-8"))
|
|
when:
|
|
CloseableHttpResponse response = client.execute(request)
|
|
then:
|
|
response.statusLine.statusCode == 404
|
|
GPathResult secondXmlResponse = Util.extractXmlResponse(response)
|
|
secondXmlResponse.name() == 'request1'
|
|
}
|
|
|
|
def "should inform that there was problem during adding mock - invalid port"() {
|
|
when:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint2',
|
|
port: -1,
|
|
predicate: '''{_ -> true}''',
|
|
response: '''{req -> "<goodResponseSoap-${req.xml.name()}/>"}''',
|
|
soap: true
|
|
))
|
|
then:
|
|
thrown(InvalidMockDefinition)
|
|
}
|
|
|
|
def "should dispatch rest mock with get method"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
response: '''{_ -> "<defaultResponse/>"}'''
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
response: '''{_ -> "<getResponse/>"}''',
|
|
method: Method.GET
|
|
))
|
|
HttpGet restGet = new HttpGet('http://localhost:9999/testEndpoint')
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restGet)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'getResponse'
|
|
}
|
|
|
|
def "should dispatch rest mock with trace method"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
response: '''{_ -> "<defaultResponse/>"}'''
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
response: '''{_ -> "<traceResponse/>"}''',
|
|
method: Method.TRACE
|
|
))
|
|
HttpTrace restTrace = new HttpTrace('http://localhost:9999/testEndpoint')
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restTrace)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'traceResponse'
|
|
}
|
|
|
|
def "should dispatch rest mock with head method"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
response: '''{_ -> "<defaultResponse/>"}'''
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
method: Method.HEAD
|
|
))
|
|
HttpHead restHead = new HttpHead('http://localhost:9999/testEndpoint')
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restHead)
|
|
then:
|
|
EntityUtils.consumeQuietly(response.entity)
|
|
response.statusLine.statusCode == 200
|
|
}
|
|
|
|
def "should dispatch rest mock with options method"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
response: '''{_ -> "<defaultResponse/>"}'''
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
method: Method.OPTIONS
|
|
))
|
|
HttpOptions restOptions = new HttpOptions('http://localhost:9999/testEndpoint')
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restOptions)
|
|
then:
|
|
response.statusLine.statusCode == 200
|
|
EntityUtils.consumeQuietly(response.entity)
|
|
}
|
|
|
|
def "should dispatch rest mock with put method"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'test1',
|
|
port: 9999,
|
|
response: '''{_ -> "<defaultResponse/>"}'''
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'test1',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request1'}''',
|
|
response: '''{_ -> "<goodResponseRest1/>"}''',
|
|
method: Method.PUT
|
|
))
|
|
HttpPut request = new HttpPut('http://localhost:9999/test1')
|
|
request.entity = new StringEntity('<request1/>', ContentType.create("text/xml", "UTF-8"))
|
|
when:
|
|
CloseableHttpResponse response = client.execute(request)
|
|
then:
|
|
GPathResult secondXmlResponse = Util.extractXmlResponse(response)
|
|
secondXmlResponse.name() == 'goodResponseRest1'
|
|
}
|
|
|
|
def "should dispatch rest mock with delete method"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'test1',
|
|
port: 9999,
|
|
response: '''{_ -> "<defaultResponse/>"}'''
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'test1',
|
|
port: 9999,
|
|
response: '''{_ -> "<goodResponseRest1/>"}''',
|
|
method: Method.DELETE
|
|
))
|
|
HttpDelete request = new HttpDelete('http://localhost:9999/test1')
|
|
when:
|
|
CloseableHttpResponse response = client.execute(request)
|
|
then:
|
|
GPathResult secondXmlResponse = Util.extractXmlResponse(response)
|
|
secondXmlResponse.name() == 'goodResponseRest1'
|
|
}
|
|
|
|
def "should dispatch rest mock with patch method"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'test1',
|
|
port: 9999,
|
|
response: '''{_ -> "<defaultResponse/>"}'''
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'test1',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request1'}''',
|
|
response: '''{_ -> "<goodResponseRest1/>"}''',
|
|
method: Method.PATCH
|
|
))
|
|
HttpPatch request = new HttpPatch('http://localhost:9999/test1')
|
|
request.entity = new StringEntity('<request1/>', ContentType.create("text/xml", "UTF-8"))
|
|
when:
|
|
CloseableHttpResponse response = client.execute(request)
|
|
then:
|
|
GPathResult secondXmlResponse = Util.extractXmlResponse(response)
|
|
secondXmlResponse.name() == 'goodResponseRest1'
|
|
}
|
|
|
|
def "should add mock that return headers"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{_ -> "<goodResponse/>"}''',
|
|
responseHeaders: '''{ req -> ['Input-Name':"${req.xml.name()}"]}'''
|
|
))
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
response.allHeaders.findAll { it.name.toLowerCase() == 'input-name' && it.value == 'request' }
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'goodResponse'
|
|
}
|
|
|
|
def "should add mock that accepts only when certain request headers exists"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{ req -> req.headers['user-agent']?.startsWith('Mozilla') &&
|
|
req.headers.pragma == 'no-cache'}''',
|
|
response: '''{_ -> "<goodResponse/>"}'''
|
|
))
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
restPost.addHeader('User-Agent', 'Mozilla/5.0')
|
|
restPost.addHeader('Pragma', 'no-cache')
|
|
HttpPost badRestPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
badRestPost.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
badRestPost.addHeader('Pragma', 'no-cache')
|
|
when:
|
|
CloseableHttpResponse badResponse = client.execute(badRestPost)
|
|
then:
|
|
badResponse.statusLine.statusCode == 404
|
|
Util.consumeResponse(badResponse)
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'goodResponse'
|
|
}
|
|
|
|
def "should add mock that accepts only when certain query params exists"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{ req -> req.query['q'] == '15' &&
|
|
req.query.id == '1'}''',
|
|
response: '''{_ -> "<goodResponse/>"}'''
|
|
))
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint?q=15&id=1')
|
|
HttpPost badRestPost = new HttpPost('http://localhost:9999/testEndpoint?q=15&id=2')
|
|
when:
|
|
CloseableHttpResponse badResponse = client.execute(badRestPost)
|
|
then:
|
|
badResponse.statusLine.statusCode == 404
|
|
Util.consumeResponse(badResponse)
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'goodResponse'
|
|
}
|
|
|
|
def "should add mock that accepts only when request has specific body"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.text == 'hello=world&id=3'}''',
|
|
response: '''{_ -> "<goodResponse/>"}'''
|
|
))
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('hello=world&id=3', ContentType.create("text/plain", "UTF-8"))
|
|
HttpPost badRestPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
badRestPost.entity = new StringEntity('hello=world&id=2', ContentType.create("text/plain", "UTF-8"))
|
|
when:
|
|
CloseableHttpResponse badResponse = client.execute(badRestPost)
|
|
then:
|
|
badResponse.statusLine.statusCode == 404
|
|
Util.consumeResponse(badResponse)
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'goodResponse'
|
|
}
|
|
|
|
def "should add mock which response json to json"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.json.id == 1 && req.json.ar == ["a", true]}''',
|
|
response: '''{req -> """{"name":"goodResponse-${req.json.id}"}"""}'''
|
|
))
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('{"id":1, "ar":["a", true]}', ContentType.create("text/json", "UTF-8"))
|
|
HttpPost badRestPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
badRestPost.entity = new StringEntity('{"id":1, "ar":["a", false]}', ContentType.create("text/json", "UTF-8"))
|
|
when:
|
|
CloseableHttpResponse badResponse = client.execute(badRestPost)
|
|
then:
|
|
badResponse.statusLine.statusCode == 404
|
|
Util.consumeResponse(badResponse)
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
Object restPostResponse = Util.extractJsonResponse(response)
|
|
restPostResponse.name == 'goodResponse-1'
|
|
}
|
|
|
|
def "should get list of mocks"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'testEndpoint',
|
|
port: 9998,
|
|
predicate: '''{ req -> req.xml.name() == 'request1'}''',
|
|
response: '''{ req -> '<response/>' }''',
|
|
responseHeaders: '{ _ -> [a: "b"] }'
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest4',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
soap: true,
|
|
statusCode: 204,
|
|
method: Method.PUT
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest3',
|
|
path: 'testEndpoint2',
|
|
port: 9999
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest5',
|
|
path: 'testEndpoint',
|
|
port: 9999
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest6',
|
|
path: 'testEndpoint2',
|
|
port: 9999
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
schema: 'schema2.xsd',
|
|
imports: [new ImportAlias(alias: 'aaa', fullClassName: 'bbb')]
|
|
))
|
|
remoteMockServer.removeMock('testRest5')
|
|
when:
|
|
List<MockReport> mockReport = remoteMockServer.listMocks()
|
|
then:
|
|
mockReport.size() == 5
|
|
assertMockReport(mockReport[0], [name: 'testRest', path: 'testEndpoint', port: 9999, predicate: '{ _ -> true }', response: '''{ _ -> '' }''', responseHeaders: '{ _ -> [:] }', soap: false, statusCode: 200, method: Method.POST, schema: 'schema2.xsd'])
|
|
assertMockReport(mockReport[1], [name: 'testRest2', path: 'testEndpoint', port: 9998, predicate: '''{ req -> req.xml.name() == 'request1'}''', response: '''{ req -> '<response/>' }''', responseHeaders: '{ _ -> [a: "b"] }', soap: false, statusCode: 200, method: Method.POST])
|
|
assertMockReport(mockReport[2], [name: 'testRest3', path: 'testEndpoint2', port: 9999, predicate: '{ _ -> true }', response: '''{ _ -> '' }''', responseHeaders: '{ _ -> [:] }', soap: false, statusCode: 200, method: Method.POST])
|
|
assertMockReport(mockReport[3], [name: 'testRest4', path: 'testEndpoint', port: 9999, predicate: '{ _ -> true }', response: '''{ _ -> '' }''', responseHeaders: '{ _ -> [:] }', soap: true, statusCode: 204, method: Method.PUT])
|
|
assertMockReport(mockReport[4], [name: 'testRest6', path: 'testEndpoint2', port: 9999, predicate: '{ _ -> true }', response: '''{ _ -> '' }''', responseHeaders: '{ _ -> [:] }', soap: false, statusCode: 200, method: Method.POST])
|
|
mockReport[0].imports.find { it.alias == 'aaa' }?.fullClassName == 'bbb'
|
|
}
|
|
|
|
private static void assertMockReport(MockReport mockReport, Map<String, Object> props) {
|
|
props.each {
|
|
assert mockReport."${it.key}" == it.value
|
|
}
|
|
}
|
|
|
|
def "should add mock accepts path certain path params"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.path[1] == '15' && req.path[2] == 'comments'}''',
|
|
response: '''{req -> """{"name":"goodResponse-${req.path[1]}"}"""}'''
|
|
))
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint/15/comments')
|
|
HttpPost badRestPost = new HttpPost('http://localhost:9999/testEndpoint/test/comments')
|
|
when:
|
|
CloseableHttpResponse badResponse = client.execute(badRestPost)
|
|
then:
|
|
badResponse.statusLine.statusCode == 404
|
|
Util.consumeResponse(badResponse)
|
|
when:
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
Object restPostResponse = Util.extractJsonResponse(response)
|
|
restPostResponse.name == 'goodResponse-15'
|
|
}
|
|
|
|
def "should get mock report when deleting mock"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name()[0..6] == 'request' }''',
|
|
response: '''{req -> "<goodResponseRest-${req.xml.name()}/>"}''',
|
|
statusCode: 201,
|
|
responseHeaders: '''{req -> ['aaa':'14']}''',
|
|
soap: false
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'reqXYZ' }''',
|
|
response: '''{req -> "<goodResponseRest/>"}''',
|
|
statusCode: 202,
|
|
responseHeaders: '''{req -> ['aaa':'15']}''',
|
|
soap: false
|
|
))
|
|
when:
|
|
HttpPost post1 = new HttpPost('http://localhost:9999/testEndpoint')
|
|
post1.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response1 = client.execute(post1)
|
|
then:
|
|
GPathResult restPostResponse1 = Util.extractXmlResponse(response1)
|
|
restPostResponse1.name() == 'goodResponseRest-request'
|
|
when:
|
|
HttpPost post2 = new HttpPost('http://localhost:9999/testEndpoint/hello')
|
|
post2.entity = new StringEntity('<request15/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response2 = client.execute(post2)
|
|
then:
|
|
GPathResult restPostResponse2 = Util.extractXmlResponse(response2)
|
|
restPostResponse2.name() == 'goodResponseRest-request15'
|
|
when:
|
|
HttpPost post3 = new HttpPost('http://localhost:9999/testEndpoint?id=123')
|
|
post3.entity = new StringEntity('<reqXYZ/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response3 = client.execute(post3)
|
|
then:
|
|
GPathResult restPostResponse3 = Util.extractXmlResponse(response3)
|
|
restPostResponse3.name() == 'goodResponseRest'
|
|
when:
|
|
List<MockEventReport> mockEvents1 = remoteMockServer.removeMock('testRest')
|
|
then:
|
|
mockEvents1.size() == 2
|
|
mockEvents1[0].request.text == '<request/>'
|
|
!mockEvents1[0].request.headers?.headers?.empty
|
|
mockEvents1[0].request.queryParams.queryParams == []
|
|
mockEvents1[0].request.path.pathParts == ['testEndpoint']
|
|
!mockEvents1[0].response.headers?.headers?.empty
|
|
mockEvents1[0].response.text == '<goodResponseRest-request/>'
|
|
mockEvents1[0].response.statusCode == 201
|
|
|
|
mockEvents1[1].request.text == '<request15/>'
|
|
!mockEvents1[1].request.headers?.headers?.empty
|
|
mockEvents1[1].request.queryParams.queryParams == []
|
|
mockEvents1[1].request.path.pathParts == ['testEndpoint', 'hello']
|
|
!mockEvents1[1].response.headers?.headers?.empty
|
|
mockEvents1[1].response.text == '<goodResponseRest-request15/>'
|
|
mockEvents1[1].response.statusCode == 201
|
|
when:
|
|
List<MockEventReport> mockEvents2 = remoteMockServer.removeMock('testRest2')
|
|
then:
|
|
mockEvents2.size() == 1
|
|
mockEvents2[0].request.text == '<reqXYZ/>'
|
|
!mockEvents2[0].request.headers?.headers?.empty
|
|
mockEvents2[0].request.queryParams.queryParams.find { it.name == 'id' }?.value == '123'
|
|
mockEvents2[0].request.path.pathParts == ['testEndpoint']
|
|
mockEvents2[0].response.headers.headers.find { it.name == 'aaa' }?.value == '15'
|
|
mockEvents2[0].response.text == '<goodResponseRest/>'
|
|
mockEvents2[0].response.statusCode == 202
|
|
}
|
|
|
|
def "should get mock report when peeking mock"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name()[0..6] == 'request' }''',
|
|
response: '''{req -> "<goodResponseRest-${req.xml.name()}/>"}''',
|
|
statusCode: 201,
|
|
responseHeaders: '''{req -> ['aaa':'14']}''',
|
|
soap: false
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'reqXYZ' }''',
|
|
response: '''{req -> "<goodResponseRest/>"}''',
|
|
statusCode: 202,
|
|
responseHeaders: '''{req -> ['aaa':'15']}''',
|
|
soap: false
|
|
))
|
|
when:
|
|
HttpPost post1 = new HttpPost('http://localhost:9999/testEndpoint')
|
|
post1.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response1 = client.execute(post1)
|
|
then:
|
|
GPathResult restPostResponse1 = Util.extractXmlResponse(response1)
|
|
restPostResponse1.name() == 'goodResponseRest-request'
|
|
when:
|
|
HttpPost post2 = new HttpPost('http://localhost:9999/testEndpoint/hello')
|
|
post2.entity = new StringEntity('<request15/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response2 = client.execute(post2)
|
|
then:
|
|
GPathResult restPostResponse2 = Util.extractXmlResponse(response2)
|
|
restPostResponse2.name() == 'goodResponseRest-request15'
|
|
when:
|
|
HttpPost post3 = new HttpPost('http://localhost:9999/testEndpoint?id=123')
|
|
post3.entity = new StringEntity('<reqXYZ/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response3 = client.execute(post3)
|
|
then:
|
|
GPathResult restPostResponse3 = Util.extractXmlResponse(response3)
|
|
restPostResponse3.name() == 'goodResponseRest'
|
|
when:
|
|
List<MockEventReport> mockEvents1 = remoteMockServer.peekMock('testRest')
|
|
then:
|
|
mockEvents1.size() == 2
|
|
mockEvents1[0].request.text == '<request/>'
|
|
!mockEvents1[0].request.headers?.headers?.empty
|
|
mockEvents1[0].request.queryParams.queryParams == []
|
|
mockEvents1[0].request.path.pathParts == ['testEndpoint']
|
|
!mockEvents1[0].response.headers?.headers?.empty
|
|
mockEvents1[0].response.text == '<goodResponseRest-request/>'
|
|
mockEvents1[0].response.statusCode == 201
|
|
|
|
mockEvents1[1].request.text == '<request15/>'
|
|
!mockEvents1[1].request.headers?.headers?.empty
|
|
mockEvents1[1].request.queryParams.queryParams == []
|
|
mockEvents1[1].request.path.pathParts == ['testEndpoint', 'hello']
|
|
!mockEvents1[1].response.headers?.headers?.empty
|
|
mockEvents1[1].response.text == '<goodResponseRest-request15/>'
|
|
mockEvents1[1].response.statusCode == 201
|
|
when:
|
|
List<MockEventReport> mockEvents2 = remoteMockServer.peekMock('testRest2')
|
|
then:
|
|
mockEvents2.size() == 1
|
|
mockEvents2[0].request.text == '<reqXYZ/>'
|
|
!mockEvents2[0].request.headers?.headers?.empty
|
|
mockEvents2[0].request.queryParams.queryParams.find { it.name == 'id' }?.value == '123'
|
|
mockEvents2[0].request.path.pathParts == ['testEndpoint']
|
|
mockEvents2[0].response.headers.headers.find { it.name == 'aaa' }?.value == '15'
|
|
mockEvents2[0].response.text == '<goodResponseRest/>'
|
|
mockEvents2[0].response.statusCode == 202
|
|
}
|
|
|
|
def "should return mock report with #mockEvents events when deleting mock with flag skip mock = #skipReport"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name()[0..6] == 'request' }''',
|
|
response: '''{req -> "<goodResponseRest-${req.xml.name()}/>"}''',
|
|
statusCode: 201,
|
|
responseHeaders: '''{req -> ['aaa':'14']}''',
|
|
soap: false
|
|
))
|
|
when:
|
|
HttpPost post1 = new HttpPost('http://localhost:9999/testEndpoint')
|
|
post1.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response1 = client.execute(post1)
|
|
then:
|
|
GPathResult restPostResponse1 = Util.extractXmlResponse(response1)
|
|
restPostResponse1.name() == 'goodResponseRest-request'
|
|
expect:
|
|
remoteMockServer.removeMock('testRest', skipReport).size() == mockEvents
|
|
where:
|
|
skipReport | mockEvents
|
|
false | 1
|
|
true | 0
|
|
}
|
|
|
|
def "should reject mock when it has System.exit in closure"() {
|
|
when:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: predicate,
|
|
response: '''{req -> "<goodResponseRest-${req.xml.name()}/>"}''',
|
|
soap: false
|
|
))
|
|
then:
|
|
thrown(InvalidMockDefinition)
|
|
expect:
|
|
remoteMockServer.listMocks() == []
|
|
where:
|
|
predicate << [
|
|
'''{req -> System.exit(-1); req.xml.name() == 'request'}''',
|
|
'''{req -> System .exit(-1); req.xml.name() == 'request'}''',
|
|
'''{req -> System
|
|
|
|
.exit(-1); req.xml.name() == 'request'}''',
|
|
'''{req -> System. exit(-1); req.xml.name() == 'request'}''',
|
|
'''{req -> System.exit (-1); req.xml.name() == 'request'}'''
|
|
]
|
|
}
|
|
|
|
def "should validate request against multiple schema files"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
schema: 'schema1.xsd',
|
|
response: '''{req -> '<goodResponseRest/>'}''',
|
|
soap: false
|
|
))
|
|
when:
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('<request xmlns="http://mockserver/test1"><id>15</id><value>unknown</value></request>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
response.statusLine.statusCode == 400
|
|
Util.extractStringResponse(response).contains('''Value 'unknown' is not facet-valid with respect to enumeration '[test, prod, preprod]'.''')
|
|
when:
|
|
HttpPost restPost2 = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost2.entity = new StringEntity('<request xmlns="http://mockserver/test1"><id>15</id><value>test</value></request>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response2 = client.execute(restPost2)
|
|
then:
|
|
Util.consumeResponse(response2)
|
|
response2.statusLine.statusCode == 200
|
|
expect:
|
|
remoteMockServer.removeMock('testRest')?.size() == 2
|
|
}
|
|
|
|
def "should validate soap request"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
schema: 'schema1.xsd',
|
|
response: '''{req -> '<goodResponse/>'}''',
|
|
soap: true
|
|
))
|
|
when:
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity(Util.soap('<request xmlns="http://mockserver/test1"><id>15</id><value>unknown</value></request>'), ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
response.statusLine.statusCode == 400
|
|
Util.extractStringResponse(response).contains('''Value 'unknown' is not facet-valid with respect to enumeration '[test, prod, preprod]'.''')
|
|
when:
|
|
HttpPost restPost2 = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost2.entity = new StringEntity(Util.soap('<request xmlns="http://mockserver/test1"><id>15</id><value>test</value></request>'), ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response2 = client.execute(restPost2)
|
|
then:
|
|
Util.consumeResponse(response2)
|
|
response2.statusLine.statusCode == 200
|
|
expect:
|
|
remoteMockServer.removeMock('testSoap')?.size() == 2
|
|
}
|
|
|
|
def "should validate soap request with namespace in envelope"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testSoap',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
schema: 'schema1.xsd',
|
|
response: '''{req -> '<goodResponse/>'}''',
|
|
soap: true
|
|
))
|
|
when:
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('''<soap-env:Envelope xmlns:soap-env='http://schemas.xmlsoap.org/soap/envelope/'
|
|
xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing"
|
|
xmlns:req="http://mockserver/test1">
|
|
<soap-env:Body>
|
|
<req:request><req:id>15</req:id><req:value>unknown</req:value></req:request>
|
|
</soap-env:Body>
|
|
</soap-env:Envelope>''', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
response.statusLine.statusCode == 400
|
|
Util.extractStringResponse(response).contains('''Value 'unknown' is not facet-valid with respect to enumeration '[test, prod, preprod]'.''')
|
|
when:
|
|
HttpPost restPost2 = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost2.entity = new StringEntity('''<soap-env:Envelope xmlns:soap-env='http://schemas.xmlsoap.org/soap/envelope/'
|
|
xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing"
|
|
xmlns:req="http://mockserver/test1">
|
|
<soap-env:Body>
|
|
<req:request><req:id>15</req:id><req:value>test</req:value></req:request>
|
|
</soap-env:Body>
|
|
</soap-env:Envelope>''', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response2 = client.execute(restPost2)
|
|
then:
|
|
Util.consumeResponse(response2)
|
|
response2.statusLine.statusCode == 200
|
|
expect:
|
|
remoteMockServer.removeMock('testSoap')?.size() == 2
|
|
}
|
|
|
|
def "should add mock with alias"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseRest-${AAA.XMLNS_ATTRIBUTE}/>"}''',
|
|
soap: false,
|
|
imports: [new ImportAlias(alias: 'AAA', fullClassName: 'javax.xml.XMLConstants')]
|
|
))
|
|
when:
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'goodResponseRest-xmlns'
|
|
expect:
|
|
remoteMockServer.removeMock('testRest')?.size() == 1
|
|
}
|
|
|
|
def "should get configuration of mocks and reconfigure new mock server based on it"() {
|
|
given:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest2',
|
|
path: 'testEndpoint',
|
|
port: 9998,
|
|
predicate: '''{ req -> req.xml.name() == 'request1'}''',
|
|
response: '''{ req -> '<response/>' }''',
|
|
responseHeaders: '{ _ -> [a: "b"] }'
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest4',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
soap: true,
|
|
statusCode: 204,
|
|
method: Method.PUT
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest3',
|
|
path: 'testEndpoint2',
|
|
port: 9999
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest5',
|
|
path: 'testEndpoint',
|
|
port: 9999
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest6',
|
|
path: 'testEndpoint2',
|
|
port: 9999
|
|
))
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
schema: 'schema2.xsd',
|
|
imports: [
|
|
new ImportAlias(alias: 'aaa', fullClassName: 'bbb'),
|
|
new ImportAlias(alias: 'ccc', fullClassName: 'bla')
|
|
],
|
|
preserveHistory: true
|
|
))
|
|
remoteMockServer.removeMock('testRest5')
|
|
when:
|
|
ConfigObject configObject = remoteMockServer.configuration
|
|
httpMockServer.stop()
|
|
httpMockServer = new HttpMockServer(9000, configObject)
|
|
|
|
then:
|
|
List<MockReport> mockReport = remoteMockServer.listMocks()
|
|
mockReport.size() == 5
|
|
assertMockReport(mockReport[0], [name: 'testRest', path: 'testEndpoint', port: 9999, predicate: '{ _ -> true }', response: '''{ _ -> '' }''', responseHeaders: '{ _ -> [:] }', soap: false, statusCode: 200, method: Method.POST, schema: 'schema2.xsd', preserveHistory: true])
|
|
assertMockReport(mockReport[1], [name: 'testRest2', path: 'testEndpoint', port: 9998, predicate: '''{ req -> req.xml.name() == 'request1'}''', response: '''{ req -> '<response/>' }''', responseHeaders: '{ _ -> [a: "b"] }', soap: false, statusCode: 200, method: Method.POST])
|
|
assertMockReport(mockReport[2], [name: 'testRest3', path: 'testEndpoint2', port: 9999, predicate: '{ _ -> true }', response: '''{ _ -> '' }''', responseHeaders: '{ _ -> [:] }', soap: false, statusCode: 200, method: Method.POST])
|
|
assertMockReport(mockReport[3], [name: 'testRest4', path: 'testEndpoint', port: 9999, predicate: '{ _ -> true }', response: '''{ _ -> '' }''', responseHeaders: '{ _ -> [:] }', soap: true, statusCode: 204, method: Method.PUT])
|
|
assertMockReport(mockReport[4], [name: 'testRest6', path: 'testEndpoint2', port: 9999, predicate: '{ _ -> true }', response: '''{ _ -> '' }''', responseHeaders: '{ _ -> [:] }', soap: false, statusCode: 200, method: Method.POST])
|
|
mockReport[0].imports.find { it.alias == 'aaa' }?.fullClassName == 'bbb'
|
|
mockReport[0].imports.find { it.alias == 'ccc' }?.fullClassName == 'bla'
|
|
}
|
|
|
|
def "should add mock without history"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> "<goodResponseRest-${req.xml.name()}/>"}''',
|
|
soap: false,
|
|
preserveHistory: false
|
|
))
|
|
when:
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
restPost.entity = new StringEntity('<request/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
GPathResult restPostResponse = Util.extractXmlResponse(response)
|
|
restPostResponse.name() == 'goodResponseRest-request'
|
|
expect:
|
|
remoteMockServer.removeMock('testRest')?.size() == 0
|
|
}
|
|
|
|
def "should handle empty post"() {
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'testRest',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
statusCode: 201,
|
|
soap: false
|
|
))
|
|
when:
|
|
HttpPost restPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
response.statusLine.statusCode == 201
|
|
Util.consumeResponse(response)
|
|
expect:
|
|
remoteMockServer.removeMock('testRest')?.size() == 1
|
|
}
|
|
|
|
def 'should handle leading slash'() {
|
|
given:
|
|
String name = "testRest-${UUID.randomUUID().toString()}"
|
|
expect:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: name,
|
|
path: mockPath,
|
|
port: 9999,
|
|
statusCode: 201,
|
|
soap: false
|
|
))
|
|
when:
|
|
HttpPost restPost = new HttpPost("http://localhost:9999/$urlPath")
|
|
CloseableHttpResponse response = client.execute(restPost)
|
|
then:
|
|
response.statusLine.statusCode == 201
|
|
Util.consumeResponse(response)
|
|
expect:
|
|
remoteMockServer.removeMock(name)?.size() == 1
|
|
where:
|
|
mockPath | urlPath
|
|
'' | ''
|
|
'/' | ''
|
|
'test' | 'test'
|
|
'/test' | 'test'
|
|
'test/other' | 'test/other'
|
|
'/test/other' | 'test/other'
|
|
}
|
|
|
|
def 'should match any method'() {
|
|
given:
|
|
String name = "testRest-${UUID.randomUUID().toString()}"
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: name,
|
|
path: 'any-method',
|
|
port: 9999,
|
|
statusCode: 201,
|
|
soap: false,
|
|
method: Method.ANY_METHOD
|
|
))
|
|
when:
|
|
CloseableHttpResponse response = client.execute(req)
|
|
then:
|
|
response.statusLine.statusCode == 201
|
|
Util.consumeResponse(response)
|
|
cleanup:
|
|
remoteMockServer.removeMock(name)
|
|
where:
|
|
req << [
|
|
new HttpGet('http://localhost:9999/any-method'),
|
|
new HttpPost('http://localhost:9999/any-method'),
|
|
new HttpPatch('http://localhost:9999/any-method')
|
|
]
|
|
}
|
|
}
|