def test_multiple_mock_servers_only_see_their_presets_and_history():
first_mock = HTTPMock('localhost', 8000, pretender_timeout=30)
second_mock = HTTPMock('localhost', 8000, pretender_timeout=30)
first_mock_response_body = b"a 1st mock fake response"
second_mock_response_body = b"a 2nd mock fake response"
# Set up the two mocks to respond differently:
# Set up first mock to respond with a 200 twice.
for i in range(2):
first_mock.when('POST /someplace').reply(first_mock_response_body,
200)
second_mock.when('POST /someplace').reply(second_mock_response_body,
601)
# create some fake clients that will post to the mock servers.
first_fake_client = get_fake_client(first_mock)
second_fake_client = get_fake_client(second_mock)
# Make some requests using the clients
# We alternate between the client calls, asserting that the responses match
# those set up above.
for i in range(2):
post_body = "first_mock_{0}".format(i).encode()
response = first_fake_client.post(
url='/someplace',
body=post_body)
assert_response_equal(response, first_mock_response_body, 200)
# Check that the historical values match those requested.
request = first_mock.get_request(i)
assert_equals(request.method, 'POST')
assert_equals(request.url, '/someplace')
assert_equals(request.body, post_body)
for i in range(2):
post_body = "second_mock_{0}".format(i).encode()
response = second_fake_client.post(url='/someplace',
body=post_body)
assert_response_equal(response, second_mock_response_body, 601)
# Check that the historical values match those requested.
request = second_mock.get_request(i)
assert_equals(request.method, 'POST')
assert_equals(request.url, '/someplace')
assert_equals(request.body, post_body)
def test_multiple_mock_servers_only_see_their_presets_and_history():
first_mock = HTTPMock('localhost', 8000, pretender_timeout=30)
second_mock = HTTPMock('localhost', 8000, pretender_timeout=30)
first_mock_response_body = b"a 1st mock fake response"
second_mock_response_body = b"a 2nd mock fake response"
# Set up the two mocks to respond differently:
# Set up first mock to respond with a 200 twice.
for i in range(2):
first_mock.when('POST /someplace').reply(first_mock_response_body, 200)
second_mock.when('POST /someplace').reply(second_mock_response_body,
601)
# create some fake clients that will post to the mock servers.
first_fake_client = get_fake_client(first_mock)
second_fake_client = get_fake_client(second_mock)
# Make some requests using the clients
# We alternate between the client calls, asserting that the responses match
# those set up above.
for i in range(2):
post_body = "first_mock_{0}".format(i).encode()
response = first_fake_client.post(url='/someplace', body=post_body)
assert_response_equal(response, first_mock_response_body, 200)
# Check that the historical values match those requested.
request = first_mock.get_request(i)
assert_equals(request.method, 'POST')
assert_equals(request.url, '/someplace')
assert_equals(request.body, post_body)
for i in range(2):
post_body = "second_mock_{0}".format(i).encode()
response = second_fake_client.post(url='/someplace', body=post_body)
assert_response_equal(response, second_mock_response_body, 601)
# Check that the historical values match those requested.
request = second_mock.get_request(i)
assert_equals(request.method, 'POST')
assert_equals(request.url, '/someplace')
assert_equals(request.body, post_body)
def test_multiple_http_mocks_independently_served():
"""
Ask for two http mocks and set up different presets.
Make calls against each.
We should get the correct responses back.
"""
http_mock_1 = HTTPMock('localhost', 8000)
http_mock_2 = HTTPMock('localhost', 8000)
fake_client_1 = get_fake_client(http_mock_1)
fake_client_2 = get_fake_client(http_mock_2)
http_mock_1.reset()
http_mock_2.reset()
http_mock_1.when('GET /test_mock1_get').reply(b'You tested a get', 201,
times=FOREVER)
http_mock_2.when('GET /test_mock2_get').reply(b'You tested a get', 200,
times=FOREVER)
assert_equals(201, fake_client_1.get(url="/test_mock1_get").status)
assert_equals(200, fake_client_2.get(url="/test_mock2_get").status)
# Check that they both 404 if used against the other url.
assert_equals(404, fake_client_1.get(url="/test_mock2_get").status)
assert_equals(404, fake_client_2.get(url="/test_mock1_get").status)
def test_get_mock_server_by_name():
http_mock = HTTPMock('localhost', 8000, timeout=5, name='fred')
# Check that we are using the name path
assert_equals(http_mock.pretend_access_point, "localhost:8000")
assert_equals(http_mock.pretend_access_path, "/mockhttp/fred")
# Set up a rule
http_mock.when('POST /someplace').reply(b"something interesting", 200)
# Perform a post from a pretend application
fake_client = get_fake_client(http_mock)
response = fake_client.post(url='/someplace', body="anything".encode())
# check the app would receive back the response from the rule we set up.
assert_equals(response.status, 200)
assert_equals(response.read(), b'something interesting')
# finally, check that we can look at the history via the http_mock.
req = http_mock.get_request(0)
assert_equals(req.method, 'POST')
assert_equals(req.url, '/someplace')
http_mock.delete_mock()
def test_clear_down_only_happens_if_no_request_for_timeout_period():
# Test that stale mock servers are not cleared if they
# recently made a request.
# TODO: Once the timeout specification can be dictated by the client
# the sleep in this test can be reduced.
http_mock = HTTPMock('localhost', 8000, timeout=5)
pretender = http_mock.get_pretender()
timeout_server = pretender.timeout_in_secs
assert_equal(pretender.last_call, pretender.start)
for i in range(3):
# Sleep for a while, check that the server is still running and then
# make a call to the mock server.
time.sleep(timeout_server / 2)
# Check that we are still running
pretender = http_mock.get_pretender()
# Make a call to the mock server.
pretender_client = get_fake_client(http_mock)
pretender_client.get(
url="/some_url"
)
def test_creating_second_mock_server_by_same_name_gives_original_server():
# Create 1
h1 = HTTPMock('localhost', 8000, timeout=5, name='duplicate_test')
# Create another
h2 = HTTPMock('localhost', 8000, timeout=5, name='duplicate_test_2')
# Creation of one with a duplicate name should succeed.
h3 = HTTPMock('localhost', 8000, name='duplicate_test')
# Requests to h1 should be visible by h3. h2 should only be seen by it.
get_fake_client(h1).get(url='/h1_get')
get_fake_client(h2).get(url='/h2_get')
get_fake_client(h3).get(url='/h3_get')
# assert that the requests h1 and h3 requests can be seen via both mocks.
assert_equals(h1.get_request(0).url, h3.get_request(0).url)
assert_equals(h1.get_request(1).url, h3.get_request(1).url)
assert_equals(h2.get_request(0).url, '/h2_get')
h1.delete_mock()
h2.delete_mock()
from nose.tools import assert_equals, assert_true, assert_raises
from pretenders.constants import FOREVER
from pretenders.exceptions import ConfigurationError
from pretenders.http.client import HTTPMock
from pretenders.http.tests.integration import get_fake_client
http_mock = HTTPMock('localhost', 8000)
fake_client = get_fake_client(http_mock)
def add_test_preset(rule='POST /fred/test/one',
body=b'You tested fred well',
status=200):
http_mock.when(rule).reply(body, status)
def test_configure_request_and_check_values():
"Requires a running pretender.http.server instance"
http_mock.reset()
add_test_preset()
response = fake_client.post(url='/fred/test/one')
assert_equals(response.status, 200)
assert_equals(response.read(), b'You tested fred well')
request = http_mock.get_request(0)
assert_equals(request.method, 'POST')
assert_equals(request.url, '/fred/test/one')
assert_equals(request.body, b'')
from nose.tools import assert_equals, assert_true, assert_raises
from pretenders.constants import PRETEND_PORT_RANGE, FOREVER
from pretenders.exceptions import ConfigurationError
from pretenders.http.client import HTTPMock
from pretenders.http.tests.integration import get_fake_client
http_mock = HTTPMock('localhost', 8000)
fake_client = get_fake_client(http_mock)
def add_test_preset(rule='POST /fred/test/one',
body=b'You tested fred well',
status=200):
http_mock.when(rule).reply(body, status)
def test_configure_request_and_check_values():
"Requires a running pretender.http.server instance"
http_mock.reset()
add_test_preset()
response = fake_client.post(url='/fred/test/one')
assert_equals(response.status, 200)
assert_equals(response.read(), b'You tested fred well')
request = http_mock.get_request(0)
assert_equals(request.method, 'POST')
assert_equals(request.url, '/fred/test/one')
assert_equals(request.body, b'')