def __init__(self, *args, **kwargs):
if pylons.test.pylonsapp:
wsgiapp = pylons.test.pylonsapp
else:
wsgiapp = loadapp('config:%s' % config['__file__'])
self.app = TestApp(wsgiapp)
url._push_object(URLGenerator(config['routes.map'], environ))
def mock_pylons():
from paste.registry import Registry
import pylons
from pylons.util import AttribSafeContextObj
import ckan.lib.app_globals as app_globals
from ckan.lib.cli import MockTranslator
from ckan.config.routing import make_map
from pylons.controllers.util import Request, Response
from routes.util import URLGenerator
class TestPylonsSession(dict):
last_accessed = None
def save(self):
pass
registry = Registry()
registry.prepare()
context_obj = AttribSafeContextObj()
registry.register(pylons.c, context_obj)
app_globals_obj = app_globals.app_globals
registry.register(pylons.g, app_globals_obj)
request_obj = Request(dict(HTTP_HOST="nohost", REQUEST_METHOD="GET"))
registry.register(pylons.request, request_obj)
translator_obj = MockTranslator()
registry.register(pylons.translator, translator_obj)
registry.register(pylons.response, Response())
mapper = make_map()
registry.register(pylons.url, URLGenerator(mapper, {}))
registry.register(pylons.session, TestPylonsSession())
def setUp(self):
from paste.fixture import TestApp
from routes.util import URLGenerator
app = make_app({})
self.app = TestApp(app)
self.url = URLGenerator(app.config['routes.map'], {})
def __init__(self, *args, **kwargs):
'''
initialize the test class
'''
TestCase.__init__(self, *args, **kwargs)
LOG.debug("ConfigFile: %s " % config['__file__'])
conffile = config['__file__']
if pylons.test.pylonsapp:
wsgiapp = pylons.test.pylonsapp
else:
wsgiapp = loadapp('config: %s' % config['__file__'])
self.app = TestApp(wsgiapp)
conf = None
if conffile.startswith('/'):
conf = appconfig('config:%s' % config['__file__'], relative_to=None)
else:
raise Exception('dont know how to load the application relatively')
#conf = appconfig('config: %s' % config['__file__'], relative_to=rel)
load_environment(conf.global_conf, conf.local_conf)
self.appconf = conf
url._push_object(URLGenerator(config['routes.map'], environ))
self.isSelfTest = False
if env.has_key("linotp.selfTest"):
self.isSelfTest = True
return
def setup_class(cls):
cls.registry = Registry()
cls.registry.prepare()
cls.context_obj = AttribSafeContextObj()
cls.registry.register(pylons.c, cls.context_obj)
cls.app_globals_obj = app_globals.Globals()
cls.registry.register(pylons.g, cls.app_globals_obj)
cls.request_obj = Request(dict(HTTP_HOST="nohost"))
cls.registry.register(pylons.request, cls.request_obj)
cls.translator_obj = MockTranslator()
cls.registry.register(pylons.translator, cls.translator_obj)
cls.buffet = pylons.templating.Buffet('genshi',
template_root='ckan.templates')
cls.registry.register(pylons.buffet, cls.buffet)
cls.registry.register(pylons.response, Response())
mapper = make_map()
cls.registry.register(pylons.url, URLGenerator(mapper, {}))
cls.registry.register(pylons.session, TestSession())
# Templates often want to find out the request's routes info, so put
# some dummy values into the routes_dict, so the templates that do
# this don't cause an exception.
pylons.request.environ.update({
'pylons.routes_dict': {
'action': 'test-action',
'controller': 'test-package::',
}
})
def __init__(self, *args, **kwargs):
wsgiapp = pylons.test.pylonsapp
config = wsgiapp.config
self.app = TestApp(wsgiapp)
# Decorate with an OPTIONS method
# The webtest version in el6 does not have it
if not hasattr(self.app, 'options'):
setattr(self.app, 'options',
types.MethodType(_app_options, self.app))
# Decorate with a post_json method
# Same thing, version in el6 does not have it
if not hasattr(self.app, 'post_json'):
setattr(self.app, 'post_json',
types.MethodType(_app_post_json, self.app))
# Decorate with a get_json method
if not hasattr(self.app, 'get_json'):
setattr(self.app, 'get_json',
types.MethodType(_app_get_json, self.app))
url._push_object(URLGenerator(config['routes.map'], environ))
TestCase.__init__(self, *args, **kwargs)
self.pkey, self.cert = _generate_mock_cert()
def __init__(self, *args, **kwargs):
wsgiapp = pylons.test.pylonsapp
config = wsgiapp.application.config
self.config = config
self.app = TestApp(wsgiapp)
self.g = self.config['pylons.app_globals']
url._push_object(URLGenerator(config['routes.map'], environ))
TestCase.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
wsgiapp = pylons.test.pylonsapp
config = wsgiapp.config
self.app = TestApp(wsgiapp)
url._push_object(URLGenerator(config['routes.map'], environ))
TestCase.__init__(self, *args, **kwargs)
self.from_date = datetime(1990, 1, 1).isoformat() + "Z"
self.until_date = datetime.utcnow().isoformat() + "Z"
def __init__(self, *args, **kwargs):
wsgiapp = pylons.test.pylonsapp
config = wsgiapp.config
self.app = webtest.TestApp(wsgiapp)
url._push_object(URLGenerator(config['routes.map'], environ))
self.__setattrs__()
self.__setcreateparams__()
TestCase.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
import sys
self.wsgiapp = pylons.test.pylonsapp
self.config = self.wsgiapp.config
self.app = fixture.TestApp(self.wsgiapp)
url._push_object(URLGenerator(self.config['routes.map'], environ))
TestRollback.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
wsgiapp = pylons.test.pylonsapp
config = wsgiapp.config
self.app = TestApp(wsgiapp)
url._push_object(URLGenerator(config['routes.map'], environ))
self.Session = Session
self.index_location = config['app_conf']['index_dir']
TestCase.__init__(self, *args, **kwargs)
def init_stack(config=None):
if not config:
config = pylons.test.pylonsapp.config
url._push_object(URLGenerator(config['routes.map'], environ))
pylons.app_globals._push_object(config['pylons.app_globals'])
pylons.config._push_object(config)
pylons.tmpl_context._push_object(ContextObj())
# Initialize a translator for tests that utilize i18n
translator = _get_translator(pylons.config.get('lang'))
pylons.translator._push_object(translator)
def __call__(self, req):
results = self.map.routematch(environ=req.environ)
if not results:
return exc.HTTPNotFound()
match, route = results
url = URLGenerator(self.map, req.environ)
req.match = match
req.route = route
controller = match['controller'](req, url, self.config, self)
return controller()
def __init__(self, *args, **kwargs):
wsgiapp = pylons.test.pylonsapp
config = wsgiapp.config
self.app = TestApp(wsgiapp)
url._push_object(URLGenerator(config['routes.map'], environ))
# should perhaps be in setup
pylons.app_globals._push_object(Globals(config))
# pylons.app_globals._pop_object() # should perhaps be in teardown
super(TestControllerBase, self).__init__(*args, **kwargs)
def _inject_url_generator_for_request(self, request):
url_mapper = self.pylons_config['routes.map']
url_generator = URLGenerator(url_mapper, request.environ)
routes_dict = url_mapper.match(environ=request.environ)
request.environ.update({
'routes.url': url_generator,
'wsgiorg.routing_args': (url_generator, routes_dict),
'pylons.routes_dict': routes_dict,
})
return url_generator
def _url(self, req, *args, **kw):
"""Generate an URL pointing to some REST service.
`req` is the current request.
Arguments and keywords are passed on to the generated
:class:`routes.util.URLGenerator` instance. So you can use it
like the `url` method described in the `routes` docs, except
that you have to pass in the `req` parameter first.
"""
url = URLGenerator(self.map, req.environ)
return url(*args, **kw)
def __init__(self, *args, **kwargs):
if pylons.test.pylonsapp:
wsgiapp = pylons.test.pylonsapp
else:
wsgiapp = loadapp('config:%s' % config['__file__'])
self.app = TestApp(wsgiapp)
url._push_object(URLGenerator(config['routes.map'], environ))
# should perhaps be in setup
pylons.app_globals._push_object(Globals())
# pylons.app_globals._pop_object() # should perhaps be in teardown
super(TestControllerBase, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
'''
initialize the test class
'''
wsgiapp = pylons.test.pylonsapp
self.app = webtest.TestApp(wsgiapp)
self.session = 'justatest'
self.resolvers = {} # Set up of resolvers in create_common_resolvers
# dict of all autheticated users cookies
self.user_service = {}
url._push_object(URLGenerator(config['routes.map'], environ))
unittest2.TestCase.__init__(self, *args, **kwargs)
self.appconf = config
self.here = self.appconf.get('here')
self.fixture_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'functional',
'fixtures',
)
# ------------------------------------------------------------------ --
current_webtest = LooseVersion(
pkg_resources.get_distribution('webtest').version
)
if current_webtest <= LooseVersion('2.0.14'):
# Fix application cookies for localhost for webtest versions
# 2.0.0 to 2.0.14 (https://github.com/Pylons/webtest/issues/84)
# The CookiePolicy code is taken from webtest
class CookiePolicy(cookielib.DefaultCookiePolicy):
"""A subclass of DefaultCookiePolicy to allow cookie set for
Domain=localhost."""
def return_ok_domain(self, cookie, request):
if cookie.domain == '.localhost':
return True
return cookielib.DefaultCookiePolicy.return_ok_domain(
self, cookie, request)
def set_ok_domain(self, cookie, request):
if cookie.domain == '.localhost':
return True
return cookielib.DefaultCookiePolicy.set_ok_domain(
self, cookie, request)
self.app.cookiejar = cookielib.CookieJar(policy=CookiePolicy())
def fake_request(pylons_config,
server_name='mediadrop.example',
language='en',
method='GET',
request_uri='/',
post_vars=None,
registry=None):
paste_registry = registry or _paste_registry(pylons.request)
app_globals = pylons_config['pylons.app_globals']
if post_vars and method.upper() != 'POST':
raise ValueError(
'You must not specify post_vars for request method %r' % method)
wsgi_environ = create_wsgi_environ('http://%s%s' %
(server_name, request_uri),
method.upper(),
request_body=post_vars)
wsgi_environ['paste.registry'] = paste_registry
request = Request(wsgi_environ, charset='utf-8')
request.language = language
request.settings = app_globals.settings
register_instance(paste_registry, 'request', request)
response = Response(content_type='application/xml', charset='utf-8')
register_instance(paste_registry, 'response', response)
setup_session(paste_registry, if_not_registered=True)
routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
register_instance(paste_registry, 'url', routes_url)
# Use ContextObj() when we get rid of 'pylons.strict_tmpl_context=False' in
# mediadrop.lib.environment
tmpl_context = AttribSafeContextObj()
tmpl_context.paginators = Bunch()
register_instance(paste_registry, 'tmpl_context', tmpl_context)
# some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
# use the '.c' alias instead.
pylons.c = pylons.tmpl_context
register_instance(paste_registry, 'c', tmpl_context)
engines = create_tw_engine_manager(app_globals)
host_framework = PylonsHostFramework(engines=engines)
paste_registry.register(tw.framework, host_framework)
setup_translator(language=language,
registry=paste_registry,
locale_dirs=pylons_config.get('locale_dirs'))
wsgi_environ.update({
'pylons.pylons': pylons,
'paste.registry': paste_registry,
'routes.url': routes_url,
})
return request
def __init__(self, *args, **kwargs):
wsgiapp = loadapp('config:test.ini', relative_to=conf_dir)
config = wsgiapp.config
pylons.app_globals._push_object(config['pylons.app_globals'])
pylons.config._push_object(config)
# Initialize a translator for tests that utilize i18n
translator = _get_translator(pylons.config.get('lang'))
pylons.translator._push_object(translator)
url._push_object(URLGenerator(config['routes.map'], environ))
self.app = TestApp(wsgiapp)
TestCase.__init__(self, *args, **kwargs)
def __call__(self, environ, start_response):
"""Called by WSGI when a request comes in."""
url = URLGenerator(self.mapper, environ)
environ['routes.url'] = url
request = Request(environ)
response = Response()
WSGIApplication.active_instance = self
# Match the path against registered routes.
kargs = self.mapper.match(request.path)
if kargs is None:
raise TypeError(
'No routes match. Provide a fallback to avoid this.')
# Extract the module and controller names from the route.
try:
module_name, class_name = kargs['controller'].split(':', 1)
del kargs['controller']
except:
raise TypeError(
'Controller is not set, or not formatted in the form "my.module.name:MyControllerName".'
)
# Initialize matched controller from given module.
try:
__import__(module_name)
module = sys.modules[module_name]
controller = getattr(module, class_name)()
controller.initialize(request, response)
except:
raise ImportError(
'Controller %s from module %s could not be initialized.' %
(class_name, module_name))
# Use the action set in the route, or the HTTP method.
if 'action' in kargs:
action = kargs['action']
del kargs['action']
else:
action = environ['REQUEST_METHOD'].lower()
if action not in [
'get', 'post', 'head', 'options', 'put', 'delete', 'trace'
]:
action = None
if controller and action:
try:
# Execute the requested action, passing the route dictionary as
# named parameters.
getattr(controller, action)(**kargs)
except Exception, e:
controller.handle_exception(e, self.__debug)
response.wsgi_write(start_response)
return ['']
def _init_stack(config=None, environ=None):
if not config:
config = pylons.test.pylonsapp.config
if not environ:
environ = {}
pylons.url._push_object(URLGenerator(config['routes.map'], environ or {}))
pylons.app_globals._push_object(config['pylons.app_globals'])
pylons.config._push_object(config)
pylons.tmpl_context._push_object(ContextObj())
# Initialize a translator for tests that utilize i18n
translator = _get_translator(pylons.config.get('lang'))
pylons.translator._push_object(translator)
pylons.session._push_object(SessionObject(environ or {}))
pylons.request._push_object(webob.Request.blank('', environ=environ))
def __init__(self, *args, **kwargs):
wsgiapp = pylons.test.pylonsapp
config = wsgiapp.config
self.app = OptionsTestApp(wsgiapp)
url._push_object(URLGenerator(config['routes.map'], environ))
TestCase.__init__(self, *args, **kwargs)
self.from_date = datetime(1990, 1, 1).isoformat() + "Z"
self.controllerName = None
def get_wsgiapp():
return wsgiapp
wsgi_intercept.add_wsgi_intercept('localhost', 80, get_wsgiapp)
wsgi_intercept.add_wsgi_intercept('127.0.0.1', 80, get_wsgiapp)
def fake_request(pylons_config,
server_name='mediacore.example',
language='en',
method='GET',
request_uri='/',
post_vars=None):
app_globals = pylons_config['pylons.app_globals']
pylons.app_globals._push_object(app_globals)
if post_vars and method.upper() != 'POST':
raise ValueError(
'You must not specify post_vars for request method %r' % method)
wsgi_environ = create_wsgi_environ('http://%s%s' %
(server_name, request_uri),
method.upper(),
request_body=post_vars)
request = Request(wsgi_environ, charset='utf-8')
request.language = language
request.settings = app_globals.settings
pylons.request._push_object(request)
response = Response(content_type='application/xml', charset='utf-8')
pylons.response._push_object(response)
session = SessionObject(wsgi_environ)
pylons.session._push_object(session)
routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
pylons.url._push_object(routes_url)
# Use ContextObj() when we get rid of 'pylons.strict_tmpl_context=False' in
# mediacore.lib.environment
tmpl_context = AttribSafeContextObj()
tmpl_context.paginators = Bunch()
pylons.tmpl_context._push_object(tmpl_context)
# some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
# use the '.c' alias instead.
pylons.c = pylons.tmpl_context
paste_registry = Registry()
paste_registry.prepare()
engines = create_tw_engine_manager(app_globals)
host_framework = PylonsHostFramework(engines=engines)
paste_registry.register(tw.framework, host_framework)
setup_translator(language=language, registry=paste_registry)
wsgi_environ.update({
'pylons.pylons': pylons,
'paste.registry': paste_registry,
})
return request
def __init__(self, *args, **kwargs):
'''
initialize the test class
'''
wsgiapp = pylons.test.pylonsapp
self.app = webtest.TestApp(wsgiapp)
self.session = 'justatest'
self.resolvers = {} # Set up in create_common_resolvers
url._push_object(URLGenerator(config['routes.map'], environ))
unittest2.TestCase.__init__(self, *args, **kwargs)
self.appconf = config
def fake_request(pylons_config, server_name='mediadrop.example', language='en',
method='GET', request_uri='/', post_vars=None):
app_globals = pylons_config['pylons.app_globals']
pylons.app_globals._push_object(app_globals)
if post_vars and method.upper() != 'POST':
raise ValueError('You must not specify post_vars for request method %r' % method)
wsgi_environ = create_wsgi_environ('http://%s%s' % (server_name, request_uri),
method.upper(), request_body=post_vars)
request = Request(wsgi_environ, charset='utf-8')
request.language = language
request.settings = app_globals.settings
pylons.request._push_object(request)
response = Response(content_type='application/xml', charset='utf-8')
pylons.response._push_object(response)
session = SessionObject(wsgi_environ)
pylons.session._push_object(session)
routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
pylons.url._push_object(routes_url)
# TODO: Use ContextObj() for Pylons 0.10
tmpl_context = AttribSafeContextObj()
tmpl_context.paginators = Bunch()
pylons.tmpl_context._push_object(tmpl_context)
# some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
# use the '.c' alias instead.
pylons.c = pylons.tmpl_context
paste_registry = Registry()
paste_registry.prepare()
engines = create_tw_engine_manager(app_globals)
host_framework = PylonsHostFramework(engines=engines)
paste_registry.register(tw.framework, host_framework)
mediacore_i18n_path = os.path.join(os.path.dirname(mediacore.__file__), 'i18n')
translator = Translator(language, dict(mediacore=mediacore_i18n_path))
# not sure why but sometimes pylons.translator is not a StackedObjectProxy
# but just a regular Translator.
if not hasattr(pylons.translator, '_push_object'):
pylons.translator = StackedObjectProxy()
paste_registry.replace(pylons.translator, translator)
wsgi_environ.update({
'pylons.pylons': pylons,
'paste.registry': paste_registry,
})
return request
def _inject_url_generator_for_request(self, request):
url_mapper = add_routes(create_mapper(self.pylons_config))
url_generator = URLGenerator(url_mapper, request.environ)
match = re.search('^.*?/([^/]+)(?:/([^/]+))?$', request.environ['PATH_INFO'])
controller = match.group(1)
action = match.group(2) or 'index'
request.environ.update({
'routes.url': url_generator,
'wsgiorg.routing_args': (
url_generator,
dict(controller=controller, action=action),
)
})
return url_generator
def __call__(self, req):
match = self._match(req)
if not match:
return webob.exc.HTTPNotFound()
req.urlvars = match
link = URLGenerator(self.mapper, req.environ)
data = None
name = match['controller'].__name__
if name in self.registory:
data = self.registory[name]
controller = match['controller'](req, link, data, **self.config)
return controller(req)
def __init__(self, *args, **kwargs):
super(TestController2, self).__init__(*args, **kwargs)
# In case we detach controller from previous standard version,
# we need to implement (at least for short amount of time)
# support for Pylons and WebTest.
import webtest
import pylons.test
from routes.util import URLGenerator
environ = {}
wsgiapp = pylons.test.pylonsapp
config = pylons.test.pylonsapp.config
self.app = webtest.TestApp(wsgiapp, environ)
self.session = 'justatest'
#self.appconf = config
# Configure url ...
url._push_object(URLGenerator(config['routes.map'], environ))
# -------------------------------------------------------------- --
current_webtest = LooseVersion(
pkg_resources.get_distribution('webtest').version)
if current_webtest <= LooseVersion('2.0.14'):
# Fix application cookies for localhost for webtest versions
# 2.0.0 to 2.0.14 (https://github.com/Pylons/webtest/issues/84)
# The CookiePolicy code is taken from webtest
class CookiePolicy(cookielib.DefaultCookiePolicy):
"""A subclass of DefaultCookiePolicy to allow cookie set
for Domain=localhost."""
def return_ok_domain(self, cookie, request):
if cookie.domain == '.localhost':
return True
return cookielib.DefaultCookiePolicy.return_ok_domain(
self, cookie, request)
def set_ok_domain(self, cookie, request):
if cookie.domain == '.localhost':
return True
return cookielib.DefaultCookiePolicy.set_ok_domain(
self, cookie, request)
self.app.cookiejar = cookielib.CookieJar(policy=CookiePolicy())
def __call__(self, req, start_response):
match = self._match(req)
print "Here 4"
if not match:
return webob.exc.HTTPNotFound()
req.start_response = start_response
req.urlvars = match
link = URLGenerator(self.mapper, req.environ)
data = None
name = match['controller'].__name__
if name in self.registory:
data = self.registory[name]
controller = match['controller'](req, link, data, **self.config)
controller.parent = self
return controller(req)
