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")