def setUp(self):
self.reg = Registry()
self.__work_zone_dir = tempfile.TemporaryDirectory()
self.reg.settings = {
'extract.work_zone_base_dir': '/tmp/work_zone',
'pickup.gatekeeper.t1': '/t/acb',
'pickup.gatekeeper.t2': '/a/df',
'pickup.gatekeeper.y': '/a/c',
'pickup.sftp.hostname': 'hostname.local.net',
'pickup.sftp.user': '******',
'pickup.sftp.private_key_file': '/home/users/myUser/.ssh/id_rsa',
'extract.available_grades': '3,4,5,6,7,8,11'
}
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'))]
edauth.set_roles(defined_roles)
set_tenant_map({get_unittest_tenant_name(): 'NC'})
dummy_session = create_test_session([RolesConstants.SAR_EXTRACTS])
self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self):
self.__request = DummyRequest()
# Must set hook_zca to false to work with unittest_with_sqlite
self.__config = testing.setUp(request=self.__request, hook_zca=False)
self.__tenant_name = get_unittest_tenant_name()
set_tenant_map({self.__tenant_name: "NC"})
defined_roles = [
(Allow, RolesConstants.PII, ('view', 'logout')),
(Allow, RolesConstants.SRS_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.SRC_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.PII])
dummy_session.set_user_context([
RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC",
"228", "242"),
RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC",
"228", "245"),
RoleRelation(RolesConstants.SRS_EXTRACTS,
get_unittest_tenant_name(), 'NC', None, None),
RoleRelation(RolesConstants.SRC_EXTRACTS,
get_unittest_tenant_name(), 'NC', None, None),
RoleRelation(RolesConstants.AUDIT_XML_EXTRACTS,
get_unittest_tenant_name(), 'NC', None, None)
])
# For Context Security, we need to save the user object
self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self):
self.reg = Registry()
self.__work_zone_dir = tempfile.TemporaryDirectory()
self.reg.settings = {'extract.work_zone_base_dir': '/tmp/work_zone',
'pickup.gatekeeper.t1': '/t/acb',
'pickup.gatekeeper.t2': '/a/df',
'pickup.gatekeeper.y': '/a/c',
'pickup.sftp.hostname': 'hostname.local.net',
'pickup.sftp.user': '******',
'pickup.sftp.private_key_file': '/home/users/myUser/.ssh/id_rsa',
'extract.available_grades': '3,4,5,6,7,8,11'}
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'))]
edauth.set_roles(defined_roles)
set_tenant_map({get_unittest_tenant_name(): 'NC'})
dummy_session = create_test_session([RolesConstants.SAR_EXTRACTS])
self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self):
self.reg = Registry()
self.__work_zone_dir = tempfile.TemporaryDirectory()
self.reg.settings = {
'extract.work_zone_base_dir': '/tmp/work_zone',
'extract.available_grades': '3,4,5,6,7,8,11',
'hpz.file_upload_base_url': 'http://somehost:82/files'
}
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.SRS_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.SRC_EXTRACTS, ('view', 'logout'))
]
edauth.set_roles(defined_roles)
dummy_session = create_test_session(
[RolesConstants.SRS_EXTRACTS, RolesConstants.SRC_EXTRACTS])
self.__config.testing_securitypolicy(dummy_session.get_user())
set_tenant_map({get_unittest_tenant_name(): '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.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):
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 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):
self.reg = Registry()
self.reg.settings = {
'extract.work_zone_base_dir': '/tmp/work_zone',
'pickup.gatekeeper.t1': '/t/acb',
'pickup.gatekeeper.t2': '/a/df',
'pickup.gatekeeper.y': '/a/c',
'pickup.sftp.hostname': 'hostname.local.net',
'pickup.sftp.user': '******',
'pickup.sftp.private_key_file': '/home/users/myUser/.ssh/id_rsa'
}
# 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'))]
edauth.set_roles(defined_roles)
# 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", "228", "242")
])
self.__config.testing_securitypolicy(dummy_session)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
initialize_db(settings)
configure(settings)
# set beaker cache region
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, root_factory=RootFactory)
# include edauth. Calls includeme
config.include(edauth)
# Pass edauth the roles/permission mapping that is defined in hpz
edauth.set_roles(RootFactory.__acl__)
# include add routes from frs. Calls includeme
config.include(frs)
config.include(swi)
config.include(services)
config.scan()
# Clean up old files from HPZ
run_cron_job(settings, HPZ_EXPIRATION + '.', cleanup)
logger.info("HPZ Started")
return config.make_wsgi_app()
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 test_session_with_role_returned(self):
# Prepare session
session = create_test_session(roles=['TEACHER', 'STAFF'], uid='linda.kim', full_name='Linda Kim', save_to_backend=True)
defined_roles = [(Allow, 'TEACHER', ('view', 'logout')), (Allow, 'STAFF', ('view', 'logout'))]
edauth.set_roles(defined_roles)
# Set up context security
session.set_user_context([RoleRelation("TEACHER", get_unittest_tenant_name(), "NC", "228", "242"),
RoleRelation("STAFF", get_unittest_tenant_name(), "NC", "228", "242")])
roles = session_check(session.get_session_id(), None)
self.assertIn("TEACHER", roles)
self.assertIn("STAFF", roles)
def setUp(self):
self.__request = DummyRequest()
# Must set hook_zca to false to work with uniittest_with_sqlite
self.__config = testing.setUp(request=self.__request, hook_zca=False)
defined_roles = [(Allow, 'STATE_EDUCATION_ADMINISTRATOR_1', ('view', 'logout'))]
edauth.set_roles(defined_roles)
# Set up context security
dummy_session = create_test_session(['STATE_EDUCATION_ADMINISTRATOR_1'])
dummy_session.set_user_context([RoleRelation("STATE_EDUCATION_ADMINISTRATOR_1", get_unittest_tenant_name(), "NC", "228", "242")])
self.__config.testing_securitypolicy(dummy_session)
set_default_min_cell_size(0)
def setUp(self):
defined_roles = [(Allow, RolesConstants.PII, ('view', 'logout')),
(Allow, RolesConstants.SAR_EXTRACTS, ('view', 'logout'))]
edauth.set_roles(defined_roles)
self.tenant = get_unittest_tenant_name()
set_tenant_map({self.tenant: "NC"})
dummy_session = create_test_session([RolesConstants.PII])
dummy_session.set_user_context([RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC", "228", "242"),
RoleRelation(RolesConstants.SAR_EXTRACTS, get_unittest_tenant_name(), "NC", "228", "242")])
self.user = dummy_session.get_user()
self.__request = DummyRequest()
self.__config = testing.setUp(request=self.__request, hook_zca=False)
self.__config.testing_securitypolicy(self.user)
def setUp(self):
cache_opts = {'cache.type': 'memory', 'cache.regions': 'public.data'}
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(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.__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.__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['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.__request = DummyRequest()
# Must set hook_zca to false to work with uniittest_with_sqlite
self.__config = testing.setUp(request=self.__request, hook_zca=False)
defined_roles = [(Allow, 'STATE_EDUCATION_ADMINISTRATOR_1',
('view', 'logout'))]
edauth.set_roles(defined_roles)
# Set up context security
dummy_session = create_test_session(
['STATE_EDUCATION_ADMINISTRATOR_1'])
dummy_session.set_user_context([
RoleRelation("STATE_EDUCATION_ADMINISTRATOR_1",
get_unittest_tenant_name(), "NC", "228", "242")
])
self.__config.testing_securitypolicy(dummy_session)
set_default_min_cell_size(0)
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 unittest_with_sqlite
self.__config = testing.setUp(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.__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.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):
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):
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 unittest_with_sqlite
self.__config = testing.setUp(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 = Session()
dummy_session.set_user_context([RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC", "228", "242")])
dummy_session.set_uid('a5ddfe12-740d-4487-9179-de70f6ac33be')
self.__config.testing_securitypolicy(dummy_session.get_user())
def test_session_with_role_returned(self):
# Prepare session
session = create_test_session(roles=['TEACHER', 'STAFF'],
uid='linda.kim',
full_name='Linda Kim',
save_to_backend=True)
defined_roles = [(Allow, 'TEACHER', ('view', 'logout')),
(Allow, 'STAFF', ('view', 'logout'))]
edauth.set_roles(defined_roles)
# Set up context security
session.set_user_context([
RoleRelation("TEACHER", get_unittest_tenant_name(), "NC", "228",
"242"),
RoleRelation("STAFF", get_unittest_tenant_name(), "NC", "228",
"242")
])
roles = session_check(session.get_session_id(), None)
self.assertIn("TEACHER", roles)
self.assertIn("STAFF", roles)
def setUp(self):
self.reg = Registry()
self.reg.settings = {'extract.work_zone_base_dir': '/tmp/work_zone',
'pickup.gatekeeper.t1': '/t/acb',
'pickup.gatekeeper.t2': '/a/df',
'pickup.gatekeeper.y': '/a/c',
'pickup.sftp.hostname': 'hostname.local.net',
'pickup.sftp.user': '******',
'pickup.sftp.private_key_file': '/home/users/myUser/.ssh/id_rsa'}
# 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'))]
edauth.set_roles(defined_roles)
# 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", "228", "242")])
self.__config.testing_securitypolicy(dummy_session)
def setUp(self):
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.__tenant_name = get_unittest_tenant_name()
set_tenant_map({self.__tenant_name: "NC"})
# Must set hook_zca to false to work with unittest_with_sqlite.
self.__config = testing.setUp(request=self.__request, hook_zca=False)
defined_roles = [(Allow, 'PII', ('view', 'logout'))]
edauth.set_roles(defined_roles)
# Set up context security
dummy_session = create_test_session(['PII'])
dummy_session.set_user_context([RoleRelation("PII", get_unittest_tenant_name(), "NC", "228", None)])
self.__config.testing_securitypolicy(dummy_session.get_user())
set_default_min_cell_size(0)
def setUp(self):
self.__request = DummyRequest()
# Must set hook_zca to false to work with unittest_with_sqlite
self.__config = testing.setUp(request=self.__request, hook_zca=False)
self.__tenant_name = get_unittest_tenant_name()
set_tenant_map({self.__tenant_name: "NC"})
defined_roles = [(Allow, RolesConstants.PII, ('view', 'logout')),
(Allow, RolesConstants.SRS_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.SRC_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.PII])
dummy_session.set_user_context([RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC", "228", "242"),
RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC", "228", "245"),
RoleRelation(RolesConstants.SRS_EXTRACTS, get_unittest_tenant_name(), 'NC', None, None),
RoleRelation(RolesConstants.SRC_EXTRACTS, get_unittest_tenant_name(), 'NC', None, None),
RoleRelation(RolesConstants.AUDIT_XML_EXTRACTS, get_unittest_tenant_name(), 'NC', None, None)])
# For Context Security, we need to save the user object
self.__config.testing_securitypolicy(dummy_session.get_user())
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 unittest_with_sqlite
self.__config = testing.setUp(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 = Session()
dummy_session.set_user_context([
RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC",
"228", "242")
])
dummy_session.set_uid('a5ddfe12-740d-4487-9179-de70f6ac33be')
self.__config.testing_securitypolicy(dummy_session.get_user())
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# Configure for environment
set_environment_path_variable(settings)
configure(settings)
config = Configurator(settings=settings, root_factory=RootFactory)
# Pass edauth the roles/permission mapping
config.include(edauth)
edauth.set_roles(RootFactory.__acl__)
# include add routes from edapi. Calls includeme
config.include(edapi)
here = os.path.abspath(os.path.dirname(__file__))
xsd_file = os.path.join(here, settings['smarter_score_batcher.xsd.path'])
xsd.xsd = xsd.XSD(xsd_file)
mode = settings.get('mode', 'prod').upper()
init_db = False if mode == 'PROD' else True
# Set up celery. Important - This must happen before scan
# We don't need to initialize the db in Prod mode as only celery workers needs db connection
setup_xml_celery(settings, prefix=prefix, db_connection=init_db)
set_cache_regions_from_settings(
get_config_from_ini(settings, 'smarter_score_batcher', True))
config.add_route('xml', '/services/xml')
config.add_route('error', '/error')
config.add_route('heartbeat', '/services/heartbeat')
config.scan(ignore=[
'smarter_score_batcher.custom', 'smarter_score_batcher.tests.custom'
])
# Set default permission
config.set_default_permission(Permission.LOAD)
logger.info("Smarter tsb started")
return config.make_wsgi_app()
def setUp(self):
defined_roles = [
(Allow, RolesConstants.SRS_EXTRACTS, ('view', 'logout')),
(Allow, RolesConstants.SRC_EXTRACTS, ('view', 'logout'))
]
self.role_constants = [
RolesConstants.SRS_EXTRACTS, RolesConstants.SRC_EXTRACTS
]
edauth.set_roles(defined_roles)
self.tenant = get_unittest_tenant_name()
set_tenant_map({self.tenant: 'ES'})
dummy_session = create_test_session(
[RolesConstants.SRS_EXTRACTS, RolesConstants.SRC_EXTRACTS])
dummy_session.set_user_context([
RoleRelation(RolesConstants.SRS_EXTRACTS, self.tenant, None, None,
None),
RoleRelation(RolesConstants.SRC_EXTRACTS, self.tenant, None, None,
None)
])
self.user = dummy_session.get_user()
self.__request = DummyRequest()
self.__config = testing.setUp(request=self.__request, hook_zca=False)
self.__config.testing_securitypolicy(self.user)
def setUp(self):
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.__tenant_name = get_unittest_tenant_name()
set_tenant_map({self.__tenant_name: "NC"})
# Must set hook_zca to false to work with unittest_with_sqlite.
self.__config = testing.setUp(request=self.__request, hook_zca=False)
defined_roles = [(Allow, 'PII', ('view', 'logout'))]
edauth.set_roles(defined_roles)
# Set up context security
dummy_session = create_test_session(['PII'])
dummy_session.set_user_context([
RoleRelation("PII", get_unittest_tenant_name(), "NC", "228", None)
])
self.__config.testing_securitypolicy(dummy_session.get_user())
set_default_min_cell_size(0)
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 main(global_config, **settings):
"""
Starting point for the Smarter application. Prepares the environment and
applies configurations. Sets paths, permissions, routes. Calls includeme
methods of EdAuth, EdApi, and EdServices.
Returns a Pyramid WSGI application.
"""
mode = settings.get('mode', 'prod').upper()
# read remote config
if mode == 'PROD' and 'edware.remote_config.url' in settings:
url = settings['edware.remote_config.url']
settings = get_remote_config(url)
# Prepare for environment specific
set_environment_path_variable(settings)
prepare_env(settings)
# set beaker cache region
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, root_factory=RootFactory)
tenant_mapping = initialize_db(EdCoreDBConnection, settings)
tenant_mapping_public = initialize_db(PublicDBConnection, settings)
initialize_db(StatsDBConnection, settings, allow_schema_create=True)
# save tenancy mapping
set_tenant_map(tenant_mapping)
# save tenant mapping for public reports
set_tenant_map_public_reports(tenant_mapping_public)
year_back = settings['smarter.reports.year_back']
set_default_year_back(year_back)
# setup celery
setup_services_celery(settings, prefix=servicesPrefix)
setup_extract_celery(settings, prefix=edextractPrefix)
initialize_hpz(settings)
# include edauth. Calls includeme
config.include(edauth)
# Pass edauth the roles/permission mapping that is defined in smarter
edauth.set_roles(RootFactory.__acl__)
# include add routes from edapi. Calls includeme
config.include(edapi)
# Get absolute paths
here = os.path.abspath(os.path.dirname(__file__))
assets_dir = os.path.abspath(os.path.join(os.path.join(here, '..'), 'assets'))
static_max_age = int(settings.get('smarter.resources.static.max_age', 3600))
config.add_static_view('assets/css', os.path.join(assets_dir, 'css'), cache_max_age=static_max_age)
config.add_static_view('assets/data', os.path.join(assets_dir, 'data'), cache_max_age=static_max_age)
config.add_static_view('assets/images', os.path.join(assets_dir, 'images'), cache_max_age=static_max_age)
config.add_static_view('assets/js', os.path.join(assets_dir, 'js'), cache_max_age=static_max_age)
config.add_static_view('assets/html', os.path.join(assets_dir, 'html'), cache_max_age=static_max_age)
config.add_static_view('assets/public', os.path.join(assets_dir, 'public'), cache_max_age=static_max_age, permission=pyramid.security.NO_PERMISSION_REQUIRED)
# Only expose test in non-production modes
if mode != 'PROD':
config.add_static_view('assets/test', os.path.join(assets_dir, 'test'), cache_max_age=static_max_age)
disable_stack_trace = settings.get('disable_stack_trace', 'False').upper()
if disable_stack_trace == 'TRUE':
# we would like to disable the stack trace when we are in production mode
sys.tracebacklimit = 0
# route for error
config.add_route('error', '/assets/public/error.html')
# include add routes from smarter.services. Calls includeme
config.include(services)
# include add routes from smarter.trigger. Calls includeme
config.include(trigger)
# scans smarter
config.scan()
# Set default permission on all views
config.set_default_permission(Permission.VIEW)
logger.info("Smarter started")
return config.make_wsgi_app()
def setUp(self):
defined_roles = [(Allow, 'PII', ('view', 'logout')),
(Allow, 'DEFAULT', ('view', 'logout', 'default'))]
edauth.set_roles(defined_roles)
set_tenant_map({'tenant1': 'NC', 'tenant2': 'CA', 'tenant3': 'WA'})
def main(global_config, **settings):
"""
Starting point for the Smarter application. Prepares the environment and
applies configurations. Sets paths, permissions, routes. Calls includeme
methods of EdAuth, EdApi, and EdServices.
Returns a Pyramid WSGI application.
"""
mode = settings.get('mode', 'prod').upper()
# read remote config
if mode == 'PROD' and 'edware.remote_config.url' in settings:
url = settings['edware.remote_config.url']
settings = get_remote_config(url)
# Prepare for environment specific
set_environment_path_variable(settings)
prepare_env(settings)
# set beaker cache region
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, root_factory=RootFactory)
tenant_mapping = initialize_db(EdCoreDBConnection, settings)
tenant_mapping_public = initialize_db(PublicDBConnection, settings)
initialize_db(StatsDBConnection, settings, allow_schema_create=True)
# save tenancy mapping
set_tenant_map(tenant_mapping)
# save tenant mapping for public reports
set_tenant_map_public_reports(tenant_mapping_public)
year_back = settings['smarter.reports.year_back']
set_default_year_back(year_back)
# setup celery
setup_services_celery(settings, prefix=servicesPrefix)
setup_extract_celery(settings, prefix=edextractPrefix)
initialize_hpz(settings)
# include edauth. Calls includeme
config.include(edauth)
# Pass edauth the roles/permission mapping that is defined in smarter
edauth.set_roles(RootFactory.__acl__)
# include add routes from edapi. Calls includeme
config.include(edapi)
# Get absolute paths
here = os.path.abspath(os.path.dirname(__file__))
assets_dir = os.path.abspath(
os.path.join(os.path.join(here, '..'), 'assets'))
static_max_age = int(settings.get('smarter.resources.static.max_age',
3600))
config.add_static_view('assets/css',
os.path.join(assets_dir, 'css'),
cache_max_age=static_max_age)
config.add_static_view('assets/data',
os.path.join(assets_dir, 'data'),
cache_max_age=static_max_age)
config.add_static_view('assets/images',
os.path.join(assets_dir, 'images'),
cache_max_age=static_max_age)
config.add_static_view('assets/js',
os.path.join(assets_dir, 'js'),
cache_max_age=static_max_age)
config.add_static_view('assets/html',
os.path.join(assets_dir, 'html'),
cache_max_age=static_max_age)
config.add_static_view('assets/public',
os.path.join(assets_dir, 'public'),
cache_max_age=static_max_age,
permission=pyramid.security.NO_PERMISSION_REQUIRED)
# Only expose test in non-production modes
if mode != 'PROD':
config.add_static_view('assets/test',
os.path.join(assets_dir, 'test'),
cache_max_age=static_max_age)
disable_stack_trace = settings.get('disable_stack_trace', 'False').upper()
if disable_stack_trace == 'TRUE':
# we would like to disable the stack trace when we are in production mode
sys.tracebacklimit = 0
# route for error
config.add_route('error', '/assets/public/error.html')
# include add routes from smarter.services. Calls includeme
config.include(services)
# include add routes from smarter.trigger. Calls includeme
config.include(trigger)
# scans smarter
config.scan()
# Set default permission on all views
config.set_default_permission(Permission.VIEW)
logger.info("Smarter started")
return config.make_wsgi_app()
def setUp(self):
defined_roles = [(Allow, 'PII', ('view', 'logout')),
(Allow, 'DEFAULT', ('view', 'logout', 'default'))]
edauth.set_roles(defined_roles)
set_tenant_map({'tenant1': 'NC', 'tenant2': 'CA', 'tenant3': 'WA'})
def setUp(self):
defined_roles = [(Allow, 'TEACHER', ('view', 'logout')),
(Allow, 'SPECIALUSER', ('view', 'logout'))]
edauth.set_roles(defined_roles)
