def get_context_data(self, **kwargs):
languages = Language.objects.exclude(code='templates')
language_choices = [(lang.id, unicode(lang)) for lang in languages]
try:
english = Language.objects.get(code='en')
default_language = english.id
except Language.DoesNotExist:
default_language = languages[0].id
filetypes = []
for info in formats.get().values():
filetypes.append([info["pk"], info["display_title"]])
project_checker_choices = [
(checker, checker) for checker in sorted(PROJECT_CHECKERS.keys())
]
plugin_choices = sorted([(x, x) for x in fs_plugins.gather()])
fs_presets = FS_PRESETS.values()
return {
'page': 'admin-projects',
'form_choices': {
'checkstyle': project_checker_choices,
'filetypes': filetypes,
'fs_plugin': plugin_choices,
'fs_preset': fs_presets,
'source_language': language_choices,
'defaults': {
'source_language': default_language,
},
},
}
def test_format_chooser():
project = Project.objects.get(code="project0")
registry = formats.get()
po = Format.objects.get(name="po")
po2 = registry.register("special_po_2", "po")
po3 = registry.register("special_po_3", "po")
xliff = Format.objects.get(name="xliff")
project.filetypes.add(xliff)
project.filetypes.add(po2)
project.filetypes.add(po3)
filetype_tool = project.filetype_tool
assert filetype_tool.choose_filetype("foo.po") == po
assert filetype_tool.choose_filetype("foo.pot") == po
assert filetype_tool.choose_filetype("foo.xliff") == xliff
# push po to the back of the queue
project.filetypes.remove(po)
project.filetypes.add(po)
assert filetype_tool.choose_filetype("foo.po") == po2
assert filetype_tool.choose_filetype("foo.pot") == po
assert filetype_tool.choose_filetype("foo.xliff") == xliff
with pytest.raises(UnrecognizedFiletype):
filetype_tool.choose_filetype("foo.bar")
def get_context_data(self, **kwargs):
languages = Language.objects.exclude(code='templates')
language_choices = [(lang.id, unicode(lang)) for lang in languages]
try:
english = Language.objects.get(code='en')
default_language = english.id
except Language.DoesNotExist:
default_language = languages[0].id
filetypes = []
for info in formats.get().values():
filetypes.append(
[info["pk"], info["display_title"]])
return {
'page': 'admin-projects',
'form_choices': {
'checkstyle': Project.checker_choices,
'filetypes': filetypes,
'source_language': language_choices,
'treestyle': Project.treestyle_choices,
'defaults': {
'source_language': default_language,
},
},
}
def get_context_data(self, **kwargs):
languages = Language.objects.exclude(code="templates")
language_choices = [(lang.id, unicode(lang)) for lang in languages]
try:
english = Language.objects.get(code="en")
default_language = english.id
except Language.DoesNotExist:
default_language = languages[0].id
filetypes = []
for info in formats.get().values():
filetypes.append([info["pk"], info["display_title"]])
project_checker_choices = [(checker, checker) for checker in sorted(PROJECT_CHECKERS.keys())]
return {
"page": "admin-projects",
"form_choices": {
"checkstyle": project_checker_choices,
"filetypes": filetypes,
"source_language": language_choices,
"treestyle": Project.treestyle_choices,
"defaults": {"source_language": default_language},
},
}
def test_format_chooser(project0):
registry = formats.get()
po = Format.objects.get(name="po")
po2 = registry.register("special_po_2", "po")
po3 = registry.register("special_po_3", "po")
xliff = Format.objects.get(name="xliff")
project0.filetypes.add(xliff)
project0.filetypes.add(po2)
project0.filetypes.add(po3)
filetype_tool = project0.filetype_tool
from pootle.core.debug import debug_sql
with debug_sql():
assert filetype_tool.choose_filetype("foo.po") == po
assert filetype_tool.choose_filetype("foo.pot") == po
assert filetype_tool.choose_filetype("foo.xliff") == xliff
# push po to the back of the queue
project0.filetypes.remove(po)
project0.filetypes.add(po)
assert filetype_tool.choose_filetype("foo.po") == po2
assert filetype_tool.choose_filetype("foo.pot") == po
assert filetype_tool.choose_filetype("foo.xliff") == xliff
with pytest.raises(UnrecognizedFiletype):
filetype_tool.choose_filetype("foo.bar")
def test_format_chooser():
project = Project.objects.get(code="project0")
registry = formats.get()
po = Format.objects.get(name="po")
po2 = registry.register("special_po_2", "po")
po3 = registry.register("special_po_3", "po")
xliff = Format.objects.get(name="xliff")
project.filetypes.add(xliff)
project.filetypes.add(po2)
project.filetypes.add(po3)
filetype_tool = project.filetype_tool
assert filetype_tool.choose_filetype("foo.po") == po
assert filetype_tool.choose_filetype("foo.pot") == po
assert filetype_tool.choose_filetype("foo.xliff") == xliff
# push po to the back of the queue
project.filetypes.remove(po)
project.filetypes.add(po)
assert filetype_tool.choose_filetype("foo.po") == po2
assert filetype_tool.choose_filetype("foo.pot") == po
assert filetype_tool.choose_filetype("foo.xliff") == xliff
with pytest.raises(UnrecognizedFiletype):
filetype_tool.choose_filetype("foo.bar")
def test_store_get_template_file_class(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.get_file_class()
class CustomFormatClass(object):
pass
@provider(format_classes)
def format_class_provider(**kwargs):
return dict(foo=CustomFormatClass)
assert store.get_file_class() == CustomFormatClass
format_classes.disconnect(format_class_provider)
def get_context_data(self, **kwargs):
languages = Language.objects.exclude(code='templates')
language_choices = [(lang.id, unicode(lang)) for lang in languages]
try:
english = Language.objects.get(code='en')
default_language = english.id
except Language.DoesNotExist:
default_language = languages[0].id
filetypes = []
for info in formats.get().values():
filetypes.append(
[info["pk"], info["display_title"]])
project_checker_choices = [
(checker, checker)
for checker
in sorted(PROJECT_CHECKERS.keys())]
plugin_choices = sorted([(x, x) for x in fs_plugins.gather()])
fs_presets = FS_PRESETS.values()
return {
'page': 'admin-projects',
'form_choices': {
'checkstyle': project_checker_choices,
'filetypes': filetypes,
'fs_plugin': plugin_choices,
'fs_preset': fs_presets,
'source_language': language_choices,
'defaults': {
'source_language': default_language,
},
},
}
def test_admin_view_projects(client, request_users, english):
user = request_users["user"]
client.login(username=user.username, password=request_users["password"])
response = client.get(reverse("pootle-admin-projects"))
if not user.is_superuser:
assert response.status_code == 403
return
languages = Language.objects.exclude(code='templates')
language_choices = [(lang.id, unicode(lang)) for lang in languages]
filetypes = []
for info in formats.get().values():
filetypes.append([info["pk"], info["display_title"]])
project_checker_choices = [(checker, checker)
for checker in sorted(PROJECT_CHECKERS.keys())]
expected = {
'page': 'admin-projects',
'form_choices': {
'checkstyle': project_checker_choices,
'filetypes': filetypes,
'source_language': language_choices,
'treestyle': Project.treestyle_choices,
'defaults': {
'source_language': english.id
}
}
}
for k, v in expected.items():
assert response.context_data[k] == v
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 po2():
from pootle.core.delegate import formats
registry = formats.get()
# register po2
return registry.register("special_po_2", "po2", template_extension="pot2")
def test_format_chooser(project0):
registry = formats.get()
po = Format.objects.get(name="po")
po2 = registry.register("special_po_2", "po")
po3 = registry.register("special_po_3", "po")
xliff = Format.objects.get(name="xliff")
project0.filetypes.add(xliff)
project0.filetypes.add(po2)
project0.filetypes.add(po3)
filetype_tool = project0.filetype_tool
from pootle.core.debug import debug_sql
with debug_sql():
assert filetype_tool.choose_filetype("foo.po") == po
assert filetype_tool.choose_filetype("foo.pot") == po
assert filetype_tool.choose_filetype("foo.xliff") == xliff
# push po to the back of the queue
project0.filetypes.remove(po)
project0.filetypes.add(po)
assert filetype_tool.choose_filetype("foo.po") == po2
assert filetype_tool.choose_filetype("foo.pot") == po
assert filetype_tool.choose_filetype("foo.xliff") == xliff
with pytest.raises(UnrecognizedFiletype):
filetype_tool.choose_filetype("foo.bar")
def test_admin_view_projects(client, request_users, english):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get(
reverse(
"pootle-admin-projects"))
if not user.is_superuser:
assert response.status_code == 403
return
languages = Language.objects.exclude(code='templates')
language_choices = [(lang.id, unicode(lang)) for lang in languages]
filetypes = []
for info in formats.get().values():
filetypes.append(
[info["pk"], info["display_title"]])
expected = {
'page': 'admin-projects',
'form_choices': {
'checkstyle': Project.checker_choices,
'filetypes': filetypes,
'source_language': language_choices,
'treestyle': Project.treestyle_choices,
'defaults': {
'source_language': english.id}}}
for k, v in expected.items():
assert response.context_data[k] == v
def po2():
from pootle.core.delegate import formats
registry = formats.get()
# register po2
return registry.register(
"special_po_2", "po2", template_extension="pot2")
def test_format_registry_object(no_formats):
format_registry = formats.get()
assert isinstance(format_registry, FormatRegistry)
assert format_registry.keys() == []
format_registry.initialize()
assert set(format_registry.keys()) == set([x[0] for x in POOTLE_FORMATS])
for filetype in POOTLE_FORMATS:
format_registry[filetype[0]] == filetype[1]
def test_format_registry_object(no_formats):
format_registry = formats.get()
assert isinstance(format_registry, FormatRegistry)
assert format_registry.keys() == []
format_registry.initialize()
assert set(format_registry.keys()) == set([x[0] for x in POOTLE_FORMATS])
for filetype in POOTLE_FORMATS:
format_registry[filetype[0]] == filetype[1]
def test_store_create():
tp = TranslationProject.objects.get(
language__code="language0", project__code="project0")
project = tp.project
registry = formats.get()
po = Format.objects.get(name="po")
po2 = registry.register("special_po_2", "po")
po3 = registry.register("special_po_3", "po")
xliff = Format.objects.get(name="xliff")
project.filetypes.add(xliff)
project.filetypes.add(po2)
project.filetypes.add(po3)
store = Store.objects.create(
name="store.po",
parent=tp.directory,
translation_project=tp)
assert store.filetype == po
assert not store.is_template
store = Store.objects.create(
name="store.pot",
parent=tp.directory,
translation_project=tp)
# not in source_language folder
assert not store.is_template
assert store.filetype == po
store = Store.objects.create(
name="store.xliff",
parent=tp.directory,
translation_project=tp)
assert store.filetype == xliff
# push po to the back of the queue
project.filetypes.remove(po)
project.filetypes.add(po)
store = Store.objects.create(
name="another_store.po",
parent=tp.directory,
translation_project=tp)
assert store.filetype == po2
store = Store.objects.create(
name="another_store.pot",
parent=tp.directory,
translation_project=tp)
assert store.filetype == po
store = Store.objects.create(
name="another_store.xliff",
parent=tp.directory,
translation_project=tp)
with pytest.raises(UnrecognizedFiletype):
store = Store.objects.create(
name="another_store.foo",
parent=tp.directory,
translation_project=tp)
def migrate_localfiletype(apps, schema_editor):
format_registry = formats.get()
projects = apps.get_model("pootle_project.Project").objects.all()
filetypes = apps.get_model("pootle_format.Format").objects.all()
for project in projects:
filetype = filetypes.get(
pk=format_registry[project.localfiletype]['pk'])
if filetype not in project.filetypes.all():
project.filetypes.add(filetype)
def migrate_store_filetypes(apps, schema_editor):
format_registry = formats.get()
projects = apps.get_model("pootle_project.Project").objects.all()
stores = apps.get_model("pootle_store.Store").objects.all()
filetypes = apps.get_model("pootle_format.Format").objects.all()
for project in projects:
for filetype in project.filetypes.all():
stores = (
stores.filter(translation_project__project=project)
.filter(filetype__isnull=True)
.filter(name__endswith=".%s" % filetype.extension))
stores.update(filetype=filetype)
def migrate_store_is_template(apps, schema_editor):
format_registry = formats.get()
tps = apps.get_model("pootle_translationproject.TranslationProject").objects.all()
for tp in tps:
try:
project = tp.project
except apps.get_model("pootle_project.Project").DoesNotExist:
logger.warn("TP with missing project '%s', not updating", tp.pootle_path)
continue
if tp.language == tp.project.source_language or tp.language.code == "templates":
tp.stores.update(is_template=True)
else:
tp.stores.update(is_template=False)
def migrate_store_filetypes(apps, schema_editor):
format_registry = formats.get()
projects = apps.get_model("pootle_project.Project").objects.all()
for project in projects:
for filetype in project.filetypes.all():
(apps.get_model("pootle_store.Store").objects.all()
.filter(translation_project__project=project)
.filter(name__endswith=".%s" % filetype.extension.name)
.update(filetype=filetype))
if filetype.extension != filetype.template_extension:
(apps.get_model("pootle_store.Store").objects.all()
.filter(translation_project__project=project)
.filter(name__endswith=".%s" % filetype.template_extension.name)
.update(filetype=filetype))
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_store_create(tp0):
tp = tp0
project = tp.project
registry = formats.get()
po = Format.objects.get(name="po")
po2 = registry.register("special_po_2", "po")
po3 = registry.register("special_po_3", "po")
xliff = Format.objects.get(name="xliff")
project.filetypes.add(xliff)
project.filetypes.add(po2)
project.filetypes.add(po3)
store = Store.objects.create(name="store.po",
parent=tp.directory,
translation_project=tp)
assert store.filetype == po
assert not store.is_template
store = Store.objects.create(name="store.pot",
parent=tp.directory,
translation_project=tp)
# not in source_language folder
assert not store.is_template
assert store.filetype == po
store = Store.objects.create(name="store.xliff",
parent=tp.directory,
translation_project=tp)
assert store.filetype == xliff
# push po to the back of the queue
project.filetypes.remove(po)
project.filetypes.add(po)
store = Store.objects.create(name="another_store.po",
parent=tp.directory,
translation_project=tp)
assert store.filetype == po2
store = Store.objects.create(name="another_store.pot",
parent=tp.directory,
translation_project=tp)
assert store.filetype == po
store = Store.objects.create(name="another_store.xliff",
parent=tp.directory,
translation_project=tp)
with pytest.raises(UnrecognizedFiletype):
store = Store.objects.create(name="another_store.foo",
parent=tp.directory,
translation_project=tp)
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_format_set_tp_from_store_filetype(po_directory, templates,
language0, po, po2):
project = ProjectDBFactory(source_language=templates)
filetypes = project.filetype_tool
registry = formats.get()
templates_tp = TranslationProjectFactory(language=templates, project=project)
lang_tp = TranslationProjectFactory(language=language0, project=project)
template = Store.objects.create(
name="mystore.pot",
translation_project=templates_tp,
parent=templates_tp.directory)
store = Store.objects.create(
name="mystore.po",
translation_project=lang_tp,
parent=lang_tp.directory)
po3 = registry.register(
"special_po_3", "po3", template_extension="pot3")
filetypes.add_filetype(po2)
filetypes.add_filetype(po3)
# this does nothing as the stores are currently po
filetypes.set_tp_filetype(lang_tp, po3, from_filetype=po2)
store = Store.objects.get(pk=store.pk)
assert store.filetype == po
assert store.name.endswith(".po")
filetypes.set_tp_filetype(templates_tp, po3, from_filetype=po2)
template = Store.objects.get(pk=template.pk)
assert template.filetype == po
assert template.name.endswith(".pot")
# it works if we switch to po2 first
filetypes.set_tp_filetype(lang_tp, po2, from_filetype=po)
filetypes.set_tp_filetype(templates_tp, po2, from_filetype=po)
filetypes.set_tp_filetype(lang_tp, po3, from_filetype=po2)
store = Store.objects.get(pk=store.pk)
assert store.filetype == po3
assert store.name.endswith(".po3")
filetypes.set_tp_filetype(templates_tp, po3, from_filetype=po2)
template = Store.objects.get(pk=template.pk)
assert template.filetype == po3
assert template.name.endswith(".pot3")
def test_format_set_tp_filetype(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_format_set_templates_tp_filetype(po_directory, templates, po2):
project = ProjectDBFactory(source_language=templates)
filetypes = project.filetype_tool
registry = formats.get()
templates_tp = TranslationProjectFactory(language=templates, project=project)
template = Store.objects.create(
name="mystore.pot",
translation_project=templates_tp,
parent=templates_tp.directory)
filetypes.add_filetype(po2)
filetypes.set_tp_filetype(templates_tp, po2)
template = Store.objects.get(pk=template.pk)
assert template.filetype == po2
assert template.name.endswith(".pot2")
po3 = registry.register(
"special_po_3", "po3", template_extension="pot3")
filetypes.add_filetype(po3)
filetypes.set_tp_filetype(templates_tp, po3)
template = Store.objects.get(pk=template.pk)
assert template.filetype == po3
assert template.name.endswith(".pot3")
def test_format_set_native_store_filetype(po_directory, templates,
language0, po2, english):
project = ProjectDBFactory(source_language=english)
filetypes = project.filetype_tool
registry = formats.get()
templates_tp = TranslationProjectFactory(language=templates, project=project)
lang_tp = TranslationProjectFactory(language=language0, project=project)
template = Store.objects.create(
name="mystore.pot3.pot",
translation_project=templates_tp,
parent=templates_tp.directory)
store = Store.objects.create(
name="mystore.po3.po",
translation_project=lang_tp,
parent=lang_tp.directory)
# register po2 - not native template extension
filetypes.add_filetype(po2)
filetypes.set_store_filetype(store, po2)
assert store.name.endswith(".po3.po2")
assert store.filetype == po2
filetypes.set_store_filetype(template, po2)
assert template.name.endswith(".pot3.pot2")
assert template.filetype == po2
# register po3 - native template extension
po3 = registry.register(
"special_po_3", "po3", template_extension="pot3")
filetypes.add_filetype(po3)
# in this case extension is just removed
filetypes.set_store_filetype(store, po3)
assert not store.name.endswith(".po3.po3")
assert store.name.endswith(".po3")
assert store.filetype == po3
filetypes.set_store_filetype(template, po3)
assert not template.name.endswith(".pot3.pot3")
assert template.name.endswith(".pot3")
assert template.filetype == po3
def test_format_set_template_store_filetype(templates, po):
project = ProjectDBFactory(source_language=templates)
filetypes = project.filetype_tool
tp = TranslationProjectFactory(language=templates, project=project)
registry = formats.get()
store = Store.objects.create(
name="mystore.pot",
translation_project=tp,
parent=tp.directory)
store_name = store.name
assert store.filetype == po
assert store.is_template
assert store.name.endswith(".pot")
# register po2 - same template extension
po2 = registry.register(
"special_po_2", "po2", template_extension="pot")
filetypes.add_filetype(po2)
filetypes.set_store_filetype(store, po2)
# the filetype is changed, but the extension is the same
store = Store.objects.get(pk=store.pk)
assert store.filetype == po2
assert store.name == store_name
# register po3 - same template extension
po3 = registry.register(
"special_po_3", "po", template_extension="pot3")
filetypes.add_filetype(po3)
filetypes.set_store_filetype(store, po3)
# the filetype and extension are changed
store = Store.objects.get(pk=store.pk)
assert store.filetype == po3
assert store.name.endswith(".pot3")
# does nothing
filetypes.set_store_filetype(store, po3)
assert store.filetype == po3
def test_format_set_tp_from_store_filetype(po_directory, templates, language0,
po, po2):
project = ProjectDBFactory(source_language=templates)
filetypes = project.filetype_tool
registry = formats.get()
templates_tp = TranslationProjectFactory(language=templates,
project=project)
lang_tp = TranslationProjectFactory(language=language0, project=project)
template = Store.objects.create(name="mystore.pot",
translation_project=templates_tp,
parent=templates_tp.directory)
store = Store.objects.create(name="mystore.po",
translation_project=lang_tp,
parent=lang_tp.directory)
po3 = registry.register("special_po_3", "po3", template_extension="pot3")
filetypes.add_filetype(po2)
filetypes.add_filetype(po3)
# this does nothing as the stores are currently po
filetypes.set_tp_filetype(lang_tp, po3, from_filetype=po2)
store = Store.objects.get(pk=store.pk)
assert store.filetype == po
assert store.name.endswith(".po")
filetypes.set_tp_filetype(templates_tp, po3, from_filetype=po2)
template = Store.objects.get(pk=template.pk)
assert template.filetype == po
assert template.name.endswith(".pot")
# it works if we switch to po2 first
filetypes.set_tp_filetype(lang_tp, po2, from_filetype=po)
filetypes.set_tp_filetype(templates_tp, po2, from_filetype=po)
filetypes.set_tp_filetype(lang_tp, po3, from_filetype=po2)
store = Store.objects.get(pk=store.pk)
assert store.filetype == po3
assert store.name.endswith(".po3")
filetypes.set_tp_filetype(templates_tp, po3, from_filetype=po2)
template = Store.objects.get(pk=template.pk)
assert template.filetype == po3
assert template.name.endswith(".pot3")
def test_format_set_native_store_filetype(po_directory, templates, language0,
po2, english):
project = ProjectDBFactory(source_language=english)
filetypes = project.filetype_tool
registry = formats.get()
templates_tp = TranslationProjectFactory(language=templates,
project=project)
lang_tp = TranslationProjectFactory(language=language0, project=project)
template = Store.objects.create(name="mystore.pot3.pot",
translation_project=templates_tp,
parent=templates_tp.directory)
store = Store.objects.create(name="mystore.po3.po",
translation_project=lang_tp,
parent=lang_tp.directory)
# register po2 - not native template extension
filetypes.add_filetype(po2)
filetypes.set_store_filetype(store, po2)
assert store.name.endswith(".po3.po2")
assert store.filetype == po2
filetypes.set_store_filetype(template, po2)
assert template.name.endswith(".pot3.pot2")
assert template.filetype == po2
# register po3 - native template extension
po3 = registry.register("special_po_3", "po3", template_extension="pot3")
filetypes.add_filetype(po3)
# in this case extension is just removed
filetypes.set_store_filetype(store, po3)
assert not store.name.endswith(".po3.po3")
assert store.name.endswith(".po3")
assert store.filetype == po3
filetypes.set_store_filetype(template, po3)
assert not template.name.endswith(".pot3.pot3")
assert template.name.endswith(".pot3")
assert template.filetype == po3
def test_format_set_store_filetype(project0):
project = project0
store = Store.objects.exclude(is_template=True).filter(
translation_project__project=project).first()
store_name = store.name
registry = formats.get()
filetypes = project.filetype_tool
# register po2
po2 = registry.register(
"special_po_2", "po", template_extension="pot2")
# filetype must be recognized for project
with pytest.raises(UnrecognizedFiletype):
filetypes.set_store_filetype(store, po2)
# add the filetype to the project
filetypes.add_filetype(po2)
# set the store's filetype
filetypes.set_store_filetype(store, po2)
# the filetype is changed, but the extension is the same
store = Store.objects.get(pk=store.pk)
assert store.filetype == po2
assert store.name == store_name
# register po3 - different extension
po3 = registry.register(
"special_po_3", "po3", template_extension="pot3")
filetypes.add_filetype(po3)
filetypes.set_store_filetype(store, po3)
# the filetype is changed, and the extension
store = Store.objects.get(pk=store.pk)
assert store.filetype == po3
assert store.name.endswith(".po3")
assert store.pootle_path.endswith(".po3")
def test_admin_view_projects(client, request_users, english):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get(
reverse(
"pootle-admin-projects"))
if not user.is_superuser:
assert response.status_code == 403
return
languages = Language.objects.exclude(code='templates')
language_choices = [(lang.id, unicode(lang)) for lang in languages]
filetypes = []
for info in formats.get().values():
filetypes.append(
[info["pk"], info["display_title"]])
project_checker_choices = [
(checker, checker)
for checker
in sorted(PROJECT_CHECKERS.keys())]
plugin_choices = [(x, x) for x in fs_plugins.gather()]
expected = {
'page': 'admin-projects',
'form_choices': {
'checkstyle': project_checker_choices,
'fs_plugin': plugin_choices,
'filetypes': filetypes,
'fs_preset': FS_PRESETS,
'source_language': language_choices,
'defaults': {
'source_language': english.id}}}
for k, v in expected.items():
assert response.context_data[k] == v
def test_format_set_template_store_filetype(po_directory, templates, po):
project = ProjectDBFactory(source_language=templates)
filetypes = project.filetype_tool
tp = TranslationProjectFactory(language=templates, project=project)
registry = formats.get()
store = Store.objects.create(name="mystore.pot",
translation_project=tp,
parent=tp.directory)
store_name = store.name
assert store.filetype == po
assert store.is_template
assert store.name.endswith(".pot")
# register po2 - same template extension
po2 = registry.register("special_po_2", "po2", template_extension="pot")
filetypes.add_filetype(po2)
filetypes.set_store_filetype(store, po2)
# the filetype is changed, but the extension is the same
store = Store.objects.get(pk=store.pk)
assert store.filetype == po2
assert store.name == store_name
# register po3 - same template extension
po3 = registry.register("special_po_3", "po", template_extension="pot3")
filetypes.add_filetype(po3)
filetypes.set_store_filetype(store, po3)
# the filetype and extension are changed
store = Store.objects.get(pk=store.pk)
assert store.filetype == po3
assert store.name.endswith(".pot3")
# does nothing
filetypes.set_store_filetype(store, po3)
assert store.filetype == po3
def test_format_set_store_filetype(project0):
project = project0
store = Store.objects.exclude(is_template=True).filter(
translation_project__project=project).first()
store_name = store.name
registry = formats.get()
filetypes = project.filetype_tool
# register po2
po2 = registry.register("special_po_2", "po", template_extension="pot2")
# filetype must be recognized for project
with pytest.raises(UnrecognizedFiletype):
filetypes.set_store_filetype(store, po2)
# add the filetype to the project
filetypes.add_filetype(po2)
# set the store's filetype
filetypes.set_store_filetype(store, po2)
# the filetype is changed, but the extension is the same
store = Store.objects.get(pk=store.pk)
assert store.filetype == po2
assert store.name == store_name
# register po3 - different extension
po3 = registry.register("special_po_3", "po3", template_extension="pot3")
filetypes.add_filetype(po3)
filetypes.set_store_filetype(store, po3)
# the filetype is changed, and the extension
store = Store.objects.get(pk=store.pk)
assert store.filetype == po3
assert store.name.endswith(".po3")
assert store.pootle_path.endswith(".po3")
def create_formats(self):
from pootle.core.delegate import formats
formats.get().initialize()
def add_arguments(self, parser):
format_names = formats.get().keys()
fs_plugins_names = fs_plugins.gather().keys()
parser.add_argument(
'code',
action='store',
help='Project code',
)
parser.add_argument(
"--name",
action="store",
dest="name",
help="Project name",
)
parser.add_argument(
"--filetype",
action="append",
dest="filetypes",
choices=format_names,
default=[],
help="File types: {0}. Default: po".format(
" | ".join(format_names)),
)
mapping_group = parser.add_mutually_exclusive_group(required=True)
mapping_group.add_argument(
"--preset-mapping",
action="store",
dest="preset_mapping",
choices=FS_PRESETS.keys(),
help="Filesystem layout preset: {0}".format(" | ".join(
FS_PRESETS.keys())),
)
mapping_group.add_argument(
"--mapping",
action="store",
dest="mapping",
help="Custom filesystem layout",
)
parser.add_argument(
"--fs-type",
action="store",
dest="fs_type",
default="localfs",
choices=fs_plugins_names,
help="Filesystem type: {0}".format(" | ".join(fs_plugins_names)),
)
parser.add_argument(
"--fs-url",
action="store",
dest="fs_url",
default="",
help="Filesystem path or URL.",
)
parser.add_argument(
"--source-language",
action="store",
dest="sourcelang",
default="en",
help=("Source language. Examples: [en | es | fr | ...]."
"Default: %(default)s"),
)
parser.add_argument(
"--report-email",
action="store",
default="",
dest="contact",
help="Contact email for reports. Example: [email protected].",
)
parser.add_argument(
"--disabled",
action="store_true",
dest="disabled",
help="Does the project start disabled?",
)
parser.add_argument(
"--checkstyle",
action="store",
dest="checkstyle",
choices=PROJECT_CHECKERS.keys(),
default="standard",
help="Quality check styles. Example: {0}. Default: %(default)s".
format(" | ".join(PROJECT_CHECKERS.keys())),
)
def add_default_formats(apps, schema_editor):
formats.get().initialize()
def add_arguments(self, parser):
format_names = formats.get().keys()
fs_plugins_names = fs_plugins.gather().keys()
parser.add_argument(
'code',
action='store',
help='Project code',
)
parser.add_argument(
"--name",
action="store",
dest="name",
help="Project name",
)
parser.add_argument(
"--filetype",
action="append",
dest="filetypes",
choices=format_names,
default=[],
help="File types: {0}. Default: po".format(
" | ".join(format_names)),
)
mapping_group = parser.add_mutually_exclusive_group(required=True)
mapping_group.add_argument(
"--preset-mapping",
action="store",
dest="preset_mapping",
choices=FS_PRESETS.keys(),
help="Filesystem layout preset: {0}".format(
" | ".join(FS_PRESETS.keys())),
)
mapping_group.add_argument(
"--mapping",
action="store",
dest="mapping",
help="Custom filesystem layout",
)
parser.add_argument(
"--fs-type",
action="store",
dest="fs_type",
default="localfs",
choices=fs_plugins_names,
help="Filesystem type: {0}".format(" | ".join(fs_plugins_names)),
)
parser.add_argument(
"--fs-url",
action="store",
dest="fs_url",
default="",
help="Filesystem path or URL.",
)
parser.add_argument(
"--source-language",
action="store",
dest="sourcelang",
default="en",
help=("Source language. Examples: [en | es | fr | ...]."
"Default: %(default)s"),
)
parser.add_argument(
"--report-email",
action="store",
default="",
dest="contact",
help="Contact email for reports. Example: [email protected].",
)
parser.add_argument(
"--disabled",
action="store_true",
dest="disabled",
help="Does the project start disabled?",
)
parser.add_argument(
"--checkstyle",
action="store",
dest="checkstyle",
choices=PROJECT_CHECKERS.keys(),
default="standard",
help="Quality check styles. Example: {0}. Default: %(default)s"
.format(" | ".join(PROJECT_CHECKERS.keys())),
)
def format_registry():
from pootle.core.delegate import formats
format_registry = formats.get()
format_registry.initialize()
return format_registry
def setup_formats(self):
from pootle.core.delegate import formats
formats.get().initialize()
def no_formats():
from pootle.core.delegate import formats
from pootle_format.models import Format
Format.objects.all().delete()
formats.get().clear()
