def _get_middleware_list(self, middleware_level, middleware_methods):
middleware_list = []
for middleware_name in middleware_level:
if isinstance(middleware_name, str):
try:
middleware = import_object(middleware_name)
middleware = middleware()
except (ImportError, AttributeError) as error:
raise InvalidMiddlewareException(error)
except TypeError as error: # It is not callable
raise InvalidMiddlewareException(error)
elif callable(middleware_name):
middleware = middleware_name()
else:
middleware = middleware_name
any_method = any([
getattr(middleware, method, None)
for method in middleware_methods
])
if not any_method:
raise BadMiddlewareException(
"'%s' middleware must have any method to process \
in this level" % middleware_name
)
middleware_list.append(middleware)
return tuple(middleware_list)
def _get_templates_info(self, config_module):
templates = getattr(config_module, 'templates', {})
assert type(templates) == dict, "templates must be an dictionary"
directory = templates.get('directory')
if directory is not None:
if not os.path.exists(directory):
raise TemplatePathException(
"Template path '%s' does not exist" % directory
)
render = templates.get('render', Jinja2Render)
if isinstance(render, str):
try:
render = import_object(render)
except ImportError as error:
raise InvalidRenderException(error)
if not callable(render):
raise InvalidRenderException("render must be callable")
else:
templates['render'] = render
return templates
def _get_url_list(self, url_patterns):
from agiliza.config.urls import include
assert type(url_patterns) == list or type(url_patterns) == tuple,\
"'url_pattern' must be a list or tuple"
urls = []
not_finished_urls = []
for url_list in url_patterns:
not_finished_urls = not_finished_urls + url_list
for url in not_finished_urls:
regexp, target, context_processors, name, layout_name = url
try:
regexp = re.compile(regexp)
except re.error as error:
raise URLBadformedException(error)
if isinstance(target, str):
try:
target_class = import_object(target)
target = target_class()
except (ImportError, AttributeError) as error:
raise ControllerNotFoundException(error)
except TypeError as error: # It is not callable
raise ControllerNotFoundException(error)
if callable(target):
target = target()
try:
context_processors = tuple([
import_object(context_processor)
for context_processor in context_processors
])
except (ImportError, AttributeError) as error:
raise ContextProcessorNotFoundException(error)
urls.append((
regexp,
target,
context_processors,
name,
layout_name,
))
return tuple(urls)
def test_must_not_load_invalid_object(self):
my_module = types.ModuleType("my_module")
sys.modules.setdefault("my_module", my_module)
with self.assertRaises(AttributeError, msg="Must be raise a ImportError"):
obj = import_object("my_module.object")
sys.modules.pop("my_module")
def test_must_not_load_an_object(self):
my_module = types.ModuleType("my_module")
my_module.object = object()
sys.modules.setdefault("my_module", my_module)
obj = import_object("my_module.object")
self.assertEqual(my_module.object, obj, "import_object must load an object")
sys.modules.pop("my_module")
def test_must_not_load_invalid_module(self):
with self.assertRaises(ImportError, msg="Must be raise a ImportError"):
import_object("invalid_module.and_attribute")
def test_must_not_load_no_string_arg(self):
with self.assertRaises(AssertionError, msg="Must be raise a AssertionError"):
import_object(3)
def test_must_not_load_too_short_name(self):
with self.assertRaises(AssertionError, msg="Must be raise a AssertionError"):
import_object("too_short")
