def test_init_fs_project_cmd_nosync(settings, test_fs, tmpdir, revision):
settings.POOTLE_FS_WORKING_PATH = str(tmpdir)
fs_path = test_fs.path("data/fs/example_fs/non_gnu_style_minimal/")
tr_path = "<language_code>/<filename>.<ext>"
call_command(
"init_fs_project",
"foo",
fs_path,
tr_path,
"--nosync",
"--checkstyle=standard",
"--filetypes=po",
"--source-language=en",
"--name=Foo"
)
project = Project.objects.get(code='foo')
assert project is not None
assert project.code == "foo"
assert project.fullname == "Foo"
assert "po" in project.filetypes.values_list("name", flat=True)
assert project.checkstyle == "standard"
assert project.source_language.code == "en"
assert project.treestyle == 'pootle_fs'
assert project.config.get('pootle_fs.fs_type') == 'localfs'
assert project.config.get('pootle_fs.fs_url') == fs_path
assert project.config.get(
'pootle_fs.translation_mappings')['default'] == tr_path
assert project.translationproject_set.all().count() == 0
plugin = FSPlugin(project)
plugin.fetch()
state = plugin.state()
assert "fs_untracked: 1" in str(state)
def __test_plugin_commit_message(hg_project):
hg_plugin = FSPlugin(hg_project)
NEW_COMMIT_MSG = "New commit message"
hg_plugin.pull()
assert not hg_plugin.config.get("pootle_fs.commit_message")
# make some updates
hg_plugin.push_translations()
# check that commit message uses default when not set in config
with tmp_hg(hg_plugin.fs_url) as (tmp_repo_path, tmp_repo):
last_commit = tmp_repo.hg.log('-1', '--pretty=%s')
assert last_commit == DEFAULT_COMMIT_MSG
# update the config
hg_plugin.config["pootle_fs.commit_message"] = NEW_COMMIT_MSG
# make further updates
hg_plugin.add_translations()
hg_plugin.sync_translations()
# test that sync_translations committed with new commit message
with tmp_hg(hg_plugin.fs_url) as (tmp_repo_path, tmp_repo):
last_commit = tmp_repo.hg.log('-1', '--pretty=%s')
assert last_commit == NEW_COMMIT_MSG
def project_fs(tmpdir, settings):
from pootle_project.models import Project
from pootle_fs.utils import FSPlugin
project = Project.objects.get(code="project0")
new_url = os.path.join(str(tmpdir), "__src__")
project.config["pootle_fs.fs_url"] = new_url
plugin = FSPlugin(project)
os.makedirs(new_url)
settings.POOTLE_FS_WORKING_PATH = str(tmpdir)
plugin.fetch()
return plugin
def _setup_project_fs(self, project):
from pootle_fs.utils import FSPlugin
from pytest_pootle.utils import add_store_fs
project.config["pootle_fs.fs_type"] = "localfs"
project.config["pootle_fs.translation_mappings"] = {
"default": "/<language_code>/<dir_path>/<filename>.<ext>"}
project.config["pootle_fs.fs_url"] = "/tmp/path/for/setup"
plugin = FSPlugin(project)
for store in plugin.resources.stores:
add_store_fs(
store=store,
fs_path=plugin.get_fs_path(store.pootle_path),
synced=True)
def _sync_translations(db_unit):
store = db_unit.store
tp = store.translation_project
project = tp.project
language = tp.language
plugin = FSPlugin(project)
plugin.fetch()
plugin.sync()
file_store = db_unit.store.deserialize(
open(os.path.join(
plugin.fs_url,
language.code,
store.name)).read())
file_unit = file_store.findid(db_unit.getid())
return file_store, file_unit
def test_project_fs_instance():
@provider(fs_plugins, sender=Project)
def provide_fs_plugin(**kwargs):
return dict(dummyfs=DummyFSPlugin)
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "dummyfs"
project.config["pootle_fs.fs_url"] = "/foo/bar"
plugin = FSPlugin(project)
assert str(plugin) == "<DummyFSPlugin(Project 0)>"
assert plugin.project == project
assert plugin.plugin_property == "Plugin property"
assert plugin.plugin_method("bar") == "Plugin method called with: bar"
assert plugin == FSPlugin(project)
def dummyfs_plugin_no_stores(settings, no_complex_po_, dummy_fs_getters):
from pootle.core.plugin import provider
from pootle_fs.delegate import fs_plugins
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
from pootle_store.models import Store
settings.POOTLE_FS_WORKING_PATH = os.sep.join(['', 'tmp', 'foo'])
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "dummyfs"
stores = Store.objects.filter(translation_project__project=project)
pootle_paths = list(stores.values_list("pootle_path", flat=True))
class NoStoresDummyPlugin(DummyPlugin):
def find_translations(self, fs_path=None, pootle_path=None):
for pp in pootle_paths:
if pootle_path and not fnmatch(pp, pootle_path):
continue
fp = self.get_fs_path(pp)
if fs_path and not fnmatch(fp, fs_path):
continue
yield pp, fp
@provider(fs_plugins, weak=False, sender=Project)
def plugin_provider_(**kwargs_):
return dict(dummyfs=NoStoresDummyPlugin)
plugin = FSPlugin(project)
return plugin
def dummyfs_plugin_fs_changed(settings, dummy_fs_getters):
from pootle.core.plugin import getter, provider
from pootle_fs.delegate import fs_file, fs_plugins
from pootle_fs.files import FSFile
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
class FSChangedFile(FSFile):
@property
def fs_changed(self):
return True
class PootleConflictDummyPlugin(DummyPlugin):
pass
@provider(fs_plugins, weak=False, sender=Project)
def plugin_provider_(**kwargs_):
return dict(dummyfs=PootleConflictDummyPlugin)
@getter(fs_file, weak=False, sender=PootleConflictDummyPlugin)
def fs_files_getter_(**kwargs_):
return FSChangedFile
project = Project.objects.get(code="project0")
settings.POOTLE_FS_WORKING_PATH = os.sep.join(['', 'tmp', 'foo'])
project.config["pootle_fs.fs_type"] = "dummyfs"
return FSPlugin(project)
def test_plugin_instance_bad_args(hg_project):
hg_plugin = FSPlugin(hg_project)
with pytest.raises(TypeError):
hg_plugin.plugin.__class__()
with pytest.raises(TypeError):
hg_plugin.plugin.__class__("FOO")
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 setup_fs(self):
from pytest_pootle.utils import add_store_fs
from pootle_project.models import Project
from pootle_fs.utils import FSPlugin
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "localfs"
project.config["pootle_fs.translation_mappings"] = {
"default": "/<language_code>/<dir_path>/<filename>.<ext>"
}
project.config["pootle_fs.fs_url"] = "/tmp/path/for/setup"
plugin = FSPlugin(project)
for store in plugin.resources.stores:
add_store_fs(store=store,
fs_path=plugin.get_fs_path(store.pootle_path),
synced=True)
def project0_dummy_plugin_no_stores(settings, request,
no_fs_plugins, no_fs_files):
from pytest_pootle.utils import add_store_fs
from pootle.core.plugin import getter, provider
from pootle_fs.delegate import fs_file, fs_plugins
from pootle_fs.files import FSFile
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
from pootle_store.models import Store
settings.POOTLE_FS_PATH = "/tmp/foo/"
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "dummyfs"
project.config["pootle_fs.fs_url"] = "/foo/bar"
stores = Store.objects.filter(
translation_project__project=project)
pootle_paths = list(stores.values_list("pootle_path", flat=True))
class NoStoresDummyPlugin(DummyPlugin):
def find_translations(self, fs_path=None, pootle_path=None):
for pp in pootle_paths:
if pootle_path and not fnmatch(pp, pootle_path):
continue
fp = self.get_fs_path(pp)
if fs_path and not fnmatch(fp, fs_path):
continue
yield pp, fp
@provider(fs_plugins, weak=False, sender=Project)
def plugin_provider(**kwargs):
return dict(dummyfs=NoStoresDummyPlugin)
@getter(fs_file, weak=False, sender=NoStoresDummyPlugin)
def fs_files_getter(**kwargs):
return FSFile
plugin = FSPlugin(project)
for store in stores:
add_store_fs(
store=store,
fs_path=plugin.get_fs_path(store.pootle_path),
synced=True)
return plugin
def create_terminology_project(self):
"""Create the terminology project.
The terminology project is used to display terminology suggestions
while translating.
"""
criteria = {
'code': "terminology",
'fullname': u"Terminology",
'source_language': self.require_english(),
'checkstyle': "terminology",
}
po = Format.objects.get(name="po")
terminology = self._create_object(Project, **criteria)[0]
terminology.filetypes.add(po)
terminology.config["pootle_fs.fs_url"] = os.path.join(
settings.POOTLE_TRANSLATION_DIRECTORY,
terminology.code)
terminology.config["pootle_fs.fs_type"] = "localfs"
terminology.config["pootle_fs.translation_mappings"] = dict(
default="/<language_code>/<dir_path>/<filename>.<ext>")
plugin = FSPlugin(terminology)
plugin.fetch()
plugin.add()
plugin.sync()
def handle_all_stores(self, translation_project, **options):
path_glob = "%s*" % translation_project.pootle_path
plugin = FSPlugin(translation_project.project)
plugin.fetch()
if translation_project.project.pk not in self.warn_on_conflict:
state = plugin.state()
if any(k in state for k in ["conflict", "conflict_untracked"]):
logger.warn(
"The project '%s' has conflicting changes in the database "
"and translation files. Use `pootle fs resolve` to tell "
"pootle how to merge", translation_project.project.code)
self.warn_on_conflict.append(translation_project.project.pk)
if not options["skip_missing"]:
plugin.add(pootle_path=path_glob, update="fs")
plugin.sync(pootle_path=path_glob, update="fs")
def handle(self, **options):
source_language_code = options['source_language']
try:
source_language = Language.objects.get(code=source_language_code)
except Language.DoesNotExist as e:
self.stdout.write('%s: Unknown language code.' %
source_language_code)
raise CommandError(e)
fs_type, fs_url = parse_fs_url(options['fs'])
code = options['code']
name = options['name'] or code.capitalize()
try:
project = Project.objects.create(
code=code,
fullname=name,
treestyle='none',
checkstyle=options['checkstyle'],
source_language=source_language)
for filetype in options["filetypes"] or ["po"]:
try:
filetype = Format.objects.get(name=filetype)
project.filetypes.add(filetype)
except Format.DoesNotExist as e:
raise CommandError(e)
project.update_all_cache()
except IntegrityError as e:
self.stdout.write('Project code "%s" already exists.'
% options['code'])
raise CommandError(e)
project.config['pootle_fs.fs_type'] = fs_type
project.config['pootle_fs.fs_url'] = fs_url
project.config['pootle_fs.translation_paths'] = {
'default': options['translation_path']
}
if options['sync']:
plugin = FSPlugin(project)
plugin.fetch()
plugin.sync()
def project_fs(tmpdir, settings):
from pootle_project.models import Project
from pootle_fs.utils import FSPlugin
project = Project.objects.get(code="project0")
new_url = os.path.join(str(tmpdir), "__src__")
project.config["pootle_fs.fs_url"] = new_url
plugin = FSPlugin(project)
os.makedirs(new_url)
settings.POOTLE_FS_PATH = str(tmpdir)
return plugin
def handle(self, *args, **kwargs):
any_configured = False
for project in Project.objects.order_by("pk"):
try:
plugin = FSPlugin(project)
self.stdout.write("%s\t%s" % (project.code, plugin.fs_url))
any_configured = True
except (MissingPluginError, NotConfiguredError):
pass
if not any_configured:
self.stdout.write("No projects configured")
def test_fs_cmd(project_fs, capsys):
call_command("fs")
out, err = capsys.readouterr()
expected = []
for project in Project.objects.order_by("pk"):
try:
plugin = FSPlugin(project)
expected.append("%s\t%s" % (project.code, plugin.fs_url))
except (MissingPluginError, NotConfiguredError):
pass
expected = ("%s\n" % '\n'.join(expected))
assert out == expected
def test_project_fs_instance_bad():
# needs a Project
with pytest.raises(TypeError):
FSPlugin()
project = Project.objects.get(code="project0")
# 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_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_plugin_commit_committer(hg_project):
plugin = FSPlugin(hg_project)
NEW_COMMITTER_NAME = "New Committer"
NEW_COMMITTER_EMAIL = "*****@*****.**"
plugin.pull()
assert not plugin.config.get("pootle_fs.committer_name")
assert not plugin.config.get("pootle_fs.committer_email")
# make some updates
plugin.push_translations()
# check that commit message uses system default when not set in config
with tmp_hg(plugin.fs_url) as (tmp_repo_path, tmp_repo):
last_committer_name = tmp_repo.hg.log('-1', '--pretty=%an')
last_committer_email = tmp_repo.hg.log('-1', '--pretty=%ae')
hg_config = tmp_repo.config_reader()
default_user = os.environ["USER"]
default_email = ("%s@%s" %
(default_user, os.environ.get("HOSTNAME", "")))
assert (last_committer_name == hg_config.get_value(
"user", "name", default_user))
assert (last_committer_email == hg_config.get_value(
"user", "email", default_email))
# update the committer name/email in config
plugin.config["pootle_fs.committer_name"] = NEW_COMMITTER_NAME
plugin.config["pootle_fs.committer_email"] = NEW_COMMITTER_EMAIL
# make further updates
plugin.add_translations()
plugin.sync_translations()
# test that sync_translations committed with new commit committer
with tmp_hg(plugin.fs_url) as (tmp_repo_path, tmp_repo):
last_committer_name = tmp_repo.hg.log('-1', '--pretty=%cn')
last_committer_email = tmp_repo.hg.log('-1', '--pretty=%ce')
assert last_committer_name == NEW_COMMITTER_NAME
assert last_committer_email == NEW_COMMITTER_EMAIL
def test_plugin_instance(project_fs_empty):
project_fs = project_fs_empty
assert project_fs.project == project_fs.plugin.project
assert project_fs.project.local_fs_path.endswith(project_fs.project.code)
assert project_fs.is_cloned is False
assert project_fs.resources.stores.exists() is False
assert project_fs.resources.tracked.exists() is False
# any instance of the same plugin is equal
new_plugin = FSPlugin(project_fs.project)
assert project_fs == new_plugin
assert project_fs is not new_plugin
# but the plugin doesnt equate to a cabbage 8)
assert not project_fs == "a cabbage"
def __test_plugin_commit_committer(hg_project):
plugin = FSPlugin(hg_project)
NEW_COMMITTER_NAME = "New Committer"
NEW_COMMITTER_EMAIL = "*****@*****.**"
plugin.pull()
assert not plugin.config.get("pootle_fs.committer_name")
assert not plugin.config.get("pootle_fs.committer_email")
# make some updates
plugin.push_translations()
# check that commit message uses system default when not set in config
with tmp_hg(plugin.fs_url) as (tmp_repo_path, tmp_repo):
last_committer_name = tmp_repo.hg.log('-1', '--pretty=%an')
last_committer_email = tmp_repo.hg.log('-1', '--pretty=%ae')
hg_config = tmp_repo.config_reader()
default_user = os.environ["USER"]
default_email = (
"%s@%s"
% (default_user, os.environ.get("HOSTNAME", "")))
assert (
last_committer_name
== hg_config.get_value("user", "name", default_user))
assert (
last_committer_email
== hg_config.get_value("user", "email", default_email))
# update the committer name/email in config
plugin.config["pootle_fs.committer_name"] = NEW_COMMITTER_NAME
plugin.config["pootle_fs.committer_email"] = NEW_COMMITTER_EMAIL
# make further updates
plugin.add_translations()
plugin.sync_translations()
# test that sync_translations committed with new commit committer
with tmp_hg(plugin.fs_url) as (tmp_repo_path, tmp_repo):
last_committer_name = tmp_repo.hg.log('-1', '--pretty=%cn')
last_committer_email = tmp_repo.hg.log('-1', '--pretty=%ce')
assert last_committer_name == NEW_COMMITTER_NAME
assert last_committer_email == NEW_COMMITTER_EMAIL
def tutorial(english, settings):
"""Require `tutorial` test project."""
import pytest_pootle
from pootle_fs.utils import FSPlugin
shutil.copytree(
os.path.join(os.path.dirname(pytest_pootle.__file__), "data", "po",
"tutorial"),
os.path.join(settings.POOTLE_TRANSLATION_DIRECTORY, "tutorial"))
project = _require_project('tutorial', 'Tutorial', english, settings)
plugin = FSPlugin(project)
plugin.fetch()
plugin.add()
plugin.sync()
return project
def setup_fs(self):
from pytest_pootle.utils import add_store_fs
from django.conf import settings
from pootle_project.models import Project
from pootle_fs.utils import FSPlugin
settings.POOTLE_FS_PATH = os.path.join(
settings.POOTLE_TRANSLATION_DIRECTORY, "__fs_working_dir__")
os.mkdir(settings.POOTLE_FS_PATH)
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "localfs"
project.config["pootle_fs.translation_paths"] = {
"default": "/<language_code>/<dir_path>/<filename>.<ext>"}
project.config["pootle_fs.fs_url"] = "/tmp/path/for/setup"
plugin = FSPlugin(project)
for store in plugin.resources.stores:
add_store_fs(
store=store,
fs_path=plugin.get_fs_path(store.pootle_path),
synced=True)
def setup_fs(self):
from pytest_pootle.utils import add_store_fs
from django.conf import settings
from pootle_project.models import Project
from pootle_fs.utils import FSPlugin
settings.POOTLE_FS_PATH = os.path.join(
settings.POOTLE_TRANSLATION_DIRECTORY, "__fs_working_dir__")
os.mkdir(settings.POOTLE_FS_PATH)
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "localfs"
project.config["pootle_fs.translation_paths"] = {
"default": "/<language_code>/<dir_path>/<filename>.<ext>"
}
project.config["pootle_fs.fs_url"] = "/tmp/path/for/setup"
plugin = FSPlugin(project)
for store in plugin.resources.stores:
add_store_fs(store=store,
fs_path=plugin.get_fs_path(store.pootle_path),
synced=True)
def dummy_cmd_state():
from pootle.core.plugin import provider
from pootle_fs.delegate import fs_plugins
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
DummyState, DummyCommandPlugin = _get_dummy_state_plugin()
@provider(fs_plugins, sender=Project, weak=False)
def plugins_provider_(**kwargs_):
return dict(dummy_state_cmd=DummyCommandPlugin)
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "dummy_state_cmd"
return FSPlugin(project), DummyState
def dummyfs(settings, dummy_fs_getters):
from pootle.core.plugin import provider
from pootle_fs.delegate import fs_plugins
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
@provider(fs_plugins, weak=False)
def plugin_provider_(**kwargs_):
return dict(dummyfs=DummyPlugin)
project = Project.objects.get(code="project0")
settings.POOTLE_FS_WORKING_PATH = os.sep.join(['', 'tmp', 'foo'])
project.config["pootle_fs.fs_type"] = "dummyfs"
return FSPlugin(project)
def handle_all_stores(self, translation_project, **options):
path_glob = "%s*" % translation_project.pootle_path
plugin = FSPlugin(translation_project.project)
plugin.fetch()
if translation_project.project.pk not in self.warn_on_conflict:
state = plugin.state()
if any(k in state for k in ["conflict", "conflict_untracked"]):
logger.warn(
"The project '%s' has conflicting changes in the database "
"and translation files. Use `pootle fs resolve` to tell "
"pootle how to merge",
translation_project.project.code)
self.warn_on_conflict.append(
translation_project.project.pk)
if not options["skip_missing"]:
plugin.add(pootle_path=path_glob, update="fs")
plugin.sync(pootle_path=path_glob, update="fs")
def test_init_fs_project_cmd(capsys, settings, test_fs, tmpdir):
settings.POOTLE_FS_WORKING_PATH = str(tmpdir)
fs_path = test_fs.path("data/fs/example_fs/non_gnu_style_minimal/")
tr_path = "<language_code>/<filename>.<ext>"
call_command("init_fs_project", "foo", fs_path, tr_path)
project = Project.objects.get(code='foo')
assert project is not None
assert project.config.get('pootle_fs.fs_type') == 'localfs'
assert project.config.get('pootle_fs.fs_url') == fs_path
assert project.config.get('pootle_fs.translation_paths')['default'] == tr_path
assert project.translationproject_set.all().count() > 0
state = FSPlugin(project).state()
assert "Nothing to report" in str(state)
def handle(self, **options):
source_language_code = options['source_language']
try:
source_language = Language.objects.get(code=source_language_code)
except Language.DoesNotExist as e:
self.stdout.write('%s: Unknown language code.' %
source_language_code)
raise CommandError(e)
fs_type, fs_url = parse_fs_url(options['fs'])
code = options['code']
name = options['name'] or code.capitalize()
try:
project = Project.objects.create(
code=code,
fullname=name,
treestyle='pootle_fs',
checkstyle=options['checkstyle'],
source_language=source_language)
except ValidationError as e:
raise CommandError(e)
for filetype in options["filetypes"] or ["po"]:
try:
filetype = Format.objects.get(name=filetype)
project.filetypes.add(filetype)
except Format.DoesNotExist as e:
raise CommandError(e)
project.config['pootle_fs.fs_type'] = fs_type
project.config['pootle_fs.fs_url'] = fs_url
project.config['pootle_fs.translation_mappings'] = {
'default': options['translation_mapping']
}
if options['sync']:
try:
plugin = FSPlugin(project)
plugin.fetch()
plugin.add()
plugin.sync()
except FSFetchError as e:
project.delete()
raise CommandError(e)
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 _sync_translations(db_unit):
store = db_unit.store
tp = store.translation_project
project = tp.project
language = tp.language
plugin = FSPlugin(project)
plugin.fetch()
plugin.sync()
file_store = db_unit.store.deserialize(
open(os.path.join(plugin.fs_url, language.code, store.name)).read())
file_unit = file_store.findid(db_unit.getid())
return file_store, file_unit
def dummy_cmd_response():
from pootle.core.plugin import provider
from pootle.core.state import State
from pootle_fs.delegate import fs_plugins
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
DummyResponse, DummyCommandPlugin = _get_dummy_api_plugin()
@provider(fs_plugins, sender=Project, weak=False)
def plugins_provider_(**kwargs_):
return dict(dummy_cmd=DummyCommandPlugin)
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "dummy_cmd"
plugin = FSPlugin(project)
dummy_response = DummyResponse(State(plugin))
return dummy_response, add_dummy_api_call
def create_default_projects(self):
"""Create the default projects that we host.
You might want to add your projects here, although you can also add
things through the web interface later.
"""
en = self.require_english()
po = Format.objects.get(name="po")
criteria = {
'code': u"tutorial",
'source_language': en,
'fullname': u"Tutorial",
'checkstyle': "standard"
}
tutorial = self._create_object(Project, **criteria)[0]
tutorial.filetypes.add(po)
tutorial.config["pootle_fs.fs_type"] = "localfs"
tutorial.config["pootle_fs.fs_url"] = (
"{POOTLE_TRANSLATION_DIRECTORY}%s" % tutorial.code)
tutorial.config["pootle_fs.translation_mappings"] = dict(
default="/<language_code>/<dir_path>/<filename>.<ext>")
plugin = FSPlugin(tutorial)
plugin.fetch()
plugin.add()
plugin.sync()
criteria = {
'active':
True,
'title':
"Project instructions",
'body':
('Tutorial project where users can play with Pootle and learn '
'more about translation and localisation.\n'
'\n'
'For more help on localisation, visit the [localization '
'guide](http://docs.translatehouse.org/projects/'
'localization-guide/en/latest/guide/start.html).'),
'virtual_path':
"announcements/projects/" + tutorial.code,
}
self._create_object(Announcement, **criteria)
def dummyfs(settings, no_fs_plugins, no_fs_files):
from pootle.core.plugin import getter, provider
from pootle_fs.delegate import fs_file, fs_plugins
from pootle_fs.files import FSFile
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
@provider(fs_plugins, weak=False)
def plugin_provider_(**kwargs_):
return dict(dummyfs=DummyPlugin)
@getter(fs_file, weak=False, sender=DummyPlugin)
def fs_files_getter_(**kwargs_):
return FSFile
project = Project.objects.get(code="project0")
settings.POOTLE_FS_WORKING_PATH = "/tmp/foo/"
project.config["pootle_fs.fs_type"] = "dummyfs"
return FSPlugin(project)
def dummyfs_plugin_no_files(settings, no_fs_plugins, no_fs_files):
from pootle.core.plugin import provider
from pootle_fs.delegate import fs_plugins
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
settings.POOTLE_FS_PATH = "/tmp/foo/"
class NoFilesDummyPlugin(DummyPlugin):
def find_translations(self, fs_path=None, pootle_path=None):
return []
@provider(fs_plugins, weak=False, sender=Project)
def plugin_provider(**kwargs):
return dict(dummyfs=NoFilesDummyPlugin)
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "dummyfs"
plugin = FSPlugin(project)
return plugin
def dummyfs_plugin_no_files(settings, no_complex_po_, dummy_fs_getters):
from pootle.core.plugin import provider
from pootle_fs.delegate import fs_plugins
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
settings.POOTLE_FS_WORKING_PATH = os.sep.join(['', 'tmp', 'foo'])
class NoFilesDummyPlugin(DummyPlugin):
def find_translations(self, fs_path=None, pootle_path=None):
return []
@provider(fs_plugins, weak=False, sender=Project)
def plugin_provider_(**kwargs_):
return dict(dummyfs=NoFilesDummyPlugin)
project = Project.objects.get(code="project0")
project.config["pootle_fs.fs_type"] = "dummyfs"
plugin = FSPlugin(project)
return plugin
def project_fs_empty(english, tmpdir, settings):
from pytest_pootle.factories import ProjectDBFactory
from pootle.core.delegate import config
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
project = ProjectDBFactory(source_language=english,
code="project_fs_empty",
treestyle="none")
settings.POOTLE_FS_PATH = str(tmpdir)
repo_path = os.path.join(str(tmpdir), "__src__")
if not os.path.exists(repo_path):
os.mkdir(repo_path)
conf = config.get(Project, instance=project)
conf.set_config("pootle_fs.fs_type", "localfs")
conf.set_config("pootle_fs.fs_url", repo_path)
conf.set_config(
"pootle_fs.translation_paths",
{"default": "/<language_code>/<dir_path>/<filename>.<ext>"})
return FSPlugin(project)
def tutorial(english, settings):
"""Require `tutorial` test project."""
import pytest_pootle
from pootle_fs.utils import FSPlugin
shutil.copytree(
os.path.join(
os.path.dirname(pytest_pootle.__file__),
"data", "po", "tutorial"),
os.path.join(
settings.POOTLE_TRANSLATION_DIRECTORY,
"tutorial"))
project = _require_project('tutorial', 'Tutorial', english, settings)
plugin = FSPlugin(project)
plugin.fetch()
plugin.add()
plugin.sync()
return project
def create_terminology_project(self):
"""Create the terminology project.
The terminology project is used to display terminology suggestions
while translating.
"""
criteria = {
'code': "terminology",
'fullname': u"Terminology",
'source_language': self.require_english(),
'checkstyle': "terminology",
}
po = Format.objects.get(name="po")
terminology = self._create_object(Project, **criteria)[0]
terminology.filetypes.add(po)
terminology.config["pootle_fs.fs_type"] = "localfs"
terminology.config["pootle_fs.fs_url"] = (
"{POOTLE_TRANSLATION_DIRECTORY}%s" % terminology.code)
terminology.config["pootle_fs.translation_mappings"] = dict(
default="/<language_code>/<dir_path>/<filename>.<ext>")
plugin = FSPlugin(terminology)
plugin.fetch()
plugin.add()
plugin.sync()
def create_default_projects(self):
"""Create the default projects that we host.
You might want to add your projects here, although you can also add
things through the web interface later.
"""
en = self.require_english()
po = Format.objects.get(name="po")
criteria = {
'code': u"tutorial",
'source_language': en,
'fullname': u"Tutorial",
'checkstyle': "standard"}
tutorial = self._create_object(Project, **criteria)[0]
tutorial.filetypes.add(po)
tutorial.config["pootle_fs.fs_url"] = os.path.join(
settings.POOTLE_TRANSLATION_DIRECTORY,
tutorial.code)
tutorial.config["pootle_fs.fs_type"] = "localfs"
tutorial.config["pootle_fs.translation_mappings"] = dict(
default="/<language_code>/<dir_path>/<filename>.<ext>")
plugin = FSPlugin(tutorial)
plugin.fetch()
plugin.add()
plugin.sync()
criteria = {
'active': True,
'title': "Project instructions",
'body': (
'Tutorial project where users can play with Pootle and learn '
'more about translation and localisation.\n'
'\n'
'For more help on localisation, visit the [localization '
'guide](http://docs.translatehouse.org/projects/'
'localization-guide/en/latest/guide/start.html).'),
'virtual_path': "announcements/projects/"+tutorial.code,
}
self._create_object(Announcement, **criteria)
def git_plugin_base(tmpdir, settings):
from pootle_fs.utils import FSPlugin
from pootle_project.models import Project
with get_dir_util() as dir_util:
dir_util.copy_tree(settings.POOTLE_FS_PATH, str(tmpdir))
settings.POOTLE_FS_WORKING_PATH = str(tmpdir)
for project_code in ["project_0", "project_1"]:
project = Project.objects.get(code="git_%s" % project_code)
repo_path = os.path.join(settings.POOTLE_FS_PATH,
"__git_src_%s__" % project_code)
project.config["pootle_fs.fs_type"] = "git"
project.config["pootle_fs.fs_url"] = repo_path
project.config["pootle_fs.translation_mappings"] = {
"default": "/<language_code>/<dir_path>/<filename>.<ext>"
}
plugin = FSPlugin(project)
if os.path.exists(project.local_fs_path):
origin = plugin.repo.remotes.origin
cw = origin.config_writer
cw.set("url", plugin.fs_url)
cw.release()
def hg_env(post_db_setup, _django_cursor_wrapper):
from django.conf import settings
import pytest_pootle
from pytest_pootle.factories import (
ProjectDBFactory, TranslationProjectFactory)
from pootle_fs.utils import FSPlugin
from pootle_language.models import Language
import tempfile
with _django_cursor_wrapper:
project0 = ProjectDBFactory(
source_language=Language.objects.get(code="en"),
code="hg_project_0")
language0 = Language.objects.get(code="language0")
TranslationProjectFactory(project=project0, language=language0)
initial_src_path = os.path.abspath(
os.path.join(
os.path.dirname(pytest_pootle.__file__),
"data/fs/example_fs"))
fs_dir = tempfile.mkdtemp()
settings.POOTLE_FS_PATH = fs_dir
repo_path = os.path.join(fs_dir, "__hg_src_project_0__")
hglib.init(repo_path)
with tmp_hg(repo_path) as (tmp_repo_path, tmp_repo):
with get_dir_util() as dir_util:
dir_util.copy_tree(initial_src_path, tmp_repo_path)
tmp_repo.add()
tmp_repo.commit("Initial commit")
tmp_repo.push()
project0.config["pootle_fs.fs_type"] = "hg"
project0.config["pootle_fs.fs_url"] = repo_path
project0.config["pootle_fs.translation_paths"] = {
"default": "/<language_code>/<dir_path>/<filename>.<ext>"}
plugin = FSPlugin(project0)
plugin.add()
plugin.fetch()
plugin.sync()
# create_test_suite(plugin)
project1 = ProjectDBFactory(
source_language=Language.objects.get(code="en"),
code="hg_project_1")
TranslationProjectFactory(project=project1, language=language0)
repo_path = os.path.join(fs_dir, "__hg_src_project_1__")
hglib.init(repo_path)
with tmp_hg(repo_path) as (tmp_repo_path, tmp_repo):
with get_dir_util() as dir_util:
dir_util.copy_tree(initial_src_path, tmp_repo_path)
tmp_repo.add()
tmp_repo.commit("Initial commit")
tmp_repo.push()
project1.config["pootle_fs.fs_type"] = "hg"
project1.config["pootle_fs.fs_url"] = repo_path
project1.config["pootle_fs.translation_paths"] = {
"default": "/<language_code>/<dir_path>/<filename>.<ext>"}
def test_fs_plugin_fetch_bad(project0):
plugin = FSPlugin(project0)
plugin.clear_repo()
with pytest.raises(FSStateError):
plugin.add()
def __test_plugin_pull(hg_project_1):
hg_plugin = FSPlugin(hg_project_1)
assert hg_plugin.is_cloned is False
hg_plugin.pull()
assert hg_plugin.is_cloned is True
