def setup_disabled_project(self):
from pytest_pootle.factories import (DirectoryFactory,
ProjectDBFactory,
TranslationProjectFactory)
from pootle.core.contextmanagers import keep_data
from pootle_format.models import Format
from pootle_language.models import Language
with keep_data():
source_language = Language.objects.get(code="en")
project = ProjectDBFactory(code="disabled_project0",
fullname="Disabled Project 0",
source_language=source_language)
project.filetypes.add(Format.objects.get(name="po"))
project.disabled = True
project.save()
language = Language.objects.get(code="language0")
tp = TranslationProjectFactory(project=project, language=language)
tp_dir = tp.directory
tp_dir.obsolete = False
tp_dir.save()
self._add_stores(tp, n=(1, 1))
subdir0 = DirectoryFactory(name="subdir0",
parent=tp.directory,
tp=tp)
self._add_stores(tp, n=(1, 1), parent=subdir0)
def test_project_fs_instance_bad(english):
# needs a Project
with pytest.raises(TypeError):
FSPlugin()
project = ProjectDBFactory(source_language=english)
# project is not configured
with pytest.raises(NotConfiguredError):
FSPlugin(project)
with pytest.raises(ValidationError):
project.config["pootle_fs.fs_type"] = "foo"
project.config["pootle_fs.fs_type"] = "localfs"
with pytest.raises(NotConfiguredError):
FSPlugin(project)
project.config["pootle_fs.fs_url"] = "/bar"
default_receivers = fs_plugins.receivers[:]
default_cache = fs_plugins.sender_receivers_cache.copy()
@provider(fs_plugins, sender=Project)
def provide_fs_plugin(**kwargs):
return dict(dummyfs=DummyFSPlugin)
project.config["pootle_fs.fs_type"] = "dummyfs"
fs_plugins.receivers = default_receivers
fs_plugins.sender_receivers_cache = default_cache
with pytest.raises(MissingPluginError):
FSPlugin(project)
def test_data_tp(english):
"""Test that you cant add a duplicate file extension
"""
tp = TranslationProjectFactory(
project=ProjectDBFactory(source_language=english),
language=LanguageDBFactory())
assert (repr(tp.data) == '<TPData: %s>' % tp.pootle_path)
def test_add_store_fs_by_path(english):
"""Add a store_fs for pootle_path
"""
project = ProjectDBFactory(source_language=english)
language = LanguageDBFactory()
tp = TranslationProjectFactory(project=project, language=language)
store = StoreDBFactory(
translation_project=tp,
parent=tp.directory,
name="example_store.po")
conf = config.get(tp.project.__class__, instance=tp.project)
conf.set_config("pootle_fs.fs_type", "localfs")
conf.set_config("pootle_fs.fs_url", "foo")
fs_path = "/some/fs/example_store.po"
pootle_path = store.pootle_path
store_fs = StoreFS.objects.create(
pootle_path=pootle_path,
path=fs_path)
assert store_fs.project == project
assert store_fs.store == store
assert store_fs.pootle_path == pootle_path
assert store_fs.path == fs_path
assert store_fs.last_sync_hash is None
assert store_fs.last_sync_mtime is None
assert store_fs.last_sync_revision is None
def test_lang_mapper_project_config(po_directory, english):
project = ProjectDBFactory(source_language=english)
project_config = ObjectConfig(project)
# upstream_code="en_US", pootle_code="en"
project_config["pootle.core.lang_mapping"] = dict(en_US="en")
project.config.reload()
mapper = lang_mapper.get(project.__class__, instance=project)
assert mapper["en_US"] == english
assert mapper.get_pootle_code("en_US") == "en"
assert mapper.get_upstream_code("en") == "en_US"
assert "en_US" in mapper
# as en_US is mapped to pootle's en its not valid as upstream code
assert mapper.get_upstream_code("en_US") is None
# as en is mapped to en_US its not valid as a pootle_code
assert mapper.get_pootle_code("en") is None
assert "en" not in mapper
# we can swap codes
project_config["pootle.core.lang_mapping"] = dict(language0="en",
en="language0")
mapper = lang_mapper.get(project.__class__, instance=project)
project.config.reload()
language0 = Language.objects.get(code="language0")
assert mapper["en"] == language0
assert mapper["language0"] == english
assert mapper.get_pootle_code("en") == "language0"
assert mapper.get_pootle_code("language0") == "en"
assert mapper.get_upstream_code("en") == "language0"
assert mapper.get_upstream_code("language0") == "en"
def test_tp_tool_clone_project_same_lang(tp0, english):
new_proj = ProjectDBFactory(source_language=english)
tp_tool = TPTool(tp0.project)
_test_tp_match(
tp0,
tp_tool.clone(tp0, tp0.language, new_proj),
new_proj)
def tp_checker_tests(request, english, checkers):
from pytest_pootle.factories import ProjectDBFactory
checker_name = checkers
project = ProjectDBFactory(checkstyle=checker_name,
source_language=english)
return (checker_name, project)
def test_add_store_bad(po_directory, english):
"""Try to create a store_fs by pootle_path for a non existent project
"""
project0 = Project.objects.get(code="project0")
project = ProjectDBFactory(source_language=english)
# project doesnt exist
with pytest.raises(ValidationError):
StoreFS.objects.create(pootle_path="/en/project0_BAD/example.po",
path="/some/fs/example.po")
# pootle_path must match project_code
with pytest.raises(ValidationError):
StoreFS.objects.create(project=project0,
pootle_path="/en/%s/en.po" % project.code,
path="/locales/en.po")
# need both pootle_path and fs_path - somehow
with pytest.raises(ValidationError):
StoreFS.objects.create(project=project0,
pootle_path="/language0/%s/en.po" %
project0.code)
with pytest.raises(ValidationError):
StoreFS.objects.create(project=project0, path="/locales/en.po")
store = setup_store("/language0/project0/en.po")
with pytest.raises(ValidationError):
StoreFS.objects.create(store=store, pootle_path=store.pootle_path)
def test_store_get_template_file_class(po_directory, templates):
project = ProjectDBFactory(source_language=templates)
tp = TranslationProjectFactory(language=templates, project=project)
format_registry = formats.get()
foo_filetype = format_registry.register("foo",
"foo",
template_extension="bar")
tp.project.filetypes.add(foo_filetype)
store = Store.objects.create(name="mystore.bar",
translation_project=tp,
parent=tp.directory)
# oh no! not recognised by ttk
with pytest.raises(ValueError):
store.syncer.file_class
class CustomFormatClass(object):
pass
@provider(format_classes)
def format_class_provider(**kwargs):
return dict(foo=CustomFormatClass)
assert store.syncer.file_class == CustomFormatClass
format_classes.disconnect(format_class_provider)
def test_project_fs_instance_bad(english):
# needs a Project
with pytest.raises(TypeError):
FSPlugin()
project = ProjectDBFactory(source_language=english)
# project is not configured
with pytest.raises(NotConfiguredError):
FSPlugin(project)
project.config["pootle_fs.fs_type"] = "foo"
with pytest.raises(NotConfiguredError):
FSPlugin(project)
project.config["pootle_fs.fs_type"] = None
project.config["pootle_fs.fs_url"] = "bar"
with pytest.raises(NotConfiguredError):
FSPlugin(project)
project.config["pootle_fs.fs_type"] = "foo"
with pytest.raises(MissingPluginError):
FSPlugin(project)
@provider(fs_plugins, sender=Project)
def provide_fs_plugin(**kwargs):
return dict(dummyfs=DummyFSPlugin)
with pytest.raises(MissingPluginError):
FSPlugin(project)
def test_tp_tool_bad(po_directory, tp0, templates, english, no_templates_tps):
other_project = ProjectDBFactory(source_language=english)
other_tp = TranslationProjectFactory(
project=other_project,
language=LanguageDBFactory())
tp_tool = TPTool(tp0.project)
with pytest.raises(ValueError):
tp_tool.check_tp(other_tp)
with pytest.raises(ValueError):
tp_tool.set_parents(tp0.directory, other_tp.directory)
with pytest.raises(ValueError):
tp_tool.set_parents(other_tp.directory, tp0.directory)
with pytest.raises(ValueError):
tp_tool.move(other_tp, templates)
with pytest.raises(ValueError):
tp_tool.clone(other_tp, templates)
with pytest.raises(ValueError):
# cant set tp to a language if a tp already exists
tp_tool.move(
tp0, Language.objects.get(code="language1"))
with pytest.raises(ValueError):
# cant clone tp to a language if a tp already exists
tp_tool.clone(
tp0, Language.objects.get(code="language1"))
def test_data_tp_checks(english):
"""Test that you cant add a duplicate file extension
"""
tp = TranslationProjectFactory(
project=ProjectDBFactory(source_language=english),
language=LanguageDBFactory())
check_data = TPChecksData.objects.create(tp=tp)
assert (repr(check_data) == '<TPChecksData: %s>' % tp.pootle_path)
def test_plugin_instance(english):
project = ProjectDBFactory(source_language=english)
project.config["pootle_fs.fs_type"] = "hg"
project.config["pootle_fs.fs_url"] = "bar"
project.config["pootle_fs.translation_paths"] = DEFAULT_TRANSLATION_PATHS
hg_plugin = FSPlugin(project)
assert hg_plugin.project == hg_plugin.plugin.project == project
assert hg_plugin.is_cloned is False
def test_store_get_or_create_templates(po_directory, templates):
project = ProjectDBFactory(source_language=templates)
tp = TranslationProjectFactory(language=templates, project=project)
po = Format.objects.get(name="po")
store = Store.objects.get_or_create(name="mystore.pot",
translation_project=tp,
parent=tp.directory)[0]
assert store.filetype == po
assert store.is_template
def test_fs_cmd_bad_project(project_fs, capsys, english):
with pytest.raises(CommandError):
call_command("fs", "state", "BAD_PROJECT_CODE")
with pytest.raises(CommandError):
call_command("fs", "BAD_SUBCOMMAND", "project0")
with pytest.raises(CommandError):
call_command("fs", "state",
ProjectDBFactory(source_language=english).code)
def test_fs_state_instance(settings, english):
settings.POOTLE_FS_PATH = "/tmp/foo/"
project = ProjectDBFactory(source_language=english)
plugin = DummyPlugin(project)
state = ProjectFSState(plugin)
assert state.project == project
assert state.states == FS_STATE.keys()
assert (str(state) == (
"<ProjectFSState(<DummyPlugin(%s)>): Nothing to report>" %
project.fullname))
def setup_terminology(self):
from pytest_pootle.factories import (ProjectDBFactory,
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)
for language in Language.objects.all():
TranslationProjectFactory(project=terminology, language=language)
def setup_disabled_project(self):
from pytest_pootle.factories import (DirectoryFactory,
ProjectDBFactory,
TranslationProjectFactory)
from pootle_language.models import Language
source_language = Language.objects.get(code="en")
project = ProjectDBFactory(code="disabled_project0",
fullname="Disabled Project 0",
source_language=source_language)
project.disabled = True
project.save()
language = Language.objects.get(code="language0")
tp = TranslationProjectFactory(project=project, language=language)
tp_dir = tp.directory
tp_dir.obsolete = False
tp_dir.save()
self._add_stores(tp, n=(1, 1))
subdir0 = DirectoryFactory(name="subdir0", parent=tp.directory)
self._add_stores(tp, n=(1, 1), parent=subdir0)
def setup_disabled_project(self):
from pytest_pootle.factories import (DirectoryFactory,
ProjectDBFactory,
TranslationProjectFactory)
from pootle_language.models import Language
source_language = Language.objects.get(code="en")
project = ProjectDBFactory(code="disabled_project0",
fullname="Disabled Project 0",
source_language=source_language)
project.disabled = True
project.save()
language = Language.objects.get(code="language0")
tp = TranslationProjectFactory(project=project, language=language)
tp_dir = tp.directory
tp_dir.obsolete = False
tp_dir.save()
self._add_stores(tp, n=(1, 1))
subdir0 = DirectoryFactory(name="subdir0", parent=tp.directory)
self._add_stores(tp, n=(1, 1), parent=subdir0)
def tp_checker_tests(request, english, checkers):
from pytest_pootle.factories import ProjectDBFactory
checker_name = checkers
project = ProjectDBFactory(checkstyle=checker_name,
source_language=english)
def _remove_project_directory():
shutil.rmtree(project.get_real_path())
request.addfinalizer(_remove_project_directory)
return (checker_name, project)
def test_lang_mapper_bad_preset(po_directory, english, caplog):
project = ProjectDBFactory(source_language=english)
mapper = lang_mapper.get(project.__class__, instance=project)
assert mapper.lang_mappings == {}
project_config = ObjectConfig(project)
project_config["pootle.core.use_lang_mapping_presets"] = [
"PRESET_DOES_NOT_EXIST"
]
project.config.reload()
mapper = lang_mapper.get(project.__class__, instance=project)
assert mapper.lang_mappings == {}
assert ("Unrecognised lang mapping preset"
in ''.join([l.message for l in caplog.records]))
def setup_site_matrix(self):
from pytest_pootle.factories import ProjectDBFactory, LanguageDBFactory
from pootle_language.models import Language
# add 2 languages
for i in range(0, 2):
LanguageDBFactory()
source_language = Language.objects.get(code="en")
for i in range(0, 2):
# add 2 projects
ProjectDBFactory(source_language=source_language)
def test_data_tp(english):
"""Test that you cant add a duplicate file extension
"""
from pytest_pootle.factories import (
LanguageDBFactory, ProjectDBFactory,
TranslationProjectFactory)
tp = TranslationProjectFactory(
project=ProjectDBFactory(source_language=english),
language=LanguageDBFactory())
data = TPData.objects.create(tp=tp)
assert (
repr(data)
== '<TPData: %s>' % tp.pootle_path)
def test_lang_mapper_no_config(po_directory, english):
project = ProjectDBFactory(source_language=english)
mapper = lang_mapper.get(project.__class__, instance=project)
# lang exists and its valid
assert mapper["en"] == english
assert mapper.get_pootle_code("en") == "en"
assert mapper.get_upstream_code("en") == "en"
assert "en" in mapper
# The lang doesnt exist but its not excluded
assert mapper["en_FOO"] is None
assert mapper.get_pootle_code("en_FOO") == "en_FOO"
assert mapper.get_upstream_code("en_FOO") == "en_FOO"
assert "en_FOO" not in mapper
def setup_disabled_project(self):
from pytest_pootle.factories import (DirectoryFactory,
ProjectDBFactory,
TranslationProjectFactory)
from pootle.core.contextmanagers import keep_data
from pootle_format.models import Format
from pootle_language.models import Language
with keep_data():
source_language = Language.objects.get(code="en")
project = ProjectDBFactory(code="disabled_project0",
fullname="Disabled Project 0",
source_language=source_language)
project.filetypes.add(Format.objects.get(name="po"))
project.disabled = True
project.save()
language = Language.objects.get(code="language0")
tp = TranslationProjectFactory(project=project, language=language)
tp_dir = tp.directory
tp_dir.obsolete = False
tp_dir.save()
self._add_stores(tp, n=(1, 1))
subdir0 = DirectoryFactory(name="subdir0", parent=tp.directory, tp=tp)
self._add_stores(tp, n=(1, 1), parent=subdir0)
def test_tp_create_with_none_treestyle(po_directory, english, templates,
settings):
project = ProjectDBFactory(source_language=english, treestyle='pootle_fs')
language = LanguageDBFactory()
TranslationProjectFactory(language=templates, project=project)
tp = TranslationProject.objects.create(project=project, language=language)
assert not tp.abs_real_path
assert not os.path.exists(
os.path.join(settings.POOTLE_TRANSLATION_DIRECTORY, project.code))
tp.save()
assert not tp.abs_real_path
assert not os.path.exists(
os.path.join(settings.POOTLE_TRANSLATION_DIRECTORY, project.code))
def setup_site_matrix(self):
from pytest_pootle.factories import ProjectDBFactory, LanguageDBFactory
from pootle_format.models import Format
from pootle_language.models import Language
# add 2 languages
for i_ in range(0, 2):
LanguageDBFactory()
source_language = Language.objects.get(code="en")
po = Format.objects.get(name="po")
for i_ in range(0, 2):
# add 2 projects
project = ProjectDBFactory(source_language=source_language)
project.filetypes.add(po)
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 project_fs_empty(english, tmpdir, settings):
from pytest_pootle.factories import ProjectDBFactory
from pootle_fs.utils import FSPlugin
project = ProjectDBFactory(source_language=english,
code="project_fs_empty")
settings.POOTLE_FS_WORKING_PATH = str(tmpdir)
repo_path = os.path.join(str(tmpdir), "__src__")
if not os.path.exists(repo_path):
os.mkdir(repo_path)
project.config["pootle_fs.fs_type"] = "localfs"
project.config["pootle_fs.fs_url"] = repo_path
project.config["pootle_fs.translation_mappings"] = {
"default": "/<language_code>/<dir_path>/<filename>.<ext>"
}
return FSPlugin(project)
def test_add_store_bad_path(po_directory, english):
"""Try to create a store_fs where pootle_path and store.pootle_path dont
match.
"""
fs_path = "/some/fs/example.po"
project = ProjectDBFactory(source_language=english)
language = LanguageDBFactory()
tp = TranslationProjectFactory(project=project, language=language)
tp.project.config["pootle_fs.fs_type"] = "localfs"
tp.project.config["pootle_fs.fs_url"] = "/foo"
store = StoreDBFactory(translation_project=tp,
parent=tp.directory,
name="example_store.po")
with pytest.raises(ValidationError):
StoreFS.objects.create(store=store,
pootle_path="/some/other/path.po",
path=fs_path)
def test_lang_mapper_preset_config(po_directory, english):
project = ProjectDBFactory(source_language=english)
project_config = ObjectConfig(project)
site_config = SiteConfig()
# add the preset
site_config["pootle.core.lang_mapping_presets"] = dict(preset_1=dict(
en_US="en"))
# project not configured yet tho
mapper = lang_mapper.get(project.__class__, instance=project)
assert mapper["en_US"] is None
assert mapper["en"] == english
# configure project to use preset
project_config["pootle.core.use_lang_mapping_presets"] = ["preset_1"]
project.config.reload()
mapper = lang_mapper.get(project.__class__, instance=project)
assert mapper["en_US"] == english
assert mapper["en"] is None
def test_format_set_tp_filetype(po_directory, english, language0, po2):
project = ProjectDBFactory(source_language=english)
filetypes = project.filetype_tool
registry = formats.get()
lang_tp = TranslationProjectFactory(language=language0, project=project)
store = Store.objects.create(name="mystore.po",
translation_project=lang_tp,
parent=lang_tp.directory)
filetypes.add_filetype(po2)
filetypes.set_tp_filetype(lang_tp, po2)
store = Store.objects.get(pk=store.pk)
assert store.filetype == po2
assert store.name.endswith(".po2")
po3 = registry.register("special_po_3", "po3", template_extension="pot")
filetypes.add_filetype(po3)
filetypes.set_tp_filetype(lang_tp, po3)
store = Store.objects.get(pk=store.pk)
assert store.filetype == po3
assert store.name.endswith(".po3")
def test_language_liveness():
language = LanguageDBFactory()
# Test unused language is not live.
assert language.translationproject_set.count() == 0
assert language not in Language.live.all()
assert language not in Language.live.get_all_queryset()
# Create obsolete TP.
obsolete_tp = TranslationProjectFactory(
language=language,
project=ProjectDBFactory(source_language=language)
)
obsolete_tp.directory.makeobsolete()
# Test language used only in obsolete TP is not live.
assert obsolete_tp.directory.obsolete
assert language.translationproject_set.count() == 1
assert language not in Language.live.all()
assert language not in Language.live.get_all_queryset()
# Create TP for disabled project.
disabled_project = ProjectDBFactory(source_language=language)
disabled_project.disabled = True
disabled_project.save()
disabled_project_tp = TranslationProjectFactory(language=language,
project=disabled_project)
# Test language used only in disabled project and obsolete TP is not live.
assert disabled_project.disabled
assert language.translationproject_set.count() == 2
assert language not in Language.live.all()
# But live for admins.
assert language in Language.live.get_all_queryset()
# Create regular TP.
TranslationProjectFactory(
language=language,
project=ProjectDBFactory(source_language=language)
)
# Test language used in regular and obsolete TPs and in TP on disabled
# project is live.
assert language.translationproject_set.count() == 3
assert language in Language.live.all()
# But live for admins.
assert language in Language.live.get_all_queryset()
# Delete TP for disabled project.
disabled_project_tp.delete()
# Test language both in obsolete and regular TP is live.
assert language.translationproject_set.count() == 2
assert language in Language.live.all()
assert language in Language.live.get_all_queryset()
# Create again TP for disabled project and delete obsolete TP.
# Delete obsolete TP.
disabled_project_tp = TranslationProjectFactory(language=language,
project=disabled_project)
obsolete_tp.delete()
# Test language both in disabled project and regular TP is live.
assert language.translationproject_set.count() == 2
assert language in Language.live.all()
assert language in Language.live.get_all_queryset()
# Delete TP for disabled project.
disabled_project_tp.delete()
# Test templates language is live.
assert language.translationproject_set.count() == 1
assert language in Language.live.all()
assert language in Language.live.get_all_queryset()
