def test_multiple_mock_servers_only_see_their_presets_and_history(): first_mock = HTTPMock('localhost', 8000, timeout=30) second_mock = HTTPMock('localhost', 8000, 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_mock_timeout_behaviour(): timeout_fake_client = get_fake_client(http_mock, timeout=10) http_mock.reset() http_mock.when( 'GET /test-long-process').reply(b'', status=200, times=FOREVER, after=20) assert_raises(socket.timeout, timeout_fake_client.get, url='/test-long-process')
def test_clear_down_removes_history(): # Test that when we clear down a pretender, the history is removed. # Otherwise we end up slowly creeping up the memory usage! http_mock = HTTPMock('localhost', 8000, timeout=5) pretender = http_mock.get_pretender() pretender_client = get_fake_client(http_mock) pretender_client.get( url="/some_url" ) assert_equal(http_mock.get_request(0).url, '/some_url') time.sleep(STALE_DELETE_FREQUENCY + pretender.timeout_in_secs + 1) assert_raises(ResourceNotFound, http_mock.get_pretender) # Check that there is no history now! req = http_mock.get_request(0) assert_equal(req, None)
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()
import socket from nose.tools import assert_equals, assert_true, assert_raises from pretenders.constants import FOREVER from pretenders.exceptions import ConfigurationError from pretenders.client.http import HTTPMock from pretenders.mock_servers.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')