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 test_with_default_permission(self):
role_rel = [
RoleRelation('DEFAULT', 'tenant', 'NY', 'a', '1'),
RoleRelation('PII', 'tenant', 'NY', 'a', '1')
]
user = User()
user.set_context(role_rel)
roles = user.get_roles()
self.assertEqual(2, len(roles))
self.assertIn('DEFAULT', roles)
self.assertIn('PII', roles)
self.assertEqual(1, len(user.get_tenants()))
def test_tenantless(self):
role_rel = [
RoleRelation('badrole', None, None, None, None),
RoleRelation('PII', 'tenant1', 'NC', 'a', '2')
]
user = User()
user.set_context(role_rel)
roles = user.get_roles()
self.assertEqual(2, len(roles))
self.assertIn('DEFAULT', roles)
self.assertIn('PII', roles)
tenants = user.get_tenants()
self.assertEqual(3, len(tenants))
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_default_permission_gets_added(self):
role_rel = [
RoleRelation('badrole', 'tenant', 'NY', 'a', '1'),
RoleRelation('PII', 'tenant', 'NY', 'a', '2'),
RoleRelation('badrole2', 'tenant', 'NY', 'b', None)
]
user = User()
user.set_context(role_rel)
roles = user.get_roles()
self.assertEqual(2, len(roles))
self.assertIn('DEFAULT', roles)
self.assertIn('PII', roles)
self.assertEqual(1, len(user.get_tenants()))
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_without_state_code_with_no_access(self):
dummy_session = Session()
dummy_session.set_user_context(
[RoleRelation("TEACHER", 'idontexist', "AB", "228", "242")])
dummy_session.set_uid('a5ddfe12-740d-4487-9179-de70f6ac33be')
self.__config.testing_securitypolicy(dummy_session.get_user())
self.assertFalse(has_access_to_state({}))
def __create_session(roles, expire_in_secs, tenant_name):
# current local time
current_datetime = datetime.now()
# How long session lasts
expiration_datetime = datetime.now() + timedelta(seconds=expire_in_secs)
# create session SAML Response
session = Session()
# make a UUID based on the host ID and current time
__session_id = str(uuid.uuid4())
session.set_session_id(__session_id)
session.set_expiration(expiration_datetime)
session.set_last_access(current_datetime)
# set session rolerelations
relations = []
for role in roles:
# This creates State Level permission
relations.append(
RoleRelation(role, tenant_name,
get_state_code_mapping([tenant_name])[0], None, None))
session.set_user_context(relations)
# set user
__uid = str(uuid.uuid4())
session.set_uid(__uid)
# save current session
get_session_backend().create_new_session(session, overwrite_timeout=True)
return session
def test_get_chain_school_level_context(self):
role_rel = [RoleRelation('Role', 'tenant', 'NY', '123', 'abcd')]
uc = UserContext(role_rel)
chain = uc.get_chain('tenant', 'Role', {'stateCode': 'NY'})
self.assertFalse(chain['all'])
self.assertIn('123', chain['guid'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': '123'
})
self.assertFalse(chain['all'])
self.assertIn('abcd', chain['guid'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': '123',
'schoolId': 'abcd'
})
self.assertTrue(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'aaa'
})
self.assertFalse(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'aaa',
'schoolId': 'abcd'
})
self.assertFalse(chain['all'])
def test_get_chain_invalid_context(self):
role_rel = [
RoleRelation('Role', 'tenant', 'NY', 'District', 'School_1')
]
uc = UserContext(role_rel)
chain = uc.get_chain('tenant', 'Role', {'stateCode': 'NC'})
self.assertFalse(chain['all'])
self.assertEqual(len(chain['guid']), 0)
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'District_2'
})
self.assertFalse(chain['all'])
self.assertEqual(len(chain['guid']), 0)
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'District',
'schoolId': 'School_2'
})
self.assertFalse(chain['all'])
self.assertEqual(len(chain['guid']), 0)
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'District_3',
'schoolId': 'School_2'
})
self.assertFalse(chain['all'])
self.assertEqual(len(chain['guid']), 0)
def test_role_undefined(self):
role_rel = [RoleRelation('invalidrole', None, None, None, None)]
user = User()
user.set_context(role_rel)
roles = user.get_roles()
self.assertEqual(1, len(roles))
self.assertIn('DEFAULT', roles)
def test_get_chain_multi_context(self):
role_rel = [
RoleRelation('Role', 'tenant', 'NY', 'a', '1'),
RoleRelation('Role', 'tenant', 'NY', 'a', '2'),
RoleRelation('Role', 'tenant', 'NY', 'b', None)
]
uc = UserContext(role_rel)
chain = uc.get_chain('tenant', 'Role', {'stateCode': 'NY'})
self.assertFalse(chain['all'])
self.assertIn('a', chain['guid'])
self.assertIn('b', chain['guid'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'b'
})
self.assertTrue(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'b',
'schoolId': '3'
})
self.assertTrue(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'b',
'schoolId': '2'
})
self.assertTrue(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'a',
'schoolId': '2'
})
self.assertTrue(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'a',
'schoolId': '1'
})
self.assertTrue(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'a',
'schoolId': '3'
})
self.assertFalse(chain['all'])
def test_add_context_without_tenant(self):
dummy_session = create_test_session(
[RolesConstants.SRS_EXTRACTS, RolesConstants.SRC_EXTRACTS])
dummy_session.set_user_context([
RoleRelation(RolesConstants.SRS_EXTRACTS, None, None, None, None),
RoleRelation(RolesConstants.SRC_EXTRACTS, None, 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:
dim_student = connection.get_table(Constants.DIM_STUDENT)
query = select([dim_student.c.student_id], from_obj=[dim_student])
state_level = StateLevel(connection, RolesConstants.SRS_EXTRACTS)
query = state_level.add_context(self.tenant, self.user, query)
self.assertIsNone(query._whereclause)
def test_validate_hierarchy(self):
role_rel = [
RoleRelation('Role', 'tenant', 'NY', 'a', None),
RoleRelation('Role', 'tenant', 'NY', 'b', None)
]
uc = UserContext(role_rel)
result = uc.validate_hierarchy('tenant', 'Role', {'stateCode': 'NY'},
'stateCode')
self.assertFalse(result['all'])
self.assertIn('a', result['guid'])
self.assertIn('b', result['guid'])
result = uc.validate_hierarchy('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'a'
}, 'districtId')
self.assertTrue(result['all'])
result = uc.validate_hierarchy('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'b'
}, 'districtId')
self.assertTrue(result['all'])
result = uc.validate_hierarchy('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'c'
}, 'districtId')
self.assertFalse(result['all'])
result = uc.validate_hierarchy('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'c',
'schoolId': 'd'
}, 'schoolId')
self.assertFalse(result['all'])
result = uc.validate_hierarchy('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'a',
'schoolId': 'd'
}, 'schoolId')
self.assertTrue(result['all'])
result = uc.validate_hierarchy('tenant', 'Role', {
'stateCode': 'NY',
'districtId': 'b',
'schoolId': 'd'
}, 'schoolId')
self.assertTrue(result['all'])
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 get_role_relationship_chain(attributes):
'''
Returns role/relationship chain. Currently, based on LDIF, we only support one tenant
'''
roles = BasicIdentityParser.get_roles(attributes)
tenants = BasicIdentityParser.get_tenant_name(attributes)
return [
RoleRelation(roles[0], tenants[0],
get_state_code_mapping(tenants)[0], None, None)
]
def test_display_home(self):
Roles.set_roles([('Allow', 'CONSORTIUM_EDUCATION_ADMINISTRATOR_1',
('view', 'logout', 'display_home'))])
user = User()
rel_chain = [
RoleRelation('CONSORTIUM_EDUCATION_ADMINISTRATOR_1', 'CA', 'CA',
'1', '2')
]
user.set_context(rel_chain)
context = user.get_user_context()
self.assertTrue(context['displayHome'])
def test_consortium_level(self):
dummy_session = create_test_session([RolesConstants.PII])
dummy_session.set_user_context([
RoleRelation(RolesConstants.PII, None, None, None, None),
RoleRelation(RolesConstants.SRS_EXTRACTS, None, None, None, None),
RoleRelation(RolesConstants.SRC_EXTRACTS, None, None, 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.assertFalse(context['item_extracts']['all'])
self.assertTrue(context['audit_xml_extracts']['all'])
def test_user_context(self):
rel_chain = [
RoleRelation('CONSORTIUM_EDUCATION_ADMINISTRATOR_1', 'CA', 'CA',
'1', '2'),
RoleRelation('CONSORTIUM_EDUCATION_ADMINISTRATOR_1', 'CA', 'CA',
'1', '3'),
RoleRelation('CONSORTIUM_EDUCATION_ADMINISTRATOR_2', 'NY', 'NY',
'2', '4'),
RoleRelation('CONSORTIUM_EDUCATION_ADMINISTRATOR_1', 'CA', 'CA',
'1', None)
]
uc = UserContext(rel_chain)
self.assertEqual(
uc.get_districts('CA', 'CONSORTIUM_EDUCATION_ADMINISTRATOR_1'),
{'1'}, 'Must be district 1')
self.assertEqual(
uc.get_schools('CA', 'CONSORTIUM_EDUCATION_ADMINISTRATOR_1'),
{'3', '2'}, 'Must be schools {2, 3}')
self.assertEqual(
uc.get_schools('NY', 'CONSORTIUM_EDUCATION_ADMINISTRATOR_2'),
{'4'}, 'Must be school {4}')
def test_get_all_user_context(self):
rel_chain = [
RoleRelation('CONSORTIUM_EDUCATION_ADMINISTRATOR_1', 'CA', None,
None, None),
RoleRelation('CONSORTIUM_EDUCATION_ADMINISTRATOR_1', 'CA', 'CA',
'1', '3'),
RoleRelation('CONSORTIUM_EDUCATION_ADMINISTRATOR_2', 'CA', 'CA',
None, None),
RoleRelation('CONSORTIUM_EDUCATION_ADMINISTRATOR_1', 'CA', 'CA',
'1', None)
]
uc = UserContext(rel_chain)
all_context = uc.get_all_context(
'CA', 'CONSORTIUM_EDUCATION_ADMINISTRATOR_2')
self.assertEqual(all_context['state_code'], {'CA'})
self.assertEqual(all_context['district_id'], set())
self.assertEqual(all_context['school_id'], set())
all_context = uc.get_all_context(
'CA', 'CONSORTIUM_EDUCATION_ADMINISTRATOR_1')
self.assertEqual(all_context['state_code'], set())
self.assertEqual(all_context['district_id'], {'1'})
self.assertEqual(all_context['school_id'], {'3'})
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 test_add_context_with_state_level(self):
dummy_session = create_test_session(
[RolesConstants.SRS_EXTRACTS, RolesConstants.SRC_EXTRACTS])
dummy_session.set_user_context([
RoleRelation(RolesConstants.SRS_EXTRACTS, self.tenant, 'ZZ', None,
None),
RoleRelation(RolesConstants.SRC_EXTRACTS, self.tenant, 'ZZ', 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])
state_level = StateLevel(connection, RolesConstants.SRS_EXTRACTS)
query = state_level.add_context(get_unittest_tenant_name(),
self.user, query)
self.assertIsNotNone(query._whereclause)
result = connection.get_result(query)
self.assertEqual(len(result), 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 test_get_chain_state_level_context(self):
role_rel = [RoleRelation('Role', 'tenant', 'NY', None, None)]
uc = UserContext(role_rel)
chain = uc.get_chain('tenant', 'Role', {'stateCode': 'NY'})
self.assertTrue(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': '1234'
})
self.assertTrue(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NY',
'districtId': '1234',
'schoolId': 'abcd'
})
self.assertTrue(chain['all'])
def test_add_context_without_tenant(self):
dummy_session = create_test_session([RolesConstants.PII])
dummy_session.set_user_context(
[RoleRelation(RolesConstants.PII, None, 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(self.tenant, self.user, query)
result = connection.get_result(query)
self.assertEqual(1228, len(result))
def test_get_chain_tenant_context_bad_tenant(self):
role_rel = [RoleRelation('Role', 'tenant1', None, None, None)]
uc = UserContext(role_rel)
chain = uc.get_chain('tenant', 'Role', {'stateCode': 'NC'})
self.assertFalse(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NC',
'districtId': 'a'
})
self.assertFalse(chain['all'])
chain = uc.get_chain('tenant', 'Role', {
'stateCode': 'NC',
'districtId': 'a',
'schoolId': '1'
})
self.assertFalse(chain['all'])
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_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 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())
