def test_manage_cookies_off(self): """ Test the behavior when manage_cookies is off (the default). Cookies shouldn't be sent """ self.client = HTTPClient() def assert_no_cookie(req_handler): return 'Cookie' not in req_handler.headers test_requests = [({ 'path': '/', 'req_assert_function': assert_no_cookie }, { 'body': b'nothing', 'headers': { 'Set-Cookie': "testcookie=42" } }), ({ 'path': '/', 'req_assert_function': assert_no_cookie }, { 'body': b'nothing' })] with mock_httpd(TESTSERVER_ADDRESS, test_requests): self.client.open(TESTSERVER_URL + '/') self.client.open(TESTSERVER_URL + '/')
def test_https_untrusted_root(self): if not supports_ssl_default_context: raise pytest.skip("old python versions require ssl_ca_certs") self.client = HTTPClient('https://untrusted-root.badssl.com/') try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL')
def test_https_no_ssl_module_insecure(self): from mapproxy.client import http old_ssl = http.ssl try: http.ssl = None self.client = HTTPClient('https://www.google.com/', insecure=True) self.client.open('https://www.google.com/') finally: http.ssl = old_ssl
def parse_capabilities_url(url): url = wms_capabilities_url(url) log.info('fetching capabilities from: %s', url) client = HTTPClient() try: resp = client.open(url) except HTTPClientError, ex: # TODO error handling raise ex
def test_https_invalid_cert(self): # load 'wrong' root cert with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://untrusted-root.badssl.com/', ssl_ca_certs=tmp) try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL')
def test_https_valid_ca_cert_file(self): # verify with fixed ca_certs file cert_file = '/etc/ssl/certs/ca-certificates.crt' if os.path.exists(cert_file): self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=cert_file) self.client.open('https://www.google.com/') else: with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) self.client.open('https://www.google.com/')
def test_https_no_ssl_module_error(self): from mapproxy.client import http old_ssl = http.ssl try: http.ssl = None try: self.client = HTTPClient('https://www.google.com/') except ImportError: pass else: assert False, 'no ImportError for missing ssl module' finally: http.ssl = old_ssl
def test_https_invalid_cert(self): try: import ssl ssl except ImportError: raise SkipTest() with TempFile() as tmp: self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) try: self.client.open('https://www.google.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL')
def test_timeouts(self): test_req = ({ 'path': '/', 'req_assert_function': lambda x: time.sleep(0.9) or True }, { 'body': b'nothing' }) import mapproxy.client.http client1 = HTTPClient(timeout=0.1) client2 = HTTPClient(timeout=0.5) with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client1.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration1 = time.time() - start with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client2.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration2 = time.time() - start # check individual timeouts assert 0.1 <= duration1 < 0.5, duration1 assert 0.5 <= duration2 < 0.9, duration2
def create_source(raster_source, app_state): url = raster_source.url username = raster_source.username password = raster_source.password http_client = HTTPClient(url, username, password) # , insecure=insecure, # ssl_ca_certs=ssl_ca_certs, timeout=timeout, # headers=headers) grid = DEFAULT_GRID image_opts = None coverage = coverage_from_geojson(raster_source.download_coverage) format = raster_source.format url_template = TileURLTemplate( '%s/%s/%s-%%(z)s-%%(x)s-%%(y)s/tile' % (url, raster_source.layer, raster_source.matrix_set), format=format) client = TileClient(url_template, http_client=http_client, grid=grid) if app_state.tilebox.is_running(): port = app_state.config.get('tilebox', 'port') url_template = TileURLTemplate( 'http://127.0.0.1:%d/%s/%s-%%(z)s-%%(x)s-%%(y)s/tile' % (port, raster_source.layer, raster_source.matrix_set), format=format) tilebox_client = TileClient(url_template, http_client=RequestsHTTPClient(), grid=grid) client = FallbackTileClient(tilebox_client, client) return TiledSource(grid, client, coverage=coverage, image_opts=image_opts)
def __init__(self, request_template, http_client=None, http_method=None, lock=None, fwd_req_params=None): self.request_template = request_template self.http_client = http_client or HTTPClient() self.http_method = http_method self.lock = lock self.fwd_req_params = fwd_req_params or set()
def __init__(self, request_template, supported_srs=None, http_client=None): self.request_template = request_template self.http_client = http_client or HTTPClient() if not supported_srs and self.request_template.params.srs is not None: supported_srs = SupportedSRS( [SRS(self.request_template.params.srs)]) self.supported_srs = supported_srs
def test_https_valid_cert(self): try: import ssl; ssl except ImportError: raise SkipTest() cert_file = '/etc/ssl/certs/ca-certificates.crt' if os.path.exists(cert_file): self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=cert_file) self.client.open('https://www.google.com/') else: with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) self.client.open('https://www.google.com/')
def test_basic_auth(self): http_client = HTTPClient(self.req_template.url, username='******', password='******') self.client.http_client = http_client def assert_auth(req_handler): assert 'Authorization' in req_handler.headers auth_data = req_handler.headers['Authorization'].split()[1] auth_data = base64.b64decode( auth_data.encode('utf-8')).decode('utf-8') eq_(auth_data, 'foo:bar@') return True expected_req = ({ 'path': r'/service?LAYERS=foo&SERVICE=WMS&FORMAT=image%2Fpng' '&REQUEST=GetMap&HEIGHT=512&SRS=EPSG%3A4326' '&VERSION=1.1.1&BBOX=0.0,10.0,10.0,20.0&WIDTH=512&STYLES=', 'require_basic_auth': True, 'req_assert_function': assert_auth }, { 'body': b'no image', 'headers': { 'content-type': 'image/png' } }) with mock_httpd(TEST_SERVER_ADDRESS, [expected_req]): q = MapQuery((0.0, 10.0, 10.0, 20.0), (512, 512), SRS(4326)) self.source.get_map(q)
def test_https_untrusted_root(self): if not supports_ssl_default_context: # old python versions require ssl_ca_certs raise SkipTest() self.client = HTTPClient('https://untrusted-root.badssl.com/') try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL')
def test_https_valid_cert(self): try: import ssl ssl except ImportError: raise SkipTest() cert_file = '/etc/ssl/certs/ca-certificates.crt' if os.path.exists(cert_file): self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=cert_file) self.client.open('https://www.google.com/') else: with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) self.client.open('https://www.google.com/')
def __init__(self, request_template, supported_srs=None, http_client=None, return_geometries=False, tolerance=5, ): self.request_template = request_template self.http_client = http_client or HTTPClient() if not supported_srs and self.request_template.params.srs is not None: supported_srs = [SRS(self.request_template.params.srs)] self.supported_srs = supported_srs or [] self.return_geometries = return_geometries self.tolerance = tolerance
def test_https_invalid_cert(self): # load 'wrong' root cert with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient( 'https://untrusted-root.badssl.com/', ssl_ca_certs=tmp) try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL')
def test_https_invalid_cert(self): try: import ssl; ssl except ImportError: raise SkipTest() with TempFile() as tmp: self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) try: self.client.open('https://www.google.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL')
def test_timeouts(self): test_req = ({'path': '/', 'req_assert_function': lambda x: time.sleep(0.9) or True}, {'body': b'nothing'}) import mapproxy.client.http client1 = HTTPClient(timeout=0.1) client2 = HTTPClient(timeout=0.5) with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client1.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration1 = time.time() - start with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client2.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration2 = time.time() - start # check individual timeouts assert 0.1 <= duration1 < 0.5, duration1 assert 0.5 <= duration2 < 0.9, duration2
def test_internal_error_hide_exception_url(self): try: with mock_httpd(TESTSERVER_ADDRESS, [({ 'path': '/' }, { 'status': '500', 'body': b'' })]): HTTPClient(hide_exception_url=True).open(TESTSERVER_URL + '/') except HTTPClientError as e: assert_re(e.args[0], r'HTTP Error: 500') else: assert False, 'expected HTTPClientError'
def test_internal_error_hide_error_details(self): try: with mock_httpd(TESTSERVER_ADDRESS, [({ 'path': '/' }, { 'status': '500', 'body': b'' })]): HTTPClient(hide_error_details=True).open(TESTSERVER_URL + '/') except HTTPClientError as e: assert_re(e.args[0], r'HTTP Error \(see logs for URL and reason\).') else: assert False, 'expected HTTPClientError'
def test_manage_cookies_on(self): """ Test behavior of manage_cookies=True. Once the remote server sends a cookie back, it should be included in future requests """ self.client = HTTPClient(manage_cookies=True) def assert_no_cookie(req_handler): return 'Cookie' not in req_handler.headers def assert_cookie(req_handler): assert 'Cookie' in req_handler.headers cookie_name, cookie_val = req_handler.headers['Cookie'].split( ';')[0].split('=') assert cookie_name == 'testcookie' assert cookie_val == '42' return True test_requests = [({ 'path': '/', 'req_assert_function': assert_no_cookie }, { 'body': b'nothing', 'headers': { 'Set-Cookie': "testcookie=42" } }), ({ 'path': '/', 'req_assert_function': assert_cookie }, { 'body': b'nothing' })] with mock_httpd(TESTSERVER_ADDRESS, test_requests): self.client.open(TESTSERVER_URL + '/') self.client.open(TESTSERVER_URL + '/')
def test_timeouts(self): test_req = ({ 'path': '/', 'req_assert_function': lambda x: time.sleep(0.5) or True }, { 'body': b'nothing' }) import mapproxy.client.http old_timeout = mapproxy.client.http._max_set_timeout mapproxy.client.http._max_set_timeout = None client1 = HTTPClient(timeout=0.1) client2 = HTTPClient(timeout=0.2) with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client1.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration1 = time.time() - start with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client2.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration2 = time.time() - start if sys.version_info >= (2, 6): # check individual timeouts assert 0.1 <= duration1 < 0.2 assert 0.2 <= duration2 < 0.3 else: # use max timeout in Python 2.5 assert 0.2 <= duration1 < 0.3 assert 0.2 <= duration2 < 0.3 mapproxy.client.http._max_set_timeout = old_timeout
def test_timeouts(self): test_req = ({'path': '/', 'req_assert_function': lambda x: time.sleep(0.5) or True}, {'body': b'nothing'}) import mapproxy.client.http old_timeout = mapproxy.client.http._max_set_timeout mapproxy.client.http._max_set_timeout = None client1 = HTTPClient(timeout=0.1) client2 = HTTPClient(timeout=0.2) with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client1.open(TESTSERVER_URL+'/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration1 = time.time() - start with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client2.open(TESTSERVER_URL+'/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration2 = time.time() - start if sys.version_info >= (2, 6): # check individual timeouts assert 0.1 <= duration1 < 0.2 assert 0.2 <= duration2 < 0.3 else: # use max timeout in Python 2.5 assert 0.2 <= duration1 < 0.3 assert 0.2 <= duration2 < 0.3 mapproxy.client.http._max_set_timeout = old_timeout
def setup(self): self.client = HTTPClient()
class TestHTTPClient(object): def setup(self): self.client = HTTPClient() def test_post(self): with mock_httpd(TESTSERVER_ADDRESS, [({ 'path': '/service?foo=bar', 'method': 'POST' }, { 'status': '200', 'body': b'' })]): self.client.open(TESTSERVER_URL + '/service', data=b"foo=bar") def test_internal_error_response(self): try: with mock_httpd(TESTSERVER_ADDRESS, [({ 'path': '/' }, { 'status': '500', 'body': b'' })]): self.client.open(TESTSERVER_URL + '/') except HTTPClientError as e: assert_re(e.args[0], r'HTTP Error ".*": 500') else: assert False, 'expected HTTPClientError' def test_invalid_url_type(self): try: self.client.open('htp://example.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "htp://example.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_invalid_url(self): try: self.client.open('this is not a url') except HTTPClientError as e: assert_re(e.args[0], r'URL not correct "this is not.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_unknown_host(self): try: self.client.open('http://thishostshouldnotexist000136really42.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "http://thishost.*": .*') else: assert False, 'expected HTTPClientError' def test_no_connect(self): try: self.client.open('http://localhost:53871') except HTTPClientError as e: assert_re( e.args[0], r'No response .* "http://localhost.*": Connection refused') else: assert False, 'expected HTTPClientError' def test_internal_error_hide_error_details(self): try: with mock_httpd(TESTSERVER_ADDRESS, [({ 'path': '/' }, { 'status': '500', 'body': b'' })]): HTTPClient(hide_error_details=True).open(TESTSERVER_URL + '/') except HTTPClientError as e: assert_re(e.args[0], r'HTTP Error \(see logs for URL and reason\).') else: assert False, 'expected HTTPClientError' @pytest.mark.online def test_https_untrusted_root(self): if not supports_ssl_default_context: raise pytest.skip("old python versions require ssl_ca_certs") self.client = HTTPClient('https://untrusted-root.badssl.com/') try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL') @pytest.mark.online def test_https_insecure(self): self.client = HTTPClient('https://untrusted-root.badssl.com/', insecure=True) self.client.open('https://untrusted-root.badssl.com/') @pytest.mark.online def test_https_valid_ca_cert_file(self): # verify with fixed ca_certs file cert_file = '/etc/ssl/certs/ca-certificates.crt' if os.path.exists(cert_file): self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=cert_file) self.client.open('https://www.google.com/') else: with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) self.client.open('https://www.google.com/') @pytest.mark.online def test_https_valid_default_cert(self): # modern python should verify by default if not supports_ssl_default_context: raise pytest.skip("old python versions require ssl_ca_certs") self.client = HTTPClient('https://www.google.com/') self.client.open('https://www.google.com/') @pytest.mark.online def test_https_invalid_cert(self): # load 'wrong' root cert with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://untrusted-root.badssl.com/', ssl_ca_certs=tmp) try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL') def test_timeouts(self): test_req = ({ 'path': '/', 'req_assert_function': lambda x: time.sleep(0.9) or True }, { 'body': b'nothing' }) import mapproxy.client.http client1 = HTTPClient(timeout=0.1) client2 = HTTPClient(timeout=0.5) with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client1.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration1 = time.time() - start with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client2.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration2 = time.time() - start # check individual timeouts assert 0.1 <= duration1 < 0.5, duration1 assert 0.5 <= duration2 < 0.9, duration2 def test_manage_cookies_off(self): """ Test the behavior when manage_cookies is off (the default). Cookies shouldn't be sent """ self.client = HTTPClient() def assert_no_cookie(req_handler): return 'Cookie' not in req_handler.headers test_requests = [({ 'path': '/', 'req_assert_function': assert_no_cookie }, { 'body': b'nothing', 'headers': { 'Set-Cookie': "testcookie=42" } }), ({ 'path': '/', 'req_assert_function': assert_no_cookie }, { 'body': b'nothing' })] with mock_httpd(TESTSERVER_ADDRESS, test_requests): self.client.open(TESTSERVER_URL + '/') self.client.open(TESTSERVER_URL + '/') def test_manage_cookies_on(self): """ Test behavior of manage_cookies=True. Once the remote server sends a cookie back, it should be included in future requests """ self.client = HTTPClient(manage_cookies=True) def assert_no_cookie(req_handler): return 'Cookie' not in req_handler.headers def assert_cookie(req_handler): assert 'Cookie' in req_handler.headers cookie_name, cookie_val = req_handler.headers['Cookie'].split( ';')[0].split('=') assert cookie_name == 'testcookie' assert cookie_val == '42' return True test_requests = [({ 'path': '/', 'req_assert_function': assert_no_cookie }, { 'body': b'nothing', 'headers': { 'Set-Cookie': "testcookie=42" } }), ({ 'path': '/', 'req_assert_function': assert_cookie }, { 'body': b'nothing' })] with mock_httpd(TESTSERVER_ADDRESS, test_requests): self.client.open(TESTSERVER_URL + '/') self.client.open(TESTSERVER_URL + '/')
class TestHTTPClient(object): def setup(self): self.client = HTTPClient() def test_post(self): with mock_httpd(TESTSERVER_ADDRESS, [({ 'path': '/service?foo=bar', 'method': 'POST' }, { 'status': '200', 'body': b'' })]): self.client.open(TESTSERVER_URL + '/service', data=b"foo=bar") def test_internal_error_response(self): try: with mock_httpd(TESTSERVER_ADDRESS, [({ 'path': '/' }, { 'status': '500', 'body': b'' })]): self.client.open(TESTSERVER_URL + '/') except HTTPClientError as e: assert_re(e.args[0], r'HTTP Error ".*": 500') else: assert False, 'expected HTTPClientError' def test_invalid_url_type(self): try: self.client.open('htp://example.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "htp://example.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_invalid_url(self): try: self.client.open('this is not a url') except HTTPClientError as e: assert_re(e.args[0], r'URL not correct "this is not.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_unknown_host(self): try: self.client.open('http://thishostshouldnotexist000136really42.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "http://thishost.*": .*') else: assert False, 'expected HTTPClientError' def test_no_connect(self): try: self.client.open('http://*****:*****@attr('online') def test_https_no_ssl_module_error(self): from mapproxy.client import http old_ssl = http.ssl try: http.ssl = None try: self.client = HTTPClient('https://www.google.com/') except ImportError: pass else: assert False, 'no ImportError for missing ssl module' finally: http.ssl = old_ssl @attr('online') def test_https_no_ssl_module_insecure(self): from mapproxy.client import http old_ssl = http.ssl try: http.ssl = None self.client = HTTPClient('https://www.google.com/', insecure=True) self.client.open('https://www.google.com/') finally: http.ssl = old_ssl @attr('online') def test_https_valid_cert(self): try: import ssl ssl except ImportError: raise SkipTest() cert_file = '/etc/ssl/certs/ca-certificates.crt' if os.path.exists(cert_file): self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=cert_file) self.client.open('https://www.google.com/') else: with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) self.client.open('https://www.google.com/') @attr('online') def test_https_invalid_cert(self): try: import ssl ssl except ImportError: raise SkipTest() with TempFile() as tmp: self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) try: self.client.open('https://www.google.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL') def test_timeouts(self): test_req = ({ 'path': '/', 'req_assert_function': lambda x: time.sleep(0.5) or True }, { 'body': b'nothing' }) import mapproxy.client.http old_timeout = mapproxy.client.http._max_set_timeout mapproxy.client.http._max_set_timeout = None client1 = HTTPClient(timeout=0.1) client2 = HTTPClient(timeout=0.2) with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client1.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration1 = time.time() - start with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client2.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration2 = time.time() - start if sys.version_info >= (2, 6): # check individual timeouts assert 0.1 <= duration1 < 0.2 assert 0.2 <= duration2 < 0.3 else: # use max timeout in Python 2.5 assert 0.2 <= duration1 < 0.3 assert 0.2 <= duration2 < 0.3 mapproxy.client.http._max_set_timeout = old_timeout
def test_https_valid_default_cert(self): # modern python should verify by default if not supports_ssl_default_context: raise SkipTest() self.client = HTTPClient('https://www.google.com/') self.client.open('https://www.google.com/')
def test_https_valid_default_cert(self): # modern python should verify by default if not supports_ssl_default_context: raise pytest.skip("old python versions require ssl_ca_certs") self.client = HTTPClient('https://www.google.com/') self.client.open('https://www.google.com/')
def test_https_insecure(self): self.client = HTTPClient( 'https://untrusted-root.badssl.com/', insecure=True) self.client.open('https://untrusted-root.badssl.com/')
class TestHTTPClient(object): def setup(self): self.client = HTTPClient() def test_post(self): with mock_httpd(TESTSERVER_ADDRESS, [({'path': '/service?foo=bar', 'method': 'POST'}, {'status': '200', 'body': b''})]): self.client.open(TESTSERVER_URL + '/service', data=b"foo=bar") def test_internal_error_response(self): try: with mock_httpd(TESTSERVER_ADDRESS, [({'path': '/'}, {'status': '500', 'body': b''})]): self.client.open(TESTSERVER_URL + '/') except HTTPClientError as e: assert_re(e.args[0], r'HTTP Error ".*": 500') else: assert False, 'expected HTTPClientError' def test_invalid_url_type(self): try: self.client.open('htp://example.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "htp://example.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_invalid_url(self): try: self.client.open('this is not a url') except HTTPClientError as e: assert_re(e.args[0], r'URL not correct "this is not.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_unknown_host(self): try: self.client.open('http://thishostshouldnotexist000136really42.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "http://thishost.*": .*') else: assert False, 'expected HTTPClientError' def test_no_connect(self): try: self.client.open('http://*****:*****@attr('online') def test_https_untrusted_root(self): if not supports_ssl_default_context: # old python versions require ssl_ca_certs raise SkipTest() self.client = HTTPClient('https://untrusted-root.badssl.com/') try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL') @attr('online') def test_https_insecure(self): self.client = HTTPClient( 'https://untrusted-root.badssl.com/', insecure=True) self.client.open('https://untrusted-root.badssl.com/') @attr('online') def test_https_valid_ca_cert_file(self): # verify with fixed ca_certs file cert_file = '/etc/ssl/certs/ca-certificates.crt' if os.path.exists(cert_file): self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=cert_file) self.client.open('https://www.google.com/') else: with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) self.client.open('https://www.google.com/') @attr('online') def test_https_valid_default_cert(self): # modern python should verify by default if not supports_ssl_default_context: raise SkipTest() self.client = HTTPClient('https://www.google.com/') self.client.open('https://www.google.com/') @attr('online') def test_https_invalid_cert(self): # load 'wrong' root cert with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient( 'https://untrusted-root.badssl.com/', ssl_ca_certs=tmp) try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL') def test_timeouts(self): test_req = ({'path': '/', 'req_assert_function': lambda x: time.sleep(0.9) or True}, {'body': b'nothing'}) import mapproxy.client.http client1 = HTTPClient(timeout=0.1) client2 = HTTPClient(timeout=0.5) with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client1.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration1 = time.time() - start with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client2.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration2 = time.time() - start # check individual timeouts assert 0.1 <= duration1 < 0.5, duration1 assert 0.5 <= duration2 < 0.9, duration2
def __init__(self, request_template, http_client=None): self.request_template = request_template self.http_client = http_client or HTTPClient()
def __init__(self, static_url, http_client=None): self.url = static_url self.http_client = http_client or HTTPClient()
class TestHTTPClient(object): def setup(self): self.client = HTTPClient() def test_post(self): with mock_httpd(TESTSERVER_ADDRESS, [({'path': '/service?foo=bar', 'method': 'POST'}, {'status': '200', 'body': b''})]): self.client.open(TESTSERVER_URL + '/service', data=b"foo=bar") def test_internal_error_response(self): try: with mock_httpd(TESTSERVER_ADDRESS, [({'path': '/'}, {'status': '500', 'body': b''})]): self.client.open(TESTSERVER_URL + '/') except HTTPClientError as e: assert_re(e.args[0], r'HTTP Error ".*": 500') else: assert False, 'expected HTTPClientError' def test_invalid_url_type(self): try: self.client.open('htp://example.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "htp://example.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_invalid_url(self): try: self.client.open('this is not a url') except HTTPClientError as e: assert_re(e.args[0], r'URL not correct "this is not.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_unknown_host(self): try: self.client.open('http://thishostshouldnotexist000136really42.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "http://thishost.*": .*') else: assert False, 'expected HTTPClientError' def test_no_connect(self): try: self.client.open('http://*****:*****@attr('online') def test_https_no_ssl_module_error(self): from mapproxy.client import http old_ssl = http.ssl try: http.ssl = None try: self.client = HTTPClient('https://www.google.com/') except ImportError: pass else: assert False, 'no ImportError for missing ssl module' finally: http.ssl = old_ssl @attr('online') def test_https_no_ssl_module_insecure(self): from mapproxy.client import http old_ssl = http.ssl try: http.ssl = None self.client = HTTPClient('https://www.google.com/', insecure=True) self.client.open('https://www.google.com/') finally: http.ssl = old_ssl @attr('online') def test_https_valid_cert(self): try: import ssl; ssl except ImportError: raise SkipTest() cert_file = '/etc/ssl/certs/ca-certificates.crt' if os.path.exists(cert_file): self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=cert_file) self.client.open('https://www.google.com/') else: with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) self.client.open('https://www.google.com/') @attr('online') def test_https_invalid_cert(self): try: import ssl; ssl except ImportError: raise SkipTest() with TempFile() as tmp: self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) try: self.client.open('https://www.google.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL') def test_timeouts(self): test_req = ({'path': '/', 'req_assert_function': lambda x: time.sleep(0.9) or True}, {'body': b'nothing'}) import mapproxy.client.http old_timeout = mapproxy.client.http._max_set_timeout mapproxy.client.http._max_set_timeout = None client1 = HTTPClient(timeout=0.1) client2 = HTTPClient(timeout=0.5) with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client1.open(TESTSERVER_URL+'/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration1 = time.time() - start with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client2.open(TESTSERVER_URL+'/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration2 = time.time() - start # check individual timeouts assert 0.1 <= duration1 < 0.5, duration1 assert 0.5 <= duration2 < 0.9, duration2 mapproxy.client.http._max_set_timeout = old_timeout
def setup(self): self.client = HTTPClient() self.args = ["command_dummy", "--host", TESTSERVER_URL + "/service"]
def setup(self): self.client = HTTPClient() self.args = ['command_dummy', '--host', TESTSERVER_URL + '/service']
class TestHTTPClient(object): def setup(self): self.client = HTTPClient() def test_post(self): with mock_httpd(TESTSERVER_ADDRESS, [({ 'path': '/service?foo=bar', 'method': 'POST' }, { 'status': '200', 'body': b'' })]): self.client.open(TESTSERVER_URL + '/service', data=b"foo=bar") def test_internal_error_response(self): try: with mock_httpd(TESTSERVER_ADDRESS, [({ 'path': '/' }, { 'status': '500', 'body': b'' })]): self.client.open(TESTSERVER_URL + '/') except HTTPClientError as e: assert_re(e.args[0], r'HTTP Error ".*": 500') else: assert False, 'expected HTTPClientError' def test_invalid_url_type(self): try: self.client.open('htp://example.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "htp://example.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_invalid_url(self): try: self.client.open('this is not a url') except HTTPClientError as e: assert_re(e.args[0], r'URL not correct "this is not.*": unknown url type') else: assert False, 'expected HTTPClientError' def test_unknown_host(self): try: self.client.open('http://thishostshouldnotexist000136really42.org') except HTTPClientError as e: assert_re(e.args[0], r'No response .* "http://thishost.*": .*') else: assert False, 'expected HTTPClientError' def test_no_connect(self): try: self.client.open('http://*****:*****@attr('online') def test_https_untrusted_root(self): if not supports_ssl_default_context: # old python versions require ssl_ca_certs raise SkipTest() self.client = HTTPClient('https://untrusted-root.badssl.com/') try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL') @attr('online') def test_https_insecure(self): self.client = HTTPClient('https://untrusted-root.badssl.com/', insecure=True) self.client.open('https://untrusted-root.badssl.com/') @attr('online') def test_https_valid_ca_cert_file(self): # verify with fixed ca_certs file cert_file = '/etc/ssl/certs/ca-certificates.crt' if os.path.exists(cert_file): self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=cert_file) self.client.open('https://www.google.com/') else: with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://www.google.com/', ssl_ca_certs=tmp) self.client.open('https://www.google.com/') @attr('online') def test_https_valid_default_cert(self): # modern python should verify by default if not supports_ssl_default_context: raise SkipTest() self.client = HTTPClient('https://www.google.com/') self.client.open('https://www.google.com/') @attr('online') def test_https_invalid_cert(self): # load 'wrong' root cert with TempFile() as tmp: with open(tmp, 'wb') as f: f.write(GOOGLE_ROOT_CERT) self.client = HTTPClient('https://untrusted-root.badssl.com/', ssl_ca_certs=tmp) try: self.client.open('https://untrusted-root.badssl.com/') except HTTPClientError as e: assert_re(e.args[0], r'Could not verify connection to URL') def test_timeouts(self): test_req = ({ 'path': '/', 'req_assert_function': lambda x: time.sleep(0.9) or True }, { 'body': b'nothing' }) import mapproxy.client.http client1 = HTTPClient(timeout=0.1) client2 = HTTPClient(timeout=0.5) with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client1.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration1 = time.time() - start with mock_httpd(TESTSERVER_ADDRESS, [test_req]): try: start = time.time() client2.open(TESTSERVER_URL + '/') except HTTPClientError as ex: assert 'timed out' in ex.args[0] else: assert False, 'HTTPClientError expected' duration2 = time.time() - start # check individual timeouts assert 0.1 <= duration1 < 0.5, duration1 assert 0.5 <= duration2 < 0.9, duration2
def test_https_insecure(self): self.client = HTTPClient('https://untrusted-root.badssl.com/', insecure=True) self.client.open('https://untrusted-root.badssl.com/')