def check_files_match(src, response):
from pootle_fs.models import StoreFS
assert all(
os.path.exists(os.path.join(src, p.fs_path.strip("/")))
for p in response["pushed_to_fs"])
assert not any(
os.path.exists(os.path.join(src, p.fs_path.strip("/")))
for p in response["pruned_from_fs"])
# Any Store/files that have been synced should now match
synced = (response["pulled_to_pootle"] + response["pushed_to_fs"] +
response["merged_from_fs"] + response["merged_from_pootle"] +
response["merged_from_fs"])
for action in synced:
store_fs = StoreFS.objects.get(pootle_path=action.pootle_path)
file_path = os.path.join(src, store_fs.path.strip("/"))
store_f = io.BytesIO(store_fs.store.serialize())
with open(file_path) as src_file:
file_store = getclass(src_file)(src_file.read())
serialized = getclass(store_f)(store_f.read())
assert ([
(x.source, x.target) for x in file_store.units if x.source
] == [(x.source, x.target) for x in serialized.units if x.source])
for action in response["removed"]:
store = action.original_status.store_fs.store
if store:
assert store.obsolete is True
assert action.original_status.store_fs.file.exists is False
assert action.original_status.store_fs.pk is None
assert not os.path.exists(os.path.join(src, action.fs_path.strip("/")))
def test_store_po_serializer(test_fs, store_po):
with test_fs.open("data/po/complex.po") as test_file:
test_string = test_file.read()
ttk_po = getclass(test_file)(test_string)
store_po.update(store_po.deserialize(test_string))
store_io = io.BytesIO(store_po.serialize())
store_ttk = getclass(store_io)(store_io.read())
assert len(store_ttk.units) == len(ttk_po.units)
def test_update_ts_plurals(store_po, test_fs):
with test_fs.open(['data', 'ts', 'add_plurals.ts']) as f:
file_store = getclass(f)(f.read())
store_po.update(file_store)
assert store_po.units[0].hasplural()
with test_fs.open(['data', 'ts', 'update_plurals.ts']) as f:
file_store = getclass(f)(f.read())
store_po.update(file_store)
assert store_po.units[0].hasplural()
def test_update_ts_plurals(store_po, test_fs):
with test_fs.open(['data', 'ts', 'add_plurals.ts']) as f:
file_store = getclass(f)(f.read())
store_po.update(file_store)
assert store_po.units[0].hasplural()
with test_fs.open(['data', 'ts', 'update_plurals.ts']) as f:
file_store = getclass(f)(f.read())
store_po.update(file_store)
assert store_po.units[0].hasplural()
def test_store_po_serializer(test_fs, store_po):
with test_fs.open("data/po/complex.po") as test_file:
test_string = test_file.read()
ttk_po = getclass(test_file)(test_string)
store_po.update(store_po.deserialize(test_string))
store_io = io.BytesIO(store_po.serialize())
store_ttk = getclass(store_io)(store_io.read())
assert len(store_ttk.units) == len(ttk_po.units)
def test_store_po_serializer(test_fs, store_po):
with test_fs.open("data/po/complex.po", "rb") as test_file:
file_bytes = test_file.read()
ttk_po = getclass(test_file)(file_bytes)
store_po.update(store_po.deserialize(file_bytes))
store_bytes = store_po.serialize()
store_io = io.BytesIO(store_bytes)
store_ttk = getclass(store_io)(store_bytes)
assert len(store_ttk.units) == len(ttk_po.units)
def load_file(self, filename):
cls = factory.getclass(filename)
self.store = cls.parsefile(filename)
self.index = int(self.config.phrase_index)
self.config.register(lambda: self.index, "phrase_index")
self.scroll(None, 0)
self.config.file = filename
def setup_terminology(self):
import pytest_pootle
from pytest_pootle.factories import (
ProjectDBFactory, StoreDBFactory, TranslationProjectFactory)
from pootle_language.models import Language
source_language = Language.objects.get(code="en")
terminology = ProjectDBFactory(code="terminology",
checkstyle="terminology",
fullname="Terminology",
source_language=source_language)
term_file = os.path.join(
os.path.dirname(pytest_pootle.__file__),
*("data", "po", "terminology.po"))
with open(term_file) as f:
term_ttk = getclass(f)(f.read())
for language in Language.objects.all():
tp = TranslationProjectFactory(
project=terminology, language=language)
if language.code not in ["language0", "language1"]:
continue
store = StoreDBFactory(
parent=tp.directory,
translation_project=tp,
name="terminology.po")
store.update(term_ttk)
def test_store_get_file_class():
store = Store.objects.filter(
translation_project__project__code="project0",
translation_project__language__code="language0").first()
# this matches because po is recognised by ttk
assert store.syncer.file_class == getclass(store)
def import_file(file, user=None):
f = getclass(file)(file.read())
if not hasattr(f, "parseheader"):
raise UnsupportedFiletypeError(_("Unsupported filetype '%s', only PO "
"files are supported at this time\n")
% file.name)
header = f.parseheader()
pootle_path = header.get("X-Pootle-Path")
if not pootle_path:
raise MissingPootlePathError(_("File '%s' missing X-Pootle-Path "
"header\n") % file.name)
rev = header.get("X-Pootle-Revision")
if not rev or not rev.isdigit():
raise MissingPootleRevError(_("File '%s' missing or invalid "
"X-Pootle-Revision header\n")
% file.name)
rev = int(rev)
try:
store, created = Store.objects.get_or_create(pootle_path=pootle_path)
except Exception as e:
raise FileImportError(_("Could not create '%s'. Missing "
"Project/Language? (%s)") % (file.name, e))
try:
store.update(overwrite=True, store=f, user=user,
submission_type=SubmissionTypes.UPLOAD)
except Exception as e:
# This should not happen!
logger.error("Error importing file: %s" % str(e))
raise FileImportError(_("There was an error uploading your file"))
def _getclass(self, obj):
try:
return getclass(obj)
except ValueError:
raise ValueError(
"Unable to find conversion class for Store '%s'"
% self.store.name)
def import_file(file):
f = getclass(file)(file.read())
header = f.parseheader()
pootle_path = header.get("X-Pootle-Path")
if not pootle_path:
raise ValueError(_("File %r missing X-Pootle-Path header\n") % (file.name))
rev = header.get("X-Pootle-Revision")
if not rev or not rev.isdigit():
raise ValueError(
_("File %r missing or invalid X-Pootle-Revision header\n") % (file.name)
)
rev = int(rev)
try:
store, created = Store.objects.get_or_create(pootle_path=pootle_path)
if rev < store.get_max_unit_revision():
# TODO we could potentially check at the unit level and only reject
# units older than most recent. But that's in store.update().
raise ValueError(
_("File %r was rejected because its X-Pootle-Revision is too old.")
% (file.name)
)
except Exception as e:
raise ValueError(
_("Could not create %r. Missing Project/Language? (%s)")
% (file.name, e)
)
store.update(overwrite=True, store=f)
def _getclass(self, obj):
try:
return getclass(obj)
except ValueError:
raise ValueError(
"Unable to find conversion class for Store '%s'"
% self.store.name)
def unit_syncer(tp0):
from pootle_store.constants import TRANSLATED
store = tp0.stores.live().first()
unit = store.units.filter(state=TRANSLATED).first()
ttk = getclass(store)
return unit, ttk.UnitClass
def pytest_generate_tests(metafunc):
import pytest_pootle
if "terminology_units" in metafunc.fixturenames:
term_file = os.path.join(os.path.dirname(pytest_pootle.__file__), *("data", "po", "terminology.po"))
with open(term_file) as f:
_terms = [x.source for x in getclass(f)(f.read()).units[1:]]
metafunc.parametrize("terminology_units", _terms)
def test_update_with_non_ascii(store0, test_fs):
store0.state = PARSED
orig_units = store0.units.count()
with test_fs.open(
["data", "po", "tutorial", "en", "tutorial_non_ascii.po"], "rb") as f:
store = getclass(f)(f.read())
store0.update(store)
assert store0.units[orig_units].target == "Hèḽḽě, ŵôrḽḓ"
def create_store(units=None):
_units = []
for src, target in units or []:
_units.append(STRING_UNIT % {"src": src, "target": target})
units = "\n\n".join(_units)
string_store = STRING_STORE % {"units": units}
io_store = io.BytesIO(string_store.encode("utf-8"))
return getclass(io_store)(io_store.read())
def test_update_with_non_ascii(store0, test_fs):
store0.state = PARSED
orig_units = store0.units.count()
with test_fs.open(['data', 'po', 'tutorial', 'en',
'tutorial_non_ascii.po']) as f:
store = getclass(f)(f.read())
store0.update(store)
assert store0.units[orig_units].target == "Hèḽḽě, ŵôrḽḓ"
def test_update_from_ts(store0, test_fs):
store0.parsed = True
orig_units = store0.units.count()
with test_fs.open(['data', 'ts', 'tutorial', 'en', 'tutorial.ts']) as f:
store = getclass(f)(f.read())
store0.update(store)
assert (not store0.units[orig_units].hasplural())
assert (store0.units[orig_units + 1].hasplural())
def test_update_with_non_ascii(store0, test_fs):
store0.state = PARSED
orig_units = store0.units.count()
with test_fs.open(['data', 'po', 'tutorial', 'en',
'tutorial_non_ascii.po']) as f:
store = getclass(f)(f.read())
store0.update(store)
assert store0.units[orig_units].target == "Hèḽḽě, ŵôrḽḓ"
def test_store_po_deserializer(test_fs, store_po):
with test_fs.open("data/po/complex.po") as test_file:
test_string = test_file.read()
ttk_po = getclass(test_file)(test_string)
store_po.update(store_po.deserialize(test_string))
assert len(ttk_po.units) - 1 == store_po.units.count()
def test_store_po_deserializer(test_fs, store_po):
with test_fs.open("data/po/complex.po") as test_file:
test_string = test_file.read()
ttk_po = getclass(test_file)(test_string)
store_po.update(store_po.deserialize(test_string))
assert len(ttk_po.units) - 1 == store_po.units.count()
def test_update_from_ts(store0, test_fs):
store0.parsed = True
orig_units = store0.units.count()
with test_fs.open(['data', 'ts', 'tutorial', 'en', 'tutorial.ts']) as f:
store = getclass(f)(f.read())
store0.update(store)
assert(not store0.units[orig_units].hasplural())
assert(store0.units[orig_units + 1].hasplural())
def test_update_with_non_ascii(en_tutorial_po, test_fs):
# Parse store
en_tutorial_po.update_from_disk()
tp = en_tutorial_po.translation_project
with test_fs.open(['data', 'po', tp.real_path,
'tutorial_non_ascii.po']) as f:
store = getclass(f)(f.read())
en_tutorial_po.update(store)
assert en_tutorial_po.units[0].target == "Hèllö, wôrld"
def pytest_generate_tests(metafunc):
import pytest_pootle
if 'terminology_units' in metafunc.fixturenames:
term_file = os.path.join(os.path.dirname(pytest_pootle.__file__),
*("data", "po", "terminology.po"))
with open(term_file) as f:
_terms = [x.source for x in getclass(f)(f.read()).units[1:]]
metafunc.parametrize("terminology_units", _terms)
def test_update_with_non_ascii(en_tutorial_po, test_fs):
# Parse store
en_tutorial_po.updater.update_from_disk()
tp = en_tutorial_po.translation_project
with test_fs.open(['data', 'po', tp.real_path,
'tutorial_non_ascii.po']) as f:
store = getclass(f)(f.read())
en_tutorial_po.update(store)
assert en_tutorial_po.units[0].target == "Hèllö, wôrld"
def parse_locale_po(lang):
unitdict = OrderedDict()
with open('locale/%s/xtle.po' % lang, 'rb') as f:
# content = f.read()
pofile = getclass(f)(f)
for unit in pofile.units[1:]:
unitdict[unit.getnotes().split("]")[0][1:]] = unit.target
return unitdict
def test_store_syncer(tp0):
store = tp0.stores.live().first()
store_tp = store.translation_project
assert isinstance(store.syncer, PoStoreSyncer)
assert store.syncer.file_class == getclass(store)
assert store.syncer.translation_project == store_tp
assert store.syncer.language == store_tp.language
assert store.syncer.project == store_tp.project
assert store.syncer.source_language == store_tp.project.source_language
def deserialize(self):
if not self.file_exists:
return
deserialized = ""
with open(self.file_path) as f:
deserialized = f.read()
if self.store_exists:
return self.store.deserialize(deserialized)
serial_io = io.BytesIO(deserialized)
return getclass(serial_io)(serial_io.read())
def test_update_from_ts(en_tutorial_po, test_fs):
# Parse store
en_tutorial_po.updater.update_from_disk()
tp = en_tutorial_po.translation_project
with test_fs.open(['data', 'ts', tp.real_path, 'tutorial.ts']) as f:
store = getclass(f)(f.read())
en_tutorial_po.update(store)
assert (not en_tutorial_po.units[1].hasplural())
assert (en_tutorial_po.units[2].hasplural())
def deserialize(self):
if not self.file_exists:
return
deserialized = ""
with open(self.file_path) as f:
deserialized = f.read()
if self.store_exists:
return self.store.deserialize(deserialized)
serial_io = io.BytesIO(deserialized)
return getclass(serial_io)(serial_io.read())
def test_update_from_ts(en_tutorial_po, test_fs):
# Parse store
en_tutorial_po.update_from_disk()
tp = en_tutorial_po.translation_project
with test_fs.open(['data', 'ts', tp.real_path, 'tutorial.ts']) as f:
store = getclass(f)(f.read())
en_tutorial_po.update(store)
assert(not en_tutorial_po.units[1].hasplural())
assert(en_tutorial_po.units[2].hasplural())
def _update_from_upload_file(tutorial, update_file,
content_type="text/x-gettext-translation",
user=None, submission_type=None):
with open(update_file, "r") as f:
upload = SimpleUploadedFile(os.path.basename(update_file),
f.read(),
content_type)
test_store = getclass(upload)(upload.read())
tutorial.update(overwrite=False, only_newer=False)
tutorial.update(overwrite=True, store=test_store,
user=user, submission_type=submission_type)
def test_wrap_store_fs_pull_submission_type(store_fs_file_store):
fs_file = store_fs_file_store
fs_file.push()
with open(fs_file.file_path, "r+") as target:
ttk = getclass(target)(target.read())
target.seek(0)
ttk.units[1].target = "BAR"
target.write(str(ttk))
target.truncate()
fs_file.pull()
assert (fs_file.store.units[0].submission_set.latest().type ==
SubmissionTypes.SYSTEM)
def import_file(file, prj, lang=None):
f = getclass(file)(file.read())
if not hasattr(f, "parseheader"):
raise Exception("Format is not supported")
header = f.parseheader()
if not lang:
lang = header['Language']
if not lang:
raise Exception("Language not set")
for unit in f.getunits():
extract_phrase(prj,unit,lang,f.getheaderplural()[1])
def moz_env(post_db_setup, _django_cursor_wrapper, ios_pootle_file):
from django.conf import settings
from pytest_pootle.factories import (
ProjectDBFactory, StoreDBFactory,
TranslationProjectFactory)
from pootle_fs.models import ProjectFS
from pootle_language.models import Language
with _django_cursor_wrapper:
ios_project = ProjectDBFactory(
source_language=Language.objects.get(code="en"),
code="ios",
localfiletype="xliff")
ios_tp = TranslationProjectFactory(
project=ios_project,
language=Language.objects.get(code="language0"))
ios_store = StoreDBFactory(
parent=ios_tp.directory,
translation_project=ios_tp,
name="firefox-ios.xliff")
ios_bytes = io.BytesIO(ios_pootle_file.encode("utf8"))
ios_store.update(
getclass(ios_bytes)(ios_bytes.read()))
fs_dir = tempfile.mkdtemp()
settings.POOTLE_FS_PATH = fs_dir
repo_path = os.path.join(fs_dir, "__moz_ios_src__")
Repo.init(repo_path, bare=True)
with tmp_git(repo_path) as (tmp_repo_path, tmp_repo):
config_file = os.path.join(tmp_repo_path, ".pootle.ini")
with open(config_file, "w") as ini:
config = (
"[default]\n"
"serializers = ios\n"
"deserializers = ios\n"
"translation_path = <lang>/<filename>.xliff")
ini.write(config)
tmp_repo.index.add([".pootle.ini"])
tmp_repo.index.commit("Add Pootle configuration")
tmp_repo.remotes.origin.push("master:master")
ios_fs = ProjectFS.objects.create(
project=ios_project,
fs_type="git",
url=repo_path)
ios_plugin = ios_fs.plugin
ios_plugin.add_translations()
def test_wrap_store_fs_pull_submission_type(store_fs_file_store):
fs_file = store_fs_file_store
fs_file.push()
with open(fs_file.file_path, "r+") as target:
ttk = getclass(target)(target.read())
target.seek(0)
ttk.units[1].target = "BAR"
target.write(str(ttk))
target.truncate()
fs_file.pull()
assert (
fs_file.store.units[0].submission_set.latest().type
== SubmissionTypes.SYSTEM)
def _update_from_upload_file(store, update_file,
content_type="text/x-gettext-translation",
user=None, submission_type=None):
with open(update_file, "r") as f:
upload = SimpleUploadedFile(os.path.basename(update_file),
f.read(),
content_type)
if store.state < PARSED:
store.update(store.file.store)
test_store = getclass(upload)(upload.read())
store_revision = parse_pootle_revision(test_store)
store.update(test_store, store_revision=store_revision,
user=user, submission_type=submission_type)
def _update_from_upload_file(store, update_file,
content_type="text/x-gettext-translation",
user=None, submission_type=None):
with open(update_file, "r") as f:
upload = SimpleUploadedFile(os.path.basename(update_file),
f.read(),
content_type)
if store.state < PARSED:
store.update(store.file.store)
test_store = getclass(upload)(upload.read())
store_revision = parse_pootle_revision(test_store)
store.update(test_store, store_revision=store_revision,
user=user, submission_type=submission_type)
def test_unit_ts_plurals(store_po, test_fs):
with test_fs.open(['data', 'ts', 'add_plurals.ts']) as f:
file_store = getclass(f)(f.read())
unit = Unit(store=store_po)
unit_ts = file_store.units[0]
unit.update(unit_ts)
assert unit.hasplural()
unit.save()
unit = Unit.objects.get(id=unit.id)
assert unit.hasplural()
unit.save()
unit = Unit.objects.get(id=unit.id)
assert unit.hasplural()
def test_unit_ts_plurals(store_po, test_fs):
with test_fs.open(['data', 'ts', 'add_plurals.ts']) as f:
file_store = getclass(f)(f.read())
unit = Unit(store=store_po, index=1)
unit_ts = file_store.units[0]
unit.update(unit_ts)
assert unit.hasplural()
unit.save()
unit = Unit.objects.get(id=unit.id)
assert unit.hasplural()
unit.save()
unit = Unit.objects.get(id=unit.id)
assert unit.hasplural()
def _update_from_upload_file(tutorial,
update_file,
content_type="text/x-gettext-translation",
user=None,
submission_type=None):
with open(update_file, "r") as f:
upload = SimpleUploadedFile(os.path.basename(update_file), f.read(),
content_type)
test_store = getclass(upload)(upload.read())
tutorial.update(overwrite=False, only_newer=False)
tutorial.update(overwrite=True,
store=test_store,
user=user,
submission_type=submission_type)
def deserialize(self, create=False):
if not create and not self.file_exists:
return
if self.file_exists:
with open(self.file_path) as f:
f = AttributeProxy(f)
f.location_root = self.store_fs.project.local_fs_path
store_file = (
self.store.syncer.file_class(f)
if self.store and self.store.syncer.file_class
else getclass(f)(f.read()))
return store_file
if self.store_exists:
return self.store.deserialize(self.store.serialize())
def deserialize(self, create=False):
if not create and not self.file_exists:
return
if self.file_exists:
with open(self.file_path, 'rb') as f:
f = AttributeProxy(f)
f.location_root = self.store_fs.project.local_fs_path
store_file = (self.store.syncer.file_class(f)
if self.store and self.store.syncer.file_class
else getclass(f)(f.read()))
if store_file.units:
return store_file
if self.store_exists:
return self.store.deserialize(self.store.serialize())
def test_store_syncer(tp0):
store = tp0.stores.live().first()
assert isinstance(store.syncer, PoStoreSyncer)
assert store.syncer.file_class == getclass(store)
assert store.syncer.translation_project == store.translation_project
assert (
store.syncer.language
== store.translation_project.language)
assert (
store.syncer.project
== store.translation_project.project)
assert (
store.syncer.source_language
== store.translation_project.project.source_language)
def create_store(pootle_path=None, store_revision=None, units=None):
_units = []
for src, target in units or []:
_units.append(STRING_UNIT % {"src": src, "target": target})
units = "\n\n".join(_units)
x_pootle_headers = ""
if pootle_path and store_revision:
x_pootle_headers = (STRING_POOTLE_HEADERS.strip()
% {"pootle_path": pootle_path,
"revision": store_revision})
string_store = STRING_STORE % {"x_pootle_headers": x_pootle_headers,
"units": units}
io_store = io.BytesIO(string_store.encode())
return getclass(io_store)(io_store.read())
def create_store(pootle_path=None, store_revision=None, units=None):
_units = []
for src, target in units or []:
_units.append(STRING_UNIT % {"src": src, "target": target})
units = "\n\n".join(_units)
x_pootle_headers = ""
if pootle_path and store_revision:
x_pootle_headers = (STRING_POOTLE_HEADERS.strip()
% {"pootle_path": pootle_path,
"revision": store_revision})
string_store = STRING_STORE % {"x_pootle_headers": x_pootle_headers,
"units": units}
io_store = io.BytesIO(string_store.encode())
return getclass(io_store)(io_store.read())
def test_update_from_ts(en_tutorial_po):
from django.conf import settings
from translate.storage.factory import getclass
# Parse store
en_tutorial_po.update_from_disk()
ts_dir = os.path.join(settings.ROOT_DIR, 'tests', 'data', 'ts')
tp = en_tutorial_po.translation_project
store_filepath = os.path.join(ts_dir, tp.real_path, 'tutorial.ts')
with open(store_filepath) as storefile:
store = getclass(storefile)(storefile.read())
en_tutorial_po.update(store)
assert(not en_tutorial_po.units[1].hasplural())
assert(en_tutorial_po.units[2].hasplural())
def test_update_from_ts(en_tutorial_po):
from django.conf import settings
from translate.storage.factory import getclass
# Parse store
en_tutorial_po.update_from_disk()
ts_dir = os.path.join(settings.ROOT_DIR, 'tests', 'data', 'ts')
tp = en_tutorial_po.translation_project
store_filepath = os.path.join(ts_dir, tp.real_path, 'tutorial.ts')
with open(store_filepath) as storefile:
store = getclass(storefile)(storefile.read())
en_tutorial_po.update(store)
assert (not en_tutorial_po.units[1].hasplural())
assert (en_tutorial_po.units[2].hasplural())
def test_update_from_ts(en_tutorial_po):
from translate.storage.factory import getclass
# Parse store
en_tutorial_po.update_from_disk()
ts_dir = os.path.join(os.path.dirname(pytest_pootle.__file__), 'data',
'ts')
tp = en_tutorial_po.translation_project
store_filepath = os.path.join(ts_dir, tp.real_path, 'tutorial.ts')
with open(store_filepath) as storefile:
store = getclass(storefile)(storefile.read())
en_tutorial_po.update(store)
assert (not en_tutorial_po.units[1].hasplural())
assert (en_tutorial_po.units[2].hasplural())
def test_update_from_ts(en_tutorial_po):
from translate.storage.factory import getclass
# Parse store
en_tutorial_po.update_from_disk()
ts_dir = os.path.join(
os.path.dirname(pytest_pootle.__file__),
'data', 'ts')
tp = en_tutorial_po.translation_project
store_filepath = os.path.join(ts_dir, tp.real_path, 'tutorial.ts')
with open(store_filepath) as storefile:
store = getclass(storefile)(storefile.read())
en_tutorial_po.update(store)
assert(not en_tutorial_po.units[1].hasplural())
assert(en_tutorial_po.units[2].hasplural())
def moz_env(post_db_setup, _django_cursor_wrapper, ios_pootle_file):
from django.conf import settings
from pytest_pootle.factories import (ProjectDBFactory, StoreDBFactory,
TranslationProjectFactory)
from pootle_fs.models import ProjectFS
from pootle_language.models import Language
with _django_cursor_wrapper:
ios_project = ProjectDBFactory(
source_language=Language.objects.get(code="en"),
code="ios",
localfiletype="xliff")
ios_tp = TranslationProjectFactory(
project=ios_project,
language=Language.objects.get(code="language0"))
ios_store = StoreDBFactory(parent=ios_tp.directory,
translation_project=ios_tp,
name="firefox-ios.xliff")
ios_bytes = io.BytesIO(ios_pootle_file.encode("utf8"))
ios_store.update(getclass(ios_bytes)(ios_bytes.read()))
fs_dir = tempfile.mkdtemp()
settings.POOTLE_FS_PATH = fs_dir
repo_path = os.path.join(fs_dir, "__moz_ios_src__")
Repo.init(repo_path, bare=True)
with tmp_git(repo_path) as (tmp_repo_path, tmp_repo):
config_file = os.path.join(tmp_repo_path, ".pootle.ini")
with open(config_file, "w") as ini:
config = ("[default]\n"
"serializers = ios\n"
"deserializers = ios\n"
"translation_path = <lang>/<filename>.xliff")
ini.write(config)
tmp_repo.index.add([".pootle.ini"])
tmp_repo.index.commit("Add Pootle configuration")
tmp_repo.remotes.origin.push("master:master")
ios_fs = ProjectFS.objects.create(project=ios_project,
fs_type="git",
url=repo_path)
ios_plugin = ios_fs.plugin
ios_plugin.add_translations()
def test_store_get_file_class():
store = Store.objects.filter(
translation_project__project__code="project0",
translation_project__language__code="language0").first()
# this matches because po is recognised by ttk
assert store.syncer.file_class == getclass(store)
# file_class is cached so lets delete it
del store.syncer.__dict__["file_class"]
class CustomFormatClass(object):
pass
@provider(format_classes)
def format_class_provider(**kwargs):
return dict(po=CustomFormatClass)
# we get the CutomFormatClass as it was registered
assert store.syncer.file_class is CustomFormatClass
# the Store.filetype is used in this case not the name
store.name = "new_store_name.foo"
del store.syncer.__dict__["file_class"]
assert store.syncer.file_class is CustomFormatClass
# lets register a foo filetype
format_registry = formats.get()
foo_filetype = format_registry.register("foo", "foo")
store.filetype = foo_filetype
store.save()
# oh no! not recognised by ttk
del store.syncer.__dict__["file_class"]
with pytest.raises(ValueError):
store.syncer.file_class
@provider(format_classes)
def another_format_class_provider(**kwargs):
return dict(foo=CustomFormatClass)
# works now
assert store.syncer.file_class is CustomFormatClass
format_classes.disconnect(format_class_provider)
format_classes.disconnect(another_format_class_provider)
def test_store_get_file_class():
store = Store.objects.filter(
translation_project__project__code="project0",
translation_project__language__code="language0").first()
# this matches because po is recognised by ttk
assert store.syncer.file_class == getclass(store)
# file_class is cached so lets delete it
del store.syncer.__dict__["file_class"]
class CustomFormatClass(object):
pass
@provider(format_classes)
def format_class_provider(**kwargs):
return dict(po=CustomFormatClass)
# we get the CutomFormatClass as it was registered
assert store.syncer.file_class is CustomFormatClass
# the Store.filetype is used in this case not the name
store.name = "new_store_name.foo"
del store.syncer.__dict__["file_class"]
assert store.syncer.file_class is CustomFormatClass
# lets register a foo filetype
format_registry = formats.get()
foo_filetype = format_registry.register("foo", "foo")
store.filetype = foo_filetype
store.save()
# oh no! not recognised by ttk
del store.syncer.__dict__["file_class"]
with pytest.raises(ValueError):
store.syncer.file_class
@provider(format_classes)
def another_format_class_provider(**kwargs):
return dict(foo=CustomFormatClass)
# works now
assert store.syncer.file_class is CustomFormatClass
format_classes.disconnect(format_class_provider)
format_classes.disconnect(another_format_class_provider)
def test_wrap_store_fs_pull_merge_default(store_fs_file):
fs_file = store_fs_file
fs_file.pull()
unit = fs_file.store.units[0]
unit.target = "FOO"
unit.save()
with open(fs_file.file_path, "r+") as target:
ttk = getclass(target)(target.read())
target.seek(0)
ttk.units[1].target = "BAR"
target.write(str(ttk))
target.truncate()
assert fs_file.fs_changed is True
assert fs_file.pootle_changed is True
fs_file.pull(merge=True)
assert fs_file.store.units[0].target == "BAR"
assert fs_file.store.units[0].get_suggestions()[0].target == "FOO"
def import_file(f, user=None):
ttk = getclass(f)(f.read())
if not hasattr(ttk, "parseheader"):
raise UnsupportedFiletypeError(_("Unsupported filetype '%s', only PO "
"files are supported at this time\n",
f.name))
header = ttk.parseheader()
pootle_path = header.get("X-Pootle-Path")
if not pootle_path:
raise MissingPootlePathError(_("File '%s' missing X-Pootle-Path "
"header\n", f.name))
rev = header.get("X-Pootle-Revision")
if not rev or not rev.isdigit():
raise MissingPootleRevError(_("File '%s' missing or invalid "
"X-Pootle-Revision header\n",
f.name))
rev = int(rev)
try:
store = Store.objects.get(pootle_path=pootle_path)
except Store.DoesNotExist as e:
raise FileImportError(
_("Could not create '%(filename)s'. Missing "
"Project/Language? (%(error)s)",
dict(filename=f.name, error=e)))
tp = store.translation_project
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
try:
store.update(store=ttk, user=user,
submission_type=SubmissionTypes.UPLOAD,
store_revision=rev,
allow_add_and_obsolete=allow_add_and_obsolete)
except Exception as e:
# This should not happen!
logger.error("Error importing file: %s", str(e))
raise FileImportError(_("There was an error uploading your file"))
def complex_po(test_fs):
"""A Store with some complex Units"""
from pootle_translationproject.models import TranslationProject
from pytest_pootle.factories import StoreDBFactory
tp = TranslationProject.objects.get(
project__code="project0",
language__code="language0")
store = StoreDBFactory(
parent=tp.directory,
translation_project=tp,
name="complex_store.po")
with test_fs.open(("data", "po", "complex.po")) as f:
ttk = getclass(f)(f.read())
store.update(ttk)
return store
def setup_complex_po(self):
import pytest_pootle
from pytest_pootle.factories import StoreDBFactory
from pootle_translationproject.models import TranslationProject
po_file = os.path.join(
os.path.dirname(pytest_pootle.__file__),
*("data", "po", "complex.po"))
with open(po_file) as f:
ttk = getclass(f)(f.read())
tp = TranslationProject.objects.get(
project__code="project0",
language__code="language0")
store = StoreDBFactory(
parent=tp.directory,
translation_project=tp,
name="complex.po")
store.update(ttk)
