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())