def test_can_get_review_by_uuid(self):
review = ReviewFactory.create()
loaded = Review.by_uuid(review.uuid, self.db)
expect(loaded.id).to_equal(review.id)
invalid = Review.by_uuid(uuid4(), self.db)
expect(invalid).to_be_null()
def test_can_get_review_by_uuid(self):
review = ReviewFactory.create()
loaded = Review.by_uuid(review.uuid, self.db)
expect(loaded.id).to_equal(review.id)
invalid = Review.by_uuid(uuid4(), self.db)
expect(invalid).to_be_null()
def save_review(self):
from holmes.models import Review
data = self.review_dao.to_dict()
Review.save_review(self.page_uuid, data, self.db, self.search_provider,
self.fact_definitions, self.violation_definitions,
self.cache, self.publish, self.config)
def save_review(self):
from holmes.models import Review
data = self.review_dao.to_dict()
Review.save_review(
self.page_uuid, data, self.db, self.search_provider,
self.fact_definitions, self.violation_definitions,
self.cache, self.publish, self.config
)
def get(self, page_uuid, review_uuid):
review = None
page = None
if self._parse_uuid(review_uuid):
review = Review.by_uuid(review_uuid, self.db)
if self._parse_uuid(page_uuid):
page = Page.by_uuid(page_uuid, self.db)
if not review and page:
self.redirect('/page/%s/review/%s/' % (page_uuid, page.last_review_uuid))
return
if not page:
self.set_status(404, self._('Page UUID [%s] not found') % page_uuid)
return
result = review.to_dict(self.application.fact_definitions,
self.application.violation_definitions,
self._)
result.update({
'violationPoints': review.get_violation_points(),
'violationCount': review.violation_count,
})
self.write_json(result)
def get(self, page_uuid, review_uuid):
review = None
page = None
if self._parse_uuid(review_uuid):
review = Review.by_uuid(review_uuid, self.db)
if self._parse_uuid(page_uuid):
page = Page.by_uuid(page_uuid, self.db)
if not review and page:
self.redirect('/page/%s/review/%s/' %
(page_uuid, page.last_review_uuid))
return
if not page:
self.set_status(404,
self._('Page UUID [%s] not found') % page_uuid)
return
result = review.to_dict(self.application.fact_definitions,
self.application.violation_definitions, self._)
result.update({
'violationPoints': review.get_violation_points(),
'violationCount': review.violation_count,
})
self.write_json(result)
def test_can_get_last_reviews(self):
dt = datetime(2010, 10, 10, 10, 10, 10)
dt2 = datetime(2010, 10, 11, 10, 10, 10)
dt3 = datetime(2010, 10, 12, 10, 10, 10)
review = ReviewFactory.create(is_active=True,
is_complete=True,
completed_date=dt3)
review2 = ReviewFactory.create(is_active=True,
is_complete=True,
completed_date=dt2)
ReviewFactory.create(is_active=True,
is_complete=True,
completed_date=dt)
ReviewFactory.create(is_active=False,
is_complete=True,
completed_date=dt)
ReviewFactory.create(is_active=False,
is_complete=True,
completed_date=dt)
ReviewFactory.create(is_active=False,
is_complete=True,
completed_date=dt)
ReviewFactory.create(is_active=False,
is_complete=True,
completed_date=dt)
ReviewFactory.create(is_active=False,
is_complete=True,
completed_date=dt)
last_reviews = Review.get_last_reviews(self.db, limit=2)
expect(last_reviews).to_length(2)
expect(last_reviews[0].id).to_equal(review.id)
expect(last_reviews[1].id).to_equal(review2.id)
def test_remove_old_reviews(self):
self.db.query(Violation).delete()
self.db.query(Fact).delete()
self.db.query(Key).delete()
self.db.query(Review).delete()
self.db.query(Page).delete()
config = Config()
config.NUMBER_OF_REVIEWS_TO_KEEP = 4
dt = datetime(2013, 12, 11, 10, 9, 8)
page1 = PageFactory.create()
ReviewFactory.create(page=page1,
is_active=True,
completed_date=dt,
number_of_violations=1,
number_of_facts=1)
page2 = PageFactory.create()
ReviewFactory.create(page=page2, is_active=True, completed_date=dt)
for x in range(6):
dt = datetime(2013, 12, 11, 10, 10, x)
ReviewFactory.create(page=page1,
is_active=False,
completed_date=dt,
number_of_violations=2,
number_of_facts=1)
self.db.flush()
reviews = self.db.query(Review).all()
expect(reviews).to_length(8)
violations = self.db.query(Violation).all()
expect(violations).to_length(13)
facts = self.db.query(Fact).all()
expect(facts).to_length(7)
Review.delete_old_reviews(self.db, config, page1)
reviews = self.db.query(Review).all()
expect(reviews).to_length(6)
violations = self.db.query(Violation).all()
expect(violations).to_length(9)
facts = self.db.query(Fact).all()
expect(facts).to_length(5)
def get(self, key_name):
current_page = int(self.get_argument('current_page', 1))
page_size = int(self.get_argument('page_size', 10))
domain_filter = self.get_argument('domain_filter', None)
page_filter = self.get_argument('page_filter', None)
violations = self.application.violation_definitions
violation_title = violations[key_name]['title']
key_id = violations[key_name]['key'].id
reviews = Review.get_by_violation_key_name(
self.db,
key_id,
current_page=current_page,
page_size=page_size,
domain_filter=domain_filter,
page_filter=page_filter,
)
reviews_count = Review.count_by_violation_key_name(
self.db,
key_id,
domain_filter=domain_filter,
page_filter=page_filter
)
reviews_data = []
for item in reviews:
reviews_data.append({
'uuid': item.review_uuid,
'page': {
'uuid': item.page_uuid,
'url': item.url,
'completedAt': item.completed_date
}
})
violation = {
'title': violation_title,
'reviews': reviews_data,
'reviewsCount': reviews_count
}
self.write_json(violation)
self.finish()
def test_can_get_last_reviews_with_domain_filter(self):
dt1 = datetime(2010, 10, 10, 10, 10, 10)
dt2 = datetime(2010, 10, 11, 10, 10, 10)
dt3 = datetime(2010, 10, 12, 10, 10, 10)
domain1 = DomainFactory.create()
domain2 = DomainFactory.create()
page1 = PageFactory.create(domain=domain1)
page2 = PageFactory.create(domain=domain2)
domain1_review1 = ReviewFactory.create(is_active=True,
is_complete=True,
page=page1,
completed_date=dt1)
domain1_review2 = ReviewFactory.create(is_active=True,
is_complete=True,
page=page1,
completed_date=dt2)
domain1_review3 = ReviewFactory.create(is_active=True,
is_complete=True,
page=page1,
completed_date=dt3)
ReviewFactory.create(is_active=True,
is_complete=True,
page=page2,
completed_date=dt1)
ReviewFactory.create(is_active=True,
is_complete=True,
page=page2,
completed_date=dt2)
ReviewFactory.create(is_active=True,
is_complete=True,
page=page2,
completed_date=dt3)
last_reviews = Review.get_last_reviews(self.db,
domain_filter=domain1.name)
expect(last_reviews).to_length(3)
expect(last_reviews[2].id).to_equal(domain1_review1.id)
expect(last_reviews[1].id).to_equal(domain1_review2.id)
expect(last_reviews[0].id).to_equal(domain1_review3.id)
last_reviews = Review.get_last_reviews(self.db)
expect(last_reviews).to_length(6)
def test_remove_old_reviews(self):
self.db.query(Violation).delete()
self.db.query(Fact).delete()
self.db.query(Key).delete()
self.db.query(Review).delete()
self.db.query(Page).delete()
config = Config()
config.NUMBER_OF_REVIEWS_TO_KEEP = 4
dt = datetime(2013, 12, 11, 10, 9, 8)
page1 = PageFactory.create()
ReviewFactory.create(page=page1, is_active=True, completed_date=dt, number_of_violations=1, number_of_facts=1)
page2 = PageFactory.create()
ReviewFactory.create(page=page2, is_active=True, completed_date=dt)
for x in range(6):
dt = datetime(2013, 12, 11, 10, 10, x)
ReviewFactory.create(
page=page1, is_active=False, completed_date=dt, number_of_violations=2, number_of_facts=1
)
self.db.flush()
reviews = self.db.query(Review).all()
expect(reviews).to_length(8)
violations = self.db.query(Violation).all()
expect(violations).to_length(13)
facts = self.db.query(Fact).all()
expect(facts).to_length(7)
Review.delete_old_reviews(self.db, config, page1)
reviews = self.db.query(Review).all()
expect(reviews).to_length(6)
violations = self.db.query(Violation).all()
expect(violations).to_length(9)
facts = self.db.query(Fact).all()
expect(facts).to_length(5)
def get(self):
reviews = Review.get_last_reviews(self.db)
reviews_json = []
for review in reviews:
review_dict = review.to_dict(self.application.fact_definitions, self.application.violation_definitions)
data = {
'violationCount': review.violation_count,
}
review_dict.update(data)
reviews_json.append(review_dict)
self.write_json(reviews_json)
def test_count_by_violation_key_name(self):
self.db.query(Review).delete()
self.db.query(Violation).delete()
review = ReviewFactory.create(is_active=True)
for i in range(3):
key = Key.get_or_create(self.db, 'violation.%d' % i)
review.add_violation(key, 'value', 100, review.domain)
self.db.flush()
key_id = review.violations[0].key_id
count = Review.count_by_violation_key_name(self.db, key_id)
expect(count).to_equal(1)
for i in range(3):
key = Key.get_or_create(self.db, 'violation.0')
review.add_violation(key, 'value', 100, review.domain)
key_id = review.violations[0].key_id
count = Review.count_by_violation_key_name(self.db, key_id)
expect(count).to_equal(4)
def get(self):
from_date = datetime.datetime.utcnow() - datetime.timedelta(hours=1)
count, first_date = Review.get_reviews_count_in_period(
self.db,
from_date=from_date,
domain_filter=self.get_argument('domain_filter', None))
if first_date:
ellapsed = (datetime.datetime.utcnow() -
first_date).total_seconds()
else:
ellapsed = 3600
self.write_json({'count': count, 'ellapsed': ellapsed})
def get(self):
from_date = datetime.datetime.utcnow() - datetime.timedelta(hours=1)
count, first_date = Review.get_reviews_count_in_period(
self.db,
from_date=from_date,
domain_filter=self.get_argument('domain_filter', None)
)
if first_date:
ellapsed = (datetime.datetime.utcnow() - first_date).total_seconds()
else:
ellapsed = 3600
self.write_json({'count': count, 'ellapsed': ellapsed})
def get(self, key_name):
current_page = int(self.get_argument('current_page', 1))
page_size = int(self.get_argument('page_size', 10))
domain_filter = self.get_argument('domain_filter', None)
page_filter = self.get_argument('page_filter', None)
domain = None
if domain_filter is not None:
domain = Domain.get_domain_by_name(domain_filter, self.db)
if not domain:
self.set_status(404,
self._('Domain %s not found') % domain_filter)
self.finish()
return
violations = self.application.violation_definitions
if key_name not in violations:
self.set_status(404, self._('Invalid violation key %s') % key_name)
self.finish()
return
violation_title = violations[key_name]['title']
key_id = violations[key_name]['key'].id
violation = yield self.application.search_provider.get_by_violation_key_name(
key_id=key_id,
current_page=current_page,
page_size=page_size,
domain=domain,
page_filter=page_filter,
)
if 'error' in violation:
self.set_status(violation['error']['status_code'],
violation['error']['reason'])
self.finish()
return
if 'reviewsCount' not in violation:
if not domain and not page_filter:
violation['reviewsCount'] = Review.count_by_violation_key_name(
self.db, key_id)
else:
violation['reviewsCount'] = None
violation['title'] = violation_title
self.write_json(violation)
self.finish()
def test_can_get_last_reviews_with_domain_filter(self):
dt1 = datetime(2010, 10, 10, 10, 10, 10)
dt2 = datetime(2010, 10, 11, 10, 10, 10)
dt3 = datetime(2010, 10, 12, 10, 10, 10)
domain1 = DomainFactory.create()
domain2 = DomainFactory.create()
page1 = PageFactory.create(domain=domain1)
page2 = PageFactory.create(domain=domain2)
domain1_review1 = ReviewFactory.create(is_active=True, is_complete=True, page=page1, completed_date=dt1)
domain1_review2 = ReviewFactory.create(is_active=True, is_complete=True, page=page1, completed_date=dt2)
domain1_review3 = ReviewFactory.create(is_active=True, is_complete=True, page=page1, completed_date=dt3)
ReviewFactory.create(is_active=True, is_complete=True, page=page2, completed_date=dt1)
ReviewFactory.create(is_active=True, is_complete=True, page=page2, completed_date=dt2)
ReviewFactory.create(is_active=True, is_complete=True, page=page2, completed_date=dt3)
last_reviews = Review.get_last_reviews(self.db, domain_filter=domain1.name)
expect(last_reviews).to_length(3)
expect(last_reviews[2].id).to_equal(domain1_review1.id)
expect(last_reviews[1].id).to_equal(domain1_review2.id)
expect(last_reviews[0].id).to_equal(domain1_review3.id)
last_reviews = Review.get_last_reviews(self.db)
expect(last_reviews).to_length(6)
def get(self, page_uuid, review_uuid):
review = None
if self._parse_uuid(review_uuid):
review = Review.by_uuid(review_uuid, self.db)
if not review:
self.set_status(404, 'Review with uuid of %s not found!' % review_uuid)
return
result = review.to_dict(self.application.fact_definitions, self.application.violation_definitions)
result.update({
'violationPoints': review.get_violation_points(),
'violationCount': review.violation_count,
})
self.write_json(result)
def test_get_by_violation_key_name(self):
self.db.query(Review).delete()
self.db.query(Violation).delete()
review = ReviewFactory.create(is_active=True)
for i in range(3):
key = Key.get_or_create(self.db, 'violation.%d' % i)
review.add_violation(key, 'value', 100, review.domain)
review.page.last_review_id = review.id
review.page.last_review_uuid = review.uuid
review.page.last_review_date = review.completed_date
self.db.flush()
key_id = review.violations[0].key_id
reviews = Review.get_by_violation_key_name(self.db, key_id)
expect(reviews).to_length(1)
def get(self):
reviews = Review.get_last_reviews(
self.db, domain_filter=self.get_argument('domain_filter', None)
)
reviews_json = []
for review in reviews:
review_dict = review.to_dict(self.application.fact_definitions,
self.application.violation_definitions,
self._)
data = {
'violationCount': review.violation_count,
}
review_dict.update(data)
reviews_json.append(review_dict)
self.write_json(reviews_json)
def get(self):
reviews = Review.get_last_reviews(self.db,
domain_filter=self.get_argument(
'domain_filter', None))
reviews_json = []
for review in reviews:
review_dict = review.to_dict(
self.application.fact_definitions,
self.application.violation_definitions, self._)
data = {
'violationCount': review.violation_count,
}
review_dict.update(data)
reviews_json.append(review_dict)
self.write_json(reviews_json)
def test_get_by_violation_key_name(self):
self.db.query(Review).delete()
self.db.query(Violation).delete()
review = ReviewFactory.create(is_active=True)
for i in range(3):
key = Key.get_or_create(self.db, "violation.%d" % i)
review.add_violation(key, "value", 100, review.domain)
review.page.last_review_id = review.id
review.page.last_review_uuid = review.uuid
review.page.last_review_date = review.completed_date
self.db.flush()
key_id = review.violations[0].key_id
reviews = Review.get_by_violation_key_name(self.db, key_id)
expect(reviews).to_length(1)
def test_can_get_last_reviews(self):
dt = datetime(2010, 10, 10, 10, 10, 10)
dt2 = datetime(2010, 10, 11, 10, 10, 10)
dt3 = datetime(2010, 10, 12, 10, 10, 10)
review = ReviewFactory.create(is_active=True, is_complete=True, completed_date=dt3)
review2 = ReviewFactory.create(is_active=True, is_complete=True, completed_date=dt2)
ReviewFactory.create(is_active=True, is_complete=True, completed_date=dt)
ReviewFactory.create(is_active=False, is_complete=True, completed_date=dt)
ReviewFactory.create(is_active=False, is_complete=True, completed_date=dt)
ReviewFactory.create(is_active=False, is_complete=True, completed_date=dt)
ReviewFactory.create(is_active=False, is_complete=True, completed_date=dt)
ReviewFactory.create(is_active=False, is_complete=True, completed_date=dt)
last_reviews = Review.get_last_reviews(self.db, limit=2)
expect(last_reviews).to_length(2)
expect(last_reviews[0].id).to_equal(review.id)
expect(last_reviews[1].id).to_equal(review2.id)
def get(self, key_name):
current_page = int(self.get_argument("current_page", 1))
page_size = int(self.get_argument("page_size", 10))
domain_filter = self.get_argument("domain_filter", None)
page_filter = self.get_argument("page_filter", None)
domain = None
if domain_filter is not None:
domain = Domain.get_domain_by_name(domain_filter, self.db)
if not domain:
self.set_status(404, self._("Domain %s not found") % domain_filter)
self.finish()
return
violations = self.application.violation_definitions
if key_name not in violations:
self.set_status(404, self._("Invalid violation key %s") % key_name)
self.finish()
return
violation_title = violations[key_name]["title"]
key_id = violations[key_name]["key"].id
violation = yield self.application.search_provider.get_by_violation_key_name(
key_id=key_id, current_page=current_page, page_size=page_size, domain=domain, page_filter=page_filter
)
if "error" in violation:
self.set_status(violation["error"]["status_code"], violation["error"]["reason"])
self.finish()
return
if "reviewsCount" not in violation:
if not domain and not page_filter:
violation["reviewsCount"] = Review.count_by_violation_key_name(self.db, key_id)
else:
violation["reviewsCount"] = None
violation["title"] = violation_title
self.write_json(violation)
self.finish()
