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.__request = DummyRequest() # Must set hook_zca to false to work with unittest_with_sqlite self.__config = testing.setUp(request=self.__request, hook_zca=False) self.__tenant_name = get_unittest_tenant_name() set_tenant_map({self.__tenant_name: "NC"}) defined_roles = [ (Allow, RolesConstants.PII, ('view', 'logout')), (Allow, RolesConstants.SRS_EXTRACTS, ('view', 'logout')), (Allow, RolesConstants.SRC_EXTRACTS, ('view', 'logout')), (Allow, RolesConstants.AUDIT_XML_EXTRACTS, ('view', 'logout')), (Allow, RolesConstants.ITEM_LEVEL_EXTRACTS, ('view', 'logout')) ] edauth.set_roles(defined_roles) dummy_session = create_test_session([RolesConstants.PII]) dummy_session.set_user_context([ RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC", "228", "242"), RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC", "228", "245"), RoleRelation(RolesConstants.SRS_EXTRACTS, get_unittest_tenant_name(), 'NC', None, None), RoleRelation(RolesConstants.SRC_EXTRACTS, get_unittest_tenant_name(), 'NC', None, None), RoleRelation(RolesConstants.AUDIT_XML_EXTRACTS, get_unittest_tenant_name(), 'NC', None, None) ]) # For Context Security, we need to save the user object self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self): self.reg = Registry() self.__work_zone_dir = tempfile.TemporaryDirectory() self.reg.settings = {'extract.work_zone_base_dir': '/tmp/work_zone', 'pickup.gatekeeper.t1': '/t/acb', 'pickup.gatekeeper.t2': '/a/df', 'pickup.gatekeeper.y': '/a/c', 'pickup.sftp.hostname': 'hostname.local.net', 'pickup.sftp.user': '******', 'pickup.sftp.private_key_file': '/home/users/myUser/.ssh/id_rsa', 'extract.available_grades': '3,4,5,6,7,8,11'} cache_opts = { 'cache.type': 'memory', 'cache.regions': 'public.data,public.filtered_data,public.shortlived' } CacheManager(**parse_cache_config_options(cache_opts)) # Set up user context self.__request = DummyRequest() # Must set hook_zca to false to work with unittest_with_sqlite self.__config = testing.setUp(registry=self.reg, request=self.__request, hook_zca=False) defined_roles = [(Allow, RolesConstants.SAR_EXTRACTS, ('view', 'logout'))] edauth.set_roles(defined_roles) set_tenant_map({get_unittest_tenant_name(): 'NC'}) dummy_session = create_test_session([RolesConstants.SAR_EXTRACTS]) self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self): self.reg = Registry() self.__work_zone_dir = tempfile.TemporaryDirectory() self.reg.settings = { 'extract.work_zone_base_dir': '/tmp/work_zone', 'extract.available_grades': '3,4,5,6,7,8,11', 'hpz.file_upload_base_url': 'http://somehost:82/files' } settings = {'extract.celery.CELERY_ALWAYS_EAGER': True} setup_celery(settings) cache_opts = { 'cache.type': 'memory', 'cache.regions': 'public.data,public.filtered_data,public.shortlived' } CacheManager(**parse_cache_config_options(cache_opts)) # Set up user context self.__request = DummyRequest() # Must set hook_zca to false to work with unittest_with_sqlite self.__config = testing.setUp(registry=self.reg, request=self.__request, hook_zca=False) defined_roles = [ (Allow, RolesConstants.SRS_EXTRACTS, ('view', 'logout')), (Allow, RolesConstants.SRC_EXTRACTS, ('view', 'logout')) ] edauth.set_roles(defined_roles) dummy_session = create_test_session( [RolesConstants.SRS_EXTRACTS, RolesConstants.SRC_EXTRACTS]) self.__config.testing_securitypolicy(dummy_session.get_user()) set_tenant_map({get_unittest_tenant_name(): 'NC'})
def setUp(self): cache_opts = { 'cache.type': 'memory', 'cache.regions': 'public.data,public.filtered_data,public.shortlived' } CacheManager(**parse_cache_config_options(cache_opts)) self.__request = DummyRequest() # Must set hook_zca to false to work with uniittest_with_sqlite reg = Registry() reg.settings = {} reg.settings = {'extract.available_grades': '3,4,5,6,7,8,9,11', 'hpz.file_upload_base_url': 'http://somehost:82/files', 'extract.raw_data_base_dir': '/opt/edware/raw_data'} self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False) self.__tenant_name = get_unittest_tenant_name() defined_roles = [(Allow, RolesConstants.AUDIT_XML_EXTRACTS, ('view', 'logout'))] edauth.set_roles(defined_roles) set_tenant_map({get_unittest_tenant_name(): 'NC'}) # Set up context security dummy_session = create_test_session([RolesConstants.AUDIT_XML_EXTRACTS]) self.__config.testing_securitypolicy(dummy_session.get_user()) # celery settings for UT settings = {'extract.celery.CELERY_ALWAYS_EAGER': True} setup_celery(settings) # for UT purposes smarter.extracts.format.json_column_mapping = {} set_tenant_map({'tomcat': 'NC'})
def setUp(self): self.reg = Registry() self.__temp_dir = tempfile.TemporaryDirectory() self.__work_zone_dir = os.path.join(self.__temp_dir.name, 'work_zone') self.__raw_data_base_dir = os.path.join(self.__temp_dir.name, 'raw_data') self.__item_level_base_dir = os.path.join(self.__temp_dir.name, 'item_level') self.reg.settings = {'extract.work_zone_base_dir': self.__work_zone_dir, 'hpz.file_upload_base_url': 'http://somehost:82/files', 'extract.available_grades': '3,4,5,6,7,8,11', 'extract.raw_data_base_dir': self.__raw_data_base_dir, 'extract.item_level_base_dir': self.__item_level_base_dir} settings = {'extract.celery.CELERY_ALWAYS_EAGER': True} setup_celery(settings) cache_opts = { 'cache.type': 'memory', 'cache.regions': 'public.data,public.filtered_data,public.shortlived' } CacheManager(**parse_cache_config_options(cache_opts)) # Set up user context self.__request = DummyRequest() # Must set hook_zca to false to work with unittest_with_sqlite self.__config = testing.setUp(registry=self.reg, request=self.__request, hook_zca=False) defined_roles = [(Allow, RolesConstants.SAR_EXTRACTS, ('view', 'logout')), (Allow, RolesConstants.AUDIT_XML_EXTRACTS, ('view', 'logout')), (Allow, RolesConstants.ITEM_LEVEL_EXTRACTS, ('view', 'logout'))] edauth.set_roles(defined_roles) dummy_session = create_test_session([RolesConstants.SAR_EXTRACTS, RolesConstants.AUDIT_XML_EXTRACTS, RolesConstants.ITEM_LEVEL_EXTRACTS]) self.__config.testing_securitypolicy(dummy_session.get_user()) set_tenant_map({get_unittest_tenant_name(): 'NC'})
def setUp(self): self.__request = DummyRequest() # Must set hook_zca to false to work with uniittest_with_sqlite reg = Registry() reg.settings = {} self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False) self.__tenant_name = get_unittest_tenant_name() defined_roles = [ (Allow, RolesConstants.SAR_EXTRACTS, ('view', 'logout')), (Allow, RolesConstants.ITEM_LEVEL_EXTRACTS, ('view', 'logout')), (Allow, RolesConstants.ITEM_LEVEL_EXTRACTS, ('view', 'logout')) ] edauth.set_roles(defined_roles) set_tenant_map({get_unittest_tenant_name(): 'NC'}) # Set up context security dummy_session = create_test_session([RolesConstants.SAR_EXTRACTS]) dummy_session.set_user_context([ RoleRelation(RolesConstants.SAR_EXTRACTS, get_unittest_tenant_name(), "NC", None, None), RoleRelation(RolesConstants.AUDIT_XML_EXTRACTS, get_unittest_tenant_name(), "NC", None, None), RoleRelation(RolesConstants.ITEM_LEVEL_EXTRACTS, get_unittest_tenant_name(), "NC", None, None) ]) self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self): self.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 main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ initialize_db(settings) configure(settings) # set beaker cache region set_cache_regions_from_settings(settings) config = Configurator(settings=settings, root_factory=RootFactory) # include edauth. Calls includeme config.include(edauth) # Pass edauth the roles/permission mapping that is defined in hpz edauth.set_roles(RootFactory.__acl__) # include add routes from frs. Calls includeme config.include(frs) config.include(swi) config.include(services) config.scan() # Clean up old files from HPZ run_cron_job(settings, HPZ_EXPIRATION + '.', cleanup) logger.info("HPZ Started") return config.make_wsgi_app()
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_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 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 setUp(self): defined_roles = [(Allow, RolesConstants.PII, ('view', 'logout')), (Allow, RolesConstants.SAR_EXTRACTS, ('view', 'logout'))] edauth.set_roles(defined_roles) self.tenant = get_unittest_tenant_name() set_tenant_map({self.tenant: "NC"}) dummy_session = create_test_session([RolesConstants.PII]) dummy_session.set_user_context([RoleRelation(RolesConstants.PII, get_unittest_tenant_name(), "NC", "228", "242"), RoleRelation(RolesConstants.SAR_EXTRACTS, get_unittest_tenant_name(), "NC", "228", "242")]) self.user = dummy_session.get_user() self.__request = DummyRequest() self.__config = testing.setUp(request=self.__request, hook_zca=False) self.__config.testing_securitypolicy(self.user)
def setUp(self): cache_opts = {'cache.type': 'memory', 'cache.regions': 'public.data'} CacheManager(**parse_cache_config_options(cache_opts)) self.__request = DummyRequest() # Must set hook_zca to false to work with unittest_with_sqlite self.__config = testing.setUp(request=self.__request, hook_zca=False) defined_roles = [(Allow, RolesConstants.PII, ('view', 'logout'))] edauth.set_roles(defined_roles) set_tenant_map({get_unittest_tenant_name(): 'NC'}) # Set up context security dummy_session = create_test_session([RolesConstants.PII]) self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self): self.__request = DummyRequest() reg = Registry() reg.settings = {} reg.settings['cache.expire'] = 10 reg.settings['cache.regions'] = 'session' reg.settings['cache.type'] = 'memory' self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False) defined_roles = [(Allow, RolesConstants.PII, ('view', 'logout'))] edauth.set_roles(defined_roles) set_tenant_map({get_unittest_tenant_name(): 'NC'}) # Set up context security dummy_session = create_test_session([RolesConstants.PII]) self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self): self.__request = DummyRequest() reg = Registry() # Set up defined roles defined_roles = [(Allow, 'TEACHER', ('view', 'logout'))] edauth.set_roles(defined_roles) self.__tenant_name = get_unittest_tenant_name() set_tenant_map({self.__tenant_name: "NC", "tenantName": "WA"}) self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False) dummy_session = Session() dummy_session.set_user_context([RoleRelation("TEACHER", self.__tenant_name, "NC", "228", "242")]) dummy_session.set_uid('a5ddfe12-740d-4487-9179-de70f6ac33be') self.__config.testing_securitypolicy(dummy_session.get_user())
def setUp(self): self.__request = DummyRequest() # Must set hook_zca to false to work with uniittest_with_sqlite 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 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 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.__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.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_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.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): cache_opts = { 'cache.type': 'memory', 'cache.regions': 'public.data,public.filtered_data,public.shortlived,public.very_shortlived' } CacheManager(**parse_cache_config_options(cache_opts)) self.__request = DummyRequest() self.__tenant_name = get_unittest_tenant_name() set_tenant_map({self.__tenant_name: "NC"}) # Must set hook_zca to false to work with unittest_with_sqlite. self.__config = testing.setUp(request=self.__request, hook_zca=False) defined_roles = [(Allow, 'PII', ('view', 'logout'))] edauth.set_roles(defined_roles) # Set up context security dummy_session = create_test_session(['PII']) dummy_session.set_user_context([RoleRelation("PII", get_unittest_tenant_name(), "NC", "228", None)]) self.__config.testing_securitypolicy(dummy_session.get_user()) set_default_min_cell_size(0)
def setUp(self): 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 main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ # Configure for environment set_environment_path_variable(settings) configure(settings) config = Configurator(settings=settings, root_factory=RootFactory) # Pass edauth the roles/permission mapping config.include(edauth) edauth.set_roles(RootFactory.__acl__) # include add routes from edapi. Calls includeme config.include(edapi) here = os.path.abspath(os.path.dirname(__file__)) xsd_file = os.path.join(here, settings['smarter_score_batcher.xsd.path']) xsd.xsd = xsd.XSD(xsd_file) mode = settings.get('mode', 'prod').upper() init_db = False if mode == 'PROD' else True # Set up celery. Important - This must happen before scan # We don't need to initialize the db in Prod mode as only celery workers needs db connection setup_xml_celery(settings, prefix=prefix, db_connection=init_db) set_cache_regions_from_settings( get_config_from_ini(settings, 'smarter_score_batcher', True)) config.add_route('xml', '/services/xml') config.add_route('error', '/error') config.add_route('heartbeat', '/services/heartbeat') config.scan(ignore=[ 'smarter_score_batcher.custom', 'smarter_score_batcher.tests.custom' ]) # Set default permission config.set_default_permission(Permission.LOAD) logger.info("Smarter tsb started") return config.make_wsgi_app()
def setUp(self): defined_roles = [ (Allow, RolesConstants.SRS_EXTRACTS, ('view', 'logout')), (Allow, RolesConstants.SRC_EXTRACTS, ('view', 'logout')) ] self.role_constants = [ RolesConstants.SRS_EXTRACTS, RolesConstants.SRC_EXTRACTS ] edauth.set_roles(defined_roles) self.tenant = get_unittest_tenant_name() set_tenant_map({self.tenant: 'ES'}) dummy_session = create_test_session( [RolesConstants.SRS_EXTRACTS, RolesConstants.SRC_EXTRACTS]) dummy_session.set_user_context([ RoleRelation(RolesConstants.SRS_EXTRACTS, self.tenant, None, None, None), RoleRelation(RolesConstants.SRC_EXTRACTS, self.tenant, None, None, None) ]) self.user = dummy_session.get_user() self.__request = DummyRequest() self.__config = testing.setUp(request=self.__request, hook_zca=False) self.__config.testing_securitypolicy(self.user)
def setUp(self): cache_opts = { 'cache.type': 'memory', 'cache.regions': 'public.data,public.filtered_data,public.shortlived,public.very_shortlived' } CacheManager(**parse_cache_config_options(cache_opts)) self.__request = DummyRequest() self.__tenant_name = get_unittest_tenant_name() set_tenant_map({self.__tenant_name: "NC"}) # Must set hook_zca to false to work with unittest_with_sqlite. self.__config = testing.setUp(request=self.__request, hook_zca=False) defined_roles = [(Allow, 'PII', ('view', 'logout'))] edauth.set_roles(defined_roles) # Set up context security dummy_session = create_test_session(['PII']) dummy_session.set_user_context([ RoleRelation("PII", get_unittest_tenant_name(), "NC", "228", None) ]) self.__config.testing_securitypolicy(dummy_session.get_user()) set_default_min_cell_size(0)
def setUp(self): cache_opts = { 'cache.type': 'memory', 'cache.regions': 'public.shortlived' } CacheManager(**parse_cache_config_options(cache_opts)) self.__request = DummyRequest() # Must set hook_zca to false to work with 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 main(global_config, **settings): """ Starting point for the Smarter application. Prepares the environment and applies configurations. Sets paths, permissions, routes. Calls includeme methods of EdAuth, EdApi, and EdServices. Returns a Pyramid WSGI application. """ mode = settings.get('mode', 'prod').upper() # read remote config if mode == 'PROD' and 'edware.remote_config.url' in settings: url = settings['edware.remote_config.url'] settings = get_remote_config(url) # Prepare for environment specific set_environment_path_variable(settings) prepare_env(settings) # set beaker cache region set_cache_regions_from_settings(settings) config = Configurator(settings=settings, root_factory=RootFactory) tenant_mapping = initialize_db(EdCoreDBConnection, settings) tenant_mapping_public = initialize_db(PublicDBConnection, settings) initialize_db(StatsDBConnection, settings, allow_schema_create=True) # save tenancy mapping set_tenant_map(tenant_mapping) # save tenant mapping for public reports set_tenant_map_public_reports(tenant_mapping_public) year_back = settings['smarter.reports.year_back'] set_default_year_back(year_back) # setup celery setup_services_celery(settings, prefix=servicesPrefix) setup_extract_celery(settings, prefix=edextractPrefix) initialize_hpz(settings) # include edauth. Calls includeme config.include(edauth) # Pass edauth the roles/permission mapping that is defined in smarter edauth.set_roles(RootFactory.__acl__) # include add routes from edapi. Calls includeme config.include(edapi) # Get absolute paths here = os.path.abspath(os.path.dirname(__file__)) assets_dir = os.path.abspath(os.path.join(os.path.join(here, '..'), 'assets')) static_max_age = int(settings.get('smarter.resources.static.max_age', 3600)) config.add_static_view('assets/css', os.path.join(assets_dir, 'css'), cache_max_age=static_max_age) config.add_static_view('assets/data', os.path.join(assets_dir, 'data'), cache_max_age=static_max_age) config.add_static_view('assets/images', os.path.join(assets_dir, 'images'), cache_max_age=static_max_age) config.add_static_view('assets/js', os.path.join(assets_dir, 'js'), cache_max_age=static_max_age) config.add_static_view('assets/html', os.path.join(assets_dir, 'html'), cache_max_age=static_max_age) config.add_static_view('assets/public', os.path.join(assets_dir, 'public'), cache_max_age=static_max_age, permission=pyramid.security.NO_PERMISSION_REQUIRED) # Only expose test in non-production modes if mode != 'PROD': config.add_static_view('assets/test', os.path.join(assets_dir, 'test'), cache_max_age=static_max_age) disable_stack_trace = settings.get('disable_stack_trace', 'False').upper() if disable_stack_trace == 'TRUE': # we would like to disable the stack trace when we are in production mode sys.tracebacklimit = 0 # route for error config.add_route('error', '/assets/public/error.html') # include add routes from smarter.services. Calls includeme config.include(services) # include add routes from smarter.trigger. Calls includeme config.include(trigger) # scans smarter config.scan() # Set default permission on all views config.set_default_permission(Permission.VIEW) logger.info("Smarter started") return config.make_wsgi_app()
def setUp(self): defined_roles = [(Allow, 'PII', ('view', 'logout')), (Allow, 'DEFAULT', ('view', 'logout', 'default'))] edauth.set_roles(defined_roles) set_tenant_map({'tenant1': 'NC', 'tenant2': 'CA', 'tenant3': 'WA'})
def main(global_config, **settings): """ Starting point for the Smarter application. Prepares the environment and applies configurations. Sets paths, permissions, routes. Calls includeme methods of EdAuth, EdApi, and EdServices. Returns a Pyramid WSGI application. """ mode = settings.get('mode', 'prod').upper() # read remote config if mode == 'PROD' and 'edware.remote_config.url' in settings: url = settings['edware.remote_config.url'] settings = get_remote_config(url) # Prepare for environment specific set_environment_path_variable(settings) prepare_env(settings) # set beaker cache region set_cache_regions_from_settings(settings) config = Configurator(settings=settings, root_factory=RootFactory) tenant_mapping = initialize_db(EdCoreDBConnection, settings) tenant_mapping_public = initialize_db(PublicDBConnection, settings) initialize_db(StatsDBConnection, settings, allow_schema_create=True) # save tenancy mapping set_tenant_map(tenant_mapping) # save tenant mapping for public reports set_tenant_map_public_reports(tenant_mapping_public) year_back = settings['smarter.reports.year_back'] set_default_year_back(year_back) # setup celery setup_services_celery(settings, prefix=servicesPrefix) setup_extract_celery(settings, prefix=edextractPrefix) initialize_hpz(settings) # include edauth. Calls includeme config.include(edauth) # Pass edauth the roles/permission mapping that is defined in smarter edauth.set_roles(RootFactory.__acl__) # include add routes from edapi. Calls includeme config.include(edapi) # Get absolute paths here = os.path.abspath(os.path.dirname(__file__)) assets_dir = os.path.abspath( os.path.join(os.path.join(here, '..'), 'assets')) static_max_age = int(settings.get('smarter.resources.static.max_age', 3600)) config.add_static_view('assets/css', os.path.join(assets_dir, 'css'), cache_max_age=static_max_age) config.add_static_view('assets/data', os.path.join(assets_dir, 'data'), cache_max_age=static_max_age) config.add_static_view('assets/images', os.path.join(assets_dir, 'images'), cache_max_age=static_max_age) config.add_static_view('assets/js', os.path.join(assets_dir, 'js'), cache_max_age=static_max_age) config.add_static_view('assets/html', os.path.join(assets_dir, 'html'), cache_max_age=static_max_age) config.add_static_view('assets/public', os.path.join(assets_dir, 'public'), cache_max_age=static_max_age, permission=pyramid.security.NO_PERMISSION_REQUIRED) # Only expose test in non-production modes if mode != 'PROD': config.add_static_view('assets/test', os.path.join(assets_dir, 'test'), cache_max_age=static_max_age) disable_stack_trace = settings.get('disable_stack_trace', 'False').upper() if disable_stack_trace == 'TRUE': # we would like to disable the stack trace when we are in production mode sys.tracebacklimit = 0 # route for error config.add_route('error', '/assets/public/error.html') # include add routes from smarter.services. Calls includeme config.include(services) # include add routes from smarter.trigger. Calls includeme config.include(trigger) # scans smarter config.scan() # Set default permission on all views config.set_default_permission(Permission.VIEW) logger.info("Smarter started") return config.make_wsgi_app()
def setUp(self): defined_roles = [(Allow, 'TEACHER', ('view', 'logout')), (Allow, 'SPECIALUSER', ('view', 'logout'))] edauth.set_roles(defined_roles)