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_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_create_facts(self):
fact = FactFactory.create(key=Key(name='some.random.fact'),
value='whatever')
loaded_fact = self.db.query(Fact).get(fact.id)
expect(loaded_fact.key.name).to_equal('some.random.fact')
expect(loaded_fact.value).to_equal('whatever')
def test_fact_str(self):
fact = FactFactory.create(
key=Key(name="some.random.fact"),
value=1203,
)
loaded_fact = self.db.query(Fact).get(fact.id)
expect(str(loaded_fact)).to_be_like('some.random.fact: 1203')
def test_can_validate_title_size_with_domain(self):
self.db.query(Key).delete()
self.db.query(KeysCategory).delete()
config = Config()
config.MAX_TITLE_SIZE = 70
key = Key(name='page.title.size')
domain = DomainFactory.create(name='globo.com', url='http://globo.com')
page = PageFactory.create(domain=domain, url='http://globo.com/a.html')
self.sync_cache.redis.delete('violations-prefs-%s' % domain.name)
DomainsViolationsPrefsFactory.create(domain=domain,
key=key,
value='10')
reviewer = Reviewer(api_url='http://localhost:2368',
page_uuid=page.uuid,
page_url=page.url,
page_score=0.0,
config=config,
validators=[],
cache=self.sync_cache)
title = 'a' * 80
content = '<html><title>%s</title></html>' % title
result = {
'url': page.url,
'status': 200,
'content': content,
'html': lxml.html.fromstring(content)
}
reviewer.responses[page.url] = result
reviewer.get_response = Mock(return_value=result)
reviewer.violation_definitions = {
'page.title.size': {
'default_value': 70,
'key': key
},
}
validator = TitleValidator(reviewer)
validator.add_violation = Mock()
validator.review.data = {'page.title_count': 1, 'page.title': title}
validator.validate()
validator.add_violation.assert_called_once_with(key='page.title.size',
value={
'max_size': 10,
'page_url':
page.url
},
points=10)
def test_users_violations_prefs_str(self):
data = UsersViolationsPrefsFactory.create(
user=User(email='*****@*****.**', fullname='Sherlock Holmes'),
key=Key(name='some.random.fact'),
is_active=False)
loaded = self.db.query(UsersViolationsPrefs).get(data.id)
expect(str(loaded)).to_be_like('[email protected]: some.random.fact')
def test_domains_violations_prefs_str(self):
data = DomainsViolationsPrefsFactory.create(
domain=Domain(name='globo.com'),
key=Key(name='some.random.fact'),
value='whatever')
loaded = self.db.query(DomainsViolationsPrefs).get(data.id)
expect(
str(loaded)).to_be_like('some.random.fact (globo.com): whatever')
def test_can_create_domains_violations_prefs(self):
data = DomainsViolationsPrefsFactory.create(
domain=Domain(name='globo.com'),
key=Key(name='some.random.fact'),
value='whatever')
loaded = self.db.query(DomainsViolationsPrefs).get(data.id)
expect(loaded.domain.name).to_equal('globo.com')
expect(loaded.key.name).to_equal('some.random.fact')
expect(loaded.value).to_equal('whatever')
def test_can_convert_to_dict(self):
data = DomainsViolationsPrefsFactory.create(
domain=Domain(name='globo.com'),
key=Key(name='some.random.fact'),
value='whatever')
expect(data.to_dict()).to_be_like({
'domain': 'globo.com',
'key': 'some.random.fact',
'value': 'whatever',
})
def test_can_convert_to_dict(self):
data = UsersViolationsPrefsFactory.create(
user=User(email='*****@*****.**', fullname='Sherlock Holmes'),
key=Key(name='some.random.fact'),
is_active=False)
expect(data.to_dict()).to_be_like({
'user': '******',
'key': 'some.random.fact',
'is_active': False
})
def test_can_create_users_violations_prefs(self):
data = UsersViolationsPrefsFactory.create(
user=User(email='*****@*****.**', fullname='Sherlock Holmes'),
key=Key(name='some.random.fact'),
is_active=False)
loaded = self.db.query(UsersViolationsPrefs).get(data.id)
expect(loaded.user.email).to_equal('*****@*****.**')
expect(loaded.key.name).to_equal('some.random.fact')
expect(loaded.is_active).to_equal(False)
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_create_violation(self):
violation = ViolationFactory.create(key=Key(name='some.random.fact'),
value='value',
points=1203)
loaded_violation = self.db.query(Violation).get(violation.id)
expect(loaded_violation.value).to_equal('value')
expect(loaded_violation.key.name).to_equal('some.random.fact')
expect(loaded_violation.points).to_equal(1203)
expect(str(loaded_violation)).to_be_like('%s: %s' % (
violation.key.name,
violation.value,
))
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_to_dict(self):
violation = ViolationFactory.create(
key=Key(name='some.random.fact'),
value='value',
points=1203,
)
violations_definitions = {'some.random.fact': {}}
expect(violation.to_dict(violations_definitions, _)).to_be_like({
'key': 'some.random.fact',
'description': 'value',
'title': 'undefined',
'points': 1203,
'category': 'undefined'
})
def test_to_dict(self):
fact = FactFactory.create(
key=Key(name='some.random.fact'),
value='whatever',
)
facts_definitions = {'some.random.fact': {}}
expect(fact.to_dict(facts_definitions, _)).to_be_like({
'key':
'some.random.fact',
'value':
'whatever',
'unit':
'value',
'title':
'unknown',
'category':
'unknown'
})
def test_to_dict_with_violations_definitions_params(self):
violation1 = ViolationFactory.create(
key=Key(name='some.random.fact.1'),
value='value',
points=120,
)
violation2 = ViolationFactory.create(
key=Key(name='some.random.fact.2'),
value='violations',
points=500,
)
violation3 = ViolationFactory.create(
key=Key(name='some.random.fact.3'),
value={'page_url': 'http://globo.com'},
points=300,
)
violation4 = ViolationFactory.create(
key=Key(name='some.random.fact.4'),
value=None,
points=100,
)
violations_definitions = {
'some.random.fact.1': {
'description': 'test'
},
'some.random.fact.2': {
'description': 'test for: %s'
},
'some.random.fact.3': {
'description': 'url: %(page_url)s'
},
'some.random.fact.4': {
'description': 'my description'
},
}
expect(violation1.to_dict(violations_definitions, _)).to_be_like({
'key':
'some.random.fact.1',
'description':
'test',
'title':
'undefined',
'points':
120,
'category':
'undefined'
})
expect(violation2.to_dict(violations_definitions, _)).to_be_like({
'key':
'some.random.fact.2',
'description':
'test for: violations',
'title':
'undefined',
'points':
500,
'category':
'undefined'
})
expect(violation3.to_dict(violations_definitions, _)).to_be_like({
'key':
'some.random.fact.3',
'description':
'url: http://globo.com',
'title':
'undefined',
'points':
300,
'category':
'undefined'
})
expect(violation4.to_dict(violations_definitions, _)).to_be_like({
'key':
'some.random.fact.4',
'description':
'my description',
'title':
'undefined',
'points':
100,
'category':
'undefined'
})
