def test_update_set_last_sync_revision(project0_nongnu, tp0, store0, test_fs):
"""Tests setting last_sync_revision after store creation.
"""
unit = store0.units.first()
unit.target = "UPDATED TARGET"
unit.save()
store0.sync()
# Store is already parsed and store.last_sync_revision should be equal to
# max unit revision
assert store0.last_sync_revision == store0.get_max_unit_revision()
# store.last_sync_revision is not changed after empty update
saved_last_sync_revision = store0.last_sync_revision
store0.updater.update_from_disk()
assert store0.last_sync_revision == saved_last_sync_revision
orig = str(store0)
update_file = test_fs.open(
"data/po/tutorial/ru/update_set_last_sync_revision_updated.po",
"r")
with update_file as sourcef:
with open(store0.file.path, "wb") as targetf:
targetf.write(sourcef.read())
# any non-empty update sets last_sync_revision to next global revision
next_revision = Revision.get() + 1
store0.updater.update_from_disk()
assert store0.last_sync_revision == next_revision
# store.last_sync_revision is not changed after empty update (even if it
# has unsynced units)
item_index = 0
next_unit_revision = Revision.get() + 1
dbunit = store0.units.first()
dbunit.target = "ANOTHER DB TARGET UPDATE"
dbunit.save()
assert dbunit.revision == next_unit_revision
store0.updater.update_from_disk()
assert store0.last_sync_revision == next_revision
# Non-empty update sets store.last_sync_revision to next global revision
# (even the store has unsynced units). There is only one unsynced unit in
# this case so its revision should be set next to store.last_sync_revision
next_revision = Revision.get() + 1
with open(store0.file.path, "wb") as targetf:
targetf.write(orig)
store0.updater.update_from_disk()
assert store0.last_sync_revision == next_revision
# Get unsynced unit in DB. Its revision should be greater
# than store.last_sync_revision to allow to keep this change during
# update from a file
dbunit = store0.units[item_index]
assert dbunit.revision == store0.last_sync_revision + 1
def test_update_set_last_sync_revision(project0_nongnu, tp0, store0, test_fs):
"""Tests setting last_sync_revision after store creation.
"""
unit = store0.units.first()
unit.target = "UPDATED TARGET"
unit.save()
store0.sync()
# Store is already parsed and store.last_sync_revision should be equal to
# max unit revision
assert store0.last_sync_revision == store0.get_max_unit_revision()
# store.last_sync_revision is not changed after empty update
saved_last_sync_revision = store0.last_sync_revision
store0.updater.update_from_disk()
assert store0.last_sync_revision == saved_last_sync_revision
orig = str(store0)
update_file = test_fs.open(
"data/po/tutorial/ru/update_set_last_sync_revision_updated.po", "r")
with update_file as sourcef:
with open(store0.file.path, "wb") as targetf:
targetf.write(sourcef.read())
# any non-empty update sets last_sync_revision to next global revision
next_revision = Revision.get() + 1
store0.updater.update_from_disk()
assert store0.last_sync_revision == next_revision
# store.last_sync_revision is not changed after empty update (even if it
# has unsynced units)
item_index = 0
next_unit_revision = Revision.get() + 1
dbunit = store0.units.first()
dbunit.target = "ANOTHER DB TARGET UPDATE"
dbunit.save()
assert dbunit.revision == next_unit_revision
store0.updater.update_from_disk()
assert store0.last_sync_revision == next_revision
# Non-empty update sets store.last_sync_revision to next global revision
# (even the store has unsynced units). There is only one unsynced unit in
# this case so its revision should be set next to store.last_sync_revision
next_revision = Revision.get() + 1
with open(store0.file.path, "wb") as targetf:
targetf.write(orig)
store0.updater.update_from_disk()
assert store0.last_sync_revision == next_revision
# Get unsynced unit in DB. Its revision should be greater
# than store.last_sync_revision to allow to keep this change during
# update from a file
dbunit = store0.units[item_index]
assert dbunit.revision == store0.last_sync_revision + 1
def test_update_set_last_sync_revision(project0_disk, tp0, store0, test_fs):
"""Tests setting last_sync_revision after store creation."""
unit = store0.units.first()
unit.target = "UPDATED TARGET"
unit.save()
store0.sync()
# Store is already parsed and nothing is unsynced
assert store0.last_sync_revision == store0.get_max_unit_revision()
# An empty update leaves `last_sync_revision` intact
saved_last_sync_revision = store0.last_sync_revision
assert not store0.updater.update_from_disk()
assert store0.last_sync_revision == saved_last_sync_revision
orig = str(store0)
update_file = test_fs.open(
"data/po/tutorial/ru/update_set_last_sync_revision_updated.po",
"r")
with update_file as sourcef:
with open(store0.file.path, "wb") as targetf:
targetf.write(sourcef.read())
# any non-empty update sets last_sync_revision to next global revision
next_revision = Revision.get() + 1
# uses `force` to omit mtime optimizations
assert store0.updater.update_from_disk(force=True)
assert store0.last_sync_revision == next_revision
# Make a change to a unit, so that it's unsynced
next_unit_revision = Revision.get() + 1
dbunit = store0.units.first()
dbunit.target = "ANOTHER DB TARGET UPDATE"
dbunit.save()
assert dbunit.revision == next_unit_revision
# After the next empty update, the store's revision remains the same
assert not store0.updater.update_from_disk()
assert store0.last_sync_revision == next_revision
# Now that there are unsynced units, the next non-empty update
# will set the last sync revision to the next global revision
next_revision = Revision.get() + 1
with open(store0.file.path, "wb") as targetf:
targetf.write(orig)
# uses `force` to omit mtime optimizations
assert store0.updater.update_from_disk(force=True)
assert store0.last_sync_revision == next_revision
# The unsynced unit's revision should be greater than the last sync
# revision to allow syncing it after this update
dbunit = store0.units[0]
assert dbunit.revision == store0.last_sync_revision + 1
def test_update_set_last_sync_revision(ru_update_set_last_sync_revision_po):
"""Tests setting last_sync_revision after store creation.
"""
store = ru_update_set_last_sync_revision_po
# Store is already parsed and store.last_sync_revision should be equal to
# max unit revision
assert store.last_sync_revision == store.get_max_unit_revision()
# store.last_sync_revision is not changed after empty update
saved_last_sync_revision = store.last_sync_revision
store.update_from_disk()
assert store.last_sync_revision == saved_last_sync_revision
dir_path = os.path.join(store.translation_project.project.get_real_path(),
store.translation_project.language.code)
copied_initial_filepath = os.path.join(
dir_path,
'update_set_last_sync_revision.po.temp'
)
shutil.copy(store.file.path, copied_initial_filepath)
updated_filepath = os.path.join(
dir_path,
'update_set_last_sync_revision_updated.po'
)
shutil.copy(updated_filepath, store.file.path)
# any non-empty update sets last_sync_revision to next global revision
next_revision = Revision.get() + 1
store.update_from_disk()
assert store.last_sync_revision == next_revision
# store.last_sync_revision is not changed after empty update (even if it
# has unsynced units)
item_index = 0
next_unit_revision = Revision.get() + 1
dbunit = _update_translation(store, item_index, {'target': u'first'},
sync=False)
assert dbunit.revision == next_unit_revision
store.update_from_disk()
assert store.last_sync_revision == next_revision
# Non-empty update sets store.last_sync_revision to next global revision
# (even the store has unsynced units). There is only one unsynced unit in
# this case so its revision should be set next to store.last_sync_revision
next_revision = Revision.get() + 1
shutil.move(copied_initial_filepath, store.file.path)
store.update_from_disk()
assert store.last_sync_revision == next_revision
# Get unsynced unit in DB. Its revision should be greater
# than store.last_sync_revision to allow to keep this change during
# update from a file
dbunit = store.getitem(item_index)
assert dbunit.revision == store.last_sync_revision + 1
def test_update_set_last_sync_revision(ru_update_set_last_sync_revision_po):
"""Tests setting last_sync_revision after store creation.
"""
store = ru_update_set_last_sync_revision_po
# Store is already parsed and store.last_sync_revision should be equal to
# max unit revision
assert store.last_sync_revision == store.get_max_unit_revision()
# store.last_sync_revision is not changed after empty update
saved_last_sync_revision = store.last_sync_revision
store.update_from_disk()
assert store.last_sync_revision == saved_last_sync_revision
dir_path = os.path.join(store.translation_project.project.get_real_path(),
store.translation_project.language.code)
copied_initial_filepath = os.path.join(
dir_path, 'update_set_last_sync_revision.po.temp')
shutil.copy(store.file.path, copied_initial_filepath)
updated_filepath = os.path.join(
dir_path, 'update_set_last_sync_revision_updated.po')
shutil.copy(updated_filepath, store.file.path)
# any non-empty update sets last_sync_revision to next global revision
next_revision = Revision.get() + 1
store.update_from_disk()
assert store.last_sync_revision == next_revision
# store.last_sync_revision is not changed after empty update (even if it
# has unsynced units)
item_index = 0
next_unit_revision = Revision.get() + 1
dbunit = _update_translation(store,
item_index, {'target': u'first'},
sync=False)
assert dbunit.revision == next_unit_revision
store.update_from_disk()
assert store.last_sync_revision == next_revision
# Non-empty update sets store.last_sync_revision to next global revision
# (even the store has unsynced units). There is only one unsynced unit in
# this case so its revision should be set next to store.last_sync_revision
next_revision = Revision.get() + 1
shutil.move(copied_initial_filepath, store.file.path)
store.update_from_disk()
assert store.last_sync_revision == next_revision
# Get unsynced unit in DB. Its revision should be greater
# than store.last_sync_revision to allow to keep this change during
# update from a file
dbunit = store.getitem(item_index)
assert dbunit.revision == store.last_sync_revision + 1
def handle_noargs(self, **options):
if options["restore"]:
from pootle_store.models import Unit
Revision.set(Unit.max_revision())
self.stdout.write("%s" % Revision.get())
def _sync_to_pootle(self, merge=False, pootle_wins=None):
"""
Update Pootle ``Store`` with the parsed FS file.
"""
tmp_store = self.deserialize()
if not tmp_store:
logger.warn("File staged for sync has disappeared: %s", self.path)
return
if pootle_wins is None:
resolve_conflict = (
self.store_fs.resolve_conflict or SOURCE_WINS)
elif pootle_wins:
resolve_conflict = POOTLE_WINS
else:
resolve_conflict = SOURCE_WINS
if merge:
revision = self.store_fs.last_sync_revision or 0
else:
# We set the revision to *anything* higher than the Store's
# This is analogous to the `overwrite` option in
# Store.update_from_disk
revision = Revision.get() + 1
update_revision, __ = self.store.update(
tmp_store,
submission_type=SubmissionTypes.SYSTEM,
user=self.latest_user,
store_revision=revision,
resolve_conflict=resolve_conflict)
logger.debug("Pulled file: %s", self.path)
return update_revision
def handle(self, **options):
if options["restore"]:
from pootle_store.models import Unit
Revision.set(Unit.max_revision())
self.stdout.write("%s" % Revision.get())
def test_update_upload_new_revision(en_tutorial_po):
update_store(
en_tutorial_po,
[("Hello, world", "Hello, world UPDATED")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
assert en_tutorial_po.units[0].target == "Hello, world UPDATED"
def _sync_to_pootle(self, merge=False, user=None, pootle_wins=None):
"""
Update Pootle ``Store`` with the parsed FS file.
"""
User = get_user_model()
if pootle_wins is None:
resolve_conflict = (
self.store_fs.resolve_conflict or SOURCE_WINS)
elif pootle_wins:
resolve_conflict = POOTLE_WINS
else:
resolve_conflict = SOURCE_WINS
if merge:
revision = self.store_fs.last_sync_revision or 0
else:
# We set the revision to *anything* higher than the Store's
# This is analogous to the `overwrite` option in
# Store.update_from_disk
revision = Revision.get() + 1
tmp_store = self.deserialize()
self.store.update(
tmp_store,
submission_type=SubmissionTypes.SYSTEM,
user=user or User.objects.get_system_user(),
store_revision=revision,
resolve_conflict=resolve_conflict)
logger.debug("Pulled file: %s", self.path)
def handle_noargs(self, **options):
last_known_revision = Revision.get()
if options['after_revision'] is not None:
after_revision = int(options['after_revision'])
else:
after_revision = Store.objects.all().aggregate(
Max('last_sync_revision'))['last_sync_revision__max'] or -1
self.stderr.write(
'Will show languages changed between revisions %s (exclusive) '
'and %s (inclusive)' % (after_revision, last_known_revision))
# if the requested revision is the same or is greater than
# the last known one, return nothing
if after_revision >= last_known_revision:
self.stderr.write('(no known changes)')
return
q = Unit.objects.filter(revision__gt=after_revision).values(
'store__translation_project__language__code', ).order_by(
'store__translation_project__language__code', ).distinct()
languages = q.values_list('store__translation_project__language__code',
flat=True)
# list languages separated by comma for easy parsing
print ','.join(languages)
def test_update_upload_member_user(store0, member):
store0.state = PARSED
unit_source = store0.units.first().source
update_store(store0, [(unit_source, "%s UPDATED" % unit_source)],
user=member,
store_revision=Revision.get() + 1)
assert store0.units[0].submitted_by == member
def test_update_upload_defaults(en_tutorial_po, system):
update_store(en_tutorial_po, [("Hello, world", "Hello, world UPDATED")],
user=system,
store_revision=Revision.get() + 1)
assert en_tutorial_po.units[0].submitted_by == system
assert (en_tutorial_po.units[0].submission_set.first().type ==
SubmissionTypes.SYSTEM)
def test_update_upload_member_user(en_tutorial_po, member):
update_store(
en_tutorial_po,
[("Hello, world", "Hello, world UPDATED")],
user=member,
store_revision=Revision.get() + 1)
assert en_tutorial_po.units[0].submitted_by == member
def handle(self, **options):
last_known_revision = Revision.get()
if options["after_revision"] is not None:
after_revision = int(options["after_revision"])
else:
after_revision = Store.objects.all().aggregate(Max("last_sync_revision"))["last_sync_revision__max"] or -1
self.stderr.write(
"Will show languages changed between revisions %s (exclusive) "
"and %s (inclusive)" % (after_revision, last_known_revision)
)
# if the requested revision is the same or is greater than the last
# known one, return nothing
if after_revision >= last_known_revision:
self.stderr.write("(no known changes)")
return
q = (
Unit.objects.filter(revision__gt=after_revision)
.values("store__translation_project__language__code")
.order_by("store__translation_project__language__code")
.distinct()
)
languages = q.values_list("store__translation_project__language__code", flat=True)
# list languages separated by comma for easy parsing
self.stdout.write(",".join(languages))
def handle(self, **options):
last_known_revision = Revision.get()
if options['after_revision'] is not None:
after_revision = int(options['after_revision'])
else:
after_revision = Store.objects.all().aggregate(
Max('last_sync_revision'))['last_sync_revision__max'] or -1
self.stderr.write(
'Will show languages changed between revisions %s (exclusive) '
'and %s (inclusive)' %
(after_revision, last_known_revision)
)
# if the requested revision is the same or is greater than the last
# known one, return nothing
if after_revision >= last_known_revision:
self.stderr.write('(no known changes)')
return
q = Unit.objects.filter(
revision__gt=after_revision
).values(
'store__translation_project__language__code',
).order_by(
'store__translation_project__language__code',
).distinct()
languages = q.values_list('store__translation_project__language__code',
flat=True)
# list languages separated by comma for easy parsing
print ','.join(languages)
def test_update_upload_again_new_revision(en_tutorial_po_no_file):
store = en_tutorial_po_no_file
assert store.state == NEW
update_store(store, [("Hello, world", "Hello, world UPDATED")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
store = Store.objects.get(pk=store.pk)
assert store.state == PARSED
assert store.units[0].target == "Hello, world UPDATED"
update_store(store, [("Hello, world", "Hello, world UPDATED AGAIN")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
store = Store.objects.get(pk=store.pk)
assert store.state == PARSED
assert store.units[0].target == "Hello, world UPDATED AGAIN"
def check_revision(app_configs=None, **kwargs):
from redis.exceptions import ConnectionError
from pootle.core.models import Revision
from pootle_store.models import Unit
errors = []
try:
revision = Revision.get()
except (ConnectionError):
return errors
try:
max_revision = Unit.max_revision()
except (OperationalError, ProgrammingError):
return errors
if revision is None or revision < max_revision:
errors.append(
checks.Critical(
_("Revision is missing or has an incorrect value."),
hint=_(
"Run `revision --restore` to reset the revision counter."),
id="pootle.C016",
))
return errors
def _sync_to_pootle(self, merge=False, user=None, pootle_wins=None):
"""
Update Pootle ``Store`` with the parsed FS file.
"""
User = get_user_model()
if pootle_wins is None:
resolve_conflict = (self.store_fs.resolve_conflict or SOURCE_WINS)
elif pootle_wins:
resolve_conflict = POOTLE_WINS
else:
resolve_conflict = SOURCE_WINS
if merge:
revision = self.store_fs.last_sync_revision or 0
else:
# We set the revision to *anything* higher than the Store's
# This is analogous to the `overwrite` option in
# Store.update_from_disk
revision = Revision.get() + 1
tmp_store = self.deserialize()
self.store.update(tmp_store,
submission_type=SubmissionTypes.SYSTEM,
user=user or User.objects.get_system_user(),
store_revision=revision,
resolve_conflict=resolve_conflict)
logger.debug("Pulled file: %s", self.path)
def test_update_upload_submission_type(store0):
store0.state = PARSED
unit_source = store0.units.first().source
update_store(store0, [(unit_source, "%s UPDATED" % unit_source)],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
assert (
store0.units[0].submission_set.last().type == SubmissionTypes.UPLOAD)
def test_update_upload_submission_type(en_tutorial_po):
update_store(
en_tutorial_po,
[("Hello, world", "Hello, world UPDATED")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
assert (en_tutorial_po.units[0].submission_set.first().type
== SubmissionTypes.UPLOAD)
def test_update_upload_member_user(store0, member):
store0.state = PARSED
unit_source = store0.units.first().source
update_store(
store0,
[(unit_source, "%s UPDATED" % unit_source)],
user=member,
store_revision=Revision.get() + 1)
assert store0.units[0].submitted_by == member
def test_changed_languages_noargs(capfd):
"""Get changed languages since last sync."""
revision = Revision.get()
call_command('changed_languages')
out, err = capfd.readouterr()
assert out == u'language0,language1\n'
assert ((
"Will show languages changed between revisions -1 (exclusive) and "
"%d (inclusive)" % (revision)) in err)
def test_update_upload_defaults(en_tutorial_po, system):
update_store(
en_tutorial_po,
[("Hello, world", "Hello, world UPDATED")],
user=system,
store_revision=Revision.get() + 1)
assert en_tutorial_po.units[0].submitted_by == system
assert (en_tutorial_po.units[0].submission_set.first().type
== SubmissionTypes.SYSTEM)
def test_update_upload_defaults(store0, system):
store0.state = PARSED
unit_source = store0.units.first().source
update_store(store0, [(unit_source, "%s UPDATED" % unit_source)],
user=system,
store_revision=Revision.get() + 1)
assert store0.units[0].submitted_by == system
assert (
store0.units[0].submission_set.last().type == SubmissionTypes.SYSTEM)
def test_changed_languages_noargs(capfd, afrikaans_tutorial, french_tutorial):
"""Get changed languages since last sync."""
call_command('changed_languages')
out, err = capfd.readouterr()
assert "(no known changes)" in err
revision = Revision.get()
assert ((
"Will show languages changed between revisions %d (exclusive) and "
"%d (inclusive)" % (revision, revision)) in err)
def __test_update_set_last_sync_revision(ru_update_set_last_sync_revision_po):
"""Tests setting last_sync_revision after store creation.
"""
store = ru_update_set_last_sync_revision_po
# Parse a store during first update
# store.last_sync_revision is set to the next global revision
next_revision = Revision.get() + 1
store.update(store.file.store)
assert store.last_sync_revision == next_revision
assert store.get_max_unit_revision() == next_revision
# store.last_sync_revision is not changed after empty update
store.update(store.file.store)
assert store.last_sync_revision == next_revision
# any non-empty update sets last_sync_revision to next global revision
store.file = 'tutorial/ru/update_set_last_sync_revision_updated.po'
next_revision = Revision.get() + 1
store.update(store.file.store)
assert store.last_sync_revision == next_revision
# store.last_sync_revision is not changed after empty update
# (even if it has unsynced units)
item_index = 0
next_unit_revision = Revision.get() + 1
dbunit = _update_translation(store, item_index, {'target': u'first'},
sync=False)
assert dbunit.revision == next_unit_revision
store.update(store.file.store, store_revision=0)
assert store.last_sync_revision == next_revision
# Non-empty update sets store.last_sync_revision to next global revision
# (even the store has unsynced units)
# There is only one unsynced unit in this case so its revision should be set
# next to store.last_sync_revision
next_revision = Revision.get() + 1
store.file = 'tutorial/ru/update_set_last_sync_revision.po'
store.update(store.file.store,
store_revision=store.get_max_unit_revision())
assert store.last_sync_revision == next_revision
unit = store.getitem(item_index)
# not sure why this was store.last_sync_revision + 1 - but no longer works
assert unit.revision == store.last_sync_revision
def test_max_revision(af_tutorial_po):
"""Tests `max_revision()` gets the latest revision."""
initial_max_revision = Unit.max_revision()
initial_revision = Revision.get()
assert initial_max_revision == initial_revision
assert initial_max_revision == 0
# Let's make 10 translation updates, this must also update their
# revision numbers
for i in range(10):
_update_translation(af_tutorial_po, 0, {'target': str(i)}, sync=False)
end_max_revision = Unit.max_revision()
end_revision = Revision.get()
assert end_max_revision == end_revision
assert end_max_revision != initial_max_revision
assert end_revision != initial_revision
assert end_revision == 10
def test_update_upload_again_new_revision(en_tutorial_po_no_file):
store = en_tutorial_po_no_file
assert store.state == NEW
update_store(
store,
[("Hello, world", "Hello, world UPDATED")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
store = Store.objects.get(pk=store.pk)
assert store.state == PARSED
assert store.units[0].target == "Hello, world UPDATED"
update_store(
store,
[("Hello, world", "Hello, world UPDATED AGAIN")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
store = Store.objects.get(pk=store.pk)
assert store.state == PARSED
assert store.units[0].target == "Hello, world UPDATED AGAIN"
def test_max_revision(af_tutorial_po):
"""Tests `max_revision()` gets the latest revision."""
initial_max_revision = Unit.max_revision()
initial_revision = Revision.get()
assert initial_max_revision == initial_revision
assert initial_max_revision == 0
# Let's make 10 translation updates, this must also update their
# revision numbers
for i in range(10):
_update_translation(af_tutorial_po, 0, {'target': str(i)},
sync=False)
end_max_revision = Unit.max_revision()
end_revision = Revision.get()
assert end_max_revision == end_revision
assert end_max_revision != initial_max_revision
assert end_revision != initial_revision
assert end_revision == 10
def test_changed_languages_noargs(capfd):
"""Get changed languages since last sync."""
revision = Revision.get()
call_command('changed_languages')
out, err = capfd.readouterr()
assert out == u'language0,language1,templates\n'
assert (
("Will show languages changed between revisions -1 (exclusive) and "
"%d (inclusive)"
% (revision))
in err)
def test_update_upload_submission_type(store0):
store0.state = PARSED
unit_source = store0.units.first().source
update_store(
store0,
[(unit_source, "%s UPDATED" % unit_source)],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
assert (
store0.units[0].submission_set.last().type
== SubmissionTypes.UPLOAD)
def test_changed_languages_noargs(capfd, afrikaans_tutorial, french_tutorial):
"""Get changed languages since last sync."""
call_command('changed_languages')
out, err = capfd.readouterr()
assert "(no known changes)" in err
revision = Revision.get()
assert (
("Will show languages changed between revisions %d (exclusive) and "
"%d (inclusive)"
% (revision, revision))
in err)
def test_update_upload_defaults(store0, system):
store0.state = PARSED
unit_source = store0.units.first().source
update_store(
store0,
[(unit_source, "%s UPDATED" % unit_source)],
user=system,
store_revision=Revision.get() + 1)
assert store0.units[0].submitted_by == system
assert (
store0.units[0].submission_set.last().type
== SubmissionTypes.SYSTEM)
def test_max_revision(revision, project0_nongnu, store0):
"""Tests `max_revision()` gets the latest revision."""
initial_max_revision = Unit.max_revision()
initial_revision = Revision.get()
assert initial_max_revision == initial_revision
# Let's make 10 translation updates, this must also update their revision
# numbers
unit = store0.units.first()
for i in range(10):
unit.target = str(i)
unit.save()
unit.refresh_from_db()
end_max_revision = Unit.max_revision()
end_revision = Revision.get()
assert end_max_revision == end_revision
assert end_max_revision != initial_max_revision
assert end_revision != initial_revision
assert end_revision == 10 + initial_revision
def test_max_revision(af_tutorial_po):
"""Tests `max_revision()` gets the latest revision."""
# update a store first, initial_revision = 1 after this update
af_tutorial_po.update(af_tutorial_po.file.store)
initial_max_revision = Unit.max_revision()
initial_revision = Revision.get()
assert initial_max_revision == initial_revision
# Let's make 10 translation updates, this must also update their revision
# numbers
for i in range(10):
_update_translation(af_tutorial_po, 0, {'target': str(i)}, sync=False)
end_max_revision = Unit.max_revision()
end_revision = Revision.get()
assert end_max_revision == end_revision
assert end_max_revision != initial_max_revision
assert end_revision != initial_revision
assert end_revision == 10 + initial_revision
def test_max_revision(af_tutorial_po):
"""Tests `max_revision()` gets the latest revision."""
# update a store first, initial_revision = 1 after this update
af_tutorial_po.update(overwrite=False, only_newer=False)
initial_max_revision = Unit.max_revision()
initial_revision = Revision.get()
assert initial_max_revision == initial_revision
assert initial_max_revision == 1
# Let's make 10 translation updates, this must also update their
# revision numbers
for i in range(10):
_update_translation(af_tutorial_po, 0, {"target": str(i)}, sync=False)
end_max_revision = Unit.max_revision()
end_revision = Revision.get()
assert end_max_revision == end_revision
assert end_max_revision != initial_max_revision
assert end_revision != initial_revision
assert end_revision == 10 + initial_revision
def test_changed_languages_noargs_nochanges(capfd, project0_disk, store0):
"""Get changed languages since last sync."""
unit = store0.units.first()
unit.target = "CHANGED"
unit.save()
store0.sync()
revision = Revision.get()
out, err = capfd.readouterr()
call_command('changed_languages')
out, err = capfd.readouterr()
assert "(no known changes)" in err
assert ((
"Will show languages changed between revisions %d (exclusive) and "
"%d (inclusive)" % (revision, revision)) in err)
def test_max_revision(revision, project0_disk, store0):
"""Tests `max_revision()` gets the latest revision."""
store0.sync()
# update a store first, initial_revision = 1 after this update
store0.update(store0.file.store)
initial_max_revision = Unit.max_revision()
initial_revision = Revision.get()
assert initial_max_revision == initial_revision
# Let's make 10 translation updates, this must also update their revision
# numbers
for i in range(10):
_update_translation(store0, 0, {"target": str(i)}, sync=False)
end_max_revision = Unit.max_revision()
end_revision = Revision.get()
assert end_max_revision == end_revision
assert end_max_revision != initial_max_revision
assert end_revision != initial_revision
assert end_revision == 10 + initial_revision
def test_max_revision(revision, project0_nongnu, store0):
"""Tests `max_revision()` gets the latest revision."""
store0.sync()
# update a store first, initial_revision = 1 after this update
store0.update(store0.file.store)
initial_max_revision = Unit.max_revision()
initial_revision = Revision.get()
assert initial_max_revision == initial_revision
# Let's make 10 translation updates, this must also update their revision
# numbers
for i in range(10):
_update_translation(store0, 0, {'target': str(i)},
sync=False)
end_max_revision = Unit.max_revision()
end_revision = Revision.get()
assert end_max_revision == end_revision
assert end_max_revision != initial_max_revision
assert end_revision != initial_revision
assert end_revision == 10 + initial_revision
def _create_submission_and_suggestion(store,
user,
units=None,
suggestion="SUGGESTION"):
from pootle.core.models import Revision
# Update store as user
if units is None:
units = [("Hello, world", "Hello, world UPDATED")]
update_store(store, units, user=user, store_revision=Revision.get() + 1)
# Add a suggestion
unit = store.units[0]
unit.add_suggestion(suggestion, user=user)
return unit
def test_changed_languages_noargs_nochanges(capfd, project0_nongnu, store0):
"""Get changed languages since last sync."""
unit = store0.units.first()
unit.target = "CHANGED"
unit.save()
store0.sync()
revision = Revision.get()
out, err = capfd.readouterr()
call_command('changed_languages')
out, err = capfd.readouterr()
assert "(no known changes)" in err
assert (
("Will show languages changed between revisions %d (exclusive) and "
"%d (inclusive)"
% (revision, revision))
in err)
def test_update_upload_old_revision_unit_conflict(en_tutorial_po):
original_revision = Revision.get()
update_store(en_tutorial_po, [("Hello, world", "Hello, world UPDATED")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=original_revision + 1)
# load update with expired revision and conflicting unit
update_store(en_tutorial_po, [("Hello, world", "Hello, world CONFLICT")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=original_revision)
# unit target is not updated
assert en_tutorial_po.units[0].target == "Hello, world UPDATED"
# but suggestion is added
suggestion = en_tutorial_po.units[0].get_suggestions()[0].target
assert suggestion == "Hello, world CONFLICT"
def _create_submission_and_suggestion(store,
user,
units=None,
suggestion="SUGGESTION"):
from pootle.core.delegate import review
from pootle.core.models import Revision
from pootle_store.models import Suggestion
# Update store as user
if units is None:
units = [("Hello, world", "Hello, world UPDATED", False)]
update_store(store, units, user=user, store_revision=Revision.get() + 1)
# Add a suggestion
unit = store.units[0]
review.get(Suggestion)().add(unit, suggestion, user)
return unit
def test_changed_languages_since_revision(capfd, project0_nongnu, tp0):
"""Changed languages since a given revision"""
# Everything
for store in tp0.stores.all():
store.sync()
rev = tp0.stores.aggregate(rev=Min('last_sync_revision'))['rev'] - 1
call_command('changed_languages', '--after-revision=%s' % rev)
out, err = capfd.readouterr()
assert out == u'language0,language1\n'
# End revisions
revision = Revision.get()
unit = tp0.stores.first().units.first()
unit.target = "NEW TARGET"
unit.save()
call_command('changed_languages', '--after-revision=%s' % revision)
out, err = capfd.readouterr()
assert out == u'language0\n'
def check_revision(app_configs=None, **kwargs):
from pootle.core.models import Revision
from pootle_store.models import Unit
errors = []
revision = Revision.get()
try:
max_revision = Unit.max_revision()
except (OperationalError, ProgrammingError):
return errors
if revision is None or revision < max_revision:
errors.append(checks.Critical(
_("Revision is missing or has an incorrect value."),
hint=_("Run `revision --restore` to reset the revision counter."),
id="pootle.C016",
))
return errors
def test_changed_languages_since_revision(capfd, project0_nongnu, tp0):
"""Changed languages since a given revision"""
# Everything
for store in tp0.stores.all():
store.sync()
rev = tp0.stores.aggregate(
rev=Min('last_sync_revision'))['rev'] - 1
call_command('changed_languages', '--after-revision=%s' % rev)
out, err = capfd.readouterr()
assert out == u'language0,language1,templates\n'
# End revisions
revision = Revision.get()
unit = tp0.stores.first().units.first()
unit.target = "NEW TARGET"
unit.save()
call_command('changed_languages', '--after-revision=%s' % revision)
out, err = capfd.readouterr()
assert out == u'language0\n'
def test_changed_languages_noargs(capfd, po_directory):
"""Get changed languages since last sync."""
revision = Revision.get()
call_command('changed_languages')
out, err = capfd.readouterr()
assert out == u'language0,language1\n'
assert ((
"Will show languages changed between revisions -1 (exclusive) and "
"%d (inclusive)" % (revision)) in err)
# sync the last changed store - this seems arbitrary - but is how the
# command works
Unit.objects.filter(revision=revision)[0].store.sync()
out, err = capfd.readouterr()
call_command('changed_languages')
out, err = capfd.readouterr()
assert "(no known changes)" in err
assert ((
"Will show languages changed between revisions %d (exclusive) and "
"%d (inclusive)" % (revision, revision)) in err)
def _create_submission_and_suggestion(store, user,
units=None,
suggestion="SUGGESTION"):
from pootle.core.models import Revision
# Update store as user
if units is None:
units = [("Hello, world", "Hello, world UPDATED")]
update_store(
store,
units,
user=user,
store_revision=Revision.get() + 1)
# Add a suggestion
unit = store.units[0]
unit.add_suggestion(suggestion, user=user)
return unit
def _create_submission_and_suggestion(store, user,
units=None,
suggestion="SUGGESTION"):
from pootle.core.delegate import review
from pootle.core.models import Revision
from pootle_store.models import Suggestion
# Update store as user
if units is None:
units = [("Hello, world", "Hello, world UPDATED", False)]
update_store(
store,
units,
user=user,
store_revision=Revision.get() + 1)
# Add a suggestion
unit = store.units[0]
review.get(Suggestion)().add(unit, suggestion, user)
return unit
def test_update_upload_old_revision_unit_conflict(en_tutorial_po):
original_revision = Revision.get()
update_store(
en_tutorial_po,
[("Hello, world", "Hello, world UPDATED")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=original_revision + 1)
# load update with expired revision and conflicting unit
update_store(
en_tutorial_po,
[("Hello, world", "Hello, world CONFLICT")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=original_revision)
# unit target is not updated
assert en_tutorial_po.units[0].target == "Hello, world UPDATED"
# but suggestion is added
suggestion = en_tutorial_po.units[0].get_suggestions()[0].target
assert suggestion == "Hello, world CONFLICT"
def test_revision_incr(af_tutorial_po):
"""Tests revision is incremented when units change."""
previous_revision = Revision.get()
db_unit = _update_translation(af_tutorial_po, 0, {"target": [u"Fleisch"]}, sync=False)
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
previous_revision = Revision.get()
db_unit = _update_translation(af_tutorial_po, 0, {"target": u"Lachs"}, sync=False)
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
def test_revision_incr(store0):
"""Tests revision is incremented when units change."""
previous_revision = Revision.get()
db_unit = store0.units.exclude(target_f="").first()
db_unit.target = "CHANGED"
db_unit.save()
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
db_unit.refresh_from_db()
previous_revision = Revision.get()
db_unit.target = ""
db_unit.save()
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
def test_revision_incr(af_tutorial_po):
"""Tests revision is incremented when units change."""
previous_revision = Revision.get()
db_unit = _update_translation(af_tutorial_po, 0, {'target': [u'Fleisch']},
sync=False)
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
previous_revision = Revision.get()
db_unit = _update_translation(af_tutorial_po, 0, {'target': u'Lachs'},
sync=False)
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
def test_revision_incr(store0):
"""Tests revision is incremented when units change."""
previous_revision = Revision.get()
db_unit = _update_translation(store0,
0, {"target": [u"Fleisch"]},
sync=False)
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
previous_revision = Revision.get()
db_unit = _update_translation(store0, 0, {"target": u"Lachs"}, sync=False)
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
def test_update_upload_new_revision(en_tutorial_po):
update_store(en_tutorial_po, [("Hello, world", "Hello, world UPDATED")],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
assert en_tutorial_po.units[0].target == "Hello, world UPDATED"
