def test_can_save_prefs_as_superuser(self): self.db.query(User).delete() user = UserFactory(email='*****@*****.**', is_superuser=True) domain = DomainFactory.create(name='globo.com') key = KeyFactory.create(name='some.random') DomainsViolationsPrefsFactory.create(domain=domain, key=key, value=100) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({ 'value': 100, 'key': 'some.random' }) yield self.authenticated_fetch( '/domains/%s/violations-prefs/' % domain.name, user_email=user.email, method='POST', body=dumps([ {'key': 'some.random', 'value': 10}, ]) ) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({ 'value': 10, 'key': 'some.random' })
def test_can_update_by_domain(self): domain = DomainFactory.create(name='globo.com') DomainsViolationsPrefsFactory.create(domain=domain, key=Key(name='some.random'), value='whatever') loaded = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(loaded).not_to_be_null() expect(loaded).to_length(1) expect(loaded).to_be_like([{ 'key': 'some.random', 'value': 'whatever' }]) data = [{ 'key': 'some.random', 'value': '10' }, { 'invalid_key': 'some.random.1', 'invalid_value': '101' }] DomainsViolationsPrefs.update_by_domain(self.db, self.cache, domain, data) loaded = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(loaded).not_to_be_null() expect(loaded).to_length(1) expect(loaded).to_be_like([{'key': 'some.random', 'value': '10'}])
def test_can_update_by_domain(self): domain = DomainFactory.create(name='globo.com') DomainsViolationsPrefsFactory.create( domain=domain, key=Key(name='some.random'), value='whatever' ) loaded = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(loaded).not_to_be_null() expect(loaded).to_length(1) expect(loaded).to_be_like([{'key': 'some.random', 'value': 'whatever'}]) data = [ {'key': 'some.random', 'value': '10'}, {'invalid_key': 'some.random.1', 'invalid_value': '101'} ] DomainsViolationsPrefs.update_by_domain(self.db, self.cache, domain, data) loaded = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(loaded).not_to_be_null() expect(loaded).to_length(1) expect(loaded).to_be_like([{'key': 'some.random', 'value': '10'}])
def test_can_save_prefs_as_superuser(self): self.db.query(User).delete() user = UserFactory(email='*****@*****.**', is_superuser=True) domain = DomainFactory.create(name='globo.com') key = KeyFactory.create(name='some.random') DomainsViolationsPrefsFactory.create(domain=domain, key=key, value=100) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({ 'value': 100, 'key': 'some.random' }) yield self.authenticated_fetch('/domains/%s/violations-prefs/' % domain.name, user_email=user.email, method='POST', body=dumps([ { 'key': 'some.random', 'value': 10 }, ])) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({'value': 10, 'key': 'some.random'})
def test_can_insert_default_violations_values_for_all_domains(self): DomainsViolationsPrefsFactory.create(domain=Domain(name='globo.com'), key=Key(name='some.random.fact'), value='whatever') for x in range(3): DomainFactory.create(name='g%d.com' % x) domains_violations_prefs = \ DomainsViolationsPrefs.get_domains_violations_prefs(self.db) expect(domains_violations_prefs).to_length(1) default_violations_values = { 'page.title.size': 100, 'total.requests.img': 5, } page_title_size = KeyFactory.create(name='page.title.size') total_requests_img = KeyFactory.create(name='total.requests.img') violation_definitions = { 'page.title.size': { 'key': page_title_size, 'default_value': 100 }, 'total.requests.img': { 'key': total_requests_img, 'default_value': 5 } } DomainsViolationsPrefs.insert_default_violations_values_for_all_domains( self.db, default_violations_values, violation_definitions, self.cache) domains_violations_prefs = \ DomainsViolationsPrefs.get_domains_violations_prefs(self.db) expect(domains_violations_prefs).to_length(4) expect(domains_violations_prefs).to_be_like({ 'globo.com': { 'some.random.fact': 'whatever', 'total.requests.img': 5, 'page.title.size': 100 }, 'g0.com': { 'page.title.size': 100, 'total.requests.img': 5 }, 'g1.com': { 'page.title.size': 100, 'total.requests.img': 5 }, 'g2.com': { 'page.title.size': 100, 'total.requests.img': 5 }, })
def test_can_insert_default_violations_values_for_domain(self): domain = DomainFactory.create() page_title_size = KeyFactory.create(name='page.title.size') total_requests_img = KeyFactory.create(name='total.requests.img') violation_definitions = { 'page.title.size': {'key': page_title_size, 'default_value': 100}, 'total.requests.img': {'key': total_requests_img, 'default_value': 5} } keys = violation_definitions.keys() data = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(data).to_length(0) DomainsViolationsPrefs.insert_default_violations_values_for_domain( self.db, domain, keys, violation_definitions, self.cache ) data = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(data).not_to_be_null() expect(data).to_length(2) expect(data).to_be_like([ {'value': 100, 'key': 'page.title.size'}, {'value': 5, 'key': 'total.requests.img'} ])
def initialize(self): self.uuid = uuid4().hex self.working_url = None self.domain_name = None self.last_ping = None self.last_update_pages_score = None authnz_wrapper_class = self.load_authnz_wrapper() if authnz_wrapper_class: self.authnz_wrapper = authnz_wrapper_class(self.config) else: self.authnz_wrapper = None self.facters = self._load_facters() self.validators = self._load_validators() self.error_handlers = [handler(self.config) for handler in self.load_error_handlers()] self.connect_sqlalchemy() self.search_provider = self.load_search_provider()( config=self.config, db=self.db, authnz_wrapper=self.authnz_wrapper ) self.connect_to_redis() self.start_otto() self.fact_definitions = {} self.violation_definitions = {} self.default_violations_values = {} for facter in self.facters: self.fact_definitions.update(facter.get_fact_definitions()) Key.insert_keys(self.db, self.fact_definitions) for validator in self.validators: self.violation_definitions.update(validator.get_violation_definitions()) self.default_violations_values.update( validator.get_default_violations_values(self.config) ) Key.insert_keys( self.db, self.violation_definitions, self.default_violations_values ) self.configure_material_girl() DomainsViolationsPrefs.insert_default_violations_values_for_all_domains( self.db, self.default_violations_values, self.violation_definitions, self.cache ) self.load_all_domains_violations_prefs()
def test_can_update_by_domain_with_empty_data(self): domain = DomainFactory.create(name='globo.com') data = [] DomainsViolationsPrefs.update_by_domain(self.db, self.cache, domain, data) loaded = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(loaded).to_equal([])
def test_can_update_by_domain_with_empty_data(self): domain = DomainFactory.create(name='globo.com') data = [] DomainsViolationsPrefs.update_by_domain(self.db, self.cache, domain, data) loaded = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(loaded).to_equal([])
def initialize(self): self.uuid = uuid4().hex self.working_url = None self.domain_name = None self.last_ping = None authnz_wrapper_class = self.load_authnz_wrapper() if authnz_wrapper_class: self.authnz_wrapper = authnz_wrapper_class(self.config) else: self.authnz_wrapper = None self.facters = self._load_facters() self.validators = self._load_validators() self.error_handlers = [ handler(self.config) for handler in self.load_error_handlers() ] self.connect_sqlalchemy() self.search_provider = self.load_search_provider()( config=self.config, db=self.db, authnz_wrapper=self.authnz_wrapper) self.connect_to_redis() self.start_otto() self.fact_definitions = {} self.violation_definitions = {} self.default_violations_values = {} for facter in self.facters: self.fact_definitions.update(facter.get_fact_definitions()) Key.insert_keys(self.db, self.fact_definitions) for validator in self.validators: self.violation_definitions.update( validator.get_violation_definitions()) self.default_violations_values.update( validator.get_default_violations_values(self.config)) Key.insert_keys(self.db, self.violation_definitions, self.default_violations_values) self.configure_material_girl() DomainsViolationsPrefs.insert_default_violations_values_for_all_domains( self.db, self.default_violations_values, self.violation_definitions, self.cache) self.load_all_domains_violations_prefs()
def test_can_get_domains_violations_prefs_by_key(self): self.db.query(DomainsViolationsPrefs).delete() self.db.query(Page).delete() self.db.query(Domain).delete() self.db.query(Key).delete() domain = DomainFactory.create(name='t.com') page = PageFactory.create(domain=domain, url='http://t.com/a.html') prefs = DomainsViolationsPrefsFactory.create( domain=domain, key=Key(name='page.title.size'), value='70' ) reviewer = self.get_reviewer( page_uuid=page.uuid, page_url=page.url, cache=self.sync_cache ) # Get default value reviewer.violation_definitions = None self.sync_cache.redis.delete('violations-prefs-%s' % domain.name) prefs = reviewer.get_domains_violations_prefs_by_key(None) expect(prefs).to_be_null() prefs = reviewer.get_domains_violations_prefs_by_key('my-key') expect(prefs).to_be_null() reviewer.violation_definitions = { 'page.title.size': {'default_value': '70'}, } self.sync_cache.redis.delete('violations-prefs-%s' % domain.name) prefs = reviewer.get_domains_violations_prefs_by_key('my-key') expect(prefs).to_be_null() self.sync_cache.redis.delete('violations-prefs-%s' % domain.name) prefs = reviewer.get_domains_violations_prefs_by_key('page.title.size') expect(prefs).to_equal('70') # Get configured value data = [{'key': 'page.title.size', 'value': '10'}] DomainsViolationsPrefs.update_by_domain(self.db, self.sync_cache, domain, data) prefs = reviewer.get_domains_violations_prefs_by_key('page.title.size') expect(prefs).to_equal('10')
def test_can_insert_default_violations_values_for_all_domains(self): DomainsViolationsPrefsFactory.create( domain=Domain(name='globo.com'), key=Key(name='some.random.fact'), value='whatever' ) for x in range(3): DomainFactory.create(name='g%d.com' % x) domains_violations_prefs = \ DomainsViolationsPrefs.get_domains_violations_prefs(self.db) expect(domains_violations_prefs).to_length(1) default_violations_values = { 'page.title.size': 100, 'total.requests.img': 5, } page_title_size = KeyFactory.create(name='page.title.size') total_requests_img = KeyFactory.create(name='total.requests.img') violation_definitions = { 'page.title.size': {'key': page_title_size, 'default_value': 100}, 'total.requests.img': {'key': total_requests_img, 'default_value': 5} } DomainsViolationsPrefs.insert_default_violations_values_for_all_domains( self.db, default_violations_values, violation_definitions, self.cache ) domains_violations_prefs = \ DomainsViolationsPrefs.get_domains_violations_prefs(self.db) expect(domains_violations_prefs).to_length(4) expect(domains_violations_prefs).to_be_like({ 'globo.com': { 'some.random.fact': 'whatever', 'total.requests.img': 5, 'page.title.size': 100 }, 'g0.com': {'page.title.size': 100, 'total.requests.img': 5}, 'g1.com': {'page.title.size': 100, 'total.requests.img': 5}, 'g2.com': {'page.title.size': 100, 'total.requests.img': 5}, })
def test_can_get_domains_violations_prefs_by_key(self): self.db.query(DomainsViolationsPrefs).delete() self.db.query(Page).delete() self.db.query(Domain).delete() self.db.query(Key).delete() domain = DomainFactory.create(name='t.com') page = PageFactory.create(domain=domain, url='http://t.com/a.html') prefs = DomainsViolationsPrefsFactory.create( domain=domain, key=Key(name='page.title.size'), value='70') reviewer = self.get_reviewer(page_uuid=page.uuid, page_url=page.url, cache=self.sync_cache) # Get default value reviewer.violation_definitions = None self.sync_cache.redis.delete('violations-prefs-%s' % domain.name) prefs = reviewer.get_domains_violations_prefs_by_key(None) expect(prefs).to_be_null() prefs = reviewer.get_domains_violations_prefs_by_key('my-key') expect(prefs).to_be_null() reviewer.violation_definitions = { 'page.title.size': { 'default_value': '70' }, } self.sync_cache.redis.delete('violations-prefs-%s' % domain.name) prefs = reviewer.get_domains_violations_prefs_by_key('my-key') expect(prefs).to_be_null() self.sync_cache.redis.delete('violations-prefs-%s' % domain.name) prefs = reviewer.get_domains_violations_prefs_by_key('page.title.size') expect(prefs).to_equal('70') # Get configured value data = [{'key': 'page.title.size', 'value': '10'}] DomainsViolationsPrefs.update_by_domain(self.db, self.sync_cache, domain, data) prefs = reviewer.get_domains_violations_prefs_by_key('page.title.size') expect(prefs).to_equal('10')
def test_cant_save_prefs_as_normal_user(self): self.db.query(User).delete() user = UserFactory(email='*****@*****.**', is_superuser=False) domain = DomainFactory.create(name='globo.com') key = KeyFactory.create(name='some.random') DomainsViolationsPrefsFactory.create(domain=domain, key=key, value=100) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({ 'value': 100, 'key': 'some.random' }) try: yield self.authenticated_fetch( '/domains/%s/violations-prefs/' % domain.name, user_email=user.email, method='POST', body=dumps([ {'key': 'some.random', 'value': 10}, ]) ) except HTTPError, e: expect(e).not_to_be_null() expect(e.code).to_equal(401) expect(e.response.reason).to_be_like('Unauthorized')
def get(self, domain_name): domain = Domain.get_domain_by_name(domain_name, self.db) if not domain: self.set_status(404, self._('Domain %s not found') % domain_name) return prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name ) violation_defs = self.application.violation_definitions result = [] for pref in prefs: key = violation_defs.get(pref.get('key')) if key is None: continue result.append({ 'key': pref.get('key'), 'title': key.get('default_value_description', None), 'category': key.get('category', None), 'value': pref.get('value'), 'default_value': key.get('default_value', None), 'unit': key.get('unit', None) }) self.write_json(result)
def test_cant_save_prefs_as_normal_user(self): self.db.query(User).delete() user = UserFactory(email='*****@*****.**', is_superuser=False) domain = DomainFactory.create(name='globo.com') key = KeyFactory.create(name='some.random') DomainsViolationsPrefsFactory.create(domain=domain, key=key, value=100) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({ 'value': 100, 'key': 'some.random' }) try: yield self.authenticated_fetch('/domains/%s/violations-prefs/' % domain.name, user_email=user.email, method='POST', body=dumps([ { 'key': 'some.random', 'value': 10 }, ])) except HTTPError, e: expect(e).not_to_be_null() expect(e.code).to_equal(401) expect(e.response.reason).to_be_like('Unauthorized')
def test_cant_save_prefs_as_anonymous_user(self): domain = DomainFactory.create(name='globo.com') key = KeyFactory.create(name='some.random') DomainsViolationsPrefsFactory.create(domain=domain, key=key, value=100) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({ 'value': 100, 'key': 'some.random' }) try: yield self.anonymous_fetch('/domains/%s/violations-prefs/' % domain.name, method='POST', body=dumps([ { 'key': 'some.random', 'value': 10 }, ])) except HTTPError, e: expect(e).not_to_be_null() expect(e.code).to_equal(401) expect(e.response.reason).to_be_like('Unauthorized')
def add_domain(cls, url, db, publish_method, config, girl, default_violations_values, violation_definitions, cache): from holmes.models import Domain, DomainsViolationsPrefs from holmes.material import expire_materials domain_name, domain_url = get_domain_from_url(url) domains = ( db.query(Domain) .filter( or_( Domain.name == domain_name, Domain.name == domain_name.rstrip("/"), Domain.name == "%s/" % domain_name, ) ) .all() ) if not domains: domain = None else: domain = domains[0] if not domain: url_hash = hashlib.sha512(domain_url).hexdigest() domain = Domain(url=domain_url, url_hash=url_hash, name=domain_name) db.add(domain) db.flush() expire_materials(girl) publish_method(dumps({"type": "new-domain", "domainUrl": str(domain_url)})) keys = default_violations_values.keys() DomainsViolationsPrefs.insert_default_violations_values_for_domain( db, domain, keys, violation_definitions, cache ) from holmes.models import Limiter connections = config.DEFAULT_NUMBER_OF_CONCURRENT_CONNECTIONS Limiter.add_or_update_limiter(db, domain_url, connections) return domain
def add_domain(cls, url, db, publish_method, config, girl, default_violations_values, violation_definitions, cache): from holmes.models import Domain, DomainsViolationsPrefs from holmes.material import expire_materials domain_name, domain_url = get_domain_from_url(url) domains = db.query(Domain).filter( or_(Domain.name == domain_name, Domain.name == domain_name.rstrip('/'), Domain.name == "%s/" % domain_name)).all() if not domains: domain = None else: domain = domains[0] if not domain: url_hash = hashlib.sha512(domain_url).hexdigest() domain = Domain(url=domain_url, url_hash=url_hash, name=domain_name) db.add(domain) db.flush() expire_materials(girl) publish_method( dumps({ 'type': 'new-domain', 'domainUrl': str(domain_url) })) keys = default_violations_values.keys() DomainsViolationsPrefs.insert_default_violations_values_for_domain( db, domain, keys, violation_definitions, cache) from holmes.models import Limiter connections = config.DEFAULT_NUMBER_OF_CONCURRENT_CONNECTIONS Limiter.add_or_update_limiter(db, domain_url, connections) return domain
def test_can_insert_domains_violations_prefs(self): domain = DomainFactory.create() key = KeyFactory.create() value = '{"page.size": 100}' DomainsViolationsPrefs.insert_domains_violations_prefs( self.db, domain, key, value) data = self.db \ .query(DomainsViolationsPrefs) \ .filter( DomainsViolationsPrefs.key_id == key.id, DomainsViolationsPrefs.domain_id == domain.id, ) \ .all() expect(data).not_to_be_null() expect(data).to_length(1) expect(data[0].value).to_equal(value)
def test_can_insert_domains_violations_prefs(self): domain = DomainFactory.create() key = KeyFactory.create() value = '{"page.size": 100}' DomainsViolationsPrefs.insert_domains_violations_prefs( self.db, domain, key, value ) data = self.db \ .query(DomainsViolationsPrefs) \ .filter( DomainsViolationsPrefs.key_id == key.id, DomainsViolationsPrefs.domain_id == domain.id, ) \ .all() expect(data).not_to_be_null() expect(data).to_length(1) expect(data[0].value).to_equal(value)
def post(self, domain_name): if not self.validate_superuser(): return domain = Domain.get_domain_by_name(domain_name, self.db) if not domain: self.set_status(404, self._('Domain %s not found') % domain_name) return post_data = loads(self.request.body) DomainsViolationsPrefs.update_by_domain( self.db, self.cache, domain, post_data ) self.write_json({ 'reason': self._('Preferences successfully saved!'), 'description': self._('Preferences successfully saved!') })
def test_can_get_all_domains_violations_prefs(self): pref1 = DomainsViolationsPrefsFactory.create(value='whatever') pref2 = DomainsViolationsPrefsFactory.create(value='{"test": 10}') pref3 = DomainsViolationsPrefsFactory.create(value='["holmes", "ab"]') data = DomainsViolationsPrefs.get_all_domains_violations_prefs(self.db) expect(data).not_to_be_null() expect(data).to_length(3) expect(data[0]).to_equal(pref1) expect(data[1]).to_equal(pref2) expect(data[2]).to_equal(pref3)
def test_can_get_domains_violations_prefs(self): data = DomainsViolationsPrefsFactory.create( domain=Domain(name='globo.com'), key=Key(name='some.random.fact'), value='whatever') data = DomainsViolationsPrefs.get_domains_violations_prefs(self.db) expect(data).to_be_like( {'globo.com': { 'some.random.fact': 'whatever' }})
def test_can_insert_default_violations_values_for_domain(self): domain = DomainFactory.create() page_title_size = KeyFactory.create(name='page.title.size') total_requests_img = KeyFactory.create(name='total.requests.img') violation_definitions = { 'page.title.size': { 'key': page_title_size, 'default_value': 100 }, 'total.requests.img': { 'key': total_requests_img, 'default_value': 5 } } keys = violation_definitions.keys() data = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(data).to_length(0) DomainsViolationsPrefs.insert_default_violations_values_for_domain( self.db, domain, keys, violation_definitions, self.cache) data = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(data).not_to_be_null() expect(data).to_length(2) expect(data).to_be_like([{ 'value': 100, 'key': 'page.title.size' }, { 'value': 5, 'key': 'total.requests.img' }])
def test_can_get_domains_violations_prefs(self): data = DomainsViolationsPrefsFactory.create( domain=Domain(name='globo.com'), key=Key(name='some.random.fact'), value='whatever' ) data = DomainsViolationsPrefs.get_domains_violations_prefs(self.db) expect(data).to_be_like({ 'globo.com': { 'some.random.fact': 'whatever' } })
def test_cant_save_prefs_as_anonymous_user(self): domain = DomainFactory.create(name='globo.com') key = KeyFactory.create(name='some.random') DomainsViolationsPrefsFactory.create(domain=domain, key=key, value=100) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({ 'value': 100, 'key': 'some.random' }) try: yield self.anonymous_fetch( '/domains/%s/violations-prefs/' % domain.name, method='POST', body=dumps([ {'key': 'some.random', 'value': 10}, ]) ) except HTTPError, e: expect(e).not_to_be_null() expect(e.code).to_equal(401) expect(e.response.reason).to_be_like('Unauthorized')
def after_start(self, io_loop): if self.db is not None: self.application.db = self.db else: self.application.db = self.application.get_sqlalchemy_session() if self.debug: from sqltap import sqltap self.sqltap = sqltap.start() authnz_wrapper_class = self._load_authnz_wrapper() if authnz_wrapper_class: self.application.authnz_wrapper = authnz_wrapper_class(self.application.config) else: self.application.authnz_wrapper = None self.application.facters = self._load_facters() self.application.validators = self._load_validators() self.application.error_handlers = [handler(self.application.config) for handler in self._load_error_handlers()] self.application.search_provider = self._load_search_provider()( config=self.application.config, db=self.application.db, authnz_wrapper=self.application.authnz_wrapper, io_loop=io_loop ) self.application.fact_definitions = {} self.application.violation_definitions = {} self.application.default_violations_values = {} for facter in self.application.facters: self.application.fact_definitions.update(facter.get_fact_definitions()) Key.insert_keys(self.application.db, self.application.fact_definitions) for validator in self.application.validators: self.application.violation_definitions.update(validator.get_violation_definitions()) self.application.default_violations_values.update( validator.get_default_violations_values(self.application.config) ) Key.insert_keys( self.application.db, self.application.violation_definitions, self.application.default_violations_values ) self.application.event_bus = EventBus(self.application) self.application.http_client = AsyncHTTPClient(io_loop=io_loop) self.application.cache = Cache(self.application) self.configure_material_girl() self.configure_i18n() DomainsViolationsPrefs.insert_default_violations_values_for_all_domains( self.application.db, self.application.default_violations_values, self.application.violation_definitions, self.application.cache )
yield self.authenticated_fetch( '/domains/%s/violations-prefs/' % domain.name, user_email=user.email, method='POST', body=dumps([ {'key': 'some.random', 'value': 10}, ]) ) except HTTPError, e: expect(e).not_to_be_null() expect(e.code).to_equal(401) expect(e.response.reason).to_be_like('Unauthorized') else: assert False, 'Should not have got this far' loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({ 'value': 100, 'key': 'some.random' }) @gen_test def test_cant_save_prefs_as_anonymous_user(self): domain = DomainFactory.create(name='globo.com') key = KeyFactory.create(name='some.random') DomainsViolationsPrefsFactory.create(domain=domain, key=key, value=100) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({
def after_start(self, io_loop): if self.db is not None: self.application.db = self.db else: self.application.db = self.application.get_sqlalchemy_session() if self.debug: from sqltap import sqltap self.sqltap = sqltap.start() authnz_wrapper_class = self._load_authnz_wrapper() if authnz_wrapper_class: self.application.authnz_wrapper = authnz_wrapper_class( self.application.config) else: self.application.authnz_wrapper = None self.application.facters = self._load_facters() self.application.validators = self._load_validators() self.application.error_handlers = [ handler(self.application.config) for handler in self._load_error_handlers() ] self.application.search_provider = self._load_search_provider()( config=self.application.config, db=self.application.db, authnz_wrapper=self.application.authnz_wrapper, io_loop=io_loop) self.application.fact_definitions = {} self.application.violation_definitions = {} self.application.default_violations_values = {} for facter in self.application.facters: self.application.fact_definitions.update( facter.get_fact_definitions()) Key.insert_keys(self.application.db, self.application.fact_definitions) for validator in self.application.validators: self.application.violation_definitions.update( validator.get_violation_definitions()) self.application.default_violations_values.update( validator.get_default_violations_values( self.application.config)) Key.insert_keys(self.application.db, self.application.violation_definitions, self.application.default_violations_values) self.application.event_bus = EventBus(self.application) self.application.http_client = AsyncHTTPClient(io_loop=io_loop) self.application.cache = Cache(self.application) self.configure_material_girl() self.configure_i18n() DomainsViolationsPrefs.insert_default_violations_values_for_all_domains( self.application.db, self.application.default_violations_values, self.application.violation_definitions, self.application.cache)
def get_domain_violations_prefs(self, domain_name): return self.get_data( 'violations-prefs-%s' % (domain_name), int(self.config.DOMAINS_VIOLATIONS_PREFS_EXPIRATION_IN_SECONDS), lambda: DomainsViolationsPrefs.get_domains_violations_prefs_by_domain(self.db, domain_name) )
user_email=user.email, method='POST', body=dumps([ { 'key': 'some.random', 'value': 10 }, ])) except HTTPError, e: expect(e).not_to_be_null() expect(e.code).to_equal(401) expect(e.response.reason).to_be_like('Unauthorized') else: assert False, 'Should not have got this far' loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(loaded_prefs).to_length(1) expect(loaded_prefs[0]).to_be_like({ 'value': 100, 'key': 'some.random' }) @gen_test def test_cant_save_prefs_as_anonymous_user(self): domain = DomainFactory.create(name='globo.com') key = KeyFactory.create(name='some.random') DomainsViolationsPrefsFactory.create(domain=domain, key=key, value=100) loaded_prefs = DomainsViolationsPrefs.get_domains_violations_prefs_by_domain( self.db, domain.name) expect(loaded_prefs).to_length(1)