def test_imposter_with_deep_equals_predicate(imposter_client):
imposter_client.delete(65000)
stubs = []
stubs.append(imposter_client.new_stub_builder().when(
http_request.query.deep_equals({})).response.is_(
http_response(status_code=200, body='first')).build())
stubs.append(imposter_client.new_stub_builder().when(
http_request.query.deep_equals({'first': '1'})).response.is_(
http_response(status_code=200, body='second')).build())
stubs.append(imposter_client.new_stub_builder().when(
http_request.query.deep_equals({
'first': '1',
'second': '2'
})).response.is_(http_response(status_code=200, body='third')).build())
imposter_client.create('sample', 'http', 65000, stubs=stubs)
response = requests.get('http://localhost:65000/test')
assert response.text == 'first'
response = requests.get('http://localhost:65000/test?First=1')
assert response.text == 'second'
response = requests.get('http://localhost:65000/test?Second=2&First=1')
assert response.text == 'third'
response = requests.get(
'http://localhost:65000/test?Second=2&First=1&Third=3')
assert response.text == ''
def test_imposter_with_exists_predicate(imposter_client):
imposter_client.delete(65000)
stubs = []
stubs.append(imposter_client.new_stub_builder().when(
http_request.query.exists('q'),
http_request.query.exists('search', False),
http_request.headers.exists('Accept'),
http_request.headers.exists('X-Rate-Limit', False)).response.is_(
http_response(200, body='first response')).build())
stubs.append(imposter_client.new_stub_builder().when(
http_request.exists('method'),
http_request.exists('body', False)).response.is_(
http_response(200, body='second response')).build())
stubs.append(imposter_client.new_stub_builder().when(
http_request.exists('body')).response.is_(
http_response(200, body='third response')).build())
imposter_client.create('sample', 'http', 65000, stubs=stubs)
response = requests.get('http://localhost:65000/?q=mountebank',
headers={'Accept': 'text/plain'})
assert 'first response' == response.text
response = requests.get('http://localhost:65000/')
assert 'second response' == response.text
response = requests.get('http://localhost:65000/', data='non-empty body')
assert 'third response' == response.text
def test_imposter_create_with_spec(imposter_client):
imposter_client.delete(65000)
stubs = []
stubs.append(imposter_client.new_stub_builder().when(
http_request.method == 'POST',
http_request.path == '/customers/123').response.is_(
http_response(
status_code=201,
headers={
'Location': 'http://*****:*****@test.com</email></customer>'),
http_response(status_code=400,
headers={'Content-Type': 'application/xml'},
body='<error>email already exists</error>')).build())
stubs.append(imposter_client.new_stub_builder().response.is_(
http_response(status_code=404)).build())
imposter_client.create('sample', 'http', 65000, stubs=stubs)
response = requests.post('http://*****:*****@test.com' in response.text
response = requests.post('http://localhost:65000/customers/123', data={})
assert response.status_code == 400
assert response.headers['Content-Type'] == 'application/xml'
assert 'email already exists' in response.text
response = requests.get('http://localhost:65000/customers/999')
assert response.status_code == 404
def test_build_response_with_equals_predicates(stub_builder):
stub_builder.when(http_request.method == 'POST',
http_request.path == '/test', http_request.query == {
'first': '1',
'second': '2'
}, http_request.headers == {
'Accept': 'text/plain'
}).response.is_(http_response(status_code=400))
expected = {
'responses': [{
'is': {
'statusCode': 400
}
}],
'predicates': [{
'equals': {
'method': 'POST',
'path': '/test',
'query': {
'first': '1',
'second': '2',
},
'headers': {
'Accept': 'text/plain',
}
},
}]
}
assert expected == stub_builder.build()
def test_build_response_with_nested_predicates(stub_builder):
stub_builder.when(
or_(
http_request.method == 'POST',
and_(http_request.path == '/begin',
http_request.body.startswith('duh')))).response.is_(
http_response(status_code=200))
expected = {
'predicates': [{
'or': {
'equals': {
'method': 'POST'
},
'and': {
'equals': {
'path': '/begin'
},
'startsWith': {
'body': 'duh'
}
}
}
}],
'responses': [{
'is': {
'statusCode': 200
}
}]
}
assert expected == stub_builder.build()
def test_build_response_with_exists_predicates(stub_builder):
stub_builder.when(http_request.query.exists('q'),
http_request.query.exists('search', False),
http_request.headers.exists('Accept'),
http_request.headers.exists(
'X-Rate-Limit',
False)).response.is_(http_response(status_code=200))
expected = {
'responses': [{
'is': {
'statusCode': 200
}
}],
'predicates': [{
'exists': {
'query': {
'q': True,
'search': False,
},
'headers': {
'Accept': True,
'X-Rate-Limit': False,
}
}
}]
}
assert expected == stub_builder.build()
def test_build_response_with_not_predicate(stub_builder):
stub_builder.when(not_(http_request.method == 'POST')) \
.response.is_(http_response(status_code=200))
expected = {'predicates': [
{'not': {'equals': {'method': 'POST'}}}],
'responses': [{'is': {'statusCode': 200}}]}
assert expected == stub_builder.build()
def test_imposter_with_equals_predicate(imposter_client):
imposter_client.delete(65000)
stubs = []
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.method == 'POST',
http_request.path == '/test',
http_request.query == {'first': '1', 'second': '2'},
http_request.headers == {'Accept': 'text/plain'})
.response.is_(http_response(status_code=400))
.build()
)
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.headers == {'Accept': 'application/xml'})
.response.is_(http_response(status_code=406))
.build()
)
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.method == 'PUT')
.response.is_(http_response(status_code=405))
.build()
)
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.method == 'PUT')
.response.is_(http_response(status_code=500))
.build()
)
imposter_client.create('sample', 'http', 65000, stubs=stubs)
response = requests.post('http://localhost:65000/test?First=1&Second=2',
headers={'accept': 'text/plain'},
data='hello, world!')
assert response.status_code == 400
response = requests.post('http://localhost:65000/test?First=1&Second=2',
headers={'accept': 'application/xml'},
data='hello, world!')
assert response.status_code == 406
response = requests.put('http://localhost:65000/test?First=1&Second=2',
headers={'accept': 'application/json'},
data='hello, world!')
assert response.status_code == 405
def test_build_response_with_multiple_predicates(stub_builder):
stub_builder.when(
http_request.body == 'OK',
http_request.path == '/foo'
).response.is_(http_response(status_code=200))
expected = {'predicates': [{'equals': {'body': 'OK',
'path': '/foo'}}],
'responses': [{'is': {'statusCode': 200}}]}
assert expected == stub_builder.build()
def test_build_response_with_only_status_code(stub_builder):
stub_builder.response.is_(http_response(status_code=400))
expected = {
'responses': [{
'is': {
'statusCode': 400
}
}]
}
assert expected == stub_builder.build()
def test_build_response_with_multiple_different_predicates(stub_builder):
stub_builder.when(
http_request.method == 'POST',
http_request.body.contains('duh')
).response.is_(http_response(status_code=200))
expected = {'predicates': [
{'contains': {'body': 'duh'}},
{'equals': {'method': 'POST'}}],
'responses': [{'is': {'statusCode': 200}}]}
assert expected['predicates'] == stub_builder.build()['predicates']
def test_build_response_with_deep_equals_predicates(stub_builder):
stub_builder.when(http_request.query.deep_equals({})
).response.is_(http_response(status_code=200, body='first'))
expected = {
'responses': [{'is': {'body': 'first', 'statusCode': 200}}],
'predicates': [{
'deepEquals': {
'query': {}
}
}]
}
assert expected == stub_builder.build()
def test_imposter_with_exists_predicate(imposter_client):
imposter_client.delete(65000)
stubs = []
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.query.exists('q'),
http_request.query.exists('search', False),
http_request.headers.exists('Accept'),
http_request.headers.exists('X-Rate-Limit', False))
.response.is_(http_response(200, body='first response'))
.build()
)
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.exists('method'),
http_request.exists('body', False))
.response.is_(http_response(200, body='second response'))
.build()
)
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.exists('body'))
.response.is_(http_response(200, body='third response'))
.build()
)
imposter_client.create('sample', 'http', 65000, stubs=stubs)
response = requests.get('http://localhost:65000/?q=mountebank',
headers={'Accept': 'text/plain'})
assert 'first response' == response.text
response = requests.get('http://localhost:65000/')
assert 'second response' == response.text
response = requests.get('http://localhost:65000/', data='non-empty body')
assert 'third response' == response.text
def test_build_response_with_multiple_responses(stub_builder):
stub_builder.response \
.is_(http_response(status_code=400),
http_response(status_code=200,
mode=http_response.Mode.TEXT,
body='OK',
headers={'Content-Type': 'text'}))
expected = {
'responses': [{
'is': {
'statusCode': 400
}
}, {
'is': {
'statusCode': 200,
'_mode': 'text',
'body': 'OK',
'headers': {'Content-Type': 'text'}
}
}]
}
assert expected == stub_builder.build()
def test_imposter_with_equals_predicate(imposter_client):
imposter_client.delete(65000)
stubs = []
stubs.append(imposter_client.new_stub_builder().when(
http_request.method == 'POST', http_request.path == '/test',
http_request.query == {
'first': '1',
'second': '2'
}, http_request.headers == {
'Accept': 'text/plain'
}).response.is_(http_response(status_code=400)).build())
stubs.append(
imposter_client.new_stub_builder().when(http_request.headers == {
'Accept': 'application/xml'
}).response.is_(http_response(status_code=406)).build())
stubs.append(imposter_client.new_stub_builder().when(
http_request.method == 'PUT').response.is_(
http_response(status_code=405)).build())
stubs.append(imposter_client.new_stub_builder().when(
http_request.method == 'PUT').response.is_(
http_response(status_code=500)).build())
imposter_client.create('sample', 'http', 65000, stubs=stubs)
response = requests.post('http://localhost:65000/test?First=1&Second=2',
headers={'accept': 'text/plain'},
data='hello, world!')
assert response.status_code == 400
response = requests.post('http://localhost:65000/test?First=1&Second=2',
headers={'accept': 'application/xml'},
data='hello, world!')
assert response.status_code == 406
response = requests.put('http://localhost:65000/test?First=1&Second=2',
headers={'accept': 'application/json'},
data='hello, world!')
assert response.status_code == 405
def test_build_response_with_and_predicate(stub_builder):
stub_builder.when(and_(http_request.method == 'POST',
http_request.path == '/begin',
http_request.body.startswith('duh'))
).response.is_(http_response(status_code=200))
expected = {'predicates': [
{'and': {'equals': {'method': 'POST',
'path': '/begin'},
'startsWith': {'body': 'duh'}
}
}
],
'responses': [{'is': {'statusCode': 200}}]}
assert expected == stub_builder.build()
def test_imposter_create_with_spec(imposter_client):
imposter_client.delete(65000)
stubs = []
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.method == 'POST',
http_request.path == '/customers/123')
.response
.is_(http_response(status_code=201,
headers={
'Location': 'http://*****:*****@test.com</email></customer>'),
http_response(status_code=400,
headers={
'Content-Type': 'application/xml'},
body='<error>email already exists</error>')
).build())
stubs.append(
imposter_client.new_stub_builder()
.response.is_(http_response(status_code=404))
.build())
imposter_client.create('sample', 'http', 65000, stubs=stubs)
response = requests.post('http://*****:*****@test.com' in response.text
response = requests.post('http://localhost:65000/customers/123', data={})
assert response.status_code == 400
assert response.headers['Content-Type'] == 'application/xml'
assert 'email already exists' in response.text
response = requests.get('http://localhost:65000/customers/999')
assert response.status_code == 404
def test_imposter_with_deep_equals_predicate(imposter_client):
imposter_client.delete(65000)
stubs = []
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.query.deep_equals({}))
.response.is_(http_response(status_code=200, body='first'))
.build()
)
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.query.deep_equals({'first': '1'}))
.response.is_(http_response(status_code=200, body='second'))
.build()
)
stubs.append(
imposter_client.new_stub_builder()
.when(http_request.query.deep_equals({'first': '1', 'second': '2'}))
.response.is_(http_response(status_code=200, body='third'))
.build()
)
imposter_client.create('sample', 'http', 65000, stubs=stubs)
response = requests.get('http://localhost:65000/test')
assert response.text == 'first'
response = requests.get('http://localhost:65000/test?First=1')
assert response.text == 'second'
response = requests.get('http://localhost:65000/test?Second=2&First=1')
assert response.text == 'third'
response = requests.get('http://localhost:65000/test?Second=2&First=1&Third=3')
assert response.text == ''
def test_build_response_with_multiple_responses(stub_builder):
stub_builder.response \
.is_(http_response(status_code=400),
http_response(status_code=200,
mode=http_response.Mode.TEXT,
body='OK',
headers={'Content-Type': 'text'}))
expected = {
'responses': [{
'is': {
'statusCode': 400
}
}, {
'is': {
'statusCode': 200,
'_mode': 'text',
'body': 'OK',
'headers': {
'Content-Type': 'text'
}
}
}]
}
assert expected == stub_builder.build()
def test_build_response_with_predicate(stub_builder):
stub_builder.when(http_request.body == 'OK') \
.response.is_(http_response(status_code=200))
expected = {
'predicates': [{
'equals': {
'body': 'OK'
}
}],
'responses': [{
'is': {
'statusCode': 200
}
}]
}
assert expected == stub_builder.build()
def test_build_response_with_deep_equals_predicates(stub_builder):
stub_builder.when(http_request.query.deep_equals({})).response.is_(
http_response(status_code=200, body='first'))
expected = {
'responses': [{
'is': {
'body': 'first',
'statusCode': 200
}
}],
'predicates': [{
'deepEquals': {
'query': {}
}
}]
}
assert expected == stub_builder.build()
def test_build_response_with_not_predicate(stub_builder):
stub_builder.when(not_(http_request.method == 'POST')) \
.response.is_(http_response(status_code=200))
expected = {
'predicates': [{
'not': {
'equals': {
'method': 'POST'
}
}
}],
'responses': [{
'is': {
'statusCode': 200
}
}]
}
assert expected == stub_builder.build()
def test_build_response_with_multiple_predicates(stub_builder):
stub_builder.when(http_request.body == 'OK',
http_request.path == '/foo').response.is_(
http_response(status_code=200))
expected = {
'predicates': [{
'equals': {
'body': 'OK',
'path': '/foo'
}
}],
'responses': [{
'is': {
'statusCode': 200
}
}]
}
assert expected == stub_builder.build()
def test_build_response_with_multiple_different_predicates(stub_builder):
stub_builder.when(http_request.method == 'POST',
http_request.body.contains('duh')).response.is_(
http_response(status_code=200))
expected = {
'predicates': [{
'contains': {
'body': 'duh'
}
}, {
'equals': {
'method': 'POST'
}
}],
'responses': [{
'is': {
'statusCode': 200
}
}]
}
assert expected['predicates'] == stub_builder.build()['predicates']
def test_build_response_with_equals_predicates(stub_builder):
stub_builder.when(http_request.method == 'POST',
http_request.path == '/test',
http_request.query == {'first': '1', 'second': '2'},
http_request.headers == {'Accept': 'text/plain'}
).response.is_(http_response(status_code=400))
expected = {
'responses': [{'is': {'statusCode': 400}}],
'predicates': [{
'equals': {
'method': 'POST',
'path': '/test',
'query': {
'first': '1',
'second': '2',
},
'headers': {
'Accept': 'text/plain',
}
},
}]}
assert expected == stub_builder.build()
def test_build_response_with_exists_predicates(stub_builder):
stub_builder.when(http_request.query.exists('q'),
http_request.query.exists('search', False),
http_request.headers.exists('Accept'),
http_request.headers.exists('X-Rate-Limit', False)
).response.is_(http_response(status_code=200))
expected = {
'responses': [{'is': {'statusCode': 200}}],
'predicates': [
{
'exists': {
'query': {
'q': True,
'search': False,
},
'headers': {
'Accept': True,
'X-Rate-Limit': False,
}
}
}
]}
assert expected == stub_builder.build()
def test_build_response_with_predicate(stub_builder):
stub_builder.when(http_request.body == 'OK') \
.response.is_(http_response(status_code=200))
expected = {'predicates': [{'equals': {'body': 'OK'}}],
'responses': [{'is': {'statusCode': 200}}]}
assert expected == stub_builder.build()
def test_build_response_with_only_status_code(stub_builder):
stub_builder.response.is_(http_response(status_code=400))
expected = {'responses': [{'is': {'statusCode': 400}}]}
assert expected == stub_builder.build()
