def test_simple(self): doc = '{"messages": {"ttl": 600}}' # Create env = testing.create_environ('/v1/480924/queues/gumshoe', method="PUT", body=doc) self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_201) location = ('Location', '/v1/480924/queues/gumshoe') self.assertIn(location, self.srmock.headers) env = testing.create_environ('/v1/480924/queues/gumshoe') result = self.app(env, self.srmock) result_doc = json.loads(result[0]) self.assertEquals(self.srmock.status, falcon.HTTP_200) self.assertEquals(result_doc, json.loads(doc)) # Delete env = testing.create_environ('/v1/480924/queues/gumshoe', method="DELETE") self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_204) # Get non-existing env = testing.create_environ('/v1/480924/queues/gumshoe') self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_404)
def test_list(self): # List empty env = testing.create_environ('/v1/480924/queues') result = self.app(env, self.srmock) result_doc = json.loads(result[0]) self.assertEquals(result_doc['queues'], []) # Create some env = testing.create_environ('/v1/480924/queues/q1', method="PUT", body='{ "_ttl": 30 }') self.app(env, self.srmock) env = testing.create_environ('/v1/480924/queues/q2', method="PUT", body='{}') self.app(env, self.srmock) # List env = testing.create_environ('/v1/480924/queues') result = self.app(env, self.srmock) result_doc = json.loads(result[0]) self.assertEquals(self.srmock.status, falcon.HTTP_200) self.assertEquals(self.srmock.headers_dict['Content-Location'], env['PATH_INFO']) for queue in result_doc['queues']: env = testing.create_environ(queue['href']) result = self.app(env, self.srmock) result_doc = json.loads(result[0]) self.assertEquals(result_doc, queue['metadata'])
def test_simple(self): doc = '{"messages": {"ttl": 600}}' env = testing.create_environ('/v1/480924/queues/gumshoe', method="PUT", body=doc) self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_503) location = ('Location', '/v1/480924/queues/gumshoe') self.assertNotIn(location, self.srmock.headers) env = testing.create_environ('/v1/480924/queues/gumshoe') result = self.app(env, self.srmock) result_doc = json.loads(result[0]) self.assertEquals(self.srmock.status, falcon.HTTP_503) self.assertNotEquals(result_doc, json.loads(doc)) env = testing.create_environ('/v1/480924/queues') self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_503) env = testing.create_environ('/v1/480924/queues/gumshoe', method='DELETE') self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_503)
def test_uri_https(self): # ======================================================= # Default port, implicit # ======================================================= req = Request(testing.create_environ( path='/hello', scheme='https')) uri = ('https://' + testing.DEFAULT_HOST + '/hello') self.assertEqual(req.uri, uri) # ======================================================= # Default port, explicit # ======================================================= req = Request(testing.create_environ( path='/hello', scheme='https', port=443)) uri = ('https://' + testing.DEFAULT_HOST + '/hello') self.assertEqual(req.uri, uri) # ======================================================= # Non-default port # ======================================================= req = Request(testing.create_environ( path='/hello', scheme='https', port=22)) uri = ('https://' + testing.DEFAULT_HOST + ':22/hello') self.assertEqual(req.uri, uri)
def _test_attribute_header(self, name, value, attr, default=None): headers = {name: value} req = Request(testing.create_environ(headers=headers)) self.assertEqual(getattr(req, attr), value) req = Request(testing.create_environ()) self.assertEqual(getattr(req, attr), default)
def test_client_accepts_props(self): headers = {'Accept': 'application/xml'} req = Request(testing.create_environ(headers=headers)) self.assertTrue(req.client_accepts_xml) self.assertFalse(req.client_accepts_json) self.assertFalse(req.client_accepts_msgpack) headers = {'Accept': 'application/*'} req = Request(testing.create_environ(headers=headers)) self.assertTrue(req.client_accepts_xml) self.assertTrue(req.client_accepts_json) self.assertTrue(req.client_accepts_msgpack) headers = {'Accept': 'application/json'} req = Request(testing.create_environ(headers=headers)) self.assertFalse(req.client_accepts_xml) self.assertTrue(req.client_accepts_json) self.assertFalse(req.client_accepts_msgpack) headers = {'Accept': 'application/x-msgpack'} req = Request(testing.create_environ(headers=headers)) self.assertFalse(req.client_accepts_xml) self.assertFalse(req.client_accepts_json) self.assertTrue(req.client_accepts_msgpack) headers = { 'Accept': 'application/json,application/xml,application/x-msgpack' } req = Request(testing.create_environ(headers=headers)) self.assertTrue(req.client_accepts_xml) self.assertTrue(req.client_accepts_json) self.assertTrue(req.client_accepts_msgpack)
def test_relative_uri(self): assert self.req.relative_uri == self.app + self.relative_uri assert self.req_noqs.relative_uri == self.app + self.path req_noapp = Request(testing.create_environ( path='/hello', query_string=self.qs, headers=self.headers)) assert req_noapp.relative_uri == self.relative_uri req_noapp = Request(testing.create_environ( path='/hello/', query_string=self.qs, headers=self.headers)) relative_trailing_uri = self.path + '/?' + self.qs # NOTE(kgriffs): Call twice to check caching works assert req_noapp.relative_uri == relative_trailing_uri assert req_noapp.relative_uri == relative_trailing_uri options = RequestOptions() options.strip_url_path_trailing_slash = False req_noapp = Request(testing.create_environ( path='/hello/', query_string=self.qs, headers=self.headers), options=options) assert req_noapp.relative_uri == '/hello/' + '?' + self.qs
def before(self): self.qs = 'marker=deadbeef&limit=10' self.headers = { 'Host': 'falcon.example.com', 'Content-Type': 'text/plain', 'Content-Length': '4829', 'Authorization': '' } self.app = '/test' self.path = '/hello' self.relative_uri = self.path + '?' + self.qs self.uri = 'http://falcon.example.com' + self.app + self.relative_uri self.uri_noqs = 'http://falcon.example.com' + self.app + self.path self.req = Request(testing.create_environ( app=self.app, path='/hello', query_string=self.qs, headers=self.headers)) self.req_noqs = Request(testing.create_environ( app=self.app, path='/hello', headers=self.headers))
def test_update_metadata(self): # Create doc1 = '{"messages": {"ttl": 600}}' env = testing.create_environ('/v1/480924/queues/xyz', method="PUT", body=doc1) self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_201) # Update doc2 = '{"messages": {"ttl": 100}}' env = testing.create_environ('/v1/480924/queues/xyz', method="PUT", body=doc2) self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_204) # Get env = testing.create_environ('/v1/480924/queues/xyz') result = self.app(env, self.srmock) result_doc = json.loads(result[0]) self.assertEquals(result_doc, json.loads(doc2)) self.assertEquals(self.srmock.headers_dict['Content-Location'], env['PATH_INFO'])
def _test_attribute_header(self, name, value, attr, default=None): headers = {name: value} req = Request(testing.create_environ(headers=headers)) assert getattr(req, attr) == value req = Request(testing.create_environ()) assert getattr(req, attr) == default
def test_content_length(self): headers = {'content-length': '5656'} req = Request(testing.create_environ(headers=headers)) self.assertEqual(req.content_length, 5656) headers = {'content-length': ''} req = Request(testing.create_environ(headers=headers)) self.assertEqual(req.content_length, None)
def _test_attribute_header(self, name, value, attr): headers = {name: value} req = Request(testing.create_environ(headers=headers)) self.assertEquals(value, getattr(req, attr)) headers = {name: None} req = Request(testing.create_environ(headers=headers)) self.assertEqual(None, getattr(req, attr))
def test_content_length(self): headers = {'content-length': '5656'} req = Request(testing.create_environ(headers=headers)) assert req.content_length == 5656 headers = {'content-length': ''} req = Request(testing.create_environ(headers=headers)) assert req.content_length is None
def test_unicode_path_in_create_environ(self): if six.PY3: self.skip('Test does not apply to Py3K') env = testing.create_environ(u'/fancy/unícode') self.assertEqual(env['PATH_INFO'], '/fancy/un\xc3\xadcode') env = testing.create_environ(u'/simple') self.assertEqual(env['PATH_INFO'], '/simple')
def test_unicode_path_in_create_environ(self): if six.PY3: self.skip("Test does not apply to Py3K") env = testing.create_environ(u"/fancy/unícode") self.assertEqual(env["PATH_INFO"], "/fancy/un\xc3\xadcode") env = testing.create_environ(u"/simple") self.assertEqual(env["PATH_INFO"], "/simple")
def test_no_uuid(self): env = testing.create_environ('/v1/480924/queues/fizbit/messages', method="POST", body='[{"body": 0, "ttl": 0}]') self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_400) env = testing.create_environ('/v1/480924/queues/fizbit/messages', method="GET") body = self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_400)
def test_bad_metadata(self): env = testing.create_environ('/v1/480924/queues/fizbat', body="{", method="PUT") self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_400) env = testing.create_environ('/v1/480924/queues/fizbat', body="[]", method="PUT") self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_400)
def test_simple(self): doc = '{"messages": {"ttl": 600}}' env = testing.create_environ('/v1/480924/queues/gumshoe', method="PUT", body=doc) self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_201) location = ('Location', '/v1/480924/queues/gumshoe') self.assertThat(self.srmock.headers, matchers.Contains(location)) env = testing.create_environ('/v1/480924/queues/gumshoe') result = self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_200) self.assertEquals(result, [doc])
def test_fallback_filename(uri, default, expected, content_type, downloadable, monkeypatch): def mockOpen(path, mode): if default in path: return path raise IOError() monkeypatch.setattr(io, 'open', mockOpen) monkeypatch.setattr('os.path.isfile', lambda file: default in file) sr = StaticRoute('/static', '/var/www/statics', downloadable=downloadable, fallback_filename=default) req_path = '/static/' + uri req = Request(testing.create_environ( host='test.com', path=req_path, app='statics' )) resp = Response() sr(req, resp) assert sr.match(req.path) assert resp.stream == os.path.join('/var/www/statics', expected) assert resp.content_type == content_type if downloadable: assert os.path.basename(expected) in resp.downloadable_as else: assert resp.downloadable_as is None
def call(method, api_or_module, url, body='', headers=None, params=None, query_string='', scheme='http', **kwargs): """Simulates a round-trip call against the given API / URL""" api = API(api_or_module).http.server() response = StartResponseMock() headers = {} if headers is None else headers if not isinstance(body, str) and 'json' in headers.get('content-type', 'application/json'): body = output_format.json(body) headers.setdefault('content-type', 'application/json') params = params if params else {} params.update(kwargs) if params: query_string = '{}{}{}'.format(query_string, '&' if query_string else '', urlencode(params, True)) result = api(create_environ(path=url, method=method, headers=headers, query_string=query_string, body=body, scheme=scheme), response) if result: try: response.data = result[0].decode('utf8') except TypeError: data = BytesIO() for chunk in result: data.write(chunk) data = data.getvalue() try: response.data = data.decode('utf8') except UnicodeDecodeError: # pragma: no cover response.data = data except (UnicodeDecodeError, AttributeError): response.data = result[0] response.content_type = response.headers_dict['content-type'] if 'application/json' in response.content_type: response.data = json.loads(response.data) return response
def test_request_cookie_parsing(self): # testing with a github-ish set of cookies headers = [ ( "Cookie", """ logged_in=no;_gh_sess=eyJzZXXzaW9uX2lkIjoiN2; tz=Europe/Berlin; _ga=GA1.2.332347814.1422308165; _gat=1; _octo=GH1.1.201722077.1422308165""", ) ] environ = testing.create_environ(headers=headers) req = falcon.Request(environ) self.assertEqual("no", req.cookies["logged_in"]) self.assertEqual("Europe/Berlin", req.cookies["tz"]) self.assertEqual("GH1.1.201722077.1422308165", req.cookies["_octo"]) self.assertIn("logged_in", req.cookies) self.assertIn("_gh_sess", req.cookies) self.assertIn("tz", req.cookies) self.assertIn("_ga", req.cookies) self.assertIn("_gat", req.cookies) self.assertIn("_octo", req.cookies)
def test_non_authenticated(self): env = testing.create_environ(self.url_prefix + '/480924/queues/', method='GET', headers=self.headers) self.app(env, self.srmock) self.assertEqual(self.srmock.status, falcon.HTTP_401)
def test_missing_qs(self): env = testing.create_environ() if 'QUERY_STRING' in env: del env['QUERY_STRING'] # Should not cause an exception when Request is instantiated Request(env)
def queues_env(): request_headers = {'Content-Type': 'application/json'} path = ('/v1/852809/queues/0fd4c8c6-bd72-11e2-8e47-db5ebd4c8125' '/claims/db5ebd4c8125') return helpers.create_environ(path, query_string='limit=10&thing=a%20b', headers=request_headers)
def simulate_request(self, path, project_id=None, **kwargs): """Simulate a request. Simulates a WSGI request to the API for testing. :param path: Request path for the desired resource :param project_id: Project ID to use for the X-Project-ID header, or None to not set the header :param kwargs: Same as falcon.testing.create_environ() :returns: standard WSGI iterable response """ # NOTE(flaper87): We create a copy regardless the headers # were passed or not. This will prevent modifying `self.headers` # in cases where simulate methods are called like: # self.simulate_put(path, headers=self.headers) headers = kwargs.get('headers', self.headers).copy() project_id = ('518b51ea133c4facadae42c328d6b77b' if project_id is None else project_id) headers['X-Project-ID'] = headers.get('X-Project-ID', project_id) kwargs['headers'] = headers try: if six.PY3: path.encode('latin1').decode('utf-8', 'replace') except UnicodeEncodeError: self.srmock.status = falcon.HTTP_400 return return self.app(ftest.create_environ(path=path, **kwargs), self.srmock)
def test_custom_metadata(self): # Set doc = '{"messages": {"ttl": 600}, "padding": "%s"}' padding_len = transport.MAX_QUEUE_METADATA_SIZE - (len(doc) - 2) doc = doc % ('x' * padding_len) env = testing.create_environ('/v1/480924/queues/gumshoe', method="PUT", body=doc) self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_201) # Get env = testing.create_environ('/v1/480924/queues/gumshoe') result = self.app(env, self.srmock) result_doc = json.loads(result[0]) self.assertEquals(result_doc, json.loads(doc))
def test_request_cookie_parsing(): # testing with a github-ish set of cookies headers = [ ( 'Cookie', """ logged_in=no;_gh_sess=eyJzZXXzaW9uX2lkIjoiN2; tz=Europe/Berlin; _ga=GA1.2.332347814.1422308165; _gat=1; _octo=GH1.1.201722077.1422308165 """ ), ] environ = testing.create_environ(headers=headers) req = falcon.Request(environ) assert req.cookies['logged_in'] == 'no' assert req.cookies['tz'] == 'Europe/Berlin' assert req.cookies['_octo'] == 'GH1.1.201722077.1422308165' assert 'logged_in' in req.cookies assert '_gh_sess' in req.cookies assert 'tz' in req.cookies assert '_ga' in req.cookies assert '_gat' in req.cookies assert '_octo' in req.cookies
def test_accept_xml(self): headers = {'Accept': 'application/xml'} req = Request(testing.create_environ(headers=headers)) self.assertTrue(req.client_accepts_xml) headers = {'Accept': '*/*'} req = Request(testing.create_environ(headers=headers)) self.assertTrue(req.client_accepts_xml) headers = {'Accept': 'application/json'} req = Request(testing.create_environ(headers=headers)) self.assertFalse(req.client_accepts_xml) headers = {'Accept': 'application/xm'} req = Request(testing.create_environ(headers=headers)) self.assertFalse(req.client_accepts_xml)
def test_forwarded_multiple_params(): req = Request(testing.create_environ( host='suchproxy02.suchtesting.com', path='/languages', headers={ 'Forwarded': ( 'host=something.org;proto=hTTps;ignore=me;for=108.166.30.185, ' 'by=203.0.113.43;host=suchproxy01.suchtesting.com;proto=httP' ) } )) assert req.forwarded is not None assert req.forwarded[0].host == 'something.org' assert req.forwarded[0].scheme == 'https' assert req.forwarded[0].src == '108.166.30.185' assert req.forwarded[0].dest is None assert req.forwarded[1].host == 'suchproxy01.suchtesting.com' assert req.forwarded[1].scheme == 'http' assert req.forwarded[1].src is None assert req.forwarded[1].dest == '203.0.113.43' assert req.forwarded_scheme == 'https' assert req.forwarded_host == 'something.org' assert req.forwarded_uri != req.uri assert req.forwarded_uri == 'https://something.org/languages' assert req.forwarded_prefix == 'https://something.org'
def test_options(resp): """ Test that options is a json serialized output of resource.describe() Args: req (falcon.Request): request instance object provided by ``req`` pytest fixture resp (falcon.Response): responce instance provided by ``resp`` pytest fixture """ # note: creating request is optional here since we bypass whole falcon # routing and dispatching procedure env = create_environ(method="OPTIONS") req = Request(env) # noqa resource = Resource() resource.on_options(req, resp) assert all([ 'OPTIONS' in _retrieve_header(resp, 'allow'), 'GET' in _retrieve_header(resp, 'allow'), ]) assert resp.status == falcon.HTTP_200 assert json.loads(resp.body) # assert this is obviously the same assert resource.describe(req, resp) == json.loads(resp.body)
def _test_header_etag(self, name, value, attr, expected_value): headers = {name: value} req = Request(testing.create_environ(headers=headers)) # NOTE(kgriffs): Loop in order to test caching for __ in range(3): value = getattr(req, attr) if expected_value is None: assert value is None return assert value is not None for element, expected_element in zip(value, expected_value): assert element == expected_element if isinstance(expected_element, ETag): assert element.is_weak == expected_element.is_weak
def create_req(ctx, body): '''creates a falcon request''' env = testing.create_environ( path='/', query_string='', protocol='HTTP/1.1', scheme='http', host='falconframework.org', port=None, headers={'Content-Type': 'application/json'}, app='', body=body, method='POST', wsgierrors=None, file_wrapper=None) req = falcon.Request(env) req.context = ctx return req
def test_invalid_limit(self): req = request.Request( testing.create_environ(path='/', query_string='limit=abc', headers={ 'X_AUTH_TOKEN': '111', 'X_USER_ID': '222', 'X_PROJECT_ID': '333', 'X_ROLES': 'terminator,predator' })) # note(trebskit) assertRaises fails to call property # so we need the actual function def property_wrapper(): return req.limit self.assertRaises(exceptions.HTTPUnprocessableEntityError, property_wrapper)
def test_validate_context_type(self): with mock.patch.object(validation, 'validate_content_type') as vc_type, \ mock.patch.object(validation, 'validate_payload_size') as vp_size, \ mock.patch.object(validation, 'validate_cross_tenant') as vc_tenant: req = request.Request(testing.create_environ()) vc_type.side_effect = Exception() try: req.validate(['test']) except Exception as ex: self.assertEqual(1, vc_type.call_count) self.assertEqual(0, vp_size.call_count) self.assertEqual(0, vc_tenant.call_count) self.assertIsInstance(ex, Exception)
def test_invalid_cookies_are_ignored(): vals = [chr(i) for i in range(0x1F)] vals += [chr(i) for i in range(0x7F, 0xFF)] vals += '()<>@,;:\\"/[]?={} \x09'.split() for c in vals: headers = [ ( 'Cookie', 'good_cookie=foo;bad' + c + 'cookie=bar' ), ] environ = testing.create_environ(headers=headers) req = falcon.Request(environ) assert req.cookies['good_cookie'] == 'foo' assert 'bad' + c + 'cookie' not in req.cookies
def simulate_request(self, path, project_id=None, **kwargs): """Simulate a request. Simulates a WSGI request to the API for testing. :param path: Request path for the desired resource :param project_id: Project ID to use for the X-Project-ID header, or None to not set the header :param kwargs: Same as falcon.testing.create_environ() :returns: standard WSGI iterable response """ if project_id is not None: headers = dict(kwargs['headers']) if 'headers' in kwargs else {} headers['X-Project-ID'] = project_id kwargs['headers'] = headers return self.app(ftest.create_environ(path=path, **kwargs), self.srmock)
def test_on_options(self): """ need to check if status of the response is set for 200 and """ env = create_environ(path='/') req = Request(env) req.context = {'doc': {}} resp = Response() resource = mongoengine.CollectionResource(objects_class=FakeObjectList, max_limit=2) resource.on_options(req=req, resp=resp) self.assertEqual(resp.get_header('Allow'), 'GET, HEAD, OPTIONS, POST, PUT') self.assertEqual( resp.body, { 'name': 'FakeObjectList', 'description': 'Extend list to match interface of List resource', })
def test_basic_documentation_output_type_accept(): """Ensure API documentation works with selectable output types""" accept_output = hug.output_format.accept( { 'application/json': hug.output_format.json, 'application/pretty-json': hug.output_format.pretty_json }, default=hug.output_format.json) with mock.patch.object(api.http, '_output_format', accept_output, create=True): handler = api.http.documentation_404() response = StartResponseMock() handler(Request(create_environ(path='v1/doc')), response) documentation = json.loads(response.data.decode('utf8'))['documentation'] assert 'handlers' in documentation and 'overview' in documentation
def test_headers_as_list(self, client): headers = [ ('Client-ID', '692ba466-74bb-11e3-bf3f-7567c531c7ca'), ('Accept', 'audio/*; q=0.2, audio/basic'), ] # Unit test environ = testing.create_environ(headers=headers) req = falcon.Request(environ) for name, value in headers: assert (name.upper(), value) in req.headers.items() # Functional test client.app.add_route('/', testing.SimpleTestResource(headers=headers)) result = client.simulate_get() for name, value in headers: assert result.headers[name] == value
def call(method, api_or_module, url, body="", headers=None, params=None, query_string="", scheme="http", host=DEFAULT_HOST, **kwargs): """Simulates a round-trip call against the given API / URL""" api = API(api_or_module).http.server() response = StartResponseMock() headers = {} if headers is None else headers if not isinstance(body, str) and "json" in headers.get( "content-type", "application/json"): body = output_format.json(body) headers.setdefault("content-type", "application/json") params = params if params else {} params.update(kwargs) if params: query_string = "{}{}{}".format(query_string, "&" if query_string else "", urlencode(params, True)) result = api( create_environ( path=url, method=method, headers=headers, query_string=query_string, body=body, scheme=scheme, host=host, ), response, ) if result: response.data = _internal_result(result) response.content_type = response.headers_dict["content-type"] if "application/json" in response.content_type: response.data = json.loads(response.data) return response
def create_bench(name): srmock = helpers.StartResponseMock() request_headers = {'Content-Type': 'application/json'} # env = helpers.create_environ('/hello/584/test', query_string='limit=10', # headers=request_headers) env = helpers.create_environ('/hello', query_string='limit=10', headers=request_headers) body = helpers.rand_string(0, 10240) # NOQA headers = {'X-Test': 'Funky Chicken'} # NOQA app = eval('create_{0}(body, headers)'.format(name.lower())) def bench(): app(env, srmock) return bench
def test_clean_check_error_raising(self): """ Check if clean function returns errors dict when `clean_param_name` raise `ParamException` """ resource = CollectionResource(objects_class=None) env = create_environ(path='/') req = Request(env) req.context = {'doc': {'id': 1, 'name': 'Opentopic'}} Response() def clean_name_test(self): raise ParamException('Test Error Message') resource.clean_name = clean_name_test data, errors = resource.clean(req.context['doc']) self.assertEqual(data, { 'id': 1, }) self.assertEqual(errors, {'name': ['Test Error Message']})
def test_fallback_filename(uri, default, expected, monkeypatch): def mockOpen(path, mode): if default in path: return path raise IOError() monkeypatch.setattr(io, 'open', mockOpen) monkeypatch.setattr('os.path.isfile', lambda file: default in file) sr = StaticRoute('/static', '/var/www/statics', fallback_filename=default) req_path = '/static/' + uri req = Request( testing.create_environ(host='test.com', path=req_path, app='statics')) resp = Response() sr(req, resp) assert sr.match(req.path) assert resp.stream == os.path.join('/var/www/statics', expected)
def test_basic_documentation_output_type_accept(): """Ensure API documentation works with selectable output types""" accept_output = hug.output_format.accept( { "application/json": hug.output_format.json, "application/pretty-json": hug.output_format.pretty_json, }, default=hug.output_format.json, ) with mock.patch.object(api.http, "_output_format", accept_output, create=True): handler = api.http.documentation_404() response = StartResponseMock() handler(Request(create_environ(path="v1/doc")), response) documentation = json.loads(response.data.decode("utf8"))["documentation"] assert "handlers" in documentation and "overview" in documentation
def test_rfc_forwarded(self): req = Request( testing.create_environ( host='example.com', path='/access_route', headers={ 'Forwarded': ('for=192.0.2.43,for=,' 'for="[2001:db8:cafe::17]:555",' 'for="unknown", by=_hidden,for="\\"\\\\",' 'for="_don\\\"t_\\try_this\\\\at_home_\\42",' 'for="198\\.51\\.100\\.17\\:1236";' 'proto=https;host=example.com') })) compares = [ '192.0.2.43', '', '2001:db8:cafe::17', 'unknown', '"\\', '_don"t_try_this\\at_home_42', '198.51.100.17' ] self.assertEqual(req.access_route, compares) # test cached self.assertEqual(req.access_route, compares)
def test_good_path(uri_prefix, uri_path, expected_path, mtype, monkeypatch): monkeypatch.setattr(io, 'open', lambda path, mode: path) sr = StaticRoute(uri_prefix, '/var/www/statics') req_path = uri_prefix[:-1] if uri_prefix.endswith('/') else uri_prefix req_path += uri_path req = Request(testing.create_environ( host='test.com', path=req_path, app='statics' )) resp = Response() sr(req, resp) assert resp.content_type == mtype assert resp.stream == '/var/www/statics' + expected_path
def test_ignore_case_role_check(self): lowercase_action = "example:lowercase_monasca_user" uppercase_action = "example:uppercase_monasca_user" monasca_user_context = request.Request( testing.create_environ( path="/", headers={ "X_USER_ID": "monasca_user", "X_PROJECT_ID": "fake", "X_ROLES": "MONASCA_user" } ) ) self.assertTrue(policy.authorize(monasca_user_context.context, lowercase_action, {})) self.assertTrue(policy.authorize(monasca_user_context.context, uppercase_action, {}))
def test_forwarded_missing_first_hop_host(): req = Request(testing.create_environ( host='suchproxy02.suchtesting.com', path='/languages', app='doge', headers={ 'Forwarded': 'for=108.166.30.185,host=suchproxy01.suchtesting.com' } )) assert req.forwarded[0].host is None assert req.forwarded[0].src == '108.166.30.185' assert req.forwarded[1].host == 'suchproxy01.suchtesting.com' assert req.forwarded[1].src is None assert req.forwarded_scheme == 'http' assert req.forwarded_host == 'suchproxy02.suchtesting.com' assert req.forwarded_uri == req.uri assert req.forwarded_uri == 'http://suchproxy02.suchtesting.com/doge/languages' assert req.forwarded_prefix == 'http://suchproxy02.suchtesting.com/doge'
class TestWSGIMediaType(base.TestBase): config_filename = 'wsgi_sqlite.conf' @ddt.data( ('GET', '/v1/queues'), ('GET', '/v1/queues/nonexistent/metadata'), ('GET', '/v1/queues/nonexistent/stats'), ('POST', '/v1/queues/nonexistent/messages'), ('GET', '/v1/queues/nonexistent/messages/deadbeaf'), ('POST', '/v1/queues/nonexistent/claims'), ('GET', '/v1/queues/nonexistent/claims/0ad'), ('GET', '/v1/health'), ) def test_json_only_endpoints(self, (method, endpoint)): headers = {'Client-ID': '30387f00', 'Accept': 'application/xml'} env = testing.create_environ(endpoint, method=method, headers=headers) self.app(env, self.srmock) self.assertEquals(self.srmock.status, falcon.HTTP_406)
def test_on_get(self): """ need to check if status of the response is set for 200 and """ env = create_environ(path='/') req = Request(env) req.context = {'doc': {}} req.params[mongoengine.CollectionResource.PARAM_TOTAL_COUNT] = '1' resp = Response() resource = mongoengine.CollectionResource( objects_class=Mock(return_value=[1, 2, 3]), max_limit=2) resource.get_object_list = Mock(return_value=[1, 2]) resource.get_total_objects = Mock(return_value={'total_count': 3}) resource.on_get(req=req, resp=resp) self.assertEqual(resp.body, { 'results': [1, 2], 'total': 3, 'returned': 2 }) self.assertEqual(resp.get_header('x-api-total'), '3') self.assertEqual(resp.get_header('x-api-returned'), '2')
def test_request_cookie_parsing(): # testing with a github-ish set of cookies headers = [ ( 'Cookie', """ logged_in=no;_gh_sess=eyJzZXXzaW9uX2lkIjoiN2; tz=Europe/Berlin; _ga =GA1.2.332347814.1422308165; tz2=Europe/Paris ; _ga2="line1\\012line2"; tz3=Europe/Madrid ;_ga3= GA3.2.332347814.1422308165; _gat=1; _octo=GH1.1.201722077.1422308165 """, ), ] environ = testing.create_environ(headers=headers) req = falcon.Request(environ) # NOTE(kgriffs): Test case-sensitivity assert req.get_cookie_values('TZ') is None assert 'TZ' not in req.cookies with pytest.raises(KeyError): req.cookies['TZ'] for name, value in [ ('logged_in', 'no'), ('_gh_sess', 'eyJzZXXzaW9uX2lkIjoiN2'), ('tz', 'Europe/Berlin'), ('tz2', 'Europe/Paris'), ('tz3', 'Europe/Madrid'), ('_ga', 'GA1.2.332347814.1422308165'), ('_ga2', 'line1\nline2'), ('_ga3', 'GA3.2.332347814.1422308165'), ('_gat', '1'), ('_octo', 'GH1.1.201722077.1422308165'), ]: assert name in req.cookies assert req.cookies[name] == value assert req.get_cookie_values(name) == [value]
def call(method, api_module, url, body='', headers=None, **params): '''Simulates a round-trip call against the given api_module / url''' api = server(api_module) response = StartResponseMock() if not isinstance(body, str): body = output_format.json(body) headers = {} if headers is None else headers headers['content-type'] = 'application/json' result = api( create_environ(path=url, method=method, headers=headers, query_string=urlencode(params), body=body), response) if result: response.data = result[0].decode('utf8') response.content_type = response.headers_dict['content-type'] if response.content_type == 'application/json': response.data = json.loads(response.data) return response
def test_forwarded_host(): req = Request(testing.create_environ( host='suchproxy02.suchtesting.com', path='/languages', headers={ 'Forwarded': 'host=something.org , host=suchproxy01.suchtesting.com' } )) assert req.forwarded is not None for f in req.forwarded: assert f.src is None assert f.dest is None assert f.scheme is None assert req.forwarded[0].host == 'something.org' assert req.forwarded[1].host == 'suchproxy01.suchtesting.com' assert req.forwarded_host == 'something.org' assert req.forwarded_uri != req.uri assert req.forwarded_uri == 'http://something.org/languages' assert req.forwarded_prefix == 'http://something.org'
def test_request_cookie_parsing(self): # testing with a github-ish set of cookies headers = [ ('Cookie', ''' logged_in=no;_gh_sess=eyJzZXXzaW9uX2lkIjoiN2; tz=Europe/Berlin; _ga=GA1.2.332347814.1422308165; _gat=1; _octo=GH1.1.201722077.1422308165'''), ] environ = testing.create_environ(headers=headers) req = falcon.Request(environ) self.assertEqual("no", req.cookies["logged_in"]) self.assertEqual("Europe/Berlin", req.cookies["tz"]) self.assertEqual("GH1.1.201722077.1422308165", req.cookies["_octo"]) self.assertIn("logged_in", req.cookies) self.assertIn("_gh_sess", req.cookies) self.assertIn("tz", req.cookies) self.assertIn("_ga", req.cookies) self.assertIn("_gat", req.cookies) self.assertIn("_octo", req.cookies)
def test_pep3333(self): api = falcon.API() mock = testing.StartResponseMock() # Simulate a web request (normally done though a WSGI server) response = api(testing.create_environ(), mock) # Verify that the response is iterable assert _is_iterable(response) # Make sure start_response was passed a valid status string assert mock.call_count == 1 assert isinstance(mock.status, str) assert re.match(r'^\d+[a-zA-Z\s]+$', mock.status) # Verify headers is a list of tuples, each containing a pair of strings assert isinstance(mock.headers, list) if len(mock.headers) != 0: header = mock.headers[0] assert isinstance(header, tuple) assert len(header) == 2 assert isinstance(header[0], str) assert isinstance(header[1], str)
def test_json_only_endpoints(self): endpoints = ( ('GET', self.url_prefix + '/queues'), ('GET', self.url_prefix + '/queues/nonexistent/stats'), ('POST', self.url_prefix + '/queues/nonexistent/messages'), ('GET', self.url_prefix + '/queues/nonexistent/messages/deadbeaf'), ('POST', self.url_prefix + '/queues/nonexistent/claims'), ('GET', self.url_prefix + '/queues/nonexistent/claims/0ad'), ('GET', self.url_prefix + '/health'), ) for method, endpoint in endpoints: headers = { 'Client-ID': str(uuid.uuid4()), 'Accept': 'application/xml', } env = testing.create_environ(endpoint, method=method, headers=headers) self.app(env, self.srmock) self.assertEqual(self.srmock.status, falcon.HTTP_406)
def test_request_cookie_parsing(self): # testing with a github-ish set of cookies headers = [ ('Cookie', ''' logged_in=no;_gh_sess=eyJzZXXzaW9uX2lkIjoiN2; tz=Europe/Berlin; _ga=GA1.2.332347814.1422308165; _gat=1; _octo=GH1.1.201722077.1422308165'''), ] environ = testing.create_environ(headers=headers) req = falcon.Request(environ) self.assertEqual('no', req.cookies['logged_in']) self.assertEqual('Europe/Berlin', req.cookies['tz']) self.assertEqual('GH1.1.201722077.1422308165', req.cookies['_octo']) self.assertIn('logged_in', req.cookies) self.assertIn('_gh_sess', req.cookies) self.assertIn('tz', req.cookies) self.assertIn('_ga', req.cookies) self.assertIn('_gat', req.cookies) self.assertIn('_octo', req.cookies)
def test_nonlatin_path(self, test_path): # NOTE(kgriffs): When a request comes in, web servers decode # the path. The decoded path may contain UTF-8 characters, # but according to the WSGI spec, no strings can contain chars # outside ISO-8859-1. Therefore, to reconcile the URI # encoding standard that allows UTF-8 with the WSGI spec # that does not, WSGI servers tunnel the string via # ISO-8859-1. falcon.testing.create_environ() mimics this # behavior, e.g.: # # tunnelled_path = path.encode('utf-8').decode('iso-8859-1') # # falcon.Request does the following to reverse the process: # # path = tunnelled_path.encode('iso-8859-1').decode('utf-8', 'replace') # req = Request(testing.create_environ( host='com', path=test_path, headers=self.headers)) self.assertEqual(req.path, falcon.uri.decode(test_path))
def test_update_params(self): """ Test if param is updated and returned """ resource = SingleResource(objects_class=None) env = create_environ(path='/') req = Request(env) req.context = { 'doc': { 'pk': 1, 'name': 'TestNewName' }, } resp = Response() resource.objects_class = FakeObjectList() resource.serialize = fake_serialize resource.on_patch(req, resp) self.assertEqual({ 'pk': 1, 'name': 'TestNewName', '_saved': True }, resp.body)
def test_pep3333(self): api = falcon.API() mock = testing.StartResponseMock() # Simulate a web request (normally done though a WSGI server) response = api(testing.create_environ(), mock) # Verify that the response is iterable self.assertTrue(_is_iterable(response)) # Make sure start_response was passed a valid status string self.assertIs(mock.call_count, 1) self.assertTrue(isinstance(mock.status, str)) self.assertThat(mock.status, MatchesRegex('^\d+[a-zA-Z\s]+$')) # Verify headers is a list of tuples, each containing a pair of strings self.assertTrue(isinstance(mock.headers, list)) if len(mock.headers) != 0: header = mock.headers[0] self.assertTrue(isinstance(header, tuple)) self.assertThat(len(header), Equals(2)) self.assertTrue(isinstance(header[0], str)) self.assertTrue(isinstance(header[1], str))