def save(self, response_url=None, commit=True):
tp = self.instance
initialize_from_templates = False
if tp.id is None:
initialize_from_templates = tp.can_be_inited_from_templates()
tp = super(TranslationProjectForm, self).save(commit)
project = tp.project
config = ObjectConfig(project)
mappings = config.get("pootle.core.lang_mapping", {})
mappings = dict((v, k) for k, v in mappings.iteritems())
if not self.cleaned_data["fs_code"]:
if tp.language.code in mappings:
del mappings[tp.language.code]
else:
mappings[tp.language.code] = self.cleaned_data["fs_code"]
config["pootle.core.lang_mapping"] = dict(
(v, k) for k, v in mappings.iteritems())
if initialize_from_templates:
def _enqueue_job():
queue = get_queue('default')
queue.enqueue(
update_translation_project,
tp,
response_url)
connection.on_commit(_enqueue_job)
return tp
def test_apiview_get_multi_config(rf):
"""Tests retrieving a single object with an m2m field using the API."""
view = UserConfigAPIView.as_view()
user0 = UserFactory.create(username='******')
user1 = UserFactory.create(username='******')
request = create_api_request(rf)
response = view(request)
response_data = json.loads(response.content)
for model in response_data["models"]:
assert model["foo0"] is None
assert model["foo1"] is None
user_config = ObjectConfig(user0)
user_config["foo0.bar"] = "user0.foo0.baz"
user_config["foo1.bar"] = "user0.foo1.baz"
user_config = ObjectConfig(user1)
user_config["foo0.bar"] = "user1.foo0.baz"
user_config["foo1.bar"] = "user1.foo1.baz"
request = create_api_request(rf)
response = view(request)
response_data = json.loads(response.content)
for model in response_data["models"]:
if model["username"] in ["user0", "user1"]:
model["foo0"] == "%s.foo0.baz" % model["username"]
model["foo1"] == "%s.foo1.baz" % model["username"]
def save(self, response_url=None, commit=True):
tp = self.instance
initialize_from_templates = False
if tp.id is None:
initialize_from_templates = tp.can_be_inited_from_templates()
tp = super(TranslationProjectForm, self).save(commit)
project = tp.project
config = ObjectConfig(project)
mappings = config.get("pootle.core.lang_mapping", {})
mappings = dict((v, k) for k, v in mappings.iteritems())
if not self.cleaned_data["fs_code"]:
if tp.language.code in mappings:
del mappings[tp.language.code]
else:
mappings[tp.language.code] = self.cleaned_data["fs_code"]
config["pootle.core.lang_mapping"] = dict(
(v, k) for k, v in mappings.iteritems())
if initialize_from_templates:
def _enqueue_job():
queue = get_queue('default')
queue.enqueue(update_translation_project, tp, response_url)
connection.on_commit(_enqueue_job)
return tp
def test_config_object_util():
project = Project.objects.first()
conf = ObjectConfig(project)
assert conf.items() == conf.values() == conf.keys() == []
# keys are returned order by key
other_dict = OrderedDict()
other_dict["foo.a"] = "bar"
other_dict["foo.b"] = dict(bar=23)
other_dict["foo.c"] = [1, 2, 3]
conf["foo.a"] = "bar"
conf["foo.b"] = dict(bar=23)
conf["foo.c"] = [1, 2, 3]
assert conf.items() == other_dict.items()
assert conf.values() == other_dict.values()
assert conf.keys() == other_dict.keys()
assert [x for x in conf] == other_dict.keys()
assert all(x in conf for x in other_dict)
assert all(conf[k] == v for k, v in other_dict.items())
assert all(conf.get(k) == v for k, v in other_dict.items())
assert conf.get("DOESNOTEXIST") is None
assert conf.get("DOESNOTEXIST", "foo") == "foo"
with pytest.raises(KeyError):
conf["DOESNOTEXIST"]
assert ObjectConfig(project).items() == other_dict.items()
assert ObjectConfig(project).values() == other_dict.values()
assert ObjectConfig(project).keys() == other_dict.keys()
assert [x for x in ObjectConfig(project)] == other_dict.keys()
assert all(x in ObjectConfig(project) for x in other_dict)
assert all(ObjectConfig(project)[k] == v for k, v in other_dict.items())
assert all(ObjectConfig(project).get(k) == v for k, v in other_dict.items())
assert ObjectConfig(project).get("DOESNOTEXIST") is None
assert ObjectConfig(project).get("DOESNOTEXIST", "foo") == "foo"
with pytest.raises(KeyError):
ObjectConfig(project)["DOESNOTEXIST"]
def delete_existing(self, tp, commit=True):
config = ObjectConfig(tp.project)
mapping = config.get("pootle.core.lang_mapping", {})
if tp.language.code in mapping:
del mapping[tp.language.code]
config["pootle.core.lang_mapping"] = mapping
super(TranslationProjectFormSet, self).delete_existing(tp,
commit=commit)
def delete_existing(self, tp, commit=True):
config = ObjectConfig(tp.project)
mapping = config.get("pootle.core.lang_mapping", {})
if tp.language.code in mapping:
del mapping[tp.language.code]
config["pootle.core.lang_mapping"] = mapping
super(TranslationProjectFormSet, self).delete_existing(
tp, commit=commit)
def serialize_config(self, info, item):
config = ObjectConfig(item)
for k, v in self.config:
if k == "fs_mapping":
mapping = config.get(v) or {}
info[k] = mapping.get("default")
else:
info[k] = config.get(v)
info["template_name"] = (
item.lang_mapper.get_upstream_code("templates"))
def serialize_config(self, info, item):
config = ObjectConfig(item)
for k, v in self.config:
if k == "fs_mapping":
mapping = config.get(v) or {}
info[k] = mapping.get("default")
else:
info[k] = config.get(v)
info["template_name"] = (
item.lang_mapper.get_upstream_code("templates"))
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_apiview_get_single_config(rf):
"""Tests retrieving a single object with an m2m field using the API."""
view = UserConfigAPIView.as_view()
user0 = UserFactory.create(username='******')
user1 = UserFactory.create(username='******')
request = create_api_request(rf)
response = view(request, id=user0.id)
response_data = json.loads(response.content)
assert response_data["foo0"] is None
assert response_data["foo1"] is None
# string config
user_config = ObjectConfig(user1)
user_config["foo0.bar"] = "foo0.baz"
user_config["foo1.bar"] = "foo1.baz"
request = create_api_request(rf)
response = view(request, id=user1.id)
response_data = json.loads(response.content)
assert response_data["foo0"] == "foo0.baz"
assert response_data["foo1"] == "foo1.baz"
# list config
user_config["foo0.bar"] = ["foo0.baz"]
user_config["foo1.bar"] = ["foo1.baz"]
request = create_api_request(rf)
response = view(request, id=user1.id)
response_data = json.loads(response.content)
assert response_data["foo0"] == ["foo0.baz"]
assert response_data["foo1"] == ["foo1.baz"]
def tp0_store(po_directory, settings, tp0, fs_src):
from pootle_config.utils import ObjectConfig
from .store import _require_store
conf = ObjectConfig(tp0.project)
conf["pootle_fs.fs_type"] = "localfs"
conf["pootle_fs.fs_url"] = fs_src
conf["pootle_fs.translation_paths"] = OrderedDict(TRANSLATION_PATHS)
return _require_store(tp0, settings.POOTLE_TRANSLATION_DIRECTORY,
'project0_fs.po')
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 _test_mapper(project, debug=False):
project.config.reload()
mapper = lang_mapper.get(project.__class__, instance=project)
assert mapper.site_config.items() == SiteConfig().items()
assert mapper.project.config.items() == ObjectConfig(project).items()
assert mapper.project_mappings == ObjectConfig(project).get(
"pootle.core.lang_mapping", {})
assert mapper.project_presets == ObjectConfig(project).get(
"pootle.core.use_lang_mapping_presets", [])
assert mapper.site_presets == SiteConfig().get(
"pootle.core.lang_mapping_presets", {})
_preset_mappings = OrderedDict()
for preset_name in mapper.project_presets:
if preset_name not in mapper.site_presets:
continue
_preset_mappings.update(mapper.site_presets[preset_name])
assert mapper.mappings_from_presets == _preset_mappings
_mapping = OrderedDict()
def _add_lang_to_mapping(upstream_code, pootle_code):
# as its a 1 to 1 mapping remove any previous items with
# same value
if pootle_code in _mapping.values():
for k, v in _mapping.items():
if v == pootle_code:
del _mapping[k]
break
_mapping[upstream_code] = pootle_code
mappings = OrderedDict(mapper.mappings_from_presets)
mappings.update(OrderedDict(mapper.project_mappings))
for upstream_code, pootle_code in mappings.items():
_add_lang_to_mapping(upstream_code, pootle_code)
assert mapper.lang_mappings == _mapping
assert len(_mapping.values()) == len(set(_mapping.values()))
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_lang_mapper_mappings(english):
project = ProjectDBFactory(source_language=english)
_test_mapper(project)
ObjectConfig(project)["pootle.core.lang_mapping"] = dict(lang0="language0")
_test_mapper(project)
ObjectConfig(project)["pootle.core.lang_mapping"] = dict(
lang0="language1", lang1="language0")
_test_mapper(project)
SiteConfig()["pootle.core.lang_mapping_presets"] = dict(
preset_1=dict(lang0="language1", lang1="language0"))
_test_mapper(project)
ObjectConfig(project)["pootle.core.lang_mapping"] = dict(
lang0="language1", lang1="en")
_test_mapper(project)
ObjectConfig(project)["pootle.core.use_lang_mapping_presets"] = ["preset_1"]
_test_mapper(project)
ObjectConfig(project)["pootle.core.use_lang_mapping_presets"] = [
"preset_1", "preset_2"]
_test_mapper(project)
ObjectConfig(project)["pootle.core.lang_mapping"] = dict(lang1="language1")
_test_mapper(project, True)
def serialize_config(self, info, item):
config = ObjectConfig(item)
for k, v in self.config:
info[k] = config.get(v)
def config(self):
return ObjectConfig(self)
def test_config_object_util(no_config_env):
project = Project.objects.first()
conf = ObjectConfig(project)
assert conf.items() == conf.values() == conf.keys() == []
# keys are returned order by key
other_dict = OrderedDict()
other_dict["foo.a"] = "bar"
other_dict["foo.b"] = dict(bar=23)
other_dict["foo.c"] = [1, 2, 3]
conf["foo.a"] = "bar"
conf["foo.b"] = dict(bar=23)
conf["foo.c"] = [1, 2, 3]
assert conf.items() == other_dict.items()
assert conf.values() == other_dict.values()
assert conf.keys() == other_dict.keys()
assert [x for x in conf] == other_dict.keys()
assert all(x in conf for x in other_dict)
assert all(conf[k] == v for k, v in other_dict.items())
assert all(conf.get(k) == v for k, v in other_dict.items())
assert conf.get("DOESNOTEXIST") is None
assert conf.get("DOESNOTEXIST", "foo") == "foo"
with pytest.raises(KeyError):
conf["DOESNOTEXIST"]
assert ObjectConfig(project).items() == other_dict.items()
assert ObjectConfig(project).values() == other_dict.values()
assert ObjectConfig(project).keys() == other_dict.keys()
assert [x for x in ObjectConfig(project)] == other_dict.keys()
assert all(x in ObjectConfig(project) for x in other_dict)
assert all(ObjectConfig(project)[k] == v for k, v in other_dict.items())
assert all(
ObjectConfig(project).get(k) == v for k, v in other_dict.items())
assert ObjectConfig(project).get("DOESNOTEXIST") is None
assert ObjectConfig(project).get("DOESNOTEXIST", "foo") == "foo"
with pytest.raises(KeyError):
ObjectConfig(project)["DOESNOTEXIST"]
def serialize_config(self, info, item):
config = ObjectConfig(item)
for k, v in self.config:
info[k] = config.get(v)