def test_set_true(self):
response = Response(
charset="utf=8",
logger=logging.basicConfig(),
serializers=[JSON()],
default_serializer=None
)
response.minify = True
self.assertTrue(response.minify)
def test_prestans_version(self):
response = Response(
charset="utf=8",
logger=logging.basicConfig(),
serializers=[JSON()],
default_serializer=None
)
from prestans import __version__
self.assertTrue("Prestans-Version" in response.headers)
self.assertEqual(response.headers["Prestans-Version"], __version__)
def test_default_serializer(self):
json_ser = JSON()
response = Response(
charset="utf=8",
logger=logging.basicConfig(),
serializers=[json_ser],
default_serializer=json_ser
)
self.assertEqual(response.default_serializer, json_ser)
def test_logger(self):
logger = logging.basicConfig()
response = Response(
charset="utf=8",
logger=logger,
serializers=[],
default_serializer=None
)
self.assertEqual(response.logger, logger)
def setUp(self):
import logging
logging.basicConfig()
self.logger = logging.getLogger("prestans")
from prestans.deserializer import JSON
charset = "utf-8"
serializers = [JSON()]
default_serializer = JSON()
class AuthProvider(Base):
def is_authorized_user(self, config):
return config["name"] == "Jack"
class HandlerWithoutProvider(RequestHandler):
@access_required({"name": "Jack"})
def get(self):
self.response.status = STATUS.NO_CONTENT
self.handler_without_provider = HandlerWithoutProvider
class HandlerWithProvider(RequestHandler):
__provider_config__ = Config(authentication=AuthProvider())
@access_required({"name": "Jack"})
def get(self):
self.response.status = STATUS.NO_CONTENT
@access_required({"name": "Jill"})
def post(self):
self.response.status = STATUS.NO_CONTENT
self.handler_with_provider = HandlerWithProvider
self.get_environ = {"REQUEST_METHOD": VERB.GET}
self.post_environ = {"REQUEST_METHOD": VERB.POST}
self.get_request = Request(environ=self.get_environ,
charset=charset,
logger=self.logger,
deserializers=serializers,
default_deserializer=default_serializer)
self.post_request = Request(environ=self.post_environ,
charset=charset,
logger=self.logger,
deserializers=serializers,
default_deserializer=default_serializer)
self.response = Response(charset=charset,
logger=self.logger,
serializers=serializers,
default_serializer=default_serializer)
def test_serializers(self):
logger = logging.basicConfig()
response = Response(
charset="utf=8",
logger=logger,
serializers=[JSON()],
default_serializer=None
)
self.assertEqual(response.supported_mime_types, ["application/json"])
self.assertEqual(response.supported_mime_types_str, "application/json")
response = Response(
charset="utf=8",
logger=logger,
serializers=[JSON(), XMLPlist()],
default_serializer=None
)
self.assertEqual(response.supported_mime_types, ["application/json", "application/xml"])
self.assertEqual(response.supported_mime_types_str, "application/json,application/xml")
def __call__(self, environ, start_response):
# say hello
self.logger.info(
"%s exposes %i end-points; prestans %s; charset %s; debug %s" %
(self._application_name, len(
self._routes), __version__, self._charset, self._debug))
# validate serializers and deserializers; are subclasses of prestans.serializer.Base
_default_outgoing_mime_types = list()
for available_serializer in self._serializers:
if not isinstance(available_serializer, serializer.Base):
msg = "registered serializer %s.%s does not inherit from prestans.serializer.Serializer" % (
available_serializer.__module__,
available_serializer.__class__.__name__)
raise TypeError(msg)
_default_outgoing_mime_types.append(
available_serializer.content_type())
_default_incoming_mime_types = list()
for available_deserializer in self._deserializers:
if not isinstance(available_deserializer, deserializer.Base):
msg = "registered deserializer %s.%s does not inherit from prestans.serializer.DeSerializer" % (
available_deserializer.__module__,
available_deserializer.__class__.__name__)
raise TypeError(msg)
_default_incoming_mime_types.append(
available_deserializer.content_type())
# report on the acceptable mime types
self._logger.info("generally accepts %s; speaks %s" %
(str(_default_outgoing_mime_types).strip("[]'"),
str(_default_incoming_mime_types).strip("[]'")))
# attempt to parse the HTTP request
request = Request(environ=environ,
charset=self._charset,
logger=self._logger,
deserializers=self._deserializers,
default_deserializer=self._default_deserializer)
# initialise the route map
route_map = self.generate_route_map(self._routes)
try:
# check if the requested URL has a valid registered handler
for regexp, handler_class in route_map:
# if absent, can assume to be empty string
# https://www.python.org/dev/peps/pep-3333/#environ-variables
match = regexp.match(environ.get("PATH_INFO", ""))
# if we've found a match; ensure its a handler subclass and return it's callable
if match:
# assemble the args and kwargs
args = match.groups()
kwargs = {}
for key, value in iter(regexp.groupindex.items()):
kwargs[key] = args[value - 1]
if len(kwargs) > 0:
args = ()
if issubclass(handler_class, BlueprintHandler):
response = DictionaryResponse(
charset=self._charset,
logger=self._logger,
serializers=self._serializers,
default_serializer=self._default_deserializer)
request_handler = handler_class(args=args,
kwargs=kwargs,
request=request,
response=response,
logger=self._logger,
debug=self._debug,
route_map=self._routes)
else:
response = Response(
charset=self._charset,
logger=self._logger,
serializers=self._serializers,
default_serializer=self._default_deserializer)
response.minify = request.is_minified
request_handler = handler_class(args=args,
kwargs=kwargs,
request=request,
response=response,
logger=self._logger,
debug=self._debug)
return request_handler(environ, start_response)
# request does not have a matched handler
no_endpoint = exception.NoEndpointError()
no_endpoint.request = request
raise no_endpoint
except exception.Base as exp:
self.logger.error(exp)
error_response = ErrorResponse(exp, self._default_serializer)
return error_response(environ, start_response)
def setUp(self):
import logging
logging.basicConfig()
self.logger = logging.getLogger("prestans")
from prestans.deserializer import JSON
charset = "utf-8"
serializers = [JSON()]
default_serializer = JSON()
self.get_environ = {"REQUEST_METHOD": VERB.GET}
self.post_environ = {"REQUEST_METHOD": VERB.POST}
self.put_environ = {"REQUEST_METHOD": VERB.PUT}
self.get_request = Request(environ=self.get_environ,
charset=charset,
logger=self.logger,
deserializers=serializers,
default_deserializer=default_serializer)
self.post_request = Request(environ=self.post_environ,
charset=charset,
logger=self.logger,
deserializers=serializers,
default_deserializer=default_serializer)
self.put_request = Request(environ=self.put_environ,
charset=charset,
logger=self.logger,
deserializers=serializers,
default_deserializer=default_serializer)
self.response = Response(charset=charset,
logger=self.logger,
serializers=serializers,
default_serializer=default_serializer)
class AuthProvider(Base):
def current_user_has_role(self, role_name):
return role_name == "Admin"
class HandlerWithoutProvider(RequestHandler):
@role_required("Admin")
def get(self):
pass
self.handler_without_provider = HandlerWithoutProvider
class HandlerWithProvider(RequestHandler):
__provider_config__ = Config(authentication=AuthProvider())
@role_required(None)
def get(self):
self.response.status = STATUS.NO_CONTENT
@role_required("Manager")
def post(self):
self.response.status = STATUS.NO_CONTENT
@role_required("Admin")
def put(self):
self.response.status = STATUS.NO_CONTENT
self.handler_with_provider = HandlerWithProvider
def setUp(self):
import logging
logging.basicConfig()
self.logger = logging.getLogger("prestans")
from prestans.deserializer import JSON
self.charset = "utf-8"
self.serializers = [JSON()]
self.default_serializer = JSON()
self.get_environ = {"REQUEST_METHOD": VERB.GET}
self.get_request = Request(
environ=self.get_environ,
charset=self.charset,
logger=self.logger,
deserializers=self.serializers,
default_deserializer=self.default_serializer)
self.response = Response(charset=self.charset,
logger=self.logger,
serializers=self.serializers,
default_serializer=self.default_serializer)
class HandlerWithoutProvider(RequestHandler):
@login_required
def get(self):
pass
self.handler_without_provider = HandlerWithoutProvider
class AuthenticatedProvider(Base):
def is_authenticated_user(self):
return True
class AuthenticatedHandler(RequestHandler):
__provider_config__ = Config(
authentication=AuthenticatedProvider())
@login_required
def get(self):
self.response.status = STATUS.NO_CONTENT
self.authenticated_handler = AuthenticatedHandler
class UnauthenticatedProvider(Base):
def is_authenticated_user(self):
return False
class UnauthenticatedHandler(RequestHandler):
__provider_config__ = Config(
authentication=UnauthenticatedProvider())
@login_required
def get(self):
self.response.status = STATUS.NO_CONTENT
self.unauthenticated_handler = UnauthenticatedHandler