def test_grouped_events(store_po):
assert grouped_events.get(Log) == GroupedEvents
units = [
('Unit 0 Source', 'Unit 0 Target', False),
('Unit 1 Source', '', False),
('Unit 2 Source', 'Unit 2 Fuzzy Target', True),
]
store_po.update(create_store(units=units))
units = [
('Unit 0 Source', 'Unit 0 Target', False),
('Unit 1 Source', 'Unit 1 Target', False),
('Unit 2 Source', 'Unit 2 Target', False),
]
store_po.update(create_store(units=units))
store_log = log.get(store_po.__class__)(store_po)
expected = [
(x.unit, x.user, x.timestamp, x.action, x.value, x.old_value, x.revision)
for x in sorted([
ComparableLogEvent(ev)
for ev in store_log.get_events()])]
result = [
(x.unit, x.user, x.timestamp, x.action, x.value, x.old_value, x.revision)
for x in GroupedEvents(store_log).sorted_events()]
assert expected == result
def tp_uploads(request, client):
from pootle.core.delegate import language_team
from pootle_language.models import Language
from pootle_translationproject.models import TranslationProject
from pootle_store.models import Store
from django.contrib.auth import get_user_model
submitter_name, uploader_name, errors = request.param
uploader = get_user_model().objects.get(username=uploader_name)
tp = TranslationProject.objects.all()[0]
store = Store.objects.filter(parent=tp.directory)[0]
kwargs = {
"project_code": tp.project.code,
"language_code": tp.language.code,
"dir_path": "",
"filename": store.name
}
password = TEST_USERS[submitter_name]['password']
language_team.get(Language)(tp.language).add_member(uploader, "submitter")
client.login(username=submitter_name, password=password)
updated_units = [(unit.source_f, "%s UPDATED" % unit.target_f, False)
for unit in store.units]
updated_store = create_store(store.pootle_path, "0", updated_units)
uploaded_file = SimpleUploadedFile(store.name, str(updated_store),
"text/x-gettext-translation")
response = client.post(reverse("pootle-tp-store-browse", kwargs=kwargs), {
'name': '',
'file': uploaded_file,
'user_id': uploader.id
})
return tp, response.wsgi_request, response, kwargs, errors
def store_diff_tests(request, en_tutorial_po, member, member2):
from pootle_store.models import StoreDiff
test = _setup_store_test(en_tutorial_po, member, member2,
UPDATE_STORE_TESTS[request.param])
test_store = create_store(units=test[1])
return [StoreDiff(test[0], test_store, test[2])] + list(test[:3])
def store_diff_tests(request, en_tutorial_po, member, member2):
from pootle_store.models import StoreDiff
test = _setup_store_test(en_tutorial_po, member, member2,
UPDATE_STORE_TESTS[request.param])
test_store = create_store(units=test[1])
return [StoreDiff(test[0], test_store, test[2])] + list(test[:3])
def test_import_add_and_obsolete_units(project0_nongnu, import_tps,
site_users):
from pytest_pootle.factories import StoreDBFactory, UnitDBFactory
tp = import_tps
user = site_users["user"]
store = StoreDBFactory(translation_project=tp)
unit = UnitDBFactory(store=store, state=TRANSLATED)
filestore = create_store(
store.pootle_path,
"0",
[(unit.source_f + " REPLACED", unit.target_f + " REPLACED", False)])
import_file(SimpleUploadedFile("import_add_and_obsolete.po",
str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
if allow_add_and_obsolete:
assert Unit.objects.filter(store=store, state=OBSOLETE).count() == 1
assert store.units.filter(state=TRANSLATED).count() == 1
unit_source = store.units[0].unit_source
assert unit_source.created_with == SubmissionTypes.UPLOAD
assert unit_source.created_by == user
assert store.units[0].change.changed_with == SubmissionTypes.UPLOAD
assert store.units[0].change.submitted_by == user
assert Unit.objects.filter(store=store).count() == 2
else:
assert store.units.all().count() == 1
def test_import_to_empty(project0_nongnu, import_tps, site_users):
from pytest_pootle.factories import StoreDBFactory
tp = import_tps
user = site_users["user"]
store = StoreDBFactory(translation_project=tp, name="import_to_empty.po")
filestore = create_store(store.pootle_path, "0",
[("Unit Source", "Unit Target", False)])
import_file(SimpleUploadedFile(store.name,
str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
if allow_add_and_obsolete:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 1
unit_source = store.units[0].unit_source
assert unit_source.created_with == SubmissionTypes.UPLOAD
assert unit_source.created_by == user
assert store.units[0].change.changed_with == SubmissionTypes.UPLOAD
assert store.units[0].change.submitted_by == user
else:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 0
def test_store_update_with_obsolete(store_po):
units = [('source1', 'target1', False)]
file_store = create_store(store_po.pootle_path, units=units)
store_po.update(file_store)
unit = store_po.units[0]
assert not unit.isobsolete()
file_store.units[1].makeobsolete()
store_po.update(file_store)
unit = store_po.UnitClass.objects.get(id=unit.id)
assert unit.isobsolete()
def test_store_update_with_obsolete(store_po):
units = [('source1', 'target1', False)]
file_store = create_store(store_po.pootle_path, units=units)
store_po.update(file_store)
unit = store_po.units[0]
assert not unit.isobsolete()
file_store.units[1].makeobsolete()
store_po.update(file_store)
unit = store_po.UnitClass.objects.get(id=unit.id)
assert unit.isobsolete()
def store_diff_tests(request, tp0, member, member2):
from pytest_pootle.factories import StoreDBFactory
from pootle_store.diff import StoreDiff
store = StoreDBFactory(translation_project=tp0, parent=tp0.directory)
test = _setup_store_test(store, member, member2,
UPDATE_STORE_TESTS[request.param])
test_store = create_store(units=test[1])
return [StoreDiff(test[0], test_store, test[2])] + list(test[:3])
def test_update_submission_ordering():
unit = Unit.objects.filter(state=UNTRANSLATED).first()
unit.markfuzzy()
unit.target = "Fuzzy Translation for " + unit.source_f
unit.save()
store = create_store(unit.store.pootle_path, "0",
[(unit.source_f, "Translation for " + unit.source_f)])
unit.store.update(store)
submission_field = Submission.objects.filter(unit=unit).latest().field
assert submission_field == SubmissionFields.TARGET
def store_diff_tests(request, tp0, member, member2):
from pootle_store.contextmanagers import update_store_after
from pootle_store.diff import StoreDiff
store = StoreDBFactory(translation_project=tp0, parent=tp0.directory)
with update_store_after(store):
test = _setup_store_test(store, member, member2,
UPDATE_STORE_TESTS[request.param])
test_store = create_store(units=test[1])
return [StoreDiff(test[0], test_store, test[2])] + list(test[:3])
def test_store_update_with_duplicate(store_po, caplog):
units = [
('source1', 'target1', False),
('source2', 'target2', False),
('source2', 'target2', False)]
file_store = create_store(store_po.pootle_path, units=units)
caplog.set_level(logging.WARN)
store_po.update(file_store)
assert (
caplog.records[0].message
== ('[diff] Duplicate unit found: %s source2'
% store_po.name))
def store_diff_tests(request, tp0, member, member2):
from pootle_store.contextmanagers import update_store_after
from pootle_store.diff import StoreDiff
store = StoreDBFactory(
translation_project=tp0,
parent=tp0.directory)
with update_store_after(store):
test = _setup_store_test(store, member, member2,
UPDATE_STORE_TESTS[request.param])
test_store = create_store(units=test[1])
return [StoreDiff(test[0], test_store, test[2])] + list(test[:3])
def test_import_new_file(project0_nongnu, import_tps, site_users):
tp = import_tps
user = site_users["user"]
store_pootle_path = tp.pootle_path + "import_new_file.po"
filestore = create_store(store_pootle_path, "0",
[("Unit Source", "Unit Target", False)])
# New store can't be created via current import command. This test will
# need to be adjusted if we allow to create new stores via import command.
from import_export.exceptions import FileImportError
with pytest.raises(FileImportError):
import_file(SimpleUploadedFile("import_new_file.po",
str(filestore),
"text/x-gettext-translation"), user)
def test_update_submission_ordering():
unit = Unit.objects.filter(state=UNTRANSLATED).first()
unit.markfuzzy()
unit.target = "Fuzzy Translation for " + unit.source_f
unit.save()
store = create_store(
unit.store.pootle_path,
"0",
[(unit.source_f, "Translation for " + unit.source_f, False)]
)
unit.store.update(store)
submission_field = Submission.objects.filter(unit=unit).latest().field
assert submission_field == SubmissionFields.STATE
def test_grouped_events(store_po):
assert grouped_events.get(Log) == GroupedEvents
units = [
('Unit 0 Source', 'Unit 0 Target', False),
('Unit 1 Source', '', False),
('Unit 2 Source', 'Unit 2 Fuzzy Target', True),
]
store_po.update(create_store(units=units))
units = [
('Unit 0 Source', 'Unit 0 Target', False),
('Unit 1 Source', 'Unit 1 Target', False),
('Unit 2 Source', 'Unit 2 Target', False),
]
store_po.update(create_store(units=units))
store_log = log.get(store_po.__class__)(store_po)
expected = [(x.unit, x.user, x.timestamp, x.action, x.value, x.old_value,
x.revision)
for x in sorted(
[ComparableLogEvent(ev) for ev in store_log.get_events()])]
result = [(x.unit, x.user, x.timestamp, x.action, x.value, x.old_value,
x.revision) for x in GroupedEvents(store_log).sorted_events()]
assert expected == result
def test_import_to_empty(import_tps, site_users):
from pytest_pootle.factories import StoreFactory
tp = import_tps
user = site_users["user"]
store = StoreFactory(translation_project=tp, name="import_to_empty.po")
filestore = create_store(store.pootle_path, "0",
[("Unit Source", "Unit Target")])
import_file(
SimpleUploadedFile(store.name, str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = (
(tp.project.checkstyle == 'terminology' or tp.is_template_project)
and check_user_permission(user, 'administrate', tp.directory))
if allow_add_and_obsolete:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 1
else:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 0
def _setup_store_test(store, member, member2, test):
from pootle_store.constants import POOTLE_WINS, SOURCE_WINS
setup = test.get("setup", None)
if setup is None:
setup = [(DEFAULT_STORE_UNITS_1),
(DEFAULT_STORE_UNITS_1 + DEFAULT_STORE_UNITS_2)]
for units in setup:
store_revision = store.get_max_unit_revision()
ttkstore = create_store(units=units)
for unit in ttkstore.units[1:]:
unit.addnote(
origin="translator",
text=("Set up unit(%s) with store_revision: %s"
% (unit.source, store_revision)))
store.update(
store=ttkstore,
store_revision=store_revision,
user=member)
store_revision, units_update = test["update_store"]
units_before = [
(unit, unit.change)
for unit in store.unit_set.select_related("change").all().order_by("index")]
fs_wins = test.get("fs_wins", True)
if fs_wins:
resolve_conflict = SOURCE_WINS
else:
resolve_conflict = POOTLE_WINS
if store_revision == "MAX":
store_revision = store.get_max_unit_revision()
elif store_revision == "MID":
revisions = [unit.revision for unit, change in units_before]
store_revision = sum(revisions) / len(revisions)
return (store, units_update, store_revision, resolve_conflict,
units_before, member, member2)
def test_mute_qualitycheck(store_po, member):
store = create_store(pootle_path=store_po.pootle_path,
units=[("Hello", "", False)])
store.units[1].target = "Hello\n\nHello"
store_po.update(store)
unit = store_po.units.first()
unit.save()
check_qs = unit.qualitycheck_set.filter(category=Category.CRITICAL,
false_positive=False)
assert check_qs.count() == 1
assert store_po.data.critical_checks == 1
check_id = check_qs[0].id
unit.toggle_qualitycheck(check_id=check_id,
false_positive=True,
user=member)
assert unit.qualitycheck_set.get(id=check_id).false_positive
assert store_po.data.critical_checks == 0
sub = unit.submission_set.get(quality_check__id=check_id)
assert sub.submitter == member
def tp_uploads(client, member):
from pootle_translationproject.models import TranslationProject
from pootle_store.models import Store
tp = TranslationProject.objects.all()[0]
store = Store.objects.filter(parent=tp.directory)[0]
kwargs = {
"project_code": tp.project.code,
"language_code": tp.language.code,
"dir_path": "",
"filename": store.name}
password = TEST_USERS[member.username]['password']
client.login(username=member.username, password=password)
response = client.post(
reverse("pootle-tp-store-browse", kwargs=kwargs),
{'name': '', 'attachment': create_store([
(unit.source_f, "%s UPDATED" % unit.target_f)
for unit in store.units])})
return tp, response.wsgi_request, response, kwargs
def tp_uploads(client, member):
from pootle_translationproject.models import TranslationProject
from pootle_store.models import Store
tp = TranslationProject.objects.all()[0]
store = Store.objects.filter(parent=tp.directory)[0]
kwargs = {
"project_code": tp.project.code,
"language_code": tp.language.code,
"dir_path": "",
"filename": store.name}
password = TEST_USERS[member.username]['password']
client.login(username=member.username, password=password)
response = client.post(
reverse("pootle-tp-store-browse", kwargs=kwargs),
{'name': '', 'attachment': create_store([
(unit.source_f, "%s UPDATED" % unit.target_f)
for unit in store.units])})
return tp, response.wsgi_request, response, kwargs
def test_mute_qualitycheck(store_po, member):
store = create_store(pootle_path=store_po.pootle_path, units=[
("Hello", "", False)
])
store.units[1].target = "Hello\n\nHello"
store_po.update(store)
unit = store_po.units.first()
unit.save()
check_qs = unit.qualitycheck_set.filter(
category=Category.CRITICAL,
false_positive=False)
assert check_qs.count() == 1
assert store_po.data.critical_checks == 1
check_id = check_qs[0].id
unit.toggle_qualitycheck(check_id=check_id, false_positive=True,
user=member)
assert unit.qualitycheck_set.get(id=check_id).false_positive
assert store_po.data.critical_checks == 0
sub = unit.submission_set.get(quality_check__id=check_id)
assert sub.submitter == member
def test_import_to_empty(import_tps, site_users):
from pytest_pootle.factories import StoreFactory
tp = import_tps
user = site_users["user"]
store = StoreFactory(translation_project=tp, name="import_to_empty.po")
filestore = create_store(store.pootle_path, "0",
[("Unit Source", "Unit Target")])
import_file(SimpleUploadedFile(store.name,
str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
if allow_add_and_obsolete:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 1
else:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 0
def _setup_store_test(store, member, member2, test):
from pootle_store.constants import POOTLE_WINS, SOURCE_WINS
setup = test.get("setup", None)
if setup is None:
setup = [(DEFAULT_STORE_UNITS_1),
(DEFAULT_STORE_UNITS_1 + DEFAULT_STORE_UNITS_2)]
for units in setup:
store_revision = store.get_max_unit_revision()
ttkstore = create_store(units=units)
for unit in ttkstore.units[1:]:
unit.addnote(origin="translator",
text=("Set up unit(%s) with store_revision: %s" %
(unit.source, store_revision)))
store.update(store=ttkstore,
store_revision=store_revision,
user=member)
store_revision, units_update = test["update_store"]
units_before = [(unit, unit.change)
for unit in store.unit_set.select_related(
"change").all().order_by("index")]
fs_wins = test.get("fs_wins", True)
if fs_wins:
resolve_conflict = SOURCE_WINS
else:
resolve_conflict = POOTLE_WINS
if store_revision == "MAX":
store_revision = store.get_max_unit_revision()
elif store_revision == "MID":
revisions = [unit.revision for unit, change in units_before]
store_revision = sum(revisions) / len(revisions)
return (store, units_update, store_revision, resolve_conflict,
units_before, member, member2)
def tp_uploads(request, client):
from pootle.core.delegate import language_team
from pootle_language.models import Language
from pootle_translationproject.models import TranslationProject
from pootle_store.models import Store
from django.contrib.auth import get_user_model
submitter_name, uploader_name, errors = request.param
uploader = get_user_model().objects.get(username=uploader_name)
tp = TranslationProject.objects.all()[0]
store = Store.objects.filter(parent=tp.directory)[0]
kwargs = {
"project_code": tp.project.code,
"language_code": tp.language.code,
"dir_path": "",
"filename": store.name}
password = TEST_USERS[submitter_name]['password']
language_team.get(Language)(tp.language).add_member(uploader, "submitter")
client.login(username=submitter_name, password=password)
updated_units = [
(unit.source_f, "%s UPDATED" % unit.target_f, False)
for unit in store.units
]
updated_store = create_store(store.pootle_path, "0", updated_units)
uploaded_file = SimpleUploadedFile(
store.name,
str(updated_store),
"text/x-gettext-translation"
)
response = client.post(
reverse("pootle-tp-store-browse", kwargs=kwargs),
{
'name': '',
'file': uploaded_file,
'user_id': uploader.id
}
)
return tp, response.wsgi_request, response, kwargs, errors
def test_tp_tool_store_clone_with_checks(store_po, system):
store_po.update(create_store(pootle_path=store_po.pootle_path, units=[
("Hello", "", False)
]))
unit = store_po.units.first()
unit.target = "Hello\n\nHello"
unit.save()
check_qs = unit.qualitycheck_set.filter(
category=Category.CRITICAL,
false_positive=False)
assert check_qs.count() == 1
check_id = check_qs[0].id
unit.toggle_qualitycheck(check_id=check_id, false_positive=True,
user=system)
assert unit.qualitycheck_set.get(id=check_id).false_positive
tool = tp_tool.get(Project)(store_po.translation_project.project)
directory = store_po.translation_project.directory.child_dirs.first()
cloned_store = tool.clone_store(store_po, directory)
cloned_unit = cloned_store.units[0]
check_qs = cloned_unit.qualitycheck_set.filter(category=Category.CRITICAL)
assert check_qs.count() == 1
assert check_qs[0].false_positive
def test_tp_tool_store_clone_with_checks(store_po, system):
store_po.update(
create_store(pootle_path=store_po.pootle_path,
units=[("Hello", "", False)]))
unit = store_po.units.first()
unit.target = "Hello\n\nHello"
unit.save()
check_qs = unit.qualitycheck_set.filter(category=Category.CRITICAL,
false_positive=False)
assert check_qs.count() == 1
check_id = check_qs[0].id
unit.toggle_qualitycheck(check_id=check_id,
false_positive=True,
user=system)
assert unit.qualitycheck_set.get(id=check_id).false_positive
tool = tp_tool.get(Project)(store_po.translation_project.project)
directory = store_po.translation_project.directory.child_dirs.first()
cloned_store = tool.clone_store(store_po, directory)
cloned_unit = cloned_store.units[0]
check_qs = cloned_unit.qualitycheck_set.filter(category=Category.CRITICAL)
assert check_qs.count() == 1
assert check_qs[0].false_positive
def test_comparable_log(member, store0, store_po):
assert comparable_event.get(Log) == ComparableLogEvent
start = timezone.now().replace(microsecond=0)
unit = store0.units.filter(state=TRANSLATED).first()
unit.target += 'UPDATED IN TEST'
unit.save(user=member)
unit = store0.units.filter(state=TRANSLATED).first()
unit.target += 'UPDATED IN TEST AGAIN'
unit.save(user=member)
unit_log = log.get(unit.__class__)(unit)
event1, event2 = [
ComparableLogEvent(x)
for x in unit_log.get_events(users=[member.id], start=start)
]
assert (event1 < event2) == (event1.revision < event2.revision)
assert (event2 < event1) == (event2.revision < event1.revision)
unit = store0.units.filter(state=UNTRANSLATED).first()
sugg1, created_ = review.get(Suggestion)().add(unit,
unit.source_f +
'SUGGESTION',
user=member)
sugg2, created_ = review.get(Suggestion)().add(unit,
unit.source_f +
'SUGGESTION AGAIN',
user=member)
Suggestion.objects.filter(id=sugg2.id).update(
creation_time=sugg1.creation_time)
unit_log = log.get(unit.__class__)(unit)
event1, event2 = [
ComparableLogEvent(x)
for x in unit_log.get_events(users=[member.id], start=start)
]
assert (event1 < event2) == (event1.value.pk < event2.value.pk)
assert (event2 < event1) == (event2.value.pk < event1.value.pk)
Suggestion.objects.filter(id=sugg2.id).update(creation_time=None)
sugg2 = Suggestion.objects.get(id=sugg2.id)
event1 = [
ComparableLogEvent(x)
for x in unit_log.get_events(users=[member.id], start=start)
][0]
event2 = ComparableLogEvent(
unit_log.event(sugg2.unit, sugg2.user, sugg2.creation_time,
"suggestion_created", sugg2))
assert event2 < event1
assert not (event1 < event2)
units = [
('Unit 0 Source', 'Unit 0 Target', False),
('Unit 1 Source', '', False),
]
store_po.update(create_store(units=units))
unit1, unit2 = store_po.units
unit2.__class__.objects.filter(id=unit2.id).update(
creation_time=unit1.creation_time)
store_log = log.get(store_po.__class__)(store_po)
event1, event2 = [ComparableLogEvent(x) for x in store_log.get_events()]
assert (event1 < event2) == (event1.unit.id < event2.unit.id)
assert (event2 < event1) == (event2.unit.id < event1.unit.id)
creation_time = unit1.creation_time + timedelta(seconds=1)
unit2.__class__.objects.filter(id=unit2.id).update(
creation_time=creation_time)
event1, event2 = [ComparableLogEvent(x) for x in store_log.get_events()]
assert (event1 < event2) == (event1.timestamp < event2.timestamp)
assert (event2 < event1) == (event2.timestamp < event1.timestamp)
unit = store_po.units.filter(state=UNTRANSLATED)[0]
unit.target = 'Unit 1 Target'
unit.save()
unit_log = log.get(unit.__class__)(unit)
event1, event2 = [
ComparableLogEvent(x) for x in unit_log.get_submission_events()
]
assert not (event1 < event2) and not (event2 < event1)
def test_comparable_log(member, store0, store_po):
assert comparable_event.get(Log) == ComparableLogEvent
start = timezone.now().replace(microsecond=0)
unit = store0.units.filter(state=TRANSLATED).first()
unit.target += 'UPDATED IN TEST'
unit.save(user=member)
unit = store0.units.filter(state=TRANSLATED).first()
unit.target += 'UPDATED IN TEST AGAIN'
unit.save(user=member)
unit_log = log.get(unit.__class__)(unit)
event1, event2 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)]
assert (event1 < event2) == (event1.revision < event2.revision)
assert (event2 < event1) == (event2.revision < event1.revision)
unit = store0.units.filter(state=UNTRANSLATED).first()
sugg1, created_ = review.get(Suggestion)().add(
unit,
unit.source_f + 'SUGGESTION',
user=member)
sugg2, created_ = review.get(Suggestion)().add(
unit,
unit.source_f + 'SUGGESTION AGAIN',
user=member)
Suggestion.objects.filter(id=sugg2.id).update(creation_time=sugg1.creation_time)
unit_log = log.get(unit.__class__)(unit)
event1, event2 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)]
assert (event1 < event2) == (event1.value.pk < event2.value.pk)
assert (event2 < event1) == (event2.value.pk < event1.value.pk)
Suggestion.objects.filter(id=sugg2.id).update(creation_time=None)
sugg2 = Suggestion.objects.get(id=sugg2.id)
event1 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)][0]
event2 = ComparableLogEvent(unit_log.event(sugg2.unit,
sugg2.user,
sugg2.creation_time,
"suggestion_created",
sugg2))
assert event2 < event1
assert not (event1 < event2)
units = [
('Unit 0 Source', 'Unit 0 Target', False),
('Unit 1 Source', '', False),
]
store_po.update(create_store(units=units))
unit1, unit2 = store_po.units
unit2.__class__.objects.filter(id=unit2.id).update(
creation_time=unit1.creation_time)
store_log = log.get(store_po.__class__)(store_po)
event1, event2 = [ComparableLogEvent(x)
for x in
store_log.get_events()]
assert (event1 < event2) == (event1.unit.id < event2.unit.id)
assert (event2 < event1) == (event2.unit.id < event1.unit.id)
creation_time = unit1.creation_time + timedelta(seconds=1)
unit2.__class__.objects.filter(id=unit2.id).update(creation_time=creation_time)
event1, event2 = [ComparableLogEvent(x)
for x in
store_log.get_events()]
assert (event1 < event2) == (event1.timestamp < event2.timestamp)
assert (event2 < event1) == (event2.timestamp < event1.timestamp)
unit = store_po.units.filter(state=UNTRANSLATED)[0]
unit.target = 'Unit 1 Target'
unit.save()
unit_log = log.get(unit.__class__)(unit)
event1, event2 = [ComparableLogEvent(x)
for x in unit_log.get_submission_events()]
assert not (event1 < event2) and not (event2 < event1)
