def handle_unit_change(**kwargs):
unit_change = kwargs["instance"]
unit = unit_change.unit
created = not unit._frozen.pk
if not created:
lifecycle.get(Unit)(unit).change()
if not unit.source_updated and not unit.target_updated:
return
new_untranslated = (created and unit.state == UNTRANSLATED)
if not new_untranslated:
update_checks.send(unit.__class__, instance=unit)
if unit.istranslated():
unit.update_tmserver()
def handle_unit_change(**kwargs):
unit_change = kwargs["instance"]
unit = unit_change.unit
created = not unit._frozen.pk
if not created:
lifecycle.get(Unit)(unit).change()
if not unit.source_updated and not unit.target_updated:
return
new_untranslated = (created and unit.state == UNTRANSLATED)
if not new_untranslated:
update_checks.send(unit.__class__, instance=unit)
if unit.istranslated():
unit.update_tmserver()
def test_unit_lifecycle_unmute_qc(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
unit_lifecycle = lifecycle.get(Unit)(unit)
qc = QualityCheck(
unit=unit,
name="foo-check",
message="Check foo!",
category="Footile")
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc()
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc(submitter=member)
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc(quality_check=qc)
sub_unmute_qc = unit_lifecycle.sub_unmute_qc(
quality_check=qc, submitter=member)
assert sub_unmute_qc.unit == unit
assert sub_unmute_qc.store == store0
assert sub_unmute_qc.translation_project == store0.translation_project
assert sub_unmute_qc.revision == unit.revision
assert sub_unmute_qc.type == SubmissionTypes.UNMUTE_CHECK
assert sub_unmute_qc.field == SubmissionFields.NONE
assert sub_unmute_qc.new_value == ""
assert sub_unmute_qc.old_value == ""
assert not sub_unmute_qc.pk
def test_unit_lifecycle_unmute_qc(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
unit_lifecycle = lifecycle.get(Unit)(unit)
qc = QualityCheck(
unit=unit,
name="foo-check",
message="Check foo!",
category="Footile")
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc()
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc(submitter=member)
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc(quality_check=qc)
sub_unmute_qc = unit_lifecycle.sub_unmute_qc(
quality_check=qc, submitter=member)
assert sub_unmute_qc.unit == unit
assert sub_unmute_qc.translation_project == store0.translation_project
assert sub_unmute_qc.revision == unit.revision
assert sub_unmute_qc.type == SubmissionTypes.WEB
assert sub_unmute_qc.field == SubmissionFields.CHECK
assert sub_unmute_qc.new_value == UNMUTED
assert sub_unmute_qc.old_value == MUTED
assert not sub_unmute_qc.pk
def test_unit_lifecycle_calc_change(store0, member):
unit = store0.units.first()
unit_lifecycle = lifecycle.get(Unit)(unit)
assert (unit_lifecycle.calculate_change() == OrderedDict())
original_target = unit.target
unit.state = 200
assert (unit_lifecycle.calculate_change() == OrderedDict(
(("state_update", {}), )))
unit.target = "changed target"
assert (unit_lifecycle.calculate_change() == OrderedDict(
(("target_update", {}), ("state_update", {}))))
unit.translator_comment = "changed comment"
assert (unit_lifecycle.calculate_change() == OrderedDict(
(("comment_update", {}), ("target_update", {}), ("state_update", {}))))
unit.source = "changed source"
assert (unit_lifecycle.calculate_change() == OrderedDict(
(("comment_update", {}), ("source_update", {}), ("target_update", {}),
("state_update", {}))))
assert (unit_lifecycle.calculate_change(foo="bar") == OrderedDict(
(("comment_update", dict(foo="bar")), ("source_update",
dict(foo="bar")),
("target_update", dict(foo="bar")), ("state_update",
dict(foo="bar")))))
unit.target = original_target
assert (unit_lifecycle.calculate_change() == OrderedDict(
(("comment_update", {}), ("source_update", {}), ("state_update", {}))))
def test_unit_lifecycle_update_state_reviewed_by(store0, system, member2):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = FUZZY
unit.save(user=system)
# force the unit to be refrozen
unit = unit.__class__.objects.get(id=unit.id)
unit.state = TRANSLATED
unit.save(reviewed_by=member2)
sub_state_update = lifecycle.get(Unit)(unit).sub_state_update()
assert isinstance(sub_state_update, Submission)
assert sub_state_update.unit == unit
assert sub_state_update.translation_project == store0.translation_project
assert sub_state_update.revision == unit.revision
assert (
sub_state_update.submitter
== unit.change.reviewed_by
== member2)
assert sub_state_update.type == SubmissionTypes.SYSTEM
assert sub_state_update.field == SubmissionFields.STATE
assert sub_state_update.new_value == unit.state
assert sub_state_update.old_value == unit._frozen.state
assert not sub_state_update.pk
def test_unit_lifecycle_instance(store0):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
unit_lifecycle = lifecycle.get(Unit)(unit)
assert isinstance(unit_lifecycle, UnitLifecycle)
assert unit_lifecycle.original == unit._frozen
assert unit_lifecycle.unit == unit
assert unit_lifecycle.submission_model == unit.submission_set.model
def test_unit_lifecycle_instance(store0):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
unit_lifecycle = lifecycle.get(Unit)(unit)
assert isinstance(unit_lifecycle, UnitLifecycle)
assert unit_lifecycle.original == unit._frozen
assert unit_lifecycle.unit == unit
assert unit_lifecycle.submission_model == unit.submission_set.model
def test_unit_lifecycle_create(store0):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.index = store0.max_index() + 1
unit.save()
sub_create = lifecycle.get(Unit)(unit).sub_create()
assert isinstance(sub_create, Submission)
assert sub_create.unit == unit
assert sub_create.store == store0
assert sub_create.translation_project == store0.translation_project
assert sub_create.revision == unit.revision
assert sub_create.type == SubmissionTypes.UNIT_CREATE
assert sub_create.field == SubmissionFields.TARGET
assert sub_create.new_value == unit.target
assert sub_create.old_value == ""
assert not sub_create.pk
def test_unit_lifecycle_calc_change(store0, member):
unit = store0.units.first()
unit_lifecycle = lifecycle.get(Unit)(unit)
assert (
unit_lifecycle.calculate_change()
== OrderedDict())
original_target = unit.target
unit.state = 200
assert (
unit_lifecycle.calculate_change()
== OrderedDict((("state_update", {}),)))
unit.target = "changed target"
assert (
unit_lifecycle.calculate_change()
== OrderedDict(
(("target_update", {}),
("state_update", {}))))
unit.translator_comment = "changed comment"
assert (
unit_lifecycle.calculate_change()
== OrderedDict(
(("comment_update", {}),
("target_update", {}),
("state_update", {}))))
unit.source = "changed source"
assert (
unit_lifecycle.calculate_change()
== OrderedDict(
(("comment_update", {}),
("source_update", {}),
("target_update", {}),
("state_update", {}))))
assert (
unit_lifecycle.calculate_change(foo="bar")
== OrderedDict(
(("comment_update", dict(foo="bar")),
("source_update", dict(foo="bar")),
("target_update", dict(foo="bar")),
("state_update", dict(foo="bar")))))
unit.target = original_target
assert (
unit_lifecycle.calculate_change()
== OrderedDict(
(("comment_update", {}),
("source_update", {}),
("state_update", {}))))
def test_unit_lifecycle_update_target(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = TRANSLATED
unit.save(user=member)
sub_target_update = lifecycle.get(Unit)(unit).sub_target_update()
assert isinstance(sub_target_update, Submission)
assert sub_target_update.unit == unit
assert sub_target_update.translation_project == store0.translation_project
assert sub_target_update.revision == unit.revision
assert (sub_target_update.submitter == unit.change.submitted_by == member)
assert sub_target_update.type == SubmissionTypes.SYSTEM
assert sub_target_update.field == SubmissionFields.TARGET
assert sub_target_update.new_value == unit.target_f
assert sub_target_update.old_value == unit._frozen.target
assert not sub_target_update.pk
def test_unit_lifecycle_update_comment(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.translator_comment = "SOME COMMENT"
unit.save(user=member)
sub_comment_update = lifecycle.get(Unit)(unit).sub_comment_update()
assert isinstance(sub_comment_update, Submission)
assert sub_comment_update.unit == unit
assert sub_comment_update.translation_project == store0.translation_project
assert sub_comment_update.revision == unit.revision
assert sub_comment_update.submitter == member
assert sub_comment_update.type == SubmissionTypes.SYSTEM
assert sub_comment_update.field == SubmissionFields.COMMENT
assert sub_comment_update.new_value == unit.translator_comment
assert sub_comment_update.old_value == (
unit._frozen.translator_comment or "")
assert not sub_comment_update.pk
def test_unit_lifecycle_update_comment(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.translator_comment = "SOME COMMENT"
unit.save(user=member)
sub_comment_update = lifecycle.get(Unit)(unit).sub_comment_update()
assert isinstance(sub_comment_update, Submission)
assert sub_comment_update.unit == unit
assert sub_comment_update.translation_project == store0.translation_project
assert sub_comment_update.revision == unit.revision
assert sub_comment_update.submitter == member
assert sub_comment_update.type == SubmissionTypes.SYSTEM
assert sub_comment_update.field == SubmissionFields.COMMENT
assert sub_comment_update.new_value == unit.translator_comment
assert sub_comment_update.old_value == (unit._frozen.translator_comment
or "")
assert not sub_comment_update.pk
def handle_toggle_quality_check(**kwargs):
check = kwargs["instance"]
false_positive = kwargs["false_positive"]
unit = check.unit
reviewer = unit.change.reviewed_by
unit_lifecycle = lifecycle.get(Unit)(unit)
subs = []
check.false_positive = false_positive
check.save()
if check.false_positive:
subs.append(
unit_lifecycle.sub_mute_qc(quality_check=check,
submitter=reviewer))
else:
subs.append(
unit_lifecycle.sub_unmute_qc(quality_check=check,
submitter=reviewer))
unit_lifecycle.save_subs(subs=subs)
store = unit.store
update_data.send(store.__class__, instance=store)
def handle_toggle_quality_check(**kwargs):
check = kwargs["instance"]
false_positive = kwargs["false_positive"]
unit = check.unit
reviewer = unit.change.reviewed_by
unit_lifecycle = lifecycle.get(Unit)(unit)
subs = []
check.false_positive = false_positive
check.save()
if check.false_positive:
subs.append(
unit_lifecycle.sub_mute_qc(quality_check=check,
submitter=reviewer))
else:
subs.append(
unit_lifecycle.sub_unmute_qc(quality_check=check,
submitter=reviewer))
unit_lifecycle.save_subs(subs=subs)
store = unit.store
update_data.send(store.__class__, instance=store)
def test_unit_lifecycle_update_state(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = TRANSLATED
unit.index = store0.max_index() + 1
unit.reviewed_by = member
unit.save()
sub_state_update = lifecycle.get(Unit)(unit).sub_state_update()
assert isinstance(sub_state_update, Submission)
assert sub_state_update.unit == unit
assert sub_state_update.store == store0
assert sub_state_update.translation_project == store0.translation_project
assert sub_state_update.revision == unit.revision
assert sub_state_update.submitter == unit.reviewed_by
assert sub_state_update.type == SubmissionTypes.SYSTEM
assert sub_state_update.field == SubmissionFields.STATE
assert sub_state_update.new_value == unit.state
assert sub_state_update.old_value == unit._frozen.state
assert not sub_state_update.pk
def test_unit_lifecycle_update_target(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = TRANSLATED
unit.save(user=member)
sub_target_update = lifecycle.get(Unit)(unit).sub_target_update()
assert isinstance(sub_target_update, Submission)
assert sub_target_update.unit == unit
assert sub_target_update.translation_project == store0.translation_project
assert sub_target_update.revision == unit.revision
assert (
sub_target_update.submitter
== unit.change.submitted_by
== member)
assert sub_target_update.type == SubmissionTypes.SYSTEM
assert sub_target_update.field == SubmissionFields.TARGET
assert sub_target_update.new_value == unit.target_f
assert sub_target_update.old_value == unit._frozen.target
assert not sub_target_update.pk
def test_unit_lifecycle_update_state_reviewed_by(store0, system, member2):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = FUZZY
unit.save(user=system)
# force the unit to be refrozen
unit = unit.__class__.objects.get(id=unit.id)
unit.state = TRANSLATED
unit.save(reviewed_by=member2)
sub_state_update = lifecycle.get(Unit)(unit).sub_state_update()
assert isinstance(sub_state_update, Submission)
assert sub_state_update.unit == unit
assert sub_state_update.translation_project == store0.translation_project
assert sub_state_update.revision == unit.revision
assert (sub_state_update.submitter == unit.change.reviewed_by == member2)
assert sub_state_update.type == SubmissionTypes.SYSTEM
assert sub_state_update.field == SubmissionFields.STATE
assert sub_state_update.new_value == unit.state
assert sub_state_update.old_value == unit._frozen.state
assert not sub_state_update.pk
def test_unit_lifecycle_update_source(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.source_f = multistring("Bar")
unit.state = TRANSLATED
unit.submitted_by = member
unit.save()
unit = Unit.objects.get(pk=unit.id)
unit.source = multistring("Foo23")
unit.save(submitted_by=member)
sub_source_update = lifecycle.get(Unit)(unit).sub_source_update()
assert isinstance(sub_source_update, Submission)
assert sub_source_update.unit == unit
assert sub_source_update.translation_project == store0.translation_project
assert sub_source_update.revision == unit.revision
assert sub_source_update.submitter == unit.submitted_by
assert sub_source_update.type == SubmissionTypes.SYSTEM
assert sub_source_update.field == SubmissionFields.SOURCE
assert sub_source_update.new_value == unit.source_f
assert sub_source_update.old_value == unit._frozen.source
assert not sub_source_update.pk
def test_log_get_submissions(member, store0):
submissions = Submission.objects.all()
submission_log = Log()
sub_events = submission_log.get_submission_events()
unit0 = store0.units[0]
unit0.source = "new source"
unit0.save(user=member)
lifecycle.get(unit0.__class__)(unit0).change()
unit1 = store0.units[0]
unit1.translator_comment = "new comment"
unit1.save(user=member)
lifecycle.get(unit1.__class__)(unit1).change()
qc = store0.units.filter(
qualitycheck__isnull=False)[0].qualitycheck_set.all()[0]
lifecycle.get(qc.unit.__class__)(qc.unit).sub_mute_qc(
submitter=member, quality_check=qc).save()
assert type(sub_events).__name__ == "generator"
assert len(list(sub_events)) == submissions.count()
expected = submissions.filter(
submitter=member).filter(
unit__store=store0).in_bulk()
result = submission_log.get_submission_events(
store=store0.pk, users=[member])
for event in result:
sub = expected[event.value.pk]
event_name = "state_changed"
if sub.field == SubmissionFields.CHECK:
event_name = (
"check_muted"
if sub.new_value == "0"
else "check_unmuted")
elif sub.field == SubmissionFields.TARGET:
event_name = "target_updated"
elif sub.field == SubmissionFields.SOURCE:
event_name = "source_updated"
elif sub.field == SubmissionFields.COMMENT:
event_name = "comment_updated"
assert isinstance(event, submission_log.event)
assert event.unit == sub.unit
assert event.user == sub.submitter
assert event.timestamp == sub.creation_time
assert event.action == event_name
assert event.value == sub
assert event.revision == sub.revision
def test_log_get_submissions(member, store0):
submissions = Submission.objects.all()
submission_log = Log()
sub_events = submission_log.get_submission_events()
unit0 = store0.units[0]
unit0.source = "new source"
unit0.save(user=member)
lifecycle.get(unit0.__class__)(unit0).change()
unit1 = store0.units[0]
unit1.translator_comment = "new comment"
unit1.save(user=member)
lifecycle.get(unit1.__class__)(unit1).change()
qc = store0.units.filter(
qualitycheck__isnull=False)[0].qualitycheck_set.all()[0]
lifecycle.get(qc.unit.__class__)(qc.unit).sub_mute_qc(
submitter=member, quality_check=qc).save()
assert type(sub_events).__name__ == "generator"
assert len(list(sub_events)) == submissions.count()
expected = submissions.filter(submitter=member).filter(
unit__store=store0).in_bulk()
result = submission_log.get_submission_events(store=store0.pk,
users=[member])
for event in result:
sub = expected[event.value.pk]
event_name = "state_changed"
if sub.field == SubmissionFields.CHECK:
event_name = ("check_muted"
if sub.new_value == "0" else "check_unmuted")
elif sub.field == SubmissionFields.TARGET:
event_name = "target_updated"
elif sub.field == SubmissionFields.SOURCE:
event_name = "source_updated"
elif sub.field == SubmissionFields.COMMENT:
event_name = "comment_updated"
assert isinstance(event, submission_log.event)
assert event.unit == sub.unit
assert event.user == sub.submitter
assert event.timestamp == sub.creation_time
assert event.action == event_name
assert event.value == sub
assert event.revision == sub.revision
