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