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 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.item_level_base_dir': '/opt/edware/item_level'
}
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
self.__tenant_name = get_unittest_tenant_name()
defined_roles = [(Allow, RolesConstants.ITEM_LEVEL_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.ITEM_LEVEL_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 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 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 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 setUp(self):
reg = Registry()
reg.settings = {}
reg.settings['ldap.base.dn'] = 'ou=dummy,dc=testing,dc=com'
self.__config = testing.setUp(registry=reg,
request=DummyRequest(),
hook_zca=False)
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 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 setUp(self):
self.__request = DummyRequest()
# Must set hook_zca to false to work with uniittest_with_sqlite
reg = Registry()
reg.settings = {}
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
self.__tenant_name = get_unittest_tenant_name()
defined_roles = [
(Allow, RolesConstants.SAR_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.ITEM_LEVEL_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.ITEM_LEVEL_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.SAR_EXTRACTS])
dummy_session.set_user_context([
RoleRelation(RolesConstants.SAR_EXTRACTS,
get_unittest_tenant_name(), "NC", None, None),
RoleRelation(RolesConstants.AUDIT_XML_EXTRACTS,
get_unittest_tenant_name(), "NC", None, None),
RoleRelation(RolesConstants.ITEM_LEVEL_EXTRACTS,
get_unittest_tenant_name(), "NC", None, None)
])
self.__config.testing_securitypolicy(dummy_session.get_user())
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 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 setUp(self):
self.__request = DummyRequest()
reg = Registry()
reg.settings = {'hpz.frs.download_base_url': 'http://blah/download'}
self.__config = testing.setUp(registry=reg,
request=self.__request,
hook_zca=False)
self.__config.add_route('download', '/{reg_id}')
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 _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 _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 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 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 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 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 test_heartbeat_fail(self):
tested = False
hpz_connector.HPZ_NAMESPACE = 'edware.db.tomcat.foo'
with tempfile.TemporaryDirectory() as tmp:
request = DummyRequest()
reg = Registry()
reg.settings = {'hpz.frs.upload_base_path': tmp}
testing.setUp(registry=reg, request=request, hook_zca=False)
res = heartbeat(request)
tested = True
self.assertTrue(tested)
self.assertEqual(type(res), HTTPServerError)
def setUp(self):
registry = Registry()
registry.settings = settings
self.config = testing.setUp(registry=registry)
pwd_context.load_path('test.ini')
# setup db
DBSession.configure(bind=engine, expire_on_commit=False)
Base.metadata.bind = engine
Base.metadata.drop_all()
Base.metadata.create_all()
# enable logging
logging.config.fileConfig('test.ini', disable_existing_loggers=False)
def test_heartbeat_fail(self):
tested = False
hpz_connector.HPZ_NAMESPACE = 'edware.db.tomcat.foo'
with tempfile.TemporaryDirectory() as tmp:
request = DummyRequest()
reg = Registry()
reg.settings = {'hpz.frs.upload_base_path': tmp}
testing.setUp(registry=reg, request=request, hook_zca=False)
res = heartbeat(request)
tested = True
self.assertTrue(tested)
self.assertEqual(type(res), HTTPServerError)
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):
self.__tempfolder = tempfile.TemporaryDirectory()
# setup registry
settings = {
'smarter_score_batcher.celery_timeout': 30,
'smarter_score_batcher.celery.celery_always_eager': True,
'smarter_score_batcher.base_dir': self.__tempfolder.name
}
reg = Registry()
reg.utilities = base.utilities
reg.settings = settings
self.__config = testing.setUp(registry=reg)
setup_celery(settings, db_connection=False)
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 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 setUp(self):
parser = ConfigParser()
parser.read('../production.ini')
pval = partial(parser.get, 'app:main')
testRegistry = Registry()
testRegistry.settings = {'mandrill_key': pval('mandrill_key')}
self.config = testing.setUp(registry=testRegistry)
setup_auth(self.config)
setup_tweens(self.config)
setup_routes(self.config)
self.config.testing_securitypolicy(userid=self.contributor.username)
def main():
parser, subparsers, global_arguments = setup_parser()
args = parser["root"].parse_args()
# FIXME: Initialialising the testing modul is currently the only
# known way to make the settings
# available in the current_registry call (which is called
# inside
# ringo when loading the form).
config = appconfig('config:%s' % args.config, "main", relative_to='.')
name = config.context.distribution.project_name
registry = Registry(name)
registry.settings = config
testing.setUp(registry)
args.func(args)
def setUp(self):
parser = ConfigParser()
parser.read('../production.ini')
pval = partial(parser.get, 'app:main')
testRegistry = Registry()
testRegistry.settings = {'mandrill_key': pval('mandrill_key')}
self.config = testing.setUp(registry=testRegistry)
self.config.include('packassembler.routes')
self.config.include('packassembler.tweens')
self.config.include('packassembler.security')
self.config.include('packassembler.sessions')
self.config.testing_securitypolicy(userid=self.contributor.username)
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 setUp(self):
self.__tempfolder = tempfile.TemporaryDirectory()
settings = {
'smarter_score_batcher.celery_timeout': 30,
'smarter_score_batcher.celery.celery_always_eager': True,
'smarter_score_batcher.base_dir': self.__tempfolder.name
}
reg = Registry()
reg.settings = settings
reg.utilities = base.utilities
CacheManager(**parse_cache_config_options({'cache.regions': 'public.shortlived', 'cache.type': 'memory', 'cache.public.shortlived.expire': 7200}))
self.__config = testing.setUp(registry=reg)
setup_celery(settings, db_connection=False)
path = os.path.join(os.path.abspath(os.path.dirname(__file__)), '../resources/meta/performance')
static_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), '../resources/meta/static')
component.provideUtility(PerfMetadataTemplateManager(asmt_meta_dir=path, static_asmt_meta_dir=static_path), IMetadataTemplateManager)
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):
self.__request = DummyRequest()
# Must set hook_zca to false to work with uniittest_with_sqlite
reg = Registry()
reg.settings = {}
self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False)
self.__tenant_name = get_unittest_tenant_name()
defined_roles = [(Allow, RolesConstants.SAR_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.ITEM_LEVEL_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.ITEM_LEVEL_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.SAR_EXTRACTS])
dummy_session.set_user_context([RoleRelation(RolesConstants.SAR_EXTRACTS, get_unittest_tenant_name(), "NC", None, None),
RoleRelation(RolesConstants.AUDIT_XML_EXTRACTS, get_unittest_tenant_name(), "NC", None, None),
RoleRelation(RolesConstants.ITEM_LEVEL_EXTRACTS, get_unittest_tenant_name(), "NC", None, None)])
self.__config.testing_securitypolicy(dummy_session.get_user())
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 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_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 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_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 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)
def _registry(app_config):
name = app_config.context.distribution.project_name
registry = Registry(name)
registry.settings = app_config
testing.setUp(registry)
return registry
def setUp(self):
reg = Registry()
reg.settings = {}
reg.settings['ldap.base.dn'] = 'ou=dummy,dc=testing,dc=com'
self.__config = testing.setUp(registry=reg, request=DummyRequest(), hook_zca=False)
def registry(settings):
from pyramid.registry import Registry
registry = Registry()
registry.settings = settings
return registry
def setUp(self):
self.__request = DummyRequest()
reg = Registry()
reg.settings = {'hpz.frs.download_base_url': 'http://blah/download'}
self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False)
self.__config.add_route('download', '/{reg_id}')
def registry(settings):
from pyramid.registry import Registry
registry = Registry()
registry.settings = settings
return registry
def _make_registry(self, **kw):
r = Registry('testing')
r.settings = kw
return r
