239 lines
11 KiB
Groovy
239 lines
11 KiB
Groovy
package eu.ztsh.mockserver.tests
|
|
|
|
|
|
import org.apache.http.client.methods.CloseableHttpResponse
|
|
import org.apache.http.client.methods.HttpPost
|
|
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 eu.ztsh.mockserver.api.request.AddMock
|
|
import eu.ztsh.mockserver.client.RemoteMockServer
|
|
import eu.ztsh.mockserver.server.HttpMockServer
|
|
import spock.lang.AutoCleanup
|
|
import spock.lang.Specification
|
|
|
|
class MockServerMaxUsesTest 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 return two mocks in order'() {
|
|
given:'mock with predicate is given but for only one use'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock1',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock1'}''',
|
|
maxUses: 1
|
|
))
|
|
and:'mock with the same predicate is given'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock2'}''',
|
|
))
|
|
when:'we call the first time'
|
|
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:'first mock should be returned and expired'
|
|
response.entity.content.text == 'mock1'
|
|
when:'we call the second time using the same request'
|
|
CloseableHttpResponse response2 = client.execute(restPost)
|
|
then:'second mock should be returned'
|
|
response2.entity.content.text == 'mock2'
|
|
when:'we call the third time using the same request'
|
|
CloseableHttpResponse response3 = client.execute(restPost)
|
|
then:'second mock should be returned, because it has unlimited uses'
|
|
response3.entity.content.text == 'mock2'
|
|
}
|
|
|
|
def 'should return two mocks in order but only once'() {
|
|
given:'mock with predicate is given but for only one use'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock1',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock1'}''',
|
|
maxUses: 1
|
|
))
|
|
and:'mock with the same predicate is given'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock2'}''',
|
|
maxUses: 1,
|
|
))
|
|
when:'we call the first time'
|
|
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:'first mock should be returned and expired'
|
|
response.entity.content.text == 'mock1'
|
|
when:'we call the second time using the same request'
|
|
CloseableHttpResponse response2 = client.execute(restPost)
|
|
then:'second mock should be returned'
|
|
response2.entity.content.text == 'mock2'
|
|
when:'we call the third time using the same request'
|
|
CloseableHttpResponse response3 = client.execute(restPost)
|
|
then:'no mock should be found'
|
|
response3.statusLine.statusCode == 404
|
|
and:'mock should exist'
|
|
remoteMockServer.listMocks().find { it.name == 'mock1' } != null
|
|
}
|
|
|
|
def 'should return two mocks in cyclic order'() {
|
|
given:'mock with predicate is given but for only one use'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock1',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock1'}''',
|
|
maxUses: 1,
|
|
cyclic: true,
|
|
preserveHistory: true
|
|
))
|
|
and:'mock with the same predicate is given'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock2'}''',
|
|
maxUses: 1,
|
|
cyclic: true
|
|
))
|
|
when:'we call the first time'
|
|
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:'first mock should be returned and expired'
|
|
response.entity.content.text == 'mock1'
|
|
when:'we call the second time using the same request'
|
|
CloseableHttpResponse response2 = client.execute(restPost)
|
|
then:'second mock should be returned and expired'
|
|
response2.entity.content.text == 'mock2'
|
|
when:'we call the third time using the same request'
|
|
CloseableHttpResponse response3 = client.execute(restPost)
|
|
then:'first mock should be returned, because these mocks are cyclic'
|
|
response3.entity.content.text == 'mock1'
|
|
when:'we call the fourth time using the same request'
|
|
CloseableHttpResponse response4 = client.execute(restPost)
|
|
then:'second mock should be returned, because these mocks are cyclic'
|
|
response4.entity.content.text == 'mock2'
|
|
and:
|
|
remoteMockServer.peekMock('mock1').size() == 2
|
|
}
|
|
|
|
def 'should return two mocks with the same request interjected by another'() {
|
|
given:'mock with predicate is given but for only one use'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock1',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock1'}''',
|
|
maxUses: 1,
|
|
cyclic: true
|
|
))
|
|
and:'mock with the same predicate is given'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock2'}''',
|
|
maxUses: 1,
|
|
cyclic: true
|
|
))
|
|
and:'mock with other predicate is given'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'otherMock',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'otherRequest'}''',
|
|
response: '''{req -> 'otherMock'}'''
|
|
))
|
|
when:'we call the first time'
|
|
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:'first mock should be returned and expired'
|
|
response.entity.content.text == 'mock1'
|
|
when:'we call other request'
|
|
HttpPost otherRestPost = new HttpPost('http://localhost:9999/testEndpoint')
|
|
otherRestPost.entity = new StringEntity('<otherRequest/>', ContentType.create("text/xml", "UTF-8"))
|
|
CloseableHttpResponse otherResponse = client.execute(otherRestPost)
|
|
then:'other mock should be called'
|
|
otherResponse.entity.content.text == 'otherMock'
|
|
when:'we call the second time using the same request'
|
|
CloseableHttpResponse response2 = client.execute(restPost)
|
|
then:'second mock should be returned and expired'
|
|
response2.entity.content.text == 'mock2'
|
|
when:'we call the third time using the same request'
|
|
CloseableHttpResponse response3 = client.execute(restPost)
|
|
then:'first mock should be returned, because these mocks are cyclic'
|
|
response3.entity.content.text == 'mock1'
|
|
}
|
|
|
|
def 'should return first mock twice'() {
|
|
given:'mock with predicate is given but for only one use'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock1',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock1'}''',
|
|
maxUses: 2
|
|
))
|
|
and:'mock with the same predicate is given'
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock2',
|
|
path: 'testEndpoint',
|
|
port: 9999,
|
|
predicate: '''{req -> req.xml.name() == 'request'}''',
|
|
response: '''{req -> 'mock2'}''',
|
|
))
|
|
when:'we call the first time'
|
|
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:'first mock should be returned and expired'
|
|
response.entity.content.text == 'mock1'
|
|
when:'we call the second time using the same request'
|
|
CloseableHttpResponse response2 = client.execute(restPost)
|
|
then:'again first mock should be returned'
|
|
response2.entity.content.text == 'mock1'
|
|
when:'we call the third time using the same request'
|
|
CloseableHttpResponse response3 = client.execute(restPost)
|
|
then:'second mock should be returned'
|
|
response3.entity.content.text == 'mock2'
|
|
}
|
|
|
|
def 'should throw exception if adding mock with incorrect maxUses'() {
|
|
when:
|
|
remoteMockServer.addMock(new AddMock(
|
|
name: 'mock1',
|
|
maxUses: 0
|
|
))
|
|
then:
|
|
thrown(RuntimeException)
|
|
}
|
|
}
|