def test_single_route_one_view_registered(self):
from zope.interface import Interface
from pyramid.registry import Registry
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
registry = Registry()
def view():
pass
class IMyRoute(Interface):
pass
registry.registerAdapter(view, (IViewClassifier, IMyRoute, Interface), IView, "")
registry.registerUtility(IMyRoute, IRouteRequest, name="a")
command = self._makeOne()
route = DummyRoute("a", "/a")
mapper = DummyMapper(route)
command._get_mapper = lambda *arg: mapper
L = []
command.out = L.append
app = DummyApp()
app.registry = registry
loadapp = DummyLoadApp(app)
command.loadapp = (loadapp,)
command.args = ("/foo/bar/myapp.ini", "myapp")
result = command.command()
self.assertEqual(result, None)
self.assertEqual(len(L), 3)
self.assertEqual(L[-1].split()[:4], ["a", "/a", "<function", "view"])
def test_single_route_one_view_registered_with_factory(self):
from zope.interface import Interface
from pyramid.registry import Registry
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
registry = Registry()
def view():pass
class IMyRoot(Interface):
pass
class IMyRoute(Interface):
pass
registry.registerAdapter(view,
(IViewClassifier, IMyRoute, IMyRoot),
IView, '')
registry.registerUtility(IMyRoute, IRouteRequest, name='a')
command = self._makeOne()
def factory(request): pass
route = dummy.DummyRoute('a', '/a', factory=factory)
mapper = dummy.DummyMapper(route)
command._get_mapper = lambda *arg: mapper
L = []
command.out = L.append
command.bootstrap = (dummy.DummyBootstrap(registry=registry),)
result = command.run()
self.assertEqual(result, None)
self.assertEqual(len(L), 3)
self.assertEqual(L[-1].split()[:3], ['a', '/a', '<unknown>'])
def test__find_view_route_multiview_no_view_registered(self):
from zope.interface import Interface
from zope.interface import implementer
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IMultiView
from pyramid.interfaces import IRootFactory
from pyramid.registry import Registry
registry = Registry()
def view1():pass
def view2():pass
class IMyRoot(Interface):
pass
class IMyRoute1(Interface):
pass
class IMyRoute2(Interface):
pass
registry.registerUtility(IMyRoute1, IRouteRequest, name='a')
registry.registerUtility(IMyRoute2, IRouteRequest, name='b')
@implementer(IMyRoot)
class Factory(object):
def __init__(self, request):
pass
registry.registerUtility(Factory, IRootFactory)
routes = [dummy.DummyRoute('a', '/a', matchdict={}),
dummy.DummyRoute('b', '/a', matchdict={})]
self._register_mapper(registry, routes)
command = self._makeOne(registry=registry)
result = command._find_view('/a', registry)
self.assertTrue(IMultiView.providedBy(result))
def setUp(self):
self.__request = DummyRequest()
# Must set hook_zca to false to work with uniittest_with_sqlite
reg = Registry()
reg.settings = {}
reg.settings['disable.context.security'] = 'False'
self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False)
def test__find_view_route_no_multiview(self):
from zope.interface import Interface
from zope.interface import implementer
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
from pyramid.registry import Registry
registry = Registry()
def view():pass
class IMyRoot(Interface):
pass
class IMyRoute(Interface):
pass
registry.registerAdapter(view,
(IViewClassifier, IMyRoute, IMyRoot),
IView, '')
registry.registerUtility(IMyRoute, IRouteRequest, name='a')
@implementer(IMyRoot)
class Factory(object):
def __init__(self, request):
pass
routes = [dummy.DummyRoute('a', '/a', factory=Factory, matchdict={}),
dummy.DummyRoute('b', '/b', factory=Factory)]
self._register_mapper(registry, routes)
command = self._makeOne(registry=registry)
result = command._find_view('/a', registry)
self.assertEqual(result, view)
def setUp(self):
self.__request = DummyRequest()
self.__request.matchdict['registration_id'] = 'a1-b2-c3-d4-e5'
self.__request.headers['File-Name'] = 'dummy.zip'
reg = Registry()
reg.settings = {'hpz.frs.upload_base_path': '/dev/null', 'hpz.frs.file_size_limit': '1024'}
self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False)
def test_single_route_one_view_registered(self):
from zope.interface import Interface
from pyramid.registry import Registry
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
registry = Registry()
def view():pass
class IMyRoute(Interface):
pass
registry.registerAdapter(view,
(IViewClassifier, IMyRoute, Interface),
IView, '')
registry.registerUtility(IMyRoute, IRouteRequest, name='a')
command = self._makeOne()
route = dummy.DummyRoute('a', '/a')
mapper = dummy.DummyMapper(route)
command._get_mapper = lambda *arg: mapper
L = []
command.out = L.append
command.bootstrap = (dummy.DummyBootstrap(registry=registry),)
result = command.run()
self.assertEqual(result, 0)
self.assertEqual(len(L), 3)
compare_to = L[-1].split()[:3]
self.assertEqual(
compare_to,
['a', '/a', 'pyramid.tests.test_scripts.test_proutes.view']
)
def setUp(self):
cache_opts = {
'cache.type': 'memory',
'cache.regions': 'public.data,public.filtered_data,public.shortlived'
}
CacheManager(**parse_cache_config_options(cache_opts))
self.__request = DummyRequest()
# Must set hook_zca to false to work with uniittest_with_sqlite
reg = Registry()
reg.settings = {}
reg.settings = {'extract.available_grades': '3,4,5,6,7,8,9,11',
'hpz.file_upload_base_url': 'http://somehost:82/files',
'extract.raw_data_base_dir': '/opt/edware/raw_data'}
self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False)
self.__tenant_name = get_unittest_tenant_name()
defined_roles = [(Allow, RolesConstants.AUDIT_XML_EXTRACTS, ('view', 'logout'))]
edauth.set_roles(defined_roles)
set_tenant_map({get_unittest_tenant_name(): 'NC'})
# Set up context security
dummy_session = create_test_session([RolesConstants.AUDIT_XML_EXTRACTS])
self.__config.testing_securitypolicy(dummy_session.get_user())
# celery settings for UT
settings = {'extract.celery.CELERY_ALWAYS_EAGER': True}
setup_celery(settings)
# for UT purposes
smarter.extracts.format.json_column_mapping = {}
set_tenant_map({'tomcat': 'NC'})
def test__find_view_traversal_multiview(self):
from zope.interface import implementer
from zope.interface import providedBy
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IMultiView
from pyramid.traversal import DefaultRootFactory
from pyramid.registry import Registry
registry = Registry()
@implementer(IMultiView)
class View1(object):
pass
request = dummy.DummyRequest()
request.path_info = '/a'
root = DefaultRootFactory(request)
root_iface = providedBy(root)
view = View1()
registry.registerAdapter(
view, (IViewClassifier, IRequest, root_iface), IMultiView, name='a'
)
self._register_mapper(registry, [])
command = self._makeOne(registry=registry)
request = self._makeRequest('/a', registry)
result = command._find_view(request)
self.assertEqual(result, view)
def setUp(self):
self.__workspace = tempfile.mkdtemp()
self.__staging = tempfile.mkdtemp()
# setup request
self.__request = DummyRequest()
self.__request.method = 'POST'
# setup settings
# use the one for UDL
here = os.path.abspath(os.path.dirname(__file__))
self.gpg_home = os.path.abspath(os.path.join(here, '..', '..', '..', '..', 'config', 'gpg'))
self.settings = {
'smarter_score_batcher.gpg.keyserver': None,
'smarter_score_batcher.gpg.homedir': self.gpg_home,
'smarter_score_batcher.gpg.public_key.ca': '*****@*****.**',
'smarter_score_batcher.gpg.public_key.cat': '*****@*****.**',
'smarter_score_batcher.gpg.public_key.fish': '*****@*****.**',
'smarter_score_batcher.gpg.path': 'gpg',
'smarter_score_batcher.base_dir.working': self.__workspace,
'smarter_score_batcher.base_dir.staging': self.__staging
}
# setup registr
reg = Registry()
reg.settings = self.settings
self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False)
self._prepare_testing_files()
def _makeRequest(self, **kwargs):
""":rtype: pyramid.request.Request"""
from pyramid.registry import Registry
registry = Registry()
registry.settings = {'app.timezone': 'Asia/Bangkok'}
testing.setUp(registry=registry)
return testing.DummyRequest(**kwargs)
def test_single_route_one_view_registered_with_factory(self):
from zope.interface import Interface
from pyramid.registry import Registry
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
registry = Registry()
def view():pass
class IMyRoot(Interface):
pass
class IMyRoute(Interface):
pass
registry.registerAdapter(view,
(IViewClassifier, IMyRoute, IMyRoot),
IView, '')
registry.registerUtility(IMyRoute, IRouteRequest, name='a')
command = self._makeOne()
def factory(request): pass
route = DummyRoute('a', '/a', factory=factory)
mapper = DummyMapper(route)
command._get_mapper = lambda *arg: mapper
L = []
command.out = L.append
app = DummyApp()
app.registry = registry
loadapp = DummyLoadApp(app)
command.loadapp = (loadapp,)
command.args = ('/foo/bar/myapp.ini', 'myapp')
result = command.command()
self.assertEqual(result, None)
self.assertEqual(len(L), 3)
self.assertEqual(L[-1].split()[:3], ['a', '/a', '<unknown>'])
def setUp(self):
reg = Registry()
reg.settings = {'store_type':'rdflib',
'debug_sparql':True}
self.config = testing.setUp(reg)
self.config.add_settings({'mako.directories':'plingback.sparql:templates'})
self.config.add_renderer(None, mako_renderer_factory)
self.config.begin()
def get_registry(settings):
registry = Registry('testing')
config = Configurator(registry=registry)
if getattr(registry, 'settings', None) is None:
config._set_settings(settings)
registry.registerUtility(RoutesMapper(), IRoutesMapper)
config.commit()
return registry
def test_dn_with_one_base_element(self):
reg = Registry()
reg.settings = {}
reg.settings['ldap.base.dn'] = 'ou=dummy'
self.__config = testing.setUp(registry=reg, request=DummyRequest(), hook_zca=False)
attributes = {'dn': ['ou=dummyOrg,ou=dummy']}
tenant = BasicIdentityParser.get_tenant_name(attributes)
self.assertEqual(tenant[0], 'dummyorg')
def test_add_settings_settings_None(self):
from pyramid.registry import Registry
from pyramid.interfaces import ISettings
reg = Registry()
config = self._makeOne(reg)
config.add_settings(None, a=1)
settings = reg.getUtility(ISettings)
self.assertEqual(settings['a'], 1)
def setUp(self):
reg = Registry()
reg.settings = {}
reg.settings['session.backend.type'] = 'beaker'
reg.settings['cache.expire'] = 10
reg.settings['cache.regions'] = 'session'
reg.settings['cache.type'] = 'memory'
reg.settings['batch.user.session.timeout'] = 15
component.provideUtility(SessionBackend(reg.settings), ISessionBackend)
def test_setup_registry_debug_logger_None_default(self):
from pyramid.registry import Registry
from pyramid.interfaces import IDebugLogger
reg = Registry()
config = self._makeOne(reg)
config.setup_registry()
logger = reg.getUtility(IDebugLogger)
self.assertEqual(logger.name, 'tests.test_config')
def test_setup_registry_no_default_root_factory(self):
from pyramid.registry import Registry
from pyramid.interfaces import IRootFactory
reg = Registry()
config = self._makeOne(reg)
config.setup_registry()
config.commit()
self.assertEqual(reg.queryUtility(IRootFactory), None)
def _set_local_roles(resource, new_local_roles: dict, registry: Registry):
old_local_roles = getattr(resource, '__local_roles__', None)
if new_local_roles == old_local_roles:
return
else:
resource.__local_roles__ = new_local_roles
event = LocalRolesModified(resource, new_local_roles, old_local_roles,
registry)
registry.notify(event)
def test_setup_registry_default_permission(self):
from pyramid.registry import Registry
from pyramid.interfaces import IDefaultPermission
reg = Registry()
config = self._makeOne(reg)
config.setup_registry(default_permission='view')
config.commit()
self.assertEqual(reg.getUtility(IDefaultPermission), 'view')
def test_setup_registry_debug_logger_name(self):
from pyramid.registry import Registry
from pyramid.interfaces import IDebugLogger
reg = Registry()
config = self._makeOne(reg)
config.setup_registry(debug_logger='foo')
result = reg.getUtility(IDebugLogger)
self.assertEqual(result.name, 'foo')
def test_add_settings_settings_not_yet_registered(self):
from pyramid.registry import Registry
from pyramid.interfaces import ISettings
reg = Registry()
config = self._makeOne(reg)
config.add_settings({"a": 1})
settings = reg.getUtility(ISettings)
self.assertEqual(settings["a"], 1)
def _makeRegistry(self, **kw):
""":rtype: pyramid.registry.Registry"""
from pyramid.registry import Registry
registry = Registry()
registry.settings = {
'app.timezone': 'Asia/Bangkok',
'app.secret': 'demo',
}
registry.settings.update(kw)
return registry
def send_back_reference_removal_notificatons(self,
references: [Reference],
registry: Registry):
"""Send SheetBackReferenceRemoved to reference targets."""
for reference in references:
event = SheetBackReferenceRemoved(reference.target,
reference.isheet,
reference,
registry)
registry.notify(event)
def test_setup_registry_debug_logger_non_None(self):
from pyramid.registry import Registry
from pyramid.interfaces import IDebugLogger
logger = object()
reg = Registry()
config = self._makeOne(reg)
config.setup_registry(debug_logger=logger)
result = reg.getUtility(IDebugLogger)
self.assertEqual(logger, result)
def test_setup_registry_alternate_renderers(self):
from pyramid.registry import Registry
from pyramid.interfaces import IRendererFactory
renderer = object()
reg = Registry()
config = self._makeOne(reg)
config.setup_registry(renderers=[('yeah', renderer)])
config.commit()
self.assertEqual(reg.getUtility(IRendererFactory, 'yeah'), renderer)
def setUp(self):
self.__request = DummyRequest()
# Must set hook_zca to false to work with uniittest_with_sqlite
reg = Registry()
reg.settings = {}
reg.settings['cache.expire'] = 10
reg.settings['cache.regions'] = 'session'
reg.settings['cache.type'] = 'memory'
reg.settings['batch.user.session.timeout'] = 15
component.provideUtility(SessionBackend(reg.settings), ISessionBackend)
self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False)
def setUp(self):
registry = Registry()
registry.settings = settings
self.config = testing.setUp(registry=registry)
# setup db
DBSession.configure(bind=engine)
Base.metadata.bind = engine
Base.metadata.drop_all()
Base.metadata.create_all()
# setup request
self.request = testing.DummyRequest()
def test_setup_registry_authentication_policy(self):
from pyramid.registry import Registry
from pyramid.interfaces import IAuthenticationPolicy
policy = object()
reg = Registry()
config = self._makeOne(reg)
config.setup_registry(authentication_policy=policy)
config.commit()
result = reg.getUtility(IAuthenticationPolicy)
self.assertEqual(policy, result)
def test_single_route_one_view_registered_with_factory(self):
from zope.interface import Interface
from pyramid.registry import Registry
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
registry = Registry()
def view():pass
class IMyRoot(Interface):
pass
class IMyRoute(Interface):
pass
registry.registerAdapter(view,
(IViewClassifier, IMyRoute, IMyRoot),
IView, '')
registry.registerUtility(IMyRoute, IRouteRequest, name='a')
command = self._makeOne()
def factory(request): pass
route = DummyRoute('a', '/a', factory=factory)
mapper = DummyMapper(route)
command._get_mapper = lambda *arg: mapper
L = []
command.out = L.append
command.bootstrap = (DummyBootstrap(registry=registry),)
result = command.command()
self.assertEqual(result, None)
self.assertEqual(len(L), 3)
self.assertEqual(L[-1].split()[:3], ['a', '/a', '<unknown>'])
def test__find_view_route_no_multiview(self):
from zope.interface import Interface
from zope.interface import implements
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
from pyramid.registry import Registry
registry = Registry()
def view():pass
class IMyRoot(Interface):
pass
class IMyRoute(Interface):
pass
registry.registerAdapter(view,
(IViewClassifier, IMyRoute, IMyRoot),
IView, '')
registry.registerUtility(IMyRoute, IRouteRequest, name='a')
class Factory(object):
implements(IMyRoot)
def __init__(self, request):
pass
routes = [DummyRoute('a', '/a', factory=Factory, matchdict={}),
DummyRoute('b', '/b', factory=Factory)]
self._register_mapper(registry, routes)
command = self._makeOne(registry=registry)
result = command._find_view('/a', registry)
self.assertEqual(result, view)
def test_single_route_one_view_registered(self):
from zope.interface import Interface
from pyramid.registry import Registry
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
registry = Registry()
def view():
pass
class IMyRoute(Interface):
pass
registry.registerAdapter(view, (IViewClassifier, IMyRoute, Interface),
IView, '')
registry.registerUtility(IMyRoute, IRouteRequest, name='a')
command = self._makeOne()
route = dummy.DummyRoute('a', '/a')
mapper = dummy.DummyMapper(route)
command._get_mapper = lambda *arg: mapper
L = []
command.out = L.append
command.bootstrap = (dummy.DummyBootstrap(registry=registry), )
result = command.run()
self.assertEqual(result, 0)
self.assertEqual(len(L), 3)
self.assertEqual(L[-1].split()[:4], ['a', '/a', '<function', 'view'])
def test__find_view_route_multiview(self):
from zope.interface import Interface
from zope.interface import implements
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
from pyramid.interfaces import IMultiView
from pyramid.interfaces import IRootFactory
from pyramid.registry import Registry
registry = Registry()
def view1():pass
def view2():pass
class IMyRoot(Interface):
pass
class IMyRoute1(Interface):
pass
class IMyRoute2(Interface):
pass
registry.registerAdapter(view1,
(IViewClassifier, IMyRoute1, IMyRoot),
IView, '')
registry.registerAdapter(view2,
(IViewClassifier, IMyRoute2, IMyRoot),
IView, '')
registry.registerUtility(IMyRoute1, IRouteRequest, name='a')
registry.registerUtility(IMyRoute2, IRouteRequest, name='b')
class Factory(object):
implements(IMyRoot)
def __init__(self, request):
pass
registry.registerUtility(Factory, IRootFactory)
routes = [DummyRoute('a', '/a', matchdict={}),
DummyRoute('b', '/a', matchdict={})]
self._register_mapper(registry, routes)
command = self._makeOne(registry=registry)
result = command._find_view('/a', registry)
self.assertTrue(IMultiView.providedBy(result))
self.assertEqual(len(result.views), 2)
self.assertTrue((None, view1, None) in result.views)
self.assertTrue((None, view2, None) in result.views)
def test__find_view_route_multiview_no_view_registered(self):
from zope.interface import Interface
from zope.interface import implementer
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IMultiView
from pyramid.interfaces import IRootFactory
from pyramid.registry import Registry
registry = Registry()
def view1():pass
def view2():pass
class IMyRoot(Interface):
pass
class IMyRoute1(Interface):
pass
class IMyRoute2(Interface):
pass
registry.registerUtility(IMyRoute1, IRouteRequest, name='a')
registry.registerUtility(IMyRoute2, IRouteRequest, name='b')
@implementer(IMyRoot)
class Factory(object):
def __init__(self, request):
pass
registry.registerUtility(Factory, IRootFactory)
routes = [dummy.DummyRoute('a', '/a', matchdict={}),
dummy.DummyRoute('b', '/a', matchdict={})]
self._register_mapper(registry, routes)
command = self._makeOne(registry=registry)
result = command._find_view('/a', registry)
self.assertTrue(IMultiView.providedBy(result))
def test_single_route_one_view_registered(self):
from zope.interface import Interface
from pyramid.registry import Registry
from pyramid.interfaces import IRouteRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
registry = Registry()
def view():
pass
class IMyRoute(Interface):
pass
registry.registerAdapter(view, (IViewClassifier, IMyRoute, Interface),
IView, '')
registry.registerUtility(IMyRoute, IRouteRequest, name='a')
command = self._makeOne()
route = DummyRoute('a', '/a')
mapper = DummyMapper(route)
command._get_mapper = lambda *arg: mapper
L = []
command.out = L.append
app = DummyApp()
app.registry = registry
loadapp = DummyLoadApp(app)
command.loadapp = (loadapp, )
command.args = ('/foo/bar/myapp.ini', 'myapp')
result = command.command()
self.assertEqual(result, None)
self.assertEqual(len(L), 3)
self.assertEqual(L[-1].split()[:4], ['a', '/a', '<function', 'view'])
def __init__(self,
registry=None,
package=None,
settings=None,
root_factory=None,
authentication_policy=None,
authorization_policy=None,
renderers=None,
debug_logger=None,
locale_negotiator=None,
request_factory=None,
response_factory=None,
default_permission=None,
session_factory=None,
default_view_mapper=None,
autocommit=False,
exceptionresponse_view=default_exceptionresponse_view,
route_prefix=None,
introspection=True,
root_package=None,
):
if package is None:
package = caller_package()
if root_package is None:
root_package = package
name_resolver = DottedNameResolver(package)
self.name_resolver = name_resolver
self.package_name = name_resolver.get_package_name()
self.package = name_resolver.get_package()
self.root_package = root_package
self.registry = registry
self.autocommit = autocommit
self.route_prefix = route_prefix
self.introspection = introspection
if registry is None:
registry = Registry(self.package_name)
self.registry = registry
self.setup_registry(
settings=settings,
root_factory=root_factory,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy,
renderers=renderers,
debug_logger=debug_logger,
locale_negotiator=locale_negotiator,
request_factory=request_factory,
response_factory=response_factory,
default_permission=default_permission,
session_factory=session_factory,
default_view_mapper=default_view_mapper,
exceptionresponse_view=exceptionresponse_view,
)
def test__get_mapper(self):
from pyramid.registry import Registry
from pyramid.urldispatch import RoutesMapper
command = self._makeOne()
registry = Registry()
class App:
pass
app = App()
app.registry = registry
result = command._get_mapper(app)
self.assertEqual(result.__class__, RoutesMapper)
def test_includeme_use_celeryconfig():
from pyramid_celery import includeme
from pyramid_celery import celery_app
from pyramid import testing
from pyramid.registry import Registry
config = testing.setUp()
config.registry = Registry()
config.registry.settings = {}
includeme(config)
config.configure_celery('tests/configs/useceleryconfig.ini')
assert celery_app.conf['broker_url'] == 'redis://localhost:1337/0'
def get_social_login_mapper(registry: Registry,
provider_id: str) -> ISocialLoginMapper:
"""Get a named social login mapper.
Example::
get_social_login_mapper(registry, "facebook")
:param registry: Pyramid registry.
:param provider_id: Provider id of a social login mapper.
:return: Implementation of ISocialLoginMapper.
"""
return registry.queryUtility(ISocialLoginMapper, name=provider_id)
def test_registry_is_config_registry_when_setup_is_called_after_ctor(self):
# see https://github.com/Pylons/pyramid/issues/165
from pyramid.registry import Registry
from pyramid.config import Configurator
request = self._makeOne()
try:
registry = Registry('this_test')
config = Configurator(registry=registry)
config.begin()
self.assertTrue(request.registry is registry)
finally:
config.end()
def test__find_view_traversal_multiview(self):
from zope.interface import implements
from zope.interface import providedBy
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IMultiView
from pyramid.traversal import DefaultRootFactory
from pyramid.registry import Registry
registry = Registry()
class View1(object):
implements(IMultiView)
request = DummyRequest({'PATH_INFO':'/a'})
root = DefaultRootFactory(request)
root_iface = providedBy(root)
view = View1()
registry.registerAdapter(view,
(IViewClassifier, IRequest, root_iface),
IMultiView, name='a')
self._register_mapper(registry, [])
command = self._makeOne(registry=registry)
result = command._find_view('/a', registry)
self.assertEqual(result, view)
def test_views_command_not_found_url_starts_without_slash(self):
from pyramid.registry import Registry
registry = Registry()
command = self._makeOne(registry=registry)
L = []
command.out = L.append
command._find_view = lambda arg1: None
command.args.config_uri = '/foo/bar/myapp.ini#myapp'
command.args.url = 'a'
result = command.run()
self.assertEqual(result, 0)
self.assertEqual(L[1], 'URL = /a')
self.assertEqual(L[3], ' Not found.')
def test_setup_registry_includes_spaces(self):
from pyramid.registry import Registry
reg = Registry()
config = self._makeOne(reg)
settings = {
'pyramid.includes':
"""tests.test_config.dummy_include tests.\
test_config.dummy_include2"""
}
config.setup_registry(settings=settings)
self.assertTrue(reg.included)
self.assertTrue(reg.also_included)
def get_input_widget(
registry: Registry,
node: ColanderNode,
node_type: Optional[colander.SchemaType] = None,
) -> Optional[InputWidget]:
node_type = node_type or node.typ
converter: Optional[InputConverter] = registry.queryAdapter(
node_type, interfaces.ISchemaNodeToInputWidget)
if converter:
widget = converter(registry, node, node_type)
if widget:
widget = _try_convert_to_select_input(registry, widget, node)
return widget
def setUp(self):
# delete all user_session before test
mappings = {('Allow', 'TEACHER', ('view', 'logout', 'default')),
('Allow', 'SYSTEM_ADMINISTRATOR', ('view', 'logout')),
('Allow', 'DATA_LOADER', ('view', 'logout')),
('Allow', 'NONE', ('logout'))}
Roles.set_roles(mappings)
set_tenant_map({get_unittest_tenant_name(): 'NC'})
self.__request = DummyRequest()
reg = Registry()
reg.settings = {}
reg.settings['session.backend.type'] = 'beaker'
reg.settings['cache.expire'] = 10
reg.settings['cache.regions'] = 'session'
reg.settings['cache.type'] = 'memory'
reg.settings['ldap.base.dn'] = 'ou=environment,dc=edwdc,dc=net'
reg.settings['batch.user.session.timeout'] = 15
component.provideUtility(SessionBackend(reg.settings), ISessionBackend)
# Must set hook_zca to false to work with uniittest_with_sqlite
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
def test__find_view_no_match_multiview_registered(self):
from zope.interface import implementer
from zope.interface import providedBy
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IMultiView
from pyramid.traversal import DefaultRootFactory
from pyramid.registry import Registry
registry = Registry()
@implementer(IMultiView)
class View1(object):
pass
request = dummy.DummyRequest({'PATH_INFO':'/a'})
root = DefaultRootFactory(request)
root_iface = providedBy(root)
registry.registerAdapter(View1(),
(IViewClassifier, IRequest, root_iface),
IMultiView)
self._register_mapper(registry, [])
command = self._makeOne(registry=registry)
result = command._find_view('/x', registry)
self.assertEqual(result, None)
def test_it_with_settings_passed_explicit_registry(self):
from zope.component import getSiteManager
from pyramid.threadlocal import manager
from pyramid.registry import Registry
registry = Registry()
try:
self._callFUT(registry=registry,
hook_zca=False,
settings=dict(a=1))
self.assertEqual(registry.settings['a'], 1)
finally:
getSiteManager.reset()
manager.clear()
def test_celery_imports():
from pyramid_celery import includeme, celery_app
from pyramid import testing
from pyramid.registry import Registry
config = testing.setUp()
config.registry = Registry()
config.registry.settings = {}
includeme(config)
config.configure_celery('tests/configs/imports.ini')
assert celery_app.conf['CELERY_IMPORTS'] == [
'myapp.tasks', 'otherapp.tasks'
]
def test_registration_valid_url(self, persist_patch):
reg = Registry()
reg.settings = {'hpz.frs.download_base_url': 'http://blah/download'}
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
persist_patch.return_value = None
self.__request.method = 'PUT'
self.__request.json_body = {'uid': '1234', 'email': '*****@*****.**'}
response = put_file_registration_service(None, self.__request)
self.assertEqual(response.status_code, 200)
response_json = json.loads(str(response.body, encoding='UTF-8'))
self.assertTrue('url' in response_json)
self.assertTrue('registration_id' in response_json)
registration_id = response_json['registration_id']
self.assertEqual('http://blah/files/' + registration_id,
response_json['url'])
def create_user(dbsession: Session,
registry: Registry,
email: str = EMAIL,
password: str = PASSWORD,
admin: bool = False) -> User:
"""A helper function to create normal and admin users for tests.
Example:
.. code-block:: python
import transaction
from websauna.tests.utils import create_user
def test_some_stuff(dbsession, registry):
with transaction.manager:
u = create_user(registry)
# Do stuff with new user
:param email: User's email address. If inot given use unit testing default.
:param password: Password as plain text. If not given use unit testing default.
:param admin: If True run :py:class:`websauna.system.user.usermixin.SiteCreator` login and set the user to admin group.
"""
user = User(email=email)
if password:
hasher = registry.getUtility(IPasswordHasher)
user.hashed_password = hasher.hash_password(password)
user.user_registration_source = "dummy"
dbsession.add(user)
dbsession.flush()
user.username = user.generate_username()
user.activated_at = now()
assert user.can_login()
# First user, make it admin
if admin:
site_creator = get_site_creator(registry)
site_creator.init_empty_site(dbsession, user)
return user
def test_push_no_renderer(dbsession: Session, user_id):
"""Create a new activity, but we do not have renderer for it yet."""
request = make_dummy_request(dbsession, Registry())
with transaction.manager:
u = dbsession.query(User).get(user_id)
# This will trigger email on transaction commit
a = create_activity(request, "demo_msg", {}, uuid4(), u)
channel = Email(request)
with pytest.raises(NoRendererRegistered):
channel.push_notification(a)
def test_setup_registry_tweens(self):
from pyramid.interfaces import ITweens
from pyramid.registry import Registry
reg = Registry()
config = self._makeOne(reg)
settings = {'pyramid.tweens': 'tests.test_config.dummy_tween_factory'}
config.setup_registry(settings=settings)
config.commit()
tweens = config.registry.getUtility(ITweens)
self.assertEqual(
tweens.explicit,
[('tests.test_config.dummy_tween_factory', dummy_tween_factory)],
)
def test_rest_view(self):
from arguxserver.views import MainViews
#request = testing.DummyRequest(params={'host':'a','items':'b'},path='/argux/rest/1.0/host/a')
r = request.Request.blank(path='/argux/rest/1.0/a/b')
r.registry = Registry()
r.registry.settings = {}
r.registry.settings['dao'] = dao.DAO()
r.matchdict = {
'host': 'localhost',
'item': 'NONE',
'action': 'details'
}
v = MainViews(r)
info = v.item_details()
def __init__(self, registry: Registry):
"""Create a new instance.
:param registry: used to retrieve and configure the mailer
"""
self.registry = registry
settings = registry.settings
self.use_mail_queue = asbool(
settings.get('adhocracy.use_mail_queue', False))
logger.debug('Messenger will use mail queue: %s', self.use_mail_queue)
self.abuse_handler_mail = settings.get('adhocracy.abuse_handler_mail')
self.site_name = settings.get('adhocracy.site_name', 'Adhocracy')
self.frontend_url = settings.get('adhocracy.frontend_url',
'http://localhost:6551')
self.mailer = registry.getUtility(IMailer)
def test_single_route_no_views_registered(self):
from zope.interface import Interface
from pyramid.registry import Registry
from pyramid.interfaces import IRouteRequest
registry = Registry()
def view():
pass
class IMyRoute(Interface):
pass
registry.registerUtility(IMyRoute, IRouteRequest, name='a')
command = self._makeOne()
route = dummy.DummyRoute('a', '/a')
mapper = dummy.DummyMapper(route)
command._get_mapper = lambda *arg: mapper
L = []
command.out = L.append
command.bootstrap = (dummy.DummyBootstrap(registry=registry), )
result = command.run()
self.assertEqual(result, None)
self.assertEqual(len(L), 3)
self.assertEqual(L[-1].split()[:3], ['a', '/a', 'None'])
def open_pyramid_request(
registry: Registry,
path='http://localhost') -> ContextManager[PyramidRequest]:
request_factory = registry.queryUtility(IRequestFactory, default=Request)
request: PyramidRequest = request_factory.blank(path)
request.registry = registry
apply_request_extensions(request)
get_pyramid_root(request)
context = RequestContext(request)
context.begin()
try:
yield request
finally:
request._process_finished_callbacks()
context.end()
def test_del_registry(self):
# see https://github.com/Pylons/pyramid/issues/165
from pyramid.registry import Registry
from pyramid.config import Configurator
request = self._makeOne()
request.registry = 'abc'
self.assertEqual(request.registry, 'abc')
del request.registry
try:
registry = Registry('this_test')
config = Configurator(registry=registry)
config.begin()
self.assertTrue(request.registry is registry)
finally:
config.end()
def test_include_me(self):
from pyramid.config import Configurator
from pyramid.registry import Registry
from pyramid.interfaces import ISessionFactory
from pyramid_nacl_session import includeme
settings = {"session.secret": self.default_secret}
reg = Registry()
config = Configurator(reg)
config.add_settings(settings)
config.include(includeme)
config.commit()
factory = self._makeOne()
self.assertIs(type(config.registry.getUtility(ISessionFactory)),
type(factory))
def setUp(self):
cache_opts = {
'cache.type': 'memory',
'cache.regions': 'public.shortlived'
}
CacheManager(**parse_cache_config_options(cache_opts))
self.__request = DummyRequest()
# Must set hook_zca to false to work with uniittest_with_sqlite
reg = Registry()
# Set up defined roles
self.__tenant_name = get_unittest_tenant_name()
set_tenant_map({self.__tenant_name: "NC"})
self.__temp_dir = tempfile.mkdtemp()
reg.settings = {}
reg.settings['pdf.report_base_dir'] = self.__temp_dir
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
defined_roles = [(Allow, RolesConstants.PII, ('view', 'logout'))]
edauth.set_roles(defined_roles)
# Set up context security
dummy_session = create_test_session([RolesConstants.PII])
dummy_session.set_user_context([
RoleRelation(RolesConstants.PII, self.__tenant_name, 'NC', '228',
'242'),
RoleRelation(RolesConstants.PII, self.__tenant_name, 'NC', '229',
'939')
])
self.__config.testing_securitypolicy(dummy_session.get_user())
# celery settings for UT
settings = {'services.celery.CELERY_ALWAYS_EAGER': True}
self.__request.matchdict[Constants.REPORT] = 'indivStudentReport.html'
self.__request.cookies = {'edware': '123'}
setup_celery(settings)
