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.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):
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.__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.__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.__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.__tmp_out_dir = tempfile.mkdtemp('raw_data_extract_output_dir')
self._tenant = get_unittest_tenant_name()
self.__state_code = 'NC'
set_tenant_map({get_unittest_tenant_name(): 'NC'})
if not TestRawDataGenerator.__built_files:
self.__build_raw_data_files()
TestRawDataGenerator.__built_files = True
def setUp(self):
self.__tmp_out_dir = tempfile.mkdtemp('item_file_archiver_test')
self._tenant = get_unittest_tenant_name()
self.__state_code = 'NC'
set_tenant_map({get_unittest_tenant_name(): 'NC'})
if not TestItemLevelGenerator.__built_files:
self.__build_item_level_files()
TestItemLevelGenerator.__built_files = True
def setUp(self):
self.__tmp_out_dir = tempfile.mkdtemp('raw_data_extract_output_dir')
self._tenant = get_unittest_tenant_name()
self.__state_code = 'NC'
set_tenant_map({get_unittest_tenant_name(): 'NC'})
if not TestRawDataGenerator.__built_files:
self.__build_raw_data_files()
TestRawDataGenerator.__built_files = True
def setUp(self):
cache_managers.clear()
cache_opts = {
'cache.type': 'memory',
'cache.regions': 'public.data, public.filtered_data, unittest, public.shortlived, public.very_shortlived'
}
self.cache_mgr = CacheManager(**parse_cache_config_options(cache_opts))
set_tenant_map({'tomcat': 'NC', get_unittest_tenant_name(): 'NC'})
def test_connector_with_multi_tenants(self):
set_tenant_map({get_unittest_tenant_name(): 'NC', 'b': 'AB'})
dummy_session = DummySession()
dummy_session.set_tenants([get_unittest_tenant_name(), 'dummyTenant'])
self.__config.testing_securitypolicy(dummy_session)
conn = EdCoreDBConnection(state_code='NC')
self.assertIsInstance(conn, EdCoreDBConnection)
dim_student = conn.get_table('dim_student')
self.assertEqual(dim_student.name, 'dim_student')
def setUp(self):
cache_managers.clear()
cache_opts = {
'cache.type':
'memory',
'cache.regions':
'public.data, public.filtered_data, unittest, public.shortlived, public.very_shortlived'
}
self.cache_mgr = CacheManager(**parse_cache_config_options(cache_opts))
set_tenant_map({'tomcat': 'NC', get_unittest_tenant_name(): 'NC'})
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):
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):
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):
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()
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()
# 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.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 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 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):
# 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 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 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 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):
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.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 test_get_state_code_to_tenant_map(self):
set_tenant_map({'a': 'NC', 'b': 'AB'})
mapping = get_state_code_to_tenant_map()
self.assertEqual(mapping['NC'], 'a')
self.assertEqual(mapping['AB'], 'b')
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):
set_tenant_map({get_unittest_tenant_name(): 'NC'})
def setUp(self):
set_tenant_map({get_unittest_tenant_name(): 'NC'})
def test_get_state_code_mapping_(self):
set_tenant_map({'a': 'NC', 'b': 'AB'})
mapping = get_state_code_mapping(['a', 'b'])
self.assertEqual(len(mapping), 2)
self.assertEqual('NC', mapping[0])
self.assertEqual('AB', mapping[1])
def test_get_mapping(self):
set_tenant_map({'a': 'NC'})
mapping = get_tenant_map()
self.assertEqual(mapping['a'], 'NC')
def test_set_mapping(self):
set_tenant_map({'c': 'NC'})
tenant_map = edcore.security.tenant.TENANT_MAP
self.assertEqual(tenant_map['c'], 'NC')
def test_get_all_statecodes(self):
set_tenant_map({'c': 'NC', 'd': 'CC'})
states = get_all_state_codes()
self.assertEqual(len(states), 2)
self.assertIn('NC', states)
self.assertIn('CC', states)
def test_get_all_tenants(self):
set_tenant_map({'c': 'NC', 'd': 'CC'})
tenants = get_all_tenants()
self.assertEqual(len(tenants), 2)
self.assertIn('c', tenants)
self.assertIn('d', tenants)
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 test_get_state_code_mapping_empty_map(self):
set_tenant_map({})
mapping = get_state_code_mapping(['a', 'b'])
self.assertEqual(len(mapping), 2)
self.assertIsNone(mapping[0])
self.assertIsNone(mapping[1])
