def test_score_user_updater_calculate(tp0, admin, member):
user_updater = score_updater.get(admin.__class__)
admin.score = -999
admin.save()
member.score = -777
member.save()
assert user_updater == UserScoreUpdater
updater = user_updater(users=[admin, member])
assert updater.users == [admin, member]
result = updater.calculate()
admin_score = admin.scores.filter(date__gte=(localdate() -
timedelta(days=30)))
admin_score = round(sum(admin_score.values_list("score", flat=True)), 2)
member_score = member.scores.filter(date__gte=(localdate() -
timedelta(days=30)))
member_score = round(sum(member_score.values_list("score", flat=True)), 2)
assert round(dict(result)[admin.pk], 2) == admin_score
assert round(dict(result)[member.pk], 2) == member_score
updater.set_scores(result)
admin.refresh_from_db()
member.refresh_from_db()
assert round(admin.score, 2) == admin_score
assert round(member.score, 2) == member_score
admin.score = -999
admin.save()
updater = user_updater((admin, ))
assert updater.users == (admin, )
result = updater.calculate()
assert round(dict(result)[admin.pk], 2) == admin_score
updater.set_scores(result)
admin.refresh_from_db()
assert round(admin.score, 2) == admin_score
def calculate(self, start=localdate(), end=None, **kwargs):
scores = self.filter_users(
self.tp_score_model.objects.filter(
date__gte=(localdate() - timedelta(days=30))),
kwargs.get("users"))
return scores.order_by("user").values_list(
"user").annotate(score=Sum("score"))
def test_user_tp_score_update_rejects(store0, member, member2):
# member makes another suggestion then member2 rejects
suggestion_text = "made a suggestion!"
suggestions = review.get(Suggestion)
current_score = member.scores.get(tp=store0.translation_project,
date=localdate())
old_score = round(current_score.score, 2)
old_suggested = current_score.suggested
old_translated = current_score.translated
old_reviewed = current_score.reviewed
m2_score = member2.scores.get(tp=store0.translation_project,
date=localdate())
m2_old_score = round(m2_score.score, 2)
m2_suggested = m2_score.suggested
m2_translated = m2_score.translated
m2_reviewed = m2_score.reviewed
unit = store0.units.filter(state=UNTRANSLATED)[0]
sugg, added = suggestions().add(unit, suggestion_text, user=member)
suggestions([sugg], member2).reject()
current_score = member.scores.get(tp=store0.translation_project,
date=localdate())
assert round(current_score.score, 2) == old_score
assert current_score.reviewed == old_reviewed
assert current_score.translated == old_translated
assert (current_score.suggested == old_suggested +
unit.unit_source.source_wordcount)
m2_score = member2.scores.get(tp=store0.translation_project,
date=localdate())
assert round(m2_score.score, 2) > m2_old_score
assert m2_score.suggested == m2_suggested
assert m2_score.translated == m2_translated
assert (m2_score.reviewed == m2_reviewed +
unit.unit_source.source_wordcount)
def calculate(self, start=localdate(), end=None, **kwargs):
scores = self.filter_users(
self.tp_score_model.objects.filter(date__gte=(localdate() -
timedelta(days=30))),
kwargs.get("users"))
return scores.order_by("user").values_list("user").annotate(
score=Sum("score"))
def _get_unit_data(self, unit):
store = unit.store
tp = store.translation_project
data = {}
data["unit_revision"] = unit.revision
data["checks"] = list(unit.qualitycheck_set.filter(name="xmltags"))
data["store_data"] = {
k: getattr(store.data, k)
for k
in ["translated_words",
"critical_checks",
"max_unit_revision",
"total_words",
"pending_suggestions"]}
store_score = unit.store.user_scores.get(
user__username="******",
date=localdate())
data["store_score"] = {
k: getattr(store_score, k)
for k
in ["translated",
"suggested",
"reviewed",
"score"]}
tp_score = tp.user_scores.get(
user__username="******",
date=localdate())
data["tp_score"] = {
k: getattr(tp_score, k)
for k
in ["translated",
"suggested",
"reviewed",
"score"]}
data["store_checks_data"] = {
cd.name: cd.count
for cd in store.check_data.all()}
data["tp_checks_data"] = {
cd.name: cd.count
for cd in tp.check_data.all()}
data["tp_data"] = {
k: getattr(tp.data, k)
for k
in ["translated_words",
"critical_checks",
"max_unit_revision",
"total_words",
"pending_suggestions"]}
data["dir_revision"] = list(
store.parent.revisions.filter(
key__in=["stats", "checks"]))
data["tp_dir_revision"] = list(
tp.directory.revisions.filter(
key__in=["stats", "checks"]))
return data
def test_scores_user(member, system):
score_data = scores.get(member.__class__)(member)
assert isinstance(score_data, UserScores)
assert score_data.ns == "pootle.score.user"
assert score_data.sw_version == PootleScoreConfig.version
assert score_data.context == member
assert score_data.public_score == member.public_score
assert (list(score_data.get_scores_by_language(10)) == list(
score_data.get_scores(10).order_by("tp__language").values(
"tp__language").annotate(Sum("score"))))
top_lang = score_data.get_scores_by_language(20).order_by(
"score__sum").first()
top_lang = Language.objects.get(id=top_lang["tp__language"])
assert (score_data.get_top_language_within(20) == top_lang)
assert (score_data.get_language_top_scores(top_lang) == scores.get(
Language)(top_lang).top_scorers)
top_lang = score_data.get_top_language_within(100)
language_scores = score_data.get_language_top_scores(top_lang)
for index, user_score in enumerate(language_scores):
if user_score['user__username'] == member.username:
assert (score_data.get_top_language(100) == (index + 1, top_lang))
break
assert (score_data.top_language == score_data.get_top_language(30))
project_directory = Directory.objects.get(pootle_path="/projects/")
assert (
score_data.revision == revision.get(Directory)(project_directory).get(
key="stats"))
assert (score_data.cache_key == (
"%s.%s.%s" % (member.id, localdate(), score_data.revision)))
# system gets no rank
sys_score_data = scores.get(system.__class__)(system)
assert (sys_score_data.top_language == (-1, None))
def cache_key(self):
return (
"%s/%s.%s.%s"
% (self.context.language.code,
self.context.project.code,
localdate(),
self.revision))
def test_user_tp_score_update_suggestions(store0, member, member2):
unit = store0.units.filter(state=UNTRANSLATED)[0]
suggestions = review.get(Suggestion)
suggestion_text = "made a suggestion!"
# member adds a suggestion
# score and sugg increase
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
old_suggested = current_score.suggested
old_score = round(current_score.score, 2)
old_suggested = current_score.suggested
old_translated = current_score.translated
old_reviewed = current_score.reviewed
sugg, added = suggestions().add(
unit, suggestion_text, user=member)
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(current_score.score, 2) == old_score
assert (
current_score.suggested
== old_suggested + unit.unit_source.source_wordcount)
assert current_score.translated == old_translated
assert current_score.reviewed == old_reviewed
# member2 reviews members suggestion
# score and review increase
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
old_m2_score = round(m2_score.score, 2)
old_m2_suggested = m2_score.suggested
old_m2_translated = m2_score.translated
old_m2_reviewed = m2_score.reviewed
suggestions([sugg], member2).accept()
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(m2_score.score, 2) > old_m2_score
assert (
m2_score.reviewed
== old_m2_reviewed + unit.unit_source.source_wordcount)
assert m2_score.suggested == old_m2_suggested
assert m2_score.translated == old_m2_translated
def test_scores_project_set(project_set):
score_data = scores.get(project_set.__class__)(project_set)
assert isinstance(score_data, ProjectSetScores)
_test_scores("projects", project_set, score_data)
assert (score_data.cache_key == ("%s.%s" %
(localdate(), score_data.revision)))
qs = score_data.scores_within_days(30)
assert score_data.filter_scores(qs) is qs
def test_scores_language(language0):
score_data = scores.get(language0.__class__)(language0)
assert isinstance(score_data, LanguageScores)
_test_scores("language", language0, score_data)
assert (score_data.cache_key == (
"%s.%s.%s" % (language0.code, localdate(), score_data.revision)))
qs = score_data.scores_within_days(30)
assert (list(score_data.filter_scores(qs)) == list(
qs.filter(tp__language_id=language0.id)))
def test_scores_project(project0):
score_data = scores.get(project0.__class__)(project0)
assert isinstance(score_data, ProjectScores)
_test_scores("project", project0, score_data)
assert (score_data.cache_key == (
"%s.%s.%s" % (project0.code, localdate(), score_data.revision)))
qs = score_data.scores_within_days(30)
assert (list(score_data.filter_scores(qs)) == list(
qs.filter(tp__project_id=project0.id)))
def save_subs(self, subs):
subs = list(subs)
if not subs:
return
self.unit.submission_set.bulk_create(subs)
update_scores.send(self.unit.store.__class__,
instance=self.unit.store,
users=[sub.submitter_id for sub in subs],
date=localdate(self.unit.mtime))
def test_user_tp_score_update_translated(store0, member, member2):
# member translates another unit, by suggesting and
# accepting own suggestion
# score, suggested and translated increase
suggestion_text = "made a suggestion!"
suggestions = review.get(Suggestion)
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
old_score = round(current_score.score, 2)
old_suggested = current_score.suggested
old_translated = current_score.translated
old_reviewed = current_score.reviewed
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
m2_old_score = round(m2_score.score, 2)
m2_suggested = m2_score.suggested
m2_translated = m2_score.translated
m2_reviewed = m2_score.reviewed
unit = store0.units.filter(state=UNTRANSLATED)[0]
sugg, added = suggestions().add(
unit, suggestion_text, user=member)
suggestions([sugg], member2).accept()
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(current_score.score, 2) > old_score
assert current_score.reviewed == old_reviewed
assert (
current_score.suggested
== old_suggested + unit.unit_source.source_wordcount)
assert (
current_score.translated
== old_translated + unit.unit_source.source_wordcount)
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(m2_score.score, 2) > m2_old_score
assert m2_score.suggested == m2_suggested
assert m2_score.translated == m2_translated
assert (
m2_score.reviewed
== m2_reviewed + unit.unit_source.source_wordcount)
def test_scores_tp(tp0):
score_data = scores.get(tp0.__class__)(tp0)
assert isinstance(score_data, TPScores)
_test_scores("tp", tp0, score_data)
assert (score_data.cache_key == ("%s/%s.%s.%s" %
(tp0.language.code, tp0.project.code,
localdate(), score_data.revision)))
qs = score_data.scores_within_days(30)
assert (list(score_data.filter_scores(qs)) == list(
qs.filter(tp_id=tp0.id)))
def handle_submission_added(**kwargs):
submission = kwargs["instance"]
is_system_user = (
submission.submitter == get_user_model().objects.get_system_user())
if is_system_user:
return
update_scores.send(submission.unit.store.__class__,
instance=submission.unit.store,
users=[submission.submitter_id],
date=localdate(submission.creation_time))
def test_scores_project_set(project_set):
score_data = scores.get(project_set.__class__)(project_set)
assert isinstance(score_data, ProjectSetScores)
_test_scores("projects", project_set, score_data)
assert (
score_data.cache_key
== ("%s.%s"
% (localdate(),
score_data.revision)))
qs = score_data.scores_within_days(30)
assert score_data.filter_scores(qs) is qs
def test_score_tp_updater_update(store0, tp0, admin, member, member2):
today = localdate()
yesterday = today - timedelta(days=1)
updater = score_updater.get(TranslationProject)(tp0)
store1 = tp0.stores.exclude(id=store0.id).first()
def _generate_data(store):
data = {}
data[today] = dict()
data[yesterday] = dict()
for user in [admin, member, member2]:
data[today][user.id] = dict(
score=(store.id * user.id),
suggested=(2 * store.id * user.id),
translated=(3 * store.id * user.id),
reviewed=(4 * store.id * user.id))
data[yesterday][user.id] = dict(
score=(5 * store.id * user.id),
suggested=(6 * store.id * user.id),
translated=(7 * store.id * user.id),
reviewed=(8 * store.id * user.id))
return data
tp0.user_scores.all().delete()
UserStoreScore.objects.filter(store__translation_project=tp0).delete()
score_updater.get(Store)(store0).set_scores(_generate_data(store0))
score_updater.get(Store)(store1).set_scores(_generate_data(store1))
updater.update()
for user in [admin, member, member2]:
scores_today = tp0.user_scores.get(date=today, user=user)
assert scores_today.score == (
(store0.id * user.id)
+ (store1.id * user.id))
assert scores_today.suggested == (
(2 * store0.id * user.id)
+ (2 * store1.id * user.id))
assert scores_today.translated == (
(3 * store0.id * user.id)
+ (3 * store1.id * user.id))
assert scores_today.reviewed == (
(4 * store0.id * user.id)
+ (4 * store1.id * user.id))
scores_yesterday = tp0.user_scores.get(date=yesterday, user=user)
assert scores_yesterday.score == (
(5 * store0.id * user.id)
+ (5 * store1.id * user.id))
assert scores_yesterday.suggested == (
(6 * store0.id * user.id)
+ (6 * store1.id * user.id))
assert scores_yesterday.translated == (
(7 * store0.id * user.id)
+ (7 * store1.id * user.id))
assert scores_yesterday.reviewed == (
(8 * store0.id * user.id)
+ (8 * store1.id * user.id))
def handle_submission_added(**kwargs):
submission = kwargs["instance"]
is_system_user = (
submission.submitter
== get_user_model().objects.get_system_user())
if is_system_user:
return
update_scores.send(
submission.unit.store.__class__,
instance=submission.unit.store,
users=[submission.submitter_id],
date=localdate(submission.creation_time))
def test_user_tp_score_update_suggestions(store0, member, member2):
unit = store0.units.filter(state=UNTRANSLATED)[0]
suggestions = review.get(Suggestion)
suggestion_text = "made a suggestion!"
# member adds a suggestion
# score and sugg increase
current_score = member.scores.get(tp=store0.translation_project,
date=localdate())
old_suggested = current_score.suggested
old_score = round(current_score.score, 2)
old_suggested = current_score.suggested
old_translated = current_score.translated
old_reviewed = current_score.reviewed
sugg, added = suggestions().add(unit, suggestion_text, user=member)
current_score = member.scores.get(tp=store0.translation_project,
date=localdate())
assert round(current_score.score, 2) == old_score
assert (current_score.suggested == old_suggested +
unit.unit_source.source_wordcount)
assert current_score.translated == old_translated
assert current_score.reviewed == old_reviewed
# member2 reviews members suggestion
# score and review increase
m2_score = member2.scores.get(tp=store0.translation_project,
date=localdate())
old_m2_score = round(m2_score.score, 2)
old_m2_suggested = m2_score.suggested
old_m2_translated = m2_score.translated
old_m2_reviewed = m2_score.reviewed
suggestions([sugg], member2).accept()
m2_score = member2.scores.get(tp=store0.translation_project,
date=localdate())
assert round(m2_score.score, 2) > old_m2_score
assert (m2_score.reviewed == old_m2_reviewed +
unit.unit_source.source_wordcount)
assert m2_score.suggested == old_m2_suggested
assert m2_score.translated == old_m2_translated
def test_score_user_updater(tp0, admin, member):
user_updater = score_updater.get(admin.__class__)
admin.score = -999
admin.save()
member.score = -777
member.save()
assert user_updater == UserScoreUpdater
updater = user_updater(users=[admin, member])
assert updater.users == [admin, member]
result = updater.calculate()
admin_score = admin.scores.filter(
date__gte=(
localdate()
- timedelta(days=30)))
admin_score = round(sum(
admin_score.values_list(
"score", flat=True)), 2)
member_score = member.scores.filter(
date__gte=(
localdate()
- timedelta(days=30)))
member_score = round(sum(
member_score.values_list(
"score", flat=True)), 2)
assert round(dict(result)[admin.pk], 2) == admin_score
assert round(dict(result)[member.pk], 2) == member_score
updater.set_scores(result)
admin.refresh_from_db()
member.refresh_from_db()
assert round(admin.score, 2) == admin_score
assert round(member.score, 2) == member_score
admin.score = -999
admin.save()
updater = user_updater((admin, ))
assert updater.users == (admin, )
result = updater.calculate()
assert round(dict(result)[admin.pk], 2) == admin_score
updater.set_scores(result)
admin.refresh_from_db()
assert round(admin.score, 2) == admin_score
def test_score_tp_updater_clear_users(tp0, admin, member):
tp_scores = tp0.user_scores.filter(date__gte=localdate() -
timedelta(days=30))
updater = TPScoreUpdater(tp0)
admin_score = admin.score
member_score = member.score
member_tp_score = tp_scores.filter(user=member).aggregate(
score=Sum('score'))['score']
updater.clear(users=[member.id])
member.refresh_from_db()
admin.refresh_from_db()
assert admin.score == admin_score
assert (round(member.score, 2) == round(member_score - member_tp_score, 2))
def test_scores_project(project0):
score_data = scores.get(project0.__class__)(project0)
assert isinstance(score_data, ProjectScores)
_test_scores("project", project0, score_data)
assert (
score_data.cache_key
== ("%s.%s.%s"
% (project0.code,
localdate(),
score_data.revision)))
qs = score_data.scores_within_days(30)
assert (
list(score_data.filter_scores(qs))
== list(qs.filter(tp__project_id=project0.id)))
def test_scores_language(language0):
score_data = scores.get(language0.__class__)(language0)
assert isinstance(score_data, LanguageScores)
_test_scores("language", language0, score_data)
assert (
score_data.cache_key
== ("%s.%s.%s"
% (language0.code,
localdate(),
score_data.revision)))
qs = score_data.scores_within_days(30)
assert (
list(score_data.filter_scores(qs))
== list(qs.filter(tp__language_id=language0.id)))
def test_scores_tp(tp0):
score_data = scores.get(tp0.__class__)(tp0)
assert isinstance(score_data, TPScores)
_test_scores("tp", tp0, score_data)
assert (
score_data.cache_key
== ("%s/%s.%s.%s"
% (tp0.language.code,
tp0.project.code,
localdate(),
score_data.revision)))
qs = score_data.scores_within_days(30)
assert (
list(score_data.filter_scores(qs))
== list(qs.filter(tp_id=tp0.id)))
def score_event(self, event, calculated_scores):
if event.action not in self.scoring:
return
scores = self.scoring[event.action](event).get_score()
if not scores or not any(x > 0 for x in scores.values()):
return
event_date = localdate(event.timestamp)
calculated_scores[event_date] = (calculated_scores.get(event_date, {}))
calculated_scores[event_date][event.user.id] = (
calculated_scores[event_date].get(event.user.id, {}))
for k, score in scores.items():
if not score:
continue
calculated_scores[event_date][event.user.id][k] = (
calculated_scores[event_date][event.user.id].get(k, 0) + score)
def _test_scores(ns, context, score_data):
today = localdate()
assert score_data.context == context
assert (
score_data.get_daterange(30)
== (today - timedelta(days=30), today))
assert score_data.ns == "pootle.score.%s" % ns
assert score_data.sw_version == PootleScoreConfig.version
assert list(score_data.score_model.order_by("id")) == list(
UserTPScore.objects.exclude(
user__username__in=User.objects.META_USERS).order_by("id"))
assert (
list(score_data.scores_within_days(5))
== list(score_data.score_model.filter(
date__range=score_data.get_daterange(5))))
assert (
list(score_data.get_scores(5))
== list(score_data.filter_scores(score_data.scores_within_days(5))))
assert (
list(score_data.get_top_scorers(10))
== list(
score_data.get_scores(10).order_by("user__username").values(
"user__username", "user__email", "user__full_name").annotate(
Sum("score"),
Sum("suggested"),
Sum("reviewed"),
Sum("translated")).filter(
score__sum__gt=0).order_by("-score__sum")))
assert (
tuple(score_data.top_scorers)
== tuple(score_data.get_top_scorers(30)))
assert (
score_data.revision
== revision.get(context.directory.__class__)(
context.directory).get(key="stats"))
score_display = score_data.display()
assert isinstance(score_display, TopScoreDisplay)
for i, item in enumerate(score_display):
data = score_data.top_scorers[i]
assert item["public_total_score"] == formatter.number(
round(data["score__sum"]))
assert isinstance(item["user"], DisplayUser)
assert item["user"].username == data["user__username"]
assert item["user"].full_name == data["user__full_name"]
assert item["user"].email == data["user__email"]
score_display = score_data.display(limit=1)
assert len(list(score_display)) <= 1
def test_scores_user(member, system):
score_data = scores.get(member.__class__)(member)
assert isinstance(score_data, UserScores)
assert score_data.ns == "pootle.score.user"
assert score_data.sw_version == PootleScoreConfig.version
assert score_data.context == member
assert score_data.public_score == member.public_score
assert(
list(score_data.get_scores_by_language(10))
== list(
score_data.get_scores(10).order_by(
"tp__language").values("tp__language").annotate(Sum("score"))))
top_lang = score_data.get_scores_by_language(20).order_by("score__sum").first()
top_lang = Language.objects.get(id=top_lang["tp__language"])
assert (
score_data.get_top_language_within(20)
== top_lang)
assert (
score_data.get_language_top_scores(top_lang)
== scores.get(Language)(top_lang).top_scorers)
top_lang = score_data.get_top_language_within(100)
language_scores = score_data.get_language_top_scores(top_lang)
for index, user_score in enumerate(language_scores):
if user_score['user__username'] == member.username:
assert (
score_data.get_top_language(100)
== (index + 1, top_lang))
break
assert (
score_data.top_language
== score_data.get_top_language(30))
project_directory = Directory.objects.get(pootle_path="/projects/")
assert (
score_data.revision
== revision.get(Directory)(
project_directory).get(key="stats"))
assert (
score_data.cache_key
== ("%s.%s.%s"
% (member.id,
localdate(),
score_data.revision)))
# system gets no rank
sys_score_data = scores.get(system.__class__)(system)
assert (
sys_score_data.top_language
== (-1, None))
def test_score_store_updater_event(store0, admin, member):
unit0 = store0.units[0]
unit1 = store0.units[1]
today = localdate()
yesterday = today - timedelta(days=1)
class DummyLogs(object):
_start = None
_end = None
_user = None
@property
def _events(self):
return [
LogEvent(unit0, admin, today, "action0", 0),
LogEvent(unit0, admin, yesterday, "action1", 1),
LogEvent(unit1, member, today, "action2", 2)]
def get_events(self, start=None, end=None, users=None, **kwargs):
self._start = start
self._end = end
self._users = users
for event in self._events:
yield event
class DummyScoreUpdater(StoreScoreUpdater):
@cached_property
def logs(self):
return DummyLogs()
updater = DummyScoreUpdater(store0)
result = updater.calculate()
assert updater.logs._start is None
assert updater.logs._end is None
assert updater.logs._users is None
# no score adapters
assert result == {}
result = updater.calculate(start=yesterday, end=today)
assert updater.logs._start == to_datetime(yesterday)
assert updater.logs._end == to_datetime(today)
assert result == {}
updater = DummyScoreUpdater(store0)
updater.calculate(users=(admin, ))
assert updater.logs._users == (admin, )
updater.calculate(users=(admin, member))
assert updater.logs._users == (admin, member)
def score_event(self, event, calculated_scores):
if event.action not in self.scoring:
return
scores = self.scoring[event.action](event).get_score()
if not scores or not any(x > 0 for x in scores.values()):
return
event_date = localdate(event.timestamp)
calculated_scores[event_date] = (
calculated_scores.get(event_date, {}))
calculated_scores[event_date][event.user.id] = (
calculated_scores[event_date].get(event.user.id, {}))
for k, score in scores.items():
if not score:
continue
calculated_scores[event_date][event.user.id][k] = (
calculated_scores[event_date][event.user.id].get(k, 0)
+ score)
def handle_suggestion_change(**kwargs):
suggestion = kwargs["instance"]
is_system_user = (
(suggestion.is_pending and
(suggestion.user_id == get_user_model().objects.get_system_user().id))
or (not suggestion.is_pending and
(suggestion.reviewer_id
== get_user_model().objects.get_system_user().id)))
if is_system_user:
return
change_date = (suggestion.review_time
if not suggestion.is_pending else suggestion.creation_time)
update_scores.send(suggestion.unit.store.__class__,
instance=suggestion.unit.store,
users=[
suggestion.user_id
if suggestion.is_pending else suggestion.reviewer_id
],
date=localdate(change_date))
def _test_scores(ns, context, score_data):
today = localdate()
assert score_data.context == context
assert (score_data.get_daterange(30) == (today - timedelta(days=30),
today))
assert score_data.ns == "pootle.score.%s" % ns
assert score_data.sw_version == PootleScoreConfig.version
assert list(score_data.score_model.order_by("id")) == list(
UserTPScore.objects.exclude(
user__username__in=User.objects.META_USERS).order_by("id"))
assert (list(score_data.scores_within_days(5)) == list(
score_data.score_model.filter(
date__range=score_data.get_daterange(5))))
assert (list(score_data.get_scores(5)) == list(
score_data.filter_scores(score_data.scores_within_days(5))))
assert (list(score_data.get_top_scorers(10)) == list(
score_data.get_scores(10).order_by("user__username").values(
"user__username", "user__email", "user__full_name").annotate(
Sum("score"), Sum("suggested"), Sum("reviewed"),
Sum("translated")).filter(
score__sum__gt=0).order_by("-score__sum")))
assert (tuple(score_data.top_scorers) == tuple(
score_data.get_top_scorers(30)))
assert (score_data.revision == revision.get(context.directory.__class__)(
context.directory).get(key="stats"))
score_display = score_data.display()
assert isinstance(score_display, TopScoreDisplay)
for i, item in enumerate(score_display):
data = score_data.top_scorers[i]
assert item["public_total_score"] == formatter.number(
round(data["score__sum"]))
assert isinstance(item["user"], DisplayUser)
assert item["user"].username == data["user__username"]
assert item["user"].full_name == data["user__full_name"]
assert item["user"].email == data["user__email"]
score_display = score_data.display(limit=1)
assert len(list(score_display)) <= 1
def handle_suggestion_change(**kwargs):
suggestion = kwargs["instance"]
is_system_user = (
(suggestion.is_pending
and (suggestion.user_id
== get_user_model().objects.get_system_user().id))
or (not suggestion.is_pending
and (suggestion.reviewer_id
== get_user_model().objects.get_system_user().id)))
if is_system_user:
return
change_date = (
suggestion.review_time
if not suggestion.is_pending
else suggestion.creation_time)
update_scores.send(
suggestion.unit.store.__class__,
instance=suggestion.unit.store,
users=[
suggestion.user_id
if suggestion.is_pending
else suggestion.reviewer_id],
date=localdate(change_date))
def get_daterange(self, days):
now = localdate()
return now - timedelta(days), now
def get_daterange(self, days):
now = localdate()
return now - timedelta(days), now
def cache_key(self):
return ("%s/%s.%s.%s" %
(self.context.language.code, self.context.project.code,
localdate(), self.revision))
def cache_key(self):
return (
"%s.%s.%s"
% (self.context.id,
localdate(),
self.revision))
def cache_key(self):
return ("%s.%s" % (localdate(), self.revision))
def test_score_store_updater_event_score(store0, admin, member, member2):
unit0 = store0.units[0]
unit1 = store0.units[1]
today = localdate()
import pytz
from pootle.core.utils.timezone import make_aware
dt_today = make_aware(
datetime.combine(
today,
datetime.min.time())).astimezone(
pytz.timezone("UTC"))
yesterday = today - timedelta(days=1)
dt_yesterday = make_aware(
datetime.combine(
yesterday,
datetime.min.time())).astimezone(
pytz.timezone("UTC"))
class DummyLogs(object):
_start = None
_end = None
@cached_property
def _events(self):
return [
LogEvent(unit0, admin, dt_yesterday, "action0", 0),
LogEvent(unit0, admin, dt_yesterday, "action1", 1),
LogEvent(unit0, admin, dt_today, "action0", 0),
LogEvent(unit0, member2, dt_today, "action1", 1),
LogEvent(unit0, member, dt_today, "action2", 2),
LogEvent(unit1, member, dt_today, "action2", 3)]
def get_events(self, start=None, end=None, **kwargs):
self._start = start
self._end = end
for event in self._events:
yield event
class DummyScoreUpdater(StoreScoreUpdater):
@cached_property
def logs(self):
return DummyLogs()
updater = DummyScoreUpdater(store0)
result = updater.calculate()
assert result == {}
class DummyScore(object):
def __init__(self, event):
self.event = event
def get_score(self):
return dict(
score=(self.event.value * self.base_score),
translated=(7 * self.base_score),
reviewed=(23 * self.base_score),
suggested=(108 * self.base_score))
class Action0Score(DummyScore):
base_score = 0
class Action1Score(DummyScore):
base_score = 1
class Action2Score(DummyScore):
base_score = 2
def get_score(self):
score = super(Action2Score, self).get_score()
score["reviewed"] = 0
return score
@provider(event_score, sender=LogEvent)
def dummy_event_score_provider(**kwargs_):
return dict(
action0=Action0Score,
action1=Action1Score,
action2=Action2Score)
updater = DummyScoreUpdater(store0)
result = updater.calculate()
assert len(result) == 2
assert len(result[today]) == 2
assert result[today][member.id] == {
'suggested': 432,
'score': 10,
'translated': 28}
assert result[today][member2.id] == {
'suggested': 108,
'score': 1,
'translated': 7,
'reviewed': 23}
assert len(result[yesterday]) == 1
assert result[yesterday][admin.id] == {
'suggested': 108,
'score': 1,
'translated': 7,
'reviewed': 23}
store0.user_scores.all().delete()
updater.update()
mem_score = UserStoreScore.objects.filter(
store=store0, user=member)
assert mem_score.get(date=today).suggested == 432
assert mem_score.get(date=today).score == 10
assert mem_score.get(date=today).translated == 28
assert mem_score.get(date=today).reviewed == 0
today_score = mem_score.get(date=today)
today_score.reviewed = 99999
today_score.score = 0
today_score.save()
updater.update()
assert mem_score.get(date=today).suggested == 432
assert mem_score.get(date=today).score == 10
assert mem_score.get(date=today).translated == 28
assert mem_score.get(date=today).reviewed == 0
def calculate(self, start=localdate(), end=None, **kwargs):
return self.filter_users(
self.tp_score_model.objects,
kwargs.get("users")).order_by("user").values_list("user").annotate(
score=Sum("score"))
def cache_key(self):
return (
"%s.%s"
% (localdate(),
self.revision))
def test_localdate(settings):
today = localdate()
assert today == timezone.localtime(timezone.now()).date()
assert (localdate(timezone.now() + timedelta(weeks=1)) == today +
timedelta(weeks=1))
def test_localdate(settings):
today = localdate()
assert today == timezone.localtime(timezone.now()).date()
assert (
localdate(timezone.now() + timedelta(weeks=1))
== today + timedelta(weeks=1))
def today():
return localdate()
def today():
return localdate()
def cache_key(self):
return ("%s.%s.%s" % (self.context.code, localdate(), self.revision))
