def update_exported_revision(self):
if self.has_changes():
revision.get(self.context.__class__)(
self.context).set(keys=["pootle.offline.tm"],
value=self.revision)
if "exported_revision" in self.__dict__:
del self.__dict__["exported_revision"]
def update_exported_revision(self):
if self.has_changes():
revision.get(self.context.__class__)(
self.context).set(keys=["pootle.offline.tm"],
value=self.revision)
if "exported_revision" in self.__dict__:
del self.__dict__["exported_revision"]
def test_languages_revisions():
initial_revision = revision.get(
Directory)(Directory.objects.root).get(key="languages")
new_language = Language.objects.create(code="NEWLANGUAGE")
new_revision = revision.get(
Directory)(Directory.objects.root).get(key="languages")
assert new_revision != initial_revision
new_language.delete()
final_revision = revision.get(
Directory)(Directory.objects.root).get(key="languages")
assert final_revision != new_revision
def fetch(self):
synced = dirsync.sync(
self.fs_url,
self.project.local_fs_path,
"sync",
create=True,
purge=True,
logger=logging.getLogger(dirsync.__name__))
if synced:
revision.get(Project)(self.project).set(
keys=["pootle.fs.fs_hash"], value=uuid.uuid4().hex)
def test_fs_plugin_cache_key(project_fs):
plugin = project_fs
assert plugin.ns == "pootle.fs.plugin"
assert plugin.sw_version == PootleFSConfig.version
assert (plugin.fs_revision == plugin.latest_hash)
assert (plugin.sync_revision == revision.get(Project)(
plugin.project).get(key="pootle.fs.sync"))
assert (plugin.pootle_revision == revision.get(Directory)(
plugin.project.directory).get(key="stats"))
assert (plugin.cache_key == ("%s.%s.%s.%s" %
(plugin.project.code, plugin.pootle_revision,
plugin.sync_revision, plugin.fs_revision)))
def fetch(self):
try:
synced = dirsync.sync(self.fs_url,
self.project.local_fs_path,
"sync",
create=True,
purge=True,
logger=logging.getLogger(dirsync.__name__))
except ValueError as e:
raise FSFetchError(e)
if synced:
revision.get(Project)(self.project).set(keys=["pootle.fs.fs_hash"],
value=uuid.uuid4().hex)
def fetch(self):
try:
synced = sync.sync(
self.fs_url,
self.project.local_fs_path,
"sync",
create=True,
purge=True,
logger=logging.getLogger(sync.__name__))
except ValueError as e:
raise FSFetchError(e)
if synced:
revision.get(Project)(self.project).set(
keys=["pootle.fs.fs_hash"], value=uuid.uuid4().hex)
def cache_key(self):
rev_context = self.object
return (
"all_languages",
self.request_lang,
revision.get(rev_context.__class__)(
rev_context).get(key="languages"))
def test_scores_user(member, system):
score_data = scores.get(member.__class__)(member)
assert isinstance(score_data, UserScores)
assert score_data.ns == "pootle.score.user"
assert score_data.sw_version == PootleScoreConfig.version
assert score_data.context == member
assert score_data.public_score == member.public_score
assert (list(score_data.get_scores_by_language(10)) == list(
score_data.get_scores(10).order_by("tp__language").values(
"tp__language").annotate(Sum("score"))))
top_lang = score_data.get_scores_by_language(20).order_by(
"score__sum").first()
top_lang = Language.objects.get(id=top_lang["tp__language"])
assert (score_data.get_top_language_within(20) == top_lang)
assert (score_data.get_language_top_scores(top_lang) == scores.get(
Language)(top_lang).top_scorers)
top_lang = score_data.get_top_language_within(100)
language_scores = score_data.get_language_top_scores(top_lang)
for index, user_score in enumerate(language_scores):
if user_score['user__username'] == member.username:
assert (score_data.get_top_language(100) == (index + 1, top_lang))
break
assert (score_data.top_language == score_data.get_top_language(30))
project_directory = Directory.objects.get(pootle_path="/projects/")
assert (
score_data.revision == revision.get(Directory)(project_directory).get(
key="stats"))
assert (score_data.cache_key == (
"%s.%s.%s" % (member.id, timezone.now().date(), score_data.revision)))
# system gets no rank
sys_score_data = scores.get(system.__class__)(system)
assert (sys_score_data.top_language == (-1, None))
def test_tp_cache_on_delete(tp0):
proj_revision = revision.get(
tp0.project.directory.__class__)(
tp0.project.directory)
orig_revision = proj_revision.get("stats")
tp0.delete()
assert (
proj_revision.get("stats")
!= orig_revision)
def test_fs_plugin_cache_key(project_fs):
plugin = project_fs
assert plugin.ns == "pootle.fs.plugin"
assert plugin.sw_version == PootleFSConfig.version
assert (
plugin.fs_revision
== plugin.latest_hash)
assert (
plugin.sync_revision
== revision.get(
Project)(plugin.project).get(key="pootle.fs.sync"))
assert (
plugin.pootle_revision
== revision.get(
Directory)(plugin.project.directory).get(key="stats"))
assert (
plugin.cache_key
== ("%s.%s.%s"
% (plugin.pootle_revision,
plugin.sync_revision,
plugin.fs_revision)))
def test_data_cache_keys(language0, project0, subdir0, vfolder0):
# language
assert ('pootle_data.%s.%s.%s' %
(language0.data_tool.cache_key_name, language0.code,
revision.get(Language)(language0).get(
key="stats")) == language0.data_tool.cache_key)
# project
assert ('pootle_data.%s.%s.%s' %
(project0.data_tool.cache_key_name, project0.code,
revision.get(Project)(project0).get(
key="stats")) == project0.data_tool.cache_key)
# directory
assert ('pootle_data.%s.%s.%s' %
(subdir0.data_tool.cache_key_name, subdir0.pootle_path,
revision.get(Directory)(subdir0).get(
key="stats")) == subdir0.data_tool.cache_key)
# projectresource
resource_path = "%s%s" % (project0.pootle_path, subdir0.path)
projectresource = ProjectResource(Directory.objects.none(), resource_path)
assert ('pootle_data.%s.%s.%s' %
(projectresource.data_tool.cache_key_name, resource_path,
revision.get(ProjectResource)(projectresource).get(
key="stats")) == projectresource.data_tool.cache_key)
# projectset
projectset = ProjectSet(Project.objects.all())
assert (
'pootle_data.%s.%s.%s' %
(projectset.data_tool.cache_key_name, "ALL", revision.get(ProjectSet)
(projectset).get(key="stats")) == projectset.data_tool.cache_key)
# vfolders
vfdata = vfolders_data_tool.get(Directory)(subdir0)
assert ('pootle_data.%s.%s.%s' %
(vfdata.cache_key_name, subdir0.pootle_path,
revision.get(subdir0.__class__)(subdir0).get(
key="stats")) == vfdata.cache_key)
def test_data_cache_keys(language0, project0, subdir0, vfolder0):
# language
assert language0.data_tool.ns == "pootle.data"
assert language0.data_tool.sw_version == PootleDataConfig.version
assert (
'%s.%s.%s'
% (language0.data_tool.cache_key_name,
language0.code,
revision.get(Language)(language0).get(key="stats"))
== language0.data_tool.cache_key)
# project
assert project0.data_tool.ns == "pootle.data"
assert project0.data_tool.sw_version == PootleDataConfig.version
assert (
'%s.%s.%s'
% (project0.data_tool.cache_key_name,
project0.code,
revision.get(Project)(project0).get(key="stats"))
== project0.data_tool.cache_key)
# directory
assert subdir0.data_tool.ns == "pootle.data"
assert subdir0.data_tool.sw_version == PootleDataConfig.version
assert (
'%s.%s.%s'
% (subdir0.data_tool.cache_key_name,
subdir0.pootle_path,
revision.get(Directory)(subdir0).get(key="stats"))
== subdir0.data_tool.cache_key)
# projectresource
resource_path = "%s%s" % (project0.pootle_path, subdir0.path)
projectresource = ProjectResource(Directory.objects.none(), resource_path)
assert projectresource.data_tool.ns == "pootle.data"
assert projectresource.data_tool.sw_version == PootleDataConfig.version
assert (
'%s.%s.%s'
% (projectresource.data_tool.cache_key_name,
resource_path,
revision.get(ProjectResource)(projectresource).get(key="stats"))
== projectresource.data_tool.cache_key)
# projectset
projectset = ProjectSet(Project.objects.all())
assert projectset.data_tool.ns == "pootle.data"
assert projectset.data_tool.sw_version == PootleDataConfig.version
assert (
'%s.%s.%s'
% (projectset.data_tool.cache_key_name,
"ALL",
revision.get(ProjectSet)(projectset).get(key="stats"))
== projectset.data_tool.cache_key)
# vfolders
vfdata = vfolders_data_tool.get(Directory)(subdir0)
assert vfdata.ns == "virtualfolder"
assert vfdata.sw_version == PootleDataConfig.version
assert (
'%s.%s.%s'
% (vfdata.cache_key_name,
subdir0.pootle_path,
revision.get(subdir0.__class__)(subdir0).get(key="stats"))
== vfdata.cache_key)
def test_view_welcome(client, member, system, project_set):
response = client.get(reverse('pootle-home'))
assert isinstance(response.context["score_data"], TopScoreDisplay)
assert isinstance(response.context["view"], WelcomeView)
assert response.context["view"].request_lang == get_language()
assert (response.context["view"].project_set.directory ==
project_set.directory)
assert (response.context["view"].revision == revision.get(
project_set.directory.__class__)(
project_set.directory).get(key="stats"))
assert (response.context["view"].cache_key == (
"%s.%s.%s" % (response.wsgi_request.user.username,
response.context["view"].revision, get_language())))
def test_directory_lifecycle_revision(subdir0, tp0, project0, language0):
target = subdir0.child_dirs.create(name="foo")
rev = revision.get(Directory)(target)
# no cache_key on creation
assert not rev.get(key="stats")
target.save()
key = rev.get(key="stats")
assert key
assert key == revision.get(Directory)(subdir0).get(key="stats")
assert key == revision.get(Directory)(tp0.directory).get(key="stats")
assert key == revision.get(Directory)(tp0.directory.parent).get(key="stats")
assert key == revision.get(Directory)(language0.directory).get(key="stats")
target.delete()
new_key = revision.get(Directory)(subdir0).get(key="stats")
assert new_key
assert new_key != key
assert new_key == revision.get(Directory)(tp0.directory).get(key="stats")
assert new_key == revision.get(Directory)(tp0.directory.parent).get(key="stats")
assert new_key == revision.get(Directory)(language0.directory).get(key="stats")
def test_scores_user(member, system):
score_data = scores.get(member.__class__)(member)
assert isinstance(score_data, UserScores)
assert score_data.ns == "pootle.score.user"
assert score_data.sw_version == PootleScoreConfig.version
assert score_data.context == member
assert score_data.public_score == member.public_score
assert(
list(score_data.get_scores_by_language(10))
== list(
score_data.get_scores(10).order_by(
"tp__language").values("tp__language").annotate(Sum("score"))))
top_lang = score_data.get_scores_by_language(20).order_by("score__sum").first()
top_lang = Language.objects.get(id=top_lang["tp__language"])
assert (
score_data.get_top_language_within(20)
== top_lang)
assert (
score_data.get_language_top_scores(top_lang)
== scores.get(Language)(top_lang).top_scorers)
top_lang = score_data.get_top_language_within(100)
language_scores = score_data.get_language_top_scores(top_lang)
for index, user_score in enumerate(language_scores):
if user_score['user__username'] == member.username:
assert (
score_data.get_top_language(100)
== (index + 1, top_lang))
break
assert (
score_data.top_language
== score_data.get_top_language(30))
project_directory = Directory.objects.get(pootle_path="/projects/")
assert (
score_data.revision
== revision.get(Directory)(
project_directory).get(key="stats"))
assert (
score_data.cache_key
== ("%s.%s.%s"
% (member.id,
timezone.now().date(),
score_data.revision)))
# system gets no rank
sys_score_data = scores.get(system.__class__)(system)
assert (
sys_score_data.top_language
== (-1, None))
def _test_scores(ns, context, score_data):
today = localdate()
assert score_data.context == context
assert (
score_data.get_daterange(30)
== (today - timedelta(days=30), today))
assert score_data.ns == "pootle.score.%s" % ns
assert score_data.sw_version == PootleScoreConfig.version
assert list(score_data.score_model.order_by("id")) == list(
UserTPScore.objects.exclude(
user__username__in=User.objects.META_USERS).order_by("id"))
assert (
list(score_data.scores_within_days(5))
== list(score_data.score_model.filter(
date__range=score_data.get_daterange(5))))
assert (
list(score_data.get_scores(5))
== list(score_data.filter_scores(score_data.scores_within_days(5))))
assert (
list(score_data.get_top_scorers(10))
== list(
score_data.get_scores(10).order_by("user__username").values(
"user__username", "user__email", "user__full_name").annotate(
Sum("score"),
Sum("suggested"),
Sum("reviewed"),
Sum("translated")).filter(
score__sum__gt=0).order_by("-score__sum")))
assert (
tuple(score_data.top_scorers)
== tuple(score_data.get_top_scorers(30)))
assert (
score_data.revision
== revision.get(context.directory.__class__)(
context.directory).get(key="stats"))
score_display = score_data.display()
assert isinstance(score_display, TopScoreDisplay)
for i, item in enumerate(score_display):
data = score_data.top_scorers[i]
assert item["public_total_score"] == formatter.number(
round(data["score__sum"]))
assert isinstance(item["user"], DisplayUser)
assert item["user"].username == data["user__username"]
assert item["user"].full_name == data["user__full_name"]
assert item["user"].email == data["user__email"]
score_display = score_data.display(limit=1)
assert len(list(score_display)) <= 1
def test_export_tmx_tp(capfd, tp0, media_test_dir):
"""Export a tp"""
lang_code = tp0.language.code
prj_code = tp0.project.code
call_command('export', '--tmx', '--project=%s' % prj_code,
'--language=%s' % lang_code)
out, err = capfd.readouterr()
rev = revision.get(tp0.__class__)(tp0.directory).get(key="stats")
filename = '%s.%s.%s.tmx.zip' % (tp0.project.code, tp0.language.code,
rev[:10])
assert os.path.join(lang_code, filename) in out
call_command('export', '--tmx', '--project=%s' % prj_code,
'--language=%s' % lang_code)
out, err = capfd.readouterr()
assert 'Translation project (%s) has not been changed' % tp0 in out
def _test_revision_updater(updater):
revisions = revision.get(Directory)
for parent in updater.parents:
assert not revisions(parent).get(key="foo")
assert not revisions(parent).get(key="bar")
updater.update(keys=["foo"])
keys = dict(foo={}, bar={})
for parent in updater.parents:
keys["foo"][parent.id] = revisions(parent).get(key="foo")
assert revisions(parent).get(key="foo")
assert not revisions(parent).get(key="bar")
updater.update(keys=["bar"])
for parent in updater.parents:
keys[parent.id] = revisions(parent).get(key="foo")
assert revisions(parent).get(key="foo") == keys["foo"][parent.id]
assert revisions(parent).get(key="bar")
def test_export_tmx_tp(capfd, tp0):
"""Export a tp"""
lang_code = tp0.language.code
prj_code = tp0.project.code
call_command('export', '--tmx', '--project=%s' % prj_code,
'--language=%s' % lang_code)
out, err = capfd.readouterr()
rev = revision.get(tp0.__class__)(tp0.directory).get(key="stats")
filename = '%s.%s.%s.tmx.zip' % (
tp0.project.fullname.replace(' ', '_'),
tp0.language.code, rev)
assert os.path.join(lang_code, filename) in out
call_command('export', '--tmx', '--project=%s' % prj_code,
'--language=%s' % lang_code)
out, err = capfd.readouterr()
assert 'Translation project (%s) has not been changed' % tp0 in out
def test_view_welcome(client, member, system, project_set):
response = client.get(reverse('pootle-home'))
assert isinstance(response.context["top_scorers"], TopScoreDisplay)
assert isinstance(response.context["view"], WelcomeView)
assert response.context["view"].request_lang == get_language()
assert (
response.context["view"].project_set.directory
== project_set.directory)
assert (
response.context["view"].revision
== revision.get(project_set.directory.__class__)(
project_set.directory).get(key="stats"))
assert (
response.context["view"].cache_key
== (
"%s.%s.%s"
% (response.wsgi_request.user.username,
response.context["view"].revision,
get_language())))
def _test_scores(ns, context, score_data):
today = localdate()
assert score_data.context == context
assert (score_data.get_daterange(30) == (today - timedelta(days=30),
today))
assert score_data.ns == "pootle.score.%s" % ns
assert score_data.sw_version == PootleScoreConfig.version
assert list(score_data.score_model.order_by("id")) == list(
UserTPScore.objects.exclude(
user__username__in=User.objects.META_USERS).order_by("id"))
assert (list(score_data.scores_within_days(5)) == list(
score_data.score_model.filter(
date__range=score_data.get_daterange(5))))
assert (list(score_data.get_scores(5)) == list(
score_data.filter_scores(score_data.scores_within_days(5))))
assert (list(score_data.get_top_scorers(10)) == list(
score_data.get_scores(10).order_by("user__username").values(
"user__username", "user__email", "user__full_name").annotate(
Sum("score"), Sum("suggested"), Sum("reviewed"),
Sum("translated")).filter(
score__sum__gt=0).order_by("-score__sum")))
assert (tuple(score_data.top_scorers) == tuple(
score_data.get_top_scorers(30)))
assert (score_data.revision == revision.get(context.directory.__class__)(
context.directory).get(key="stats"))
score_display = score_data.display()
assert isinstance(score_display, TopScoreDisplay)
for i, item in enumerate(score_display):
data = score_data.top_scorers[i]
assert item["public_total_score"] == formatter.number(
round(data["score__sum"]))
assert isinstance(item["user"], DisplayUser)
assert item["user"].username == data["user__username"]
assert item["user"].full_name == data["user__full_name"]
assert item["user"].email == data["user__email"]
score_display = score_data.display(limit=1)
assert len(list(score_display)) <= 1
def revision(self):
return revision.get(self.context.__class__)(
self.context.directory).get(key="stats")[:10] or "0"
def latest_hash(self):
return revision.get(Project)(
self.project).get(key="pootle.fs.fs_hash")
def get_filename(tp):
rev = revision.get(tp.__class__)(tp.directory).get(key="stats")
filename = '%s.%s.%s.tmx.zip' % (
tp.project.code,
tp.language.code, rev[:10])
return os.path.join(lang_code, filename)
def test_tp_cache_on_delete(tp0):
proj_revision = revision.get(tp0.project.directory.__class__)(
tp0.project.directory)
orig_revision = proj_revision.get("stats")
tp0.delete()
assert (proj_revision.get("stats") != orig_revision)
def save(self):
self.project.config["pootle.core.lang_mapping"] = self.cleaned_mapping
revision.get(self.project.__class__)(self.project).set(
keys=["pootle.fs.sync"], value=uuid.uuid4().hex)
def revision(self):
return revision.get(Directory)(
self.context.directory).get(key="stats")
def revision(self):
return revision.get(Directory)(
Directory.objects.projects).get(key="stats")
def expire_sync_cache(self):
revision.get(Project)(self.project).set(keys=["pootle.fs.sync"],
value=uuid.uuid4().hex)
def sync_revision(self):
return revision.get(Project)(self.project).get(key="pootle.fs.sync")
def exported_revision(self):
return revision.get(self.context.__class__)(
self.context).get(key="pootle.offline.tm")
def revision(self):
return revision.get(Directory)(
Directory.objects.projects).get(key="stats")
def revision(self):
return revision.get(self.context.__class__)(
self.context.directory).get(key="stats")[:10] or "0"
def save(self):
self.project.config["pootle.core.lang_mapping"] = self.cleaned_mapping
revision.get(self.project.__class__)(self.project).set(
keys=["pootle.fs.sync"], value=uuid.uuid4().hex)
def get_filename(tp):
rev = revision.get(tp.__class__)(tp.directory).get(key="stats")
filename = '%s.%s.%s.tmx.zip' % (tp.project.code, tp.language.code,
rev[:10])
return os.path.join(lang_code, filename)
def rev_cache_key(self):
return revision.get(
self.context.__class__)(self.context).get(key="stats")
def cache_key(self):
rev_context = self.object
return ("all_languages", self.request_lang,
revision.get(
rev_context.__class__)(rev_context).get(key="languages"))
def exported_revision(self):
return revision.get(self.context.__class__)(
self.context).get(key="pootle.offline.tm")
def sync_revision(self):
return revision.get(
Project)(self.project).get(key="pootle.fs.sync")
def test_formset_fs_project_lang_mapper(project0, language0, language1):
formset = LangMappingFormSet(project=project0)
assert formset.project == project0
assert not formset.forms[0].fields["pootle_code"].initial
assert formset.forms[0].initial == {}
# add a mapping
data = _get_management_data(formset)
data["form-0-pootle_code"] = language0.code
data["form-0-fs_code"] = "FOO"
formset = LangMappingFormSet(
project=project0,
data=data)
assert formset.is_valid()
assert formset.forms[0].project == project0
assert (
formset.forms[0].cleaned_data
== dict(remove=False, pootle_code=language0, fs_code="FOO"))
assert (
formset.cleaned_mapping
== OrderedDict([(u'FOO', u'language0')]))
orig_revision = revision.get(
formset.project.__class__)(
formset.project).get(key="pootle.fs.sync")
formset.save()
assert (
orig_revision
!= revision.get(
formset.project.__class__)(
formset.project).get(key="pootle.fs.sync"))
assert (
project0.config["pootle.core.lang_mapping"]
== OrderedDict([(u'FOO', u'language0')]))
# add another mapping
formset = LangMappingFormSet(project=project0)
data = _get_management_data(formset)
assert data['form-INITIAL_FORMS'] == 1
assert formset.initial == [{'fs_code': u'FOO', 'pootle_code': u'language0'}]
data["form-0-pootle_code"] = language0.code
data["form-0-fs_code"] = "FOO"
data["form-1-pootle_code"] = language1.code
data["form-1-fs_code"] = "BAR"
formset = LangMappingFormSet(
project=project0,
data=data)
assert formset.is_valid()
assert (
formset.forms[1].cleaned_data
== dict(remove=False, pootle_code=language1, fs_code="BAR"))
# language0 is excluded from other fields choices
assert (
sorted(
formset.forms[1].fields[
"pootle_code"].queryset.values_list("code", flat=True))
== sorted(
Language.objects.exclude(
code=language0.code).values_list("code", flat=True)))
formset.save()
assert (
project0.config["pootle.core.lang_mapping"]
== OrderedDict([(u'FOO', u'language0'), (u'BAR', 'language1')]))
# update the first
formset = LangMappingFormSet(project=project0)
languageX = LanguageDBFactory()
data = _get_management_data(formset)
data["form-0-pootle_code"] = languageX.code
data["form-0-fs_code"] = "FOO"
data["form-1-pootle_code"] = language1.code
data["form-1-fs_code"] = "BAR"
formset = LangMappingFormSet(
project=project0,
data=data)
assert formset.is_valid()
assert (
formset.forms[0].cleaned_data
== dict(remove=False, pootle_code=languageX, fs_code="FOO"))
formset.save()
assert (
project0.config["pootle.core.lang_mapping"]
== OrderedDict([(u'FOO', languageX.code), (u'BAR', 'language1')]))
# remove the second
formset = LangMappingFormSet(project=project0)
languageX = LanguageDBFactory()
data = _get_management_data(formset)
data["form-0-pootle_code"] = languageX.code
data["form-0-fs_code"] = "FOO"
data["form-1-pootle_code"] = language1.code
data["form-1-fs_code"] = "BAR"
data["form-1-remove"] = True
formset = LangMappingFormSet(
project=project0,
data=data)
assert formset.is_valid()
assert (
formset.forms[1].cleaned_data
== dict(remove=True, pootle_code=language1, fs_code="BAR"))
formset.save()
assert (
project0.config["pootle.core.lang_mapping"]
== OrderedDict([(u'FOO', languageX.code)]))
def rev_cache_key(self):
rev_context = self.revision_context
return (
revision.get(rev_context.__class__)(rev_context).get(key="stats")
if rev_context
else "")
def rev_cache_key(self):
rev_context = self.revision_context
return (revision.get(rev_context.__class__)(rev_context).get(
key="stats") if rev_context else "")
def latest_hash(self):
return revision.get(Project)(self.project).get(key="pootle.fs.fs_hash")
def revision(self):
return revision.get(Directory)(self.context.directory).get(key="stats")
def expire_sync_cache(self):
revision.get(Project)(self.project).set(
keys=["pootle.fs.sync"], value=uuid.uuid4().hex)
def pootle_revision(self):
return revision.get(Directory)(self.project.directory).get(key="stats")
def pootle_revision(self):
return revision.get(Directory)(
self.project.directory).get(key="stats")
def revision(self):
return revision.get(self.project_set.directory.__class__)(
self.project_set.directory).get(key="stats")
def revision(self):
return revision.get(self.project_set.directory.__class__)(
self.project_set.directory).get(key="stats")
def rev_cache_key(self):
return revision.get(self.context.__class__)(
self.context).get(key="stats")
def test_formset_fs_project_lang_mapper(project0, language0, language1):
formset = LangMappingFormSet(project=project0)
assert formset.project == project0
assert not formset.forms[0].fields["pootle_code"].initial
assert formset.forms[0].initial == {}
# add a mapping
data = _get_management_data(formset)
data["form-0-pootle_code"] = language0.code
data["form-0-fs_code"] = "FOO"
formset = LangMappingFormSet(
project=project0,
data=data)
assert formset.is_valid()
assert formset.forms[0].project == project0
assert (
formset.forms[0].cleaned_data
== dict(remove=False, pootle_code=language0, fs_code="FOO"))
assert (
formset.cleaned_mapping
== OrderedDict([(u'FOO', u'language0')]))
orig_revision = revision.get(
formset.project.__class__)(
formset.project).get(key="pootle.fs.sync")
formset.save()
assert (
orig_revision
!= revision.get(
formset.project.__class__)(
formset.project).get(key="pootle.fs.sync"))
assert (
project0.config["pootle.core.lang_mapping"]
== OrderedDict([(u'FOO', u'language0')]))
# add another mapping
formset = LangMappingFormSet(project=project0)
data = _get_management_data(formset)
assert data['form-INITIAL_FORMS'] == 1
assert formset.initial == [{'fs_code': u'FOO', 'pootle_code': u'language0'}]
data["form-0-pootle_code"] = language0.code
data["form-0-fs_code"] = "FOO"
data["form-1-pootle_code"] = language1.code
data["form-1-fs_code"] = "BAR"
formset = LangMappingFormSet(
project=project0,
data=data)
assert formset.is_valid()
assert (
formset.forms[1].cleaned_data
== dict(remove=False, pootle_code=language1, fs_code="BAR"))
# language0 is excluded from other fields choices
assert (
sorted(
formset.forms[1].fields[
"pootle_code"].queryset.values_list("code", flat=True))
== sorted(
Language.objects.exclude(
code=language0.code).values_list("code", flat=True)))
formset.save()
assert (
project0.config["pootle.core.lang_mapping"]
== OrderedDict([(u'FOO', u'language0'), (u'BAR', 'language1')]))
# update the first
formset = LangMappingFormSet(project=project0)
languageX = LanguageDBFactory()
data = _get_management_data(formset)
data["form-0-pootle_code"] = languageX.code
data["form-0-fs_code"] = "FOO"
data["form-1-pootle_code"] = language1.code
data["form-1-fs_code"] = "BAR"
formset = LangMappingFormSet(
project=project0,
data=data)
assert formset.is_valid()
assert (
formset.forms[0].cleaned_data
== dict(remove=False, pootle_code=languageX, fs_code="FOO"))
formset.save()
assert (
project0.config["pootle.core.lang_mapping"]
== OrderedDict([(u'FOO', languageX.code), (u'BAR', 'language1')]))
# remove the second
formset = LangMappingFormSet(project=project0)
languageX = LanguageDBFactory()
data = _get_management_data(formset)
data["form-0-pootle_code"] = languageX.code
data["form-0-fs_code"] = "FOO"
data["form-1-pootle_code"] = language1.code
data["form-1-fs_code"] = "BAR"
data["form-1-remove"] = True
formset = LangMappingFormSet(
project=project0,
data=data)
assert formset.is_valid()
assert (
formset.forms[1].cleaned_data
== dict(remove=True, pootle_code=language1, fs_code="BAR"))
formset.save()
assert (
project0.config["pootle.core.lang_mapping"]
== OrderedDict([(u'FOO', languageX.code)]))
