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'
}
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_get_names(self):
# not existing school
results = get_names(get_unittest_tenant_name(), 'NC', '228', '-1')
self.assertIsNone(results)
# existing school
results = get_names(get_unittest_tenant_name(), 'NC', '228', '242')
self.assertIsNotNone(results)
def test_get_names(self):
# not existing school
results = get_names(get_unittest_tenant_name(), 'NC', '228', '-1')
self.assertIsNone(results)
# existing school
results = get_names(get_unittest_tenant_name(), 'NC', '228', '242')
self.assertIsNotNone(results)
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.__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):
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 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 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):
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 test_state_level(self):
dummy_session = create_test_session([RolesConstants.PII])
dummy_session.set_user_context([RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), 'NC', None, None),
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, None, None, None, None)])
# For Context Security, we need to save the user object
self.__config.testing_securitypolicy(dummy_session.get_user())
context = get_current_context({'stateCode': 'NC', 'districtId': '229', 'schoolId': '242'})
self.assertTrue(context['pii']['all'])
self.assertTrue(context['srs_extracts']['all'])
self.assertTrue(context['src_extracts']['all'])
self.assertTrue(context['audit_xml_extracts']['all'])
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 test_get_district_level_context_names(self):
tenant = get_unittest_tenant_name()
results = get_district_level_context_names(tenant, 'NC', '228')
self.assertEqual('Sunset School District', results['name'])
self.assertEqual(3, len(results['schools']))
self.assertEqual('Sunset - Eastern Elementary',
results['schools']['242']['name'])
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)
dummy_session = DummySession()
dummy_session.set_tenants([get_unittest_tenant_name()])
self.__config.testing_securitypolicy(dummy_session)
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 test_get_empty_custom_metadata(self):
tenant = get_unittest_tenant_name()
results = get_custom_metadata('blablabla', tenant)
# check empty results
self.assertEqual(set(['subject1', 'subject2', 'branding']), results.keys(), "result map should contain two subjects' id")
text = results.get('subject1').get(Constants.COLORS)
self.assertIsNone(text, "subject1 should be empty")
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):
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.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.__tmp_dir = tempfile.mkdtemp('file_archiver_test')
self._tenant = get_unittest_tenant_name()
self.task_info = {
Constants.TASK_ID: '01',
Constants.CELERY_TASK_ID: '02',
Constants.REQUEST_GUID: '03'
}
def setUp(self):
cache_managers.clear()
cache_opts = {
'cache.type': 'memory',
'cache.regions': 'public.data, public.filtered_data, unittest, public.shortlived, public.very_shortlived'
}
CacheManager(**parse_cache_config_options(cache_opts))
self.tenant = get_unittest_tenant_name()
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_get_empty_custom_metadata(self):
tenant = get_unittest_tenant_name()
results = get_custom_metadata('blablabla', tenant)
# check empty results
self.assertEqual(set(['subject1', 'subject2', 'branding']),
results.keys(),
"result map should contain two subjects' id")
text = results.get('subject1').get(Constants.COLORS)
self.assertIsNone(text, "subject1 should be empty")
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 test_get_aggregate_dim(self):
tenant = get_unittest_tenant_name()
agg_results = get_aggregate_dim_interim('NC', None, None, 2016, tenant, {'subject1': 'Math', 'subject2': 'ELA'})
records = agg_results[Constants.RECORDS]
self.assertEqual(4, len(records))
record = records[3]
results = record[Constants.RESULTS]
self.assertFalse(results['subject1'][Constants.HASINTERIM])
self.assertTrue(results['subject2'][Constants.HASINTERIM])
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):
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 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 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 test_school_rollup_bound(self):
params = {
'stateCode': 'NC',
'districtId': '228',
'schoolId': '242'
} # existing school
results = get_user_close_context(params,
tenant=get_unittest_tenant_name(),
school_rollup_bound=0)
self.assertEqual('Sunset School District',
results['districts'][0]['name'])
self.assertEqual(0, len(results['schools']))
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 test_get_user_close_context(self):
params = {
'stateCode': 'NC',
'districtId': '228',
'schoolId': '242'
} # existing school
results = get_user_close_context(params,
tenant=get_unittest_tenant_name())
self.assertEqual('Sunset School District',
results['districts'][0]['name'])
self.assertEqual(1, len(results['schools']))
self.assertEqual('Sunset - Eastern Elementary',
results['schools'][0]['name'])
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 test_get_aggregate_dim(self):
tenant = get_unittest_tenant_name()
agg_results = get_aggregate_dim_interim('NC', None, None, 2016, tenant,
{
'subject1': 'Math',
'subject2': 'ELA'
})
records = agg_results[Constants.RECORDS]
self.assertEqual(4, len(records))
record = records[3]
results = record[Constants.RESULTS]
self.assertFalse(results['subject1'][Constants.HASINTERIM])
self.assertTrue(results['subject2'][Constants.HASINTERIM])
def test_state_level(self):
dummy_session = create_test_session([RolesConstants.PII])
dummy_session.set_user_context([
RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), 'NC',
None, None),
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, None, None, None,
None)
])
# For Context Security, we need to save the user object
self.__config.testing_securitypolicy(dummy_session.get_user())
context = get_current_context({
'stateCode': 'NC',
'districtId': '229',
'schoolId': '242'
})
self.assertTrue(context['pii']['all'])
self.assertTrue(context['srs_extracts']['all'])
self.assertTrue(context['src_extracts']['all'])
self.assertTrue(context['audit_xml_extracts']['all'])
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 test_get_custom_metadata(self):
tenant = get_unittest_tenant_name()
results = get_custom_metadata('NC', tenant)
# check non-empty results
self.assertEqual(set(['subject1', 'subject2', 'branding']), results.keys(), "result map should contain two subjects' id")
subject1 = results.get('subject1')
self.assertIsNotNone(subject1, "subject1 should not be empty")
self.assertEqual(4, len(subject1[Constants.COLORS]), "subject 1 should contain 4 colors")
self.assertIsInstance(subject1[Constants.COLORS][0], dict, "subject 1 value should be a json object")
self.assertEqual(2, subject1[Constants.MIN_CELL_SIZE])
subject2 = results.get('subject2')
self.assertEqual(2, subject2[Constants.MIN_CELL_SIZE])
branding = results.get('branding')
self.assertEqual(branding['display'], 'North Carolina Reporting')
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):
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 test_add_context_with_tenant(self):
dummy_session = create_test_session([RolesConstants.PII])
dummy_session.set_user_context([RoleRelation(RolesConstants.PII, 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)
with UnittestEdcoreDBConnection() as connection:
fact = connection.get_table(Constants.FACT_ASMT_OUTCOME_VW)
query = select([fact.c.state_code], from_obj=[fact])
pii = PII(connection, RolesConstants.PII)
query = pii.add_context(get_unittest_tenant_name(), self.user, query)
result = connection.get_result(query)
self.assertEqual(1228, len(result))
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 test_add_context_with_state_level(self):
dummy_session = create_test_session([RolesConstants.PII])
dummy_session.set_user_context([RoleRelation(RolesConstants.PII, self.tenant, 'NC', 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)
# Checks that the query has applied where clause
with UnittestEdcoreDBConnection() as connection:
fact = connection.get_table(Constants.FACT_ASMT_OUTCOME_VW)
query = select([fact.c.student_id], from_obj=[fact])
pii = PII(connection, RolesConstants.PII)
query = pii.add_context(get_unittest_tenant_name(), self.user, query)
self.assertIsNotNone(query._whereclause)
result = connection.get_result(query)
self.assertEqual(len(result), 1228)
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 test_add_context_with_district_level(self):
dummy_session = create_test_session([RolesConstants.PII])
dummy_session.set_user_context(
[RoleRelation(RolesConstants.PII, self.tenant, 'NC', '228', 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)
# Checks that the query has applied where clause
with UnittestEdcoreDBConnection() as connection:
fact = connection.get_table(Constants.FACT_ASMT_OUTCOME_VW)
query = select([fact.c.state_code], from_obj=[fact])
pii = PII(connection, RolesConstants.PII)
query = pii.add_context(get_unittest_tenant_name(), self.user,
query)
result = connection.get_result(query)
self.assertEqual(344, len(result))
def test_get_custom_metadata(self):
tenant = get_unittest_tenant_name()
results = get_custom_metadata('NC', tenant)
# check non-empty results
self.assertEqual(set(['subject1', 'subject2', 'branding']),
results.keys(),
"result map should contain two subjects' id")
subject1 = results.get('subject1')
self.assertIsNotNone(subject1, "subject1 should not be empty")
self.assertEqual(4, len(subject1[Constants.COLORS]),
"subject 1 should contain 4 colors")
self.assertIsInstance(subject1[Constants.COLORS][0], dict,
"subject 1 value should be a json object")
self.assertEqual(2, subject1[Constants.MIN_CELL_SIZE])
subject2 = results.get('subject2')
self.assertEqual(2, subject2[Constants.MIN_CELL_SIZE])
branding = results.get('branding')
self.assertEqual(branding['display'], 'North Carolina Reporting')
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.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):
# 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_flush_district_view_report(self):
cache_trigger = CacheTrigger(get_unittest_tenant_name(), 'NC', {})
cache_trigger.recache_cpop_report('228')
def test_recache_state_view_report(self):
cache_trigger = CacheTrigger(get_unittest_tenant_name(), 'NC', {})
cache_trigger.recache_cpop_report()
def test_connector(self):
conn = EdCoreDBConnection(tenant=get_unittest_tenant_name())
self.assertIsInstance(conn, EdCoreDBConnection)
dim_student = conn.get_table('dim_student')
self.assertEqual(dim_student.name, 'dim_student')
