def test_views_command_single_view_function_traversal(self):
from pyramid.registry import Registry
registry = Registry()
command = self._makeOne(registry=registry)
L = []
command.out = L.append
def view(): pass
view.__request_attrs__ = {'context': 'context', 'view_name': 'a'}
command._find_view = lambda arg1, arg2: view
command.args = ('/foo/bar/myapp.ini#myapp', '/a')
result = command.command()
self.assertEqual(result, None)
self.assertEqual(L[1], 'URL = /a')
self.assertEqual(L[3], ' context: context')
self.assertEqual(L[4], ' view name: a')
self.assertEqual(L[8], ' pyramid.tests.test_paster.view')
def setUp(self):
self.__request = DummyRequest()
reg = Registry()
reg.settings = {}
reg.settings['cache.expire'] = 10
reg.settings['cache.regions'] = 'session'
reg.settings['cache.type'] = 'memory'
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_tenant_map({get_unittest_tenant_name(): 'NC'})
# Set up context security
dummy_session = create_test_session([RolesConstants.PII])
self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self):
self.__tempfolder = tempfile.TemporaryDirectory()
# setup request
self.__request = DummyRequest()
self.__request.method = 'POST'
# setup registry
settings = {
'smarter_score_batcher.celery_timeout': 30,
'smarter_score_batcher.celery.celery_always_eager': True
}
reg = Registry()
reg.settings = settings
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
setup_celery(settings, db_connection=False)
def test_views_command_single_view_traversal(self):
from pyramid.registry import Registry
registry = Registry()
command = self._makeOne(registry=registry)
L = []
command.out = L.append
view = dummy.DummyView(context='context', view_name='a')
command._find_view = lambda arg1, arg2: view
command.args = ('/foo/bar/myapp.ini#myapp', '/a')
result = command.run()
self.assertEqual(result, 0)
self.assertEqual(L[1], 'URL = /a')
self.assertEqual(L[3], ' context: context')
self.assertEqual(L[4], ' view name: a')
self.assertEqual(L[8],
' pyramid.tests.test_scripts.dummy.DummyView')
def test_views_command_not_found_url_starts_without_slash(self):
from pyramid.registry import Registry
command = self._makeOne()
registry = Registry()
L = []
command.out = L.append
command._find_view = lambda arg1, arg2: None
app = DummyApp()
app.registry = registry
loadapp = DummyLoadApp(app)
command.loadapp = (loadapp, )
command.args = ('/foo/bar/myapp.ini', 'myapp', 'a')
result = command.command()
self.assertEqual(result, None)
self.assertEqual(L[1], 'URL = /a')
self.assertEqual(L[3], ' Not found.')
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_includeme_custom_config():
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/dev.ini')
assert celery_app.conf['broker_url'] == 'redis://localhost:1337/0'
assert celery_app.conf['timezone'] == 'America/Los_Angeles'
assert celery_app.conf['broker_transport_options'] == {
'visibility_timeout': 18000,
'max_retries': 5,
}
def test_setup_registry_authorization_policy_dottedname(self):
from pyramid.registry import Registry
from pyramid.interfaces import IAuthorizationPolicy
reg = Registry()
config = self._makeOne(reg)
dummy = object()
config.setup_registry(
authentication_policy=dummy,
authorization_policy='tests.test_config',
)
config.commit()
result = reg.getUtility(IAuthorizationPolicy)
import tests.test_config
self.assertEqual(result, tests.test_config)
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,
default_permission=None,
session_factory=None,
default_view_mapper=None,
autocommit=False,
exceptionresponse_view=default_exceptionresponse_view,
route_prefix=None,
introspection=True,
):
if package is None:
package = caller_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.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,
default_permission=default_permission,
session_factory=session_factory,
default_view_mapper=default_view_mapper,
exceptionresponse_view=exceptionresponse_view,
)
def test_service_decorator():
with pytest.raises(ValueError, match='.*Invalid scope.*'):
@service(scope='something else')
class Test:
pass
with pytest.warns(DeprecationWarning, match='.*global.*'):
@service(scope='global')
class Test:
pass
with pytest.warns(DeprecationWarning, match='.*renamed.*'):
class Test(BaseService):
pass
with pytest.warns(DeprecationWarning, match='.*renamed.*'):
Test(registry=Registry())
def test_views_command_single_view_traversal_with_permission(self):
from pyramid.registry import Registry
registry = Registry()
command = self._makeOne(registry=registry)
L = []
command.out = L.append
view = DummyView(context='context', view_name='a')
view.__permission__ = 'test'
command._find_view = lambda arg1, arg2: view
command.args = ('/foo/bar/myapp.ini#myapp', '/a')
result = command.command()
self.assertEqual(result, None)
self.assertEqual(L[1], 'URL = /a')
self.assertEqual(L[3], ' context: context')
self.assertEqual(L[4], ' view name: a')
self.assertEqual(L[8], ' pyramid.tests.test_paster.DummyView')
self.assertEqual(L[9], ' required permission = test')
def setUp(self):
self.__request = DummyRequest()
reg = Registry()
# Set up defined roles
defined_roles = [(Allow, 'TEACHER', ('view', 'logout'))]
edauth.set_roles(defined_roles)
self.__tenant_name = get_unittest_tenant_name()
set_tenant_map({self.__tenant_name: "NC", "tenantName": "WA"})
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
dummy_session = Session()
dummy_session.set_user_context(
[RoleRelation("TEACHER", self.__tenant_name, "NC", "228", "242")])
dummy_session.set_uid('a5ddfe12-740d-4487-9179-de70f6ac33be')
self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self):
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['batch.user.session.timeout'] = 15
component.provideUtility(SessionBackend(reg.settings), ISessionBackend)
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
self.__policy = EdAuthAuthenticationPolicy('secret',
callback=None,
cookie_name='cookieName')
def setUp(self):
# Register mail utility
from repoze.sendmail.interfaces import IMailDelivery
from karl.testing import DummyMailer
self.mailer = DummyMailer()
from pyramid.threadlocal import manager
from pyramid.registry import Registry
manager.stack[0]['registry'] = Registry('testing')
karl.testing.registerUtility(self.mailer, IMailDelivery)
# Register BlogEntryAlert adapter
from karl.models.interfaces import IProfile
from karl.content.interfaces import IBlogEntry
from karl.content.views.adapters import BlogEntryAlert
from karl.utilities.interfaces import IAlert
from pyramid.interfaces import IRequest
karl.testing.registerAdapter(BlogEntryAlert,
(IBlogEntry, IProfile, IRequest), IAlert)
karl.testing.registerDummySecurityPolicy("a")
# Create dummy site skel
from karl.testing import DummyCommunity
self.community = DummyCommunity()
self.site = self.community.__parent__.__parent__
self.profiles = testing.DummyModel()
self.site["profiles"] = self.profiles
from karl.testing import DummyProfile
self.profiles["a"] = DummyProfile()
self.profiles["b"] = DummyProfile()
self.profiles["c"] = DummyProfile()
for profile in self.profiles.values():
profile["alerts"] = testing.DummyModel()
self.community.member_names = set([
"b",
"c",
])
self.community.moderator_names = set([
"a",
])
self.blog = self._makeContext()
self.community["blog"] = self.blog
def test_views_command_multiview(self):
from pyramid.registry import Registry
registry = Registry()
command = self._makeOne(registry=registry)
L = []
command.out = L.append
view = DummyView(context='context')
view.__name__ = 'view'
view.__view_attr__ = 'call'
multiview = DummyMultiView(view, context='context', view_name='a')
command._find_view = lambda arg1, arg2: multiview
command.args = ('/foo/bar/myapp.ini#myapp', '/a')
result = command.command()
self.assertEqual(result, None)
self.assertEqual(L[1], 'URL = /a')
self.assertEqual(L[3], ' context: context')
self.assertEqual(L[4], ' view name: a')
self.assertEqual(L[8], ' pyramid.tests.test_paster.view.call')
def setUp(self):
self.reg = Registry()
self.reg.settings = {EDWARE_PUBLIC_SECRET: SECRET}
cache_opts = {
'cache.type': 'memory',
'cache.regions': 'public.data,public.filtered_data,public.shortlived,public.very_shortlived'
}
CacheManager(**parse_cache_config_options(cache_opts))
self.__request = DummyRequest()
# Must set hook_zca to false to work with unittest_with_sqlite
self.__config = testing.setUp(registry=self.reg, request=self.__request, hook_zca=False)
defined_roles = [(Allow, RolesConstants.PII, ('view', 'logout'))]
edauth.set_roles(defined_roles)
set_tenant_map_public_reports({get_unittest_tenant_name(): 'NC'})
set_default_min_cell_size(0)
# so that it works with unittest edcore module
PublicDBConnection.CONFIG_NAMESPACE = 'edware.db'
def setUp(self):
reg = Registry()
reg.settings = {EDWARE_PUBLIC_SECRET: SECRET}
cache_opts = {
'cache.type':
'memory',
'cache.regions':
'public.data,public.filtered_data,public.shortlived,public.very_shortlived'
}
CacheManager(**parse_cache_config_options(cache_opts))
self.__request = DummyRequest()
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
dummy_session = create_test_session(['SUPER_USER'],
uid='272',
tenant='cat')
self.__config.testing_securitypolicy(dummy_session)
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(): # pragma: no cover
pass
def view2(): # pragma: no cover
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:
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)
request = self._makeRequest('/a', registry)
result = command._find_view(request)
self.assertTrue(IMultiView.providedBy(result))
def test__find_view_traversal(self):
from zope.interface import providedBy
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IView
from pyramid.traversal import DefaultRootFactory
from pyramid.registry import Registry
registry = Registry()
def view1(): pass
request = dummy.DummyRequest({'PATH_INFO':'/a'})
root = DefaultRootFactory(request)
root_iface = providedBy(root)
registry.registerAdapter(view1,
(IViewClassifier, IRequest, root_iface),
IView, name='a')
self._register_mapper(registry, [])
command = self._makeOne(registry=registry)
result = command._find_view('/a', registry)
self.assertEqual(result, view1)
def test_views_command_single_view_traversal_with_predicates(self):
from pyramid.registry import Registry
registry = Registry()
command = self._makeOne(registry=registry)
L = []
command.out = L.append
def predicate(): pass
predicate.__text__ = "predicate = x"
view = DummyView(context='context', view_name='a')
view.__predicates__ = [predicate]
command._find_view = lambda arg1, arg2: view
command.args = ('/foo/bar/myapp.ini#myapp', '/a')
result = command.command()
self.assertEqual(result, None)
self.assertEqual(L[1], 'URL = /a')
self.assertEqual(L[3], ' context: context')
self.assertEqual(L[4], ' view name: a')
self.assertEqual(L[8], ' pyramid.tests.test_paster.DummyView')
self.assertEqual(L[9], ' view predicates (predicate = x)')
def test_views_command_single_view_traversal(self):
from pyramid.registry import Registry
command = self._makeOne()
registry = Registry()
L = []
command.out = L.append
view = DummyView(context='context', view_name='a')
command._find_view = lambda arg1, arg2: view
app = DummyApp()
app.registry = registry
loadapp = DummyLoadApp(app)
command.loadapp = (loadapp, )
command.args = ('/foo/bar/myapp.ini', 'myapp', '/a')
result = command.command()
self.assertEqual(result, None)
self.assertEqual(L[1], 'URL = /a')
self.assertEqual(L[3], ' context: context')
self.assertEqual(L[4], ' view name: a')
self.assertEqual(L[8], ' pyramid.tests.test_paster.DummyView')
def test_views_command_single_view_traversal_with_permission(self):
from pyramid.registry import Registry
registry = Registry()
command = self._makeOne(registry=registry)
L = []
command.out = L.append
view = dummy.DummyView(context='context', view_name='a')
view.__permission__ = 'test'
command._find_view = lambda arg1: view
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], ' context: context')
self.assertEqual(L[4], ' view name: a')
self.assertEqual(L[8], ' tests.test_scripts.dummy.DummyView')
self.assertEqual(L[9], ' required permission = test')
def test__find_view_route_multiview_no_view_registered(self):
from zope.interface import Interface
from zope.interface import implements
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')
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()
result = command._find_view('/a', registry)
self.failUnless(IMultiView.providedBy(result))
def setup_thelma(thelma_settings):
# Create source DB session.
src_db_string = "postgresql+psycopg2://%s:%s@%s:%s/%s" \
% (DB_USER, DB_PWD, SOURCE_DB_HOST,
SOURCE_DB_PORT, SOURCE_DB_NAME)
src_engine = create_engine(src_db_string)
src_session_maker = sessionmaker(bind=src_engine)
src_sess = src_session_maker()
# Initialize TheLMA and create target DB session.
reg = Registry('thelma')
config = create_config(thelma_settings, registry=reg)
config.setup_registry(settings=thelma_settings)
config.begin()
config.load_zcml('configure.zcml')
repo_mgr = config.get_registered_utility(IRepositoryManager)
repo_mgr.initialize_all()
tgt_engine = get_engine(REPOSITORY_TYPES.RDB)
tgt_session_maker = sessionmaker(bind=tgt_engine)
tgt_sess = tgt_session_maker()
return src_sess, tgt_sess
def test_ini_logging():
from celery import signals
from pyramid_celery import includeme
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/dev.ini')
with mock.patch('pyramid_celery.setup_logging') as setup_logging:
signals.setup_logging.send(
sender=None,
loglevel='INFO',
logfile=None,
format='',
colorize=False,
)
setup_logging.assert_called_with('tests/configs/dev.ini')
def setUp(self):
import ptah.scripts
import pyramid.paster
self.original_get_app = ptah.scripts.get_app
self.original_global_registries = ptah.scripts.global_registries
self.app = app = object()
self.registry = registry = Registry()
class DummyGetApp(object):
last = registry
def __call__(self, *a, **kw):
self.a = a
self.kw = kw
return app
pyramid.paster.get_app = DummyGetApp()
ptah.scripts.global_registries = DummyGetApp()
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 = DummyRoute('a', '/a')
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', 'None'])
def test__find_view_route_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.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')
@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)
request = self._makeRequest('/a', registry)
result = command._find_view(request)
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 setUp(self):
self.reg = Registry()
self.__temp_dir = tempfile.TemporaryDirectory()
self.__work_zone_dir = os.path.join(self.__temp_dir.name, 'work_zone')
self.__raw_data_base_dir = os.path.join(self.__temp_dir.name,
'raw_data')
self.__item_level_base_dir = os.path.join(self.__temp_dir.name,
'item_level')
self.reg.settings = {
'extract.work_zone_base_dir': self.__work_zone_dir,
'hpz.file_upload_base_url': 'http://somehost:82/files',
'extract.available_grades': '3,4,5,6,7,8,11',
'extract.raw_data_base_dir': self.__raw_data_base_dir,
'extract.item_level_base_dir': self.__item_level_base_dir
}
settings = {'extract.celery.CELERY_ALWAYS_EAGER': True}
setup_celery(settings)
cache_opts = {
'cache.type': 'memory',
'cache.regions':
'public.data,public.filtered_data,public.shortlived'
}
CacheManager(**parse_cache_config_options(cache_opts))
# Set up user context
self.__request = DummyRequest()
# Must set hook_zca to false to work with unittest_with_sqlite
self.__config = testing.setUp(registry=self.reg,
request=self.__request,
hook_zca=False)
defined_roles = [
(Allow, RolesConstants.SAR_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.AUDIT_XML_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.ITEM_LEVEL_EXTRACTS, ('view', 'logout'))
]
edauth.set_roles(defined_roles)
dummy_session = create_test_session([
RolesConstants.SAR_EXTRACTS, RolesConstants.AUDIT_XML_EXTRACTS,
RolesConstants.ITEM_LEVEL_EXTRACTS
])
self.__config.testing_securitypolicy(dummy_session.get_user())
set_tenant_map({get_unittest_tenant_name(): 'NC'})
def test_views_command_single_view_function_traversal(self):
from pyramid.registry import Registry
registry = Registry()
command = self._makeOne(registry=registry)
L = []
command.out = L.append
def view(): # pragma: no cover
pass
view.__request_attrs__ = {'context': 'context', 'view_name': 'a'}
command._find_view = lambda arg1: view
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], ' context: context')
self.assertEqual(L[4], ' view name: a')
self.assertEqual(L[8], ' tests.test_scripts.test_pviews.view')
