id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
14,900
|
directory.py
|
translate_pootle/pytest_pootle/fixtures/models/directory.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
@pytest.fixture(scope="session")
def root():
"""Require the root directory."""
from pootle_app.models import Directory
return Directory.objects.root
@pytest.fixture
def subdir0(tp0):
return tp0.directory.child_dirs.get(name="subdir0")
| 546
|
Python
|
.py
| 16
| 31.75
| 77
| 0.755725
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,901
|
utils.py
|
translate_pootle/pytest_pootle/fixtures/formats/utils.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
class Result(object):
def __init__(self):
self.clear()
def __getitem__(self, i):
return self._results[i]
def clear(self):
self._results = []
def add(self, *args):
self._results.append(args)
@pytest.fixture
def dummy_filetypes_class():
from pootle_format.utils import ProjectFiletypes
class DummyProjectFiletypes(ProjectFiletypes):
def set_tp_filetype(self, tp, filetype, from_filetype, matching):
self.result.add(tp, filetype, from_filetype, matching)
return DummyProjectFiletypes
@pytest.fixture
def dummy_project_filetypes(request, dummy_filetypes_class):
from pootle.core.delegate import filetype_tool
from pootle.core.plugin import getter
from pootle_project.models import Project
receivers = filetype_tool.receivers
receiver_cache = filetype_tool.sender_receivers_cache.copy()
filetype_tool.receivers = []
filetype_tool.sender_receivers_cache.clear()
result = Result()
@getter(filetype_tool, sender=Project, weak=False)
def filetype_tool_getter_(**kwargs_):
dummy_filetypes_class.result = result
return dummy_filetypes_class
def _restore_filetypes():
filetype_tool.receivers = receivers
filetype_tool.sender_receivers_cache = receiver_cache
request.addfinalizer(_restore_filetypes)
| 1,655
|
Python
|
.py
| 42
| 34.142857
| 77
| 0.723965
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,902
|
registry.py
|
translate_pootle/pytest_pootle/fixtures/formats/registry.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
@pytest.fixture
def no_formats():
from pootle.core.delegate import formats
from pootle_format.models import Format
Format.objects.all().delete()
formats.get().clear()
@pytest.fixture
def format_registry():
from pootle.core.delegate import formats
format_registry = formats.get()
format_registry.initialize()
return format_registry
| 659
|
Python
|
.py
| 20
| 30
| 77
| 0.756329
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,903
|
wordcount.py
|
translate_pootle/pytest_pootle/fixtures/core/utils/wordcount.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from collections import OrderedDict
import pytest
WORDCOUNT_TESTS = OrderedDict()
WORDCOUNT_TESTS['string_with_repeated_newlines'] = {
"string": ("There is a woman in town by the name of Elsie Dolban. She is "
"eccentric, and that has caused some of the villagers to "
"condemn her. I'm interested in *your* opinion of "
"her.\n\nSpeak to Inquisitor Roche, he has strong opinions in "
"this matter."),
"ttk": 44,
"pootle": 45,
}
WORDCOUNT_TESTS['simple_string'] = {
"string": ("There is a woman in town by the name of Elsie Dolban."),
"ttk": 12,
"pootle": 12,
}
WORDCOUNT_TESTS['dots'] = {
"string": ("Before.After"),
"ttk": 2,
"pootle": 1,
}
WORDCOUNT_TESTS['escaped_tags'] = {
"string": ("<b>"),
"ttk": 1,
"pootle": 0,
}
WORDCOUNT_TESTS['xml_tags'] = {
"string": ("<b>"),
"ttk": 0,
"pootle": 0,
}
WORDCOUNT_TESTS['xml_tags_with_attributes'] = {
"string": ('<p class="whatever">'),
"ttk": 0,
"pootle": 0,
}
WORDCOUNT_TESTS['java_format'] = {
"string": ("\23 said"),
"ttk": 2,
"pootle": 1,
}
WORDCOUNT_TESTS['template_format'] = {
"string": ("Hi ${name}"),
"ttk": 2,
"pootle": 1,
}
WORDCOUNT_TESTS['android_format'] = {
"string": ("%3$n"),
"ttk": 1,
"pootle": 0,
}
WORDCOUNT_TESTS['sprintf'] = {
"string": ("I am %s."),
"ttk": 3,
"pootle": 2,
}
WORDCOUNT_TESTS['objective_c'] = {
"string": ("Hi %@"),
"ttk": 1,
"pootle": 1,
}
WORDCOUNT_TESTS['dollar_sign'] = {
"string": ("$name$"),
"ttk": 1,
"pootle": 0,
}
WORDCOUNT_TESTS['newlines'] = {
"string": ("\n\n"),
"ttk": 0,
"pootle": 0,
}
WORDCOUNT_TESTS['escape_sequences'] = {
"string": ("\r\n\t"),
"ttk": 0,
"pootle": 0,
}
WORDCOUNT_TESTS['xml_entities'] = {
"string": ("‐"),
"ttk": 1,
"pootle": 0,
}
WORDCOUNT_TESTS['numeric_xml_entities'] = {
"string": ("{"),
"ttk": 1,
"pootle": 0,
}
WORDCOUNT_TESTS['product_names'] = {
"string": ("Evernote International"),
"ttk": 2,
"pootle": 0,
}
WORDCOUNT_TESTS['shortcuts'] = {
"string": ("Ctrl+A"),
"ttk": 1,
"pootle": 0,
}
WORDCOUNT_TESTS['shortcuts_modifiers'] = {
"string": ("Ctrl+"),
"ttk": 1,
"pootle": 0,
}
@pytest.fixture(params=WORDCOUNT_TESTS.keys())
def wordcount_names(request):
return request.param
| 2,691
|
Python
|
.py
| 112
| 20.348214
| 78
| 0.58382
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,904
|
subcommands.py
|
translate_pootle/pytest_pootle/fixtures/core/management/subcommands.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
@pytest.fixture
def command_caller():
def call_command_object(command, *args, **options):
parser = command.create_parser('', command.name)
opt_mapping = {
sorted(o.option_strings)[0].lstrip('-').replace('-', '_'): o.dest
for o in parser._actions if o.option_strings}
arg_options = {
opt_mapping.get(key, key): value for key, value in options.items()}
defaults = parser.parse_args(args=args)
defaults = dict(defaults._get_kwargs(), **arg_options)
args = defaults.pop('args', ())
return command.execute(*args, **defaults)
def _call_command(command, *args):
exited = False
try:
call_command_object(command, *args)
except SystemExit:
exited = True
return exited
return _call_command
@pytest.fixture
def argv_caller():
def _call_argv(command, *args):
exited = False
try:
command.run_from_argv((["", "foo"] + list(args)))
except SystemExit:
exited = True
return exited
return _call_argv
@pytest.fixture(params=["command", "argv"])
def command_calls(request, argv_caller, command_caller):
if request.param == "command":
return command_caller
return argv_caller
| 1,597
|
Python
|
.py
| 44
| 29.522727
| 79
| 0.633182
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,905
|
state.py
|
translate_pootle/pytest_pootle/fixtures/pootle_fs/state.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
from collections import OrderedDict
from fnmatch import fnmatch
import pytest
from django.db.models import Q
from django.utils.functional import cached_property
STATE_FILTERS = [
dict(fs_paths=None, pootle_paths=None, states=None),
dict(fs_paths=None,
pootle_paths=["/language0/project0/store0.po",
"/language0/project0/store1.po"],
states=None),
dict(fs_paths=["/language0/store0.po",
"/language0/store1.po"],
pootle_paths=None,
states=None),
dict(fs_paths=["/language0/store0.po",
"/language0/store1.po"],
pootle_paths=["/language0/project0/store0.po",
"/language0/project0/store1.po"],
states=None),
dict(fs_paths=["/language0/store0.po",
"/language0/store1.po"],
pootle_paths=None,
states=["fs_removed", "pootle_removed"]),
dict(fs_paths=None,
pootle_paths=None,
states=["fs_removed", "pootle_removed"]),
dict(fs_paths=None,
pootle_paths=None,
states=["DOES_NOT_EXIST"])]
FS_PATH_QS = OrderedDict((
("all", (
(None, None, None))),
("language0", (
(Q(pootle_path__startswith="/language0"),
"/language0/*", None))),
("fs/language1", (
(Q(pootle_path__startswith="/language1"),
None, "*language1/*"))),
("store0.po", (
(Q(pootle_path__endswith="store0.po"),
"*/store0.po", "*/store0.po"))),
("none", (
(False, "/language0/*", "/fs/language1/*")))))
def pytest_generate_tests(metafunc):
from pootle_fs.response import FS_RESPONSE
from pootle_fs.state import FS_STATE
if 'fs_responses' in metafunc.fixturenames:
metafunc.parametrize("fs_responses", FS_RESPONSE)
if 'fs_states' in metafunc.fixturenames:
metafunc.parametrize("fs_states", FS_STATE)
class DummyPlugin(object):
def __str__(self):
return "<DummyPlugin(%s)>" % self.project
def __init__(self, project):
self.project = project
def find_translations(self, fs_path=None, pootle_path=None):
for pp in self.resources.stores.values_list("pootle_path", flat=True):
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
@cached_property
def resources(self):
from pootle_fs.resources import FSProjectResources
return FSProjectResources(self.project)
def get_fs_path(self, pootle_path):
from pootle.core.url_helpers import split_pootle_path
lang_code, proj_code_, dir_path, filename = split_pootle_path(pootle_path)
parts = ["", lang_code]
if dir_path:
parts.append(dir_path.rstrip("/"))
parts.append(filename)
return os.sep.join(parts)
@pytest.fixture
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)
@pytest.fixture
def dummyfs_untracked(dummyfs):
dummyfs.resources.tracked.delete()
return dummyfs
@pytest.fixture(params=FS_PATH_QS.keys())
def fs_path_qs(request):
return FS_PATH_QS[request.param]
@pytest.fixture
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)
@pytest.fixture
def dummyfs_plugin_fs_unchanged(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 FSUnchangedFile(FSFile):
@property
def fs_changed(self):
return False
@property
def pootle_changed(self):
return True
@property
def latest_hash(self):
return 23
class PootleFSUnchangedDummyPlugin(DummyPlugin):
pass
@provider(fs_plugins, weak=False, sender=Project)
def plugin_provider_(**kwargs_):
return dict(dummyfs=PootleFSUnchangedDummyPlugin)
@getter(fs_file, weak=False, sender=PootleFSUnchangedDummyPlugin)
def fs_files_getter_(**kwargs_):
return FSUnchangedFile
project = Project.objects.get(code="project0")
settings.POOTLE_FS_WORKING_PATH = os.sep.join(['', 'tmp', 'foo'])
project.config["pootle_fs.fs_type"] = "dummyfs"
plugin = FSPlugin(project)
return plugin
@pytest.fixture
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
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)
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))
plugin = FSPlugin(project)
return plugin
@pytest.fixture
def dummyfs_plugin_del_stores(dummyfs_plugin_no_stores):
dummyfs_plugin_no_stores.resources.stores.delete()
return dummyfs_plugin_no_stores
@pytest.fixture
def dummyfs_plugin_obs_stores(dummyfs_plugin_no_stores):
for store in dummyfs_plugin_no_stores.resources.stores:
store.makeobsolete()
return dummyfs_plugin_no_stores
@pytest.fixture
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
@pytest.fixture(params=STATE_FILTERS)
def state_filters(request):
return request.param
| 8,589
|
Python
|
.py
| 213
| 33.328638
| 82
| 0.675533
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,906
|
getters.py
|
translate_pootle/pytest_pootle/fixtures/pootle_fs/getters.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from contextlib import contextmanager
import pytest
from pytest_pootle.utils import suppress_getter, suppress_provider
from pootle_fs.delegate import fs_file, fs_finder, fs_plugins
@contextmanager
def _no_fs_files():
with suppress_getter(fs_file):
yield
@pytest.fixture
def no_fs_files():
return _no_fs_files
@contextmanager
def _no_fs_plugins():
with suppress_provider(fs_plugins):
yield
@pytest.fixture
def no_fs_plugins():
return _no_fs_plugins
@contextmanager
def _no_fs_finder():
with suppress_getter(fs_finder):
yield
@pytest.fixture
def no_fs_finder():
return _no_fs_finder
@pytest.fixture
def dummy_fs_files(request):
fs_file_receivers = fs_file.receivers
fs_file_receiver_cache = fs_file.sender_receivers_cache.copy()
fs_file.receivers = []
fs_file.sender_receivers_cache.clear()
def _restore_plugins():
fs_file.sender_receivers_cache = fs_file_receiver_cache
fs_file.receivers = fs_file_receivers
request.addfinalizer(_restore_plugins)
@pytest.fixture
def dummy_fs_finder(request):
fs_finder_receivers = fs_finder.receivers
fs_finder_receiver_cache = fs_finder.sender_receivers_cache.copy()
fs_finder.receivers = []
fs_finder.sender_receivers_cache.clear()
def _restore_plugins():
fs_finder.sender_receivers_cache = fs_finder_receiver_cache
fs_finder.receivers = fs_finder_receivers
request.addfinalizer(_restore_plugins)
@pytest.fixture
def dummy_fs_plugins(request):
fs_plugins_receivers = fs_plugins.receivers
fs_plugins_receiver_cache = fs_plugins.sender_receivers_cache.copy()
fs_plugins.receivers = []
fs_plugins.sender_receivers_cache.clear()
def _restore_plugins():
fs_plugins.sender_receivers_cache = fs_plugins_receiver_cache
fs_plugins.receivers = fs_plugins_receivers
request.addfinalizer(_restore_plugins)
@pytest.fixture
def dummy_fs_getters(dummy_fs_plugins, dummy_fs_files):
pass
| 2,279
|
Python
|
.py
| 65
| 31.015385
| 77
| 0.741773
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,907
|
resources.py
|
translate_pootle/pytest_pootle/fixtures/pootle_fs/resources.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
@pytest.fixture
def project0_fs_resources():
from pootle_fs.models import StoreFS
from pootle_project.models import Project
from pootle_store.models import Store
project = Project.objects.get(code="project0")
stores = Store.objects.filter(
translation_project__project=project)
batch = int(stores.count() / 4)
StoreFS.objects.all().delete()
for store in stores[0:batch]:
store.makeobsolete()
for store in stores[batch:batch * 2]:
StoreFS.objects.create(
store=store,
path="/some/fs%s" % store.pootle_path)
store.makeobsolete()
for store in stores[batch * 2:batch * 3]:
StoreFS.objects.create(
store=store,
path="/some/fs%s" % store.pootle_path)
return project
| 1,085
|
Python
|
.py
| 30
| 30.633333
| 77
| 0.68411
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,908
|
finder.py
|
translate_pootle/pytest_pootle/fixtures/pootle_fs/finder.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
from collections import OrderedDict
import pytest
BAD_FINDER_PATHS = [
"lang/foo.<ext>",
"<language_code>/<foo>.<ext>",
"<language_code>/foo.po",
"../<language_code>/foo.<ext>",
"<language_code>/../foo.<ext>",
"<language_code>/..",
"foo/@<language_code>/bar.<ext>"]
ROOT_PATHS = OrderedDict()
ROOT_PATHS["<language_code>.<ext>"] = ""
ROOT_PATHS["foo/<language_code>.<ext>"] = "foo"
ROOT_PATHS["foo/bar/baz-<filename>-<language_code>.<ext>"] = "foo/bar"
MATCHES = OrderedDict()
MATCHES["po/<language_code>.<ext>"] = (
["en.po", "foo/bar/en.po"],
[("po/en.po", dict(language_code="en", ext="po"))])
MATCHES["po-<filename>/<language_code>.<ext>"] = (
["en.po", "po/en.po"],
[("po-foo/en.po", dict(language_code="en", filename="foo", ext="po"))])
MATCHES["po/<filename>-<language_code>.<ext>"] = (
["en.po", "po/en.po"],
[("po/foo-en.po", dict(language_code="en", filename="foo", ext="po"))])
MATCHES["<language_code>/<dir_path>/<filename>.<ext>"] = (
["foo.po"],
[("en/foo.po",
dict(language_code="en", dir_path="", filename="foo", ext="po")),
("en/foo.pot",
dict(language_code="en", dir_path="", filename="foo", ext="pot")),
("en/bar/baz/foo.po",
dict(language_code="en", dir_path="bar/baz", filename="foo", ext="po"))])
MATCHES["<dir_path>/<language_code>/<filename>.<ext>"] = (
["foo.po", "en/foo.poo"],
[("en/foo.po",
dict(language_code="en", dir_path="", filename="foo", ext="po")),
("en/foo.pot",
dict(language_code="en", dir_path="", filename="foo", ext="pot")),
("bar/baz/en/foo.po",
dict(language_code="en", dir_path="bar/baz", filename="foo", ext="po"))])
FINDER_REGEXES = [
"<language_code>.<ext>",
"<language_code>/<filename>.<ext>",
"<dir_path>/<language_code>.<ext>",
"<language_code><dir_path>/<filename>.<ext>"]
FILES = OrderedDict()
FILES["gnu_style/po/<language_code>.<ext>"] = (
("gnu_style/po/language0.po",
dict(language_code="language0",
ext="po",
filename="language0",
dir_path="")),
("gnu_style/po/language1.po",
dict(language_code="language1",
ext="po",
filename="language1",
dir_path="")))
FILES["gnu_style_named_files/po/<filename>-<language_code>.<ext>"] = (
("gnu_style_named_files/po/example1-language1.po",
dict(language_code="language1",
filename="example1",
ext="po",
dir_path="")),
("gnu_style_named_files/po/example1-language0.po",
dict(language_code="language0",
filename="example1",
ext="po",
dir_path="")),
("gnu_style_named_files/po/example2-language1.po",
dict(language_code="language1",
filename="example2",
ext="po",
dir_path="")),
("gnu_style_named_files/po/example2-language0.po",
dict(language_code="language0",
filename="example2",
ext="po",
dir_path="")))
FILES["gnu_style_named_folders/po-<filename>/<language_code>.<ext>"] = (
("gnu_style_named_folders/po-example1/language1.po",
dict(language_code="language1",
filename="example1",
ext="po",
dir_path="")),
("gnu_style_named_folders/po-example1/language0.po",
dict(language_code="language0",
filename="example1",
ext="po",
dir_path="")),
("gnu_style_named_folders/po-example2/language1.po",
dict(language_code="language1",
filename="example2",
ext="po",
dir_path="")),
("gnu_style_named_folders/po-example2/language0.po",
dict(language_code="language0",
filename="example2",
ext="po",
dir_path="")))
FILES["non_gnu_style/locales/<language_code>/<dir_path>/<filename>.<ext>"] = (
("non_gnu_style/locales/language1/example1.po",
dict(language_code=u"language1",
filename=u"example1",
ext=u"po",
dir_path=u"")),
("non_gnu_style/locales/language0/example1.po",
dict(language_code=u"language0",
filename=u"example1",
ext=u"po",
dir_path=u"")),
("non_gnu_style/locales/language1/example2.po",
dict(language_code=u"language1",
filename=u"example2",
ext=u"po",
dir_path=u"")),
("non_gnu_style/locales/language0/example2.po",
dict(language_code=u"language0",
filename=u"example2",
ext=u"po",
dir_path=u"")),
("non_gnu_style/locales/language1/subsubdir/example3.po",
dict(language_code=u"language1",
filename=u"example3",
ext=u"po",
dir_path=u"subsubdir")),
("non_gnu_style/locales/language0/subsubdir/example3.po",
dict(language_code=u"language0",
filename=u"example3",
ext=u"po",
dir_path=u"subsubdir")),
("non_gnu_style/locales/language1/subsubdir/example4.po",
dict(language_code=u"language1",
filename=u"example4",
ext=u"po",
dir_path=u"subsubdir")),
("non_gnu_style/locales/language0/subsubdir/example4.po",
dict(language_code=u"language0",
filename=u"example4",
ext=u"po",
dir_path=u"subsubdir")))
@pytest.fixture(params=FINDER_REGEXES)
def finder_regexes(request):
return request.param
@pytest.fixture(params=BAD_FINDER_PATHS)
def bad_finder_paths(request):
return request.param
@pytest.fixture(params=FILES.keys())
def finder_files(request):
return request.param, FILES[request.param]
@pytest.fixture
def fs_finder(test_fs, finder_files):
from pootle_fs.finder import TranslationFileFinder
translation_mapping, expected = finder_files
test_filepath = test_fs.path("data/fs/example_fs")
finder = TranslationFileFinder(
os.path.join(
test_filepath,
translation_mapping))
expected = [
(os.path.join(test_filepath, path), parsed)
for path, parsed
in expected]
return finder, expected
@pytest.fixture(params=MATCHES.keys())
def finder_matches(request):
return [request.param] + list(MATCHES[request.param])
@pytest.fixture(params=ROOT_PATHS.keys())
def finder_root_paths(request):
return request.param, ROOT_PATHS[request.param]
| 6,569
|
Python
|
.py
| 177
| 30.666667
| 79
| 0.614757
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,909
|
plugin.py
|
translate_pootle/pytest_pootle/fixtures/pootle_fs/plugin.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
import shutil
import pytest
from pytest_pootle.fs.utils import parse_fs_action_args
RESPONSE_MAP = {
"conflict": dict(
rm_force=("staged_for_removal", "remove"),
resolve_overwrite=("staged_for_overwrite_fs", "fs_staged"),
resolve_pootle_overwrite=("staged_for_overwrite_pootle", "pootle_staged"),
resolve_pootle=("staged_for_merge_pootle", "merge_pootle_wins"),
resolve=("staged_for_merge_fs", "merge_fs_wins")),
"conflict_untracked": dict(
rm_force=("staged_for_removal", "remove"),
resolve_pootle_overwrite=("staged_for_overwrite_pootle", "pootle_staged"),
resolve_overwrite=("staged_for_overwrite_fs", "fs_staged"),
resolve_pootle=("staged_for_merge_pootle", "merge_pootle_wins"),
resolve=("staged_for_merge_fs", "merge_fs_wins")),
"fs_ahead": dict(
sync=("pulled_to_pootle", None)),
"fs_removed": dict(
add_force=("readded_from_pootle", "pootle_staged"),
rm=("staged_for_removal", "remove"),
rm_force=("staged_for_removal", "remove")),
"fs_staged": dict(
sync=("pulled_to_pootle", None)),
"fs_untracked": dict(
add=("added_from_fs", "fs_staged"),
add_force=("added_from_fs", "fs_staged"),
rm_force=("staged_for_removal", "remove")),
"merge_fs_wins": dict(
sync=("merged_from_fs", None)),
"merge_pootle_wins": dict(
sync=("merged_from_pootle", None)),
"pootle_ahead": dict(
sync=("pushed_to_fs", None)),
"pootle_removed": dict(
add_force=("readded_from_fs", "fs_staged"),
rm=("staged_for_removal", "remove"),
rm_force=("staged_for_removal", "remove")),
"pootle_staged": dict(
sync=("pushed_to_fs", None)),
"pootle_untracked": dict(
add=("added_from_pootle", "pootle_staged"),
add_force=("added_from_pootle", "pootle_staged"),
rm_force=("staged_for_removal", "remove")),
"remove": dict(
sync=("removed", None))}
def _possible_actions():
actions = set()
for state in RESPONSE_MAP:
actions.update(RESPONSE_MAP[state].keys())
return actions
def pytest_generate_tests(metafunc):
if 'localfs_envs' in metafunc.fixturenames:
from pootle_fs.state import FS_STATE
env_names = [e for e in FS_STATE.keys() if e not in ["both_removed"]]
metafunc.parametrize("localfs_env_names", env_names)
if "possible_action_keys" in metafunc.fixturenames:
metafunc.parametrize("possible_action_keys", _possible_actions())
@pytest.fixture
def fs_response_map():
return RESPONSE_MAP
@pytest.fixture
def possible_actions(possible_action_keys):
return (
(possible_action_keys, )
+ parse_fs_action_args(possible_action_keys))
@pytest.fixture
def localfs_envs(request, localfs_env_names):
return (
localfs_env_names,
request.getfixturevalue(
"localfs_%s" % localfs_env_names))
@pytest.fixture(params=["force_added"])
def localfs_staged_envs(request):
return (
request.param,
request.getfixturevalue(
"localfs_%s" % request.param))
@pytest.fixture
def localfs_env(project_fs, no_complex_po_, revision):
return project_fs
@pytest.fixture
def localfs_base(localfs_env):
localfs_env.resources.tracked.delete()
shutil.rmtree(localfs_env.fs_url)
os.makedirs(
os.path.join(
localfs_env.fs_url,
localfs_env.project.code))
return localfs_env
@pytest.fixture
def localfs_dummy_finder(dummy_fs_finder, localfs_env):
from pootle.core.plugin import getter
from pootle.core.url_helpers import split_pootle_path
from pootle_fs.delegate import fs_finder
from pootle_fs.finder import TranslationFileFinder
plugin = localfs_env
stores = plugin.resources.stores
pootle_paths = list(stores.values_list("pootle_path", flat=True))
class DummyFSFinder(TranslationFileFinder):
def find(self):
for pootle_path in pootle_paths:
matched = dict()
(matched['language_code'],
__,
matched['dir_path'],
matched['filename']) = split_pootle_path(pootle_path)
matched["ext"] = "po"
matched['filename'] = os.path.splitext(matched["filename"])[0]
yield plugin.get_fs_path(pootle_path), matched
@getter(fs_finder, sender=plugin.__class__, weak=False)
def get_fs_finder_(**kwargs_):
return DummyFSFinder
@pytest.fixture
def localfs_dummy_finder_empty(dummy_fs_finder, localfs_env):
from pootle.core.plugin import getter
from pootle_fs.delegate import fs_finder
from pootle_fs.finder import TranslationFileFinder
plugin = localfs_env
class DummyEmptyFSFinder(TranslationFileFinder):
def find(self):
return []
@getter(fs_finder, sender=plugin.__class__, weak=False)
def get_fs_finder_(**kwargs_):
return DummyEmptyFSFinder
@pytest.fixture
def localfs_dummy_file(dummy_fs_files):
from pootle.core.plugin import getter
from pootle_fs.delegate import fs_file
from pootle_fs.files import FSFile
from pootle_fs.localfs import LocalFSPlugin
class DummyFSFile(FSFile):
_added = False
_deleted = False
_merged = False
_pulled = False
_pushed = False
_resolved = False
_removed = False
_saved = False
_synced = False
_unstaged = False
@property
def latest_hash(self):
return str(hash(self.pootle_path))
def delete(self):
self._deleted = True
def on_sync(self, sync_hash, sync_revision, save=False):
self._sync_hash = sync_hash
self._sync_revision = sync_revision
self._synced = True
self._saved = save
def pull(self, **kwargs):
self._pulled = True
self._pull_data = sorted(kwargs.items())
def push(self):
self._pushed = True
@getter(fs_file, sender=LocalFSPlugin, weak=False)
def get_fs_file_(**kwargs_):
return DummyFSFile
@pytest.fixture
def localfs(localfs_env, localfs_dummy_file):
return localfs_env
@pytest.fixture
def localfs_no_storefs(localfs):
localfs.resources.tracked.delete()
return localfs
@pytest.fixture
def localfs_pootle_untracked(localfs_no_storefs):
plugin = localfs_no_storefs
stores = plugin.resources.stores
state = plugin.state()
assert len(state["pootle_untracked"]) == stores.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_fs_removed(localfs):
plugin = localfs
state = plugin.state()
assert len(state["fs_removed"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_conflict(localfs, localfs_dummy_finder):
plugin = localfs
for store_fs in plugin.resources.tracked:
store_fs.last_sync_revision = store_fs.last_sync_revision - 1
store_fs.save()
state = plugin.state()
assert len(state["conflict"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_conflict_untracked(localfs_no_storefs, localfs_dummy_finder):
plugin = localfs_no_storefs
stores = plugin.resources.stores
pootle_paths = list(stores.values_list("pootle_path", flat=True))
state = plugin.state()
assert len(state["conflict_untracked"]) == len(pootle_paths)
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_pootle_removed(localfs, localfs_dummy_finder):
plugin = localfs
plugin.resources.stores.delete()
for store_fs in plugin.resources.tracked:
store_fs.last_sync_hash = store_fs.file.latest_hash
store_fs.save()
state = plugin.state()
assert len(state["pootle_removed"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_fs_untracked(no_complex_po_, localfs_base,
localfs_dummy_finder, localfs_dummy_file):
plugin = localfs_base
plugin.resources.stores.delete()
state = plugin.state()
assert len(state["fs_untracked"]) == len(list(plugin.find_translations()))
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_merge_pootle_wins(localfs, localfs_dummy_finder):
from pootle_store.models import POOTLE_WINS
plugin = localfs
plugin.resources.tracked.update(
resolve_conflict=POOTLE_WINS,
staged_for_merge=True)
state = plugin.state()
assert len(state["merge_pootle_wins"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_merge_fs_wins(localfs, localfs_dummy_finder):
from pootle_store.constants import SOURCE_WINS
plugin = localfs
stores = plugin.resources.stores
plugin.resources.tracked.update(
resolve_conflict=SOURCE_WINS,
staged_for_merge=True)
state = plugin.state()
assert len(state["merge_fs_wins"]) == stores.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_fs_ahead(localfs, localfs_dummy_finder):
plugin = localfs
state = plugin.state()
assert len(state["fs_ahead"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_fs_staged(localfs, localfs_dummy_finder):
plugin = localfs
plugin.resources.stores.delete()
plugin.resources.tracked.update(
last_sync_hash=None,
last_sync_revision=None)
state = plugin.state()
assert len(state["fs_staged"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_pootle_ahead(localfs, localfs_dummy_finder):
plugin = localfs
for store_fs in plugin.resources.tracked:
store_fs.last_sync_hash = store_fs.file.latest_hash
store_fs.last_sync_revision = store_fs.last_sync_revision - 1
store_fs.save()
state = plugin.state()
assert len(state["pootle_ahead"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_pootle_staged(localfs, localfs_dummy_finder_empty):
plugin = localfs
plugin.resources.tracked.update(
last_sync_hash=None,
last_sync_revision=None)
state = plugin.state()
assert len(state["pootle_staged"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_remove(localfs, localfs_dummy_finder_empty):
plugin = localfs
plugin.resources.tracked.update(
last_sync_hash=None,
last_sync_revision=None,
staged_for_removal=True)
state = plugin.state()
assert len(state["remove"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_pootle_staged_real(localfs_base):
from pytest_pootle.utils import add_store_fs
plugin = localfs_base
for store in plugin.resources.stores:
add_store_fs(
store=store,
fs_path=plugin.get_fs_path(store.pootle_path))
state = plugin.state()
assert len(state["pootle_staged"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
@pytest.fixture
def localfs_force_added(localfs, localfs_dummy_finder):
from pootle_store.models import POOTLE_WINS
plugin = localfs
for store_fs in plugin.resources.tracked:
store_fs.last_sync_revision = store_fs.last_sync_revision - 1
store_fs.resolve_conflict = POOTLE_WINS
store_fs.save()
state = plugin.state()
assert len(state["pootle_ahead"]) == plugin.resources.tracked.count()
assert len([x for x in state]) == 1
return plugin
| 12,379
|
Python
|
.py
| 326
| 31.708589
| 82
| 0.669814
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,910
|
base.py
|
translate_pootle/pytest_pootle/fixtures/pootle_fs/base.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
import pytest
@pytest.fixture
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
@pytest.fixture
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)
| 1,425
|
Python
|
.py
| 37
| 34.243243
| 77
| 0.712835
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,911
|
files.py
|
translate_pootle/pytest_pootle/fixtures/pootle_fs/files.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
import pytest
@pytest.fixture
def store_fs_file(settings, tmpdir, test_fs):
from pootle_fs.files import FSFile
from pootle_fs.models import StoreFS
from pootle_project.models import Project
settings.POOTLE_FS_WORKING_PATH = os.path.join(str(tmpdir), "fs_file_test")
project = Project.objects.get(code="project0")
pootle_path = "/language0/%s/example.po" % project.code
fs_path = "/some/fs/example.po"
store_fs = StoreFS.objects.create(
path=fs_path,
pootle_path=pootle_path)
fs_file = FSFile(store_fs)
os.makedirs(os.path.dirname(fs_file.file_path))
with test_fs.open("data/po/complex.po") as src:
with open(fs_file.file_path, "w") as target:
data = src.read()
target.write(data)
return fs_file
@pytest.fixture
def store_fs_file_store(settings, tmpdir, tp0_store, test_fs):
from pootle_fs.files import FSFile
from pootle_fs.models import StoreFS
settings.POOTLE_FS_WORKING_PATH = os.path.join(str(tmpdir), "fs_file_test")
fs_path = "/some/fs/example.po"
store_fs = StoreFS.objects.create(
path=fs_path,
store=tp0_store)
fs_file = FSFile(store_fs)
with test_fs.open("data/po/complex.po") as src:
tp0_store.update(tp0_store.deserialize(src.read()))
return fs_file
| 1,607
|
Python
|
.py
| 41
| 34.292683
| 79
| 0.697047
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,912
|
commands.py
|
translate_pootle/pytest_pootle/fixtures/pootle_fs/commands.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.utils.functional import cached_property
from django.utils.lru_cache import lru_cache
DUMMY_RESPONSE_MAP = dict(
add="added_from_pootle",
resolve="staged_for_merge_fs",
rm="remove",
sync="merged_from_pootle")
def add_dummy_api_call(response, call_type, **kwargs):
from pootle_fs.state import FSItemState
call_type = DUMMY_RESPONSE_MAP[call_type]
for k, v in sorted(kwargs.items()):
response.add(
"%s_args" % call_type,
fs_state=FSItemState(
state=response.context,
state_type="%s_args" % call_type,
pootle_path=k,
fs_path=v))
@lru_cache()
def _get_dummy_api_plugin():
from pootle.core.state import State
from pootle_fs.plugin import Plugin
from pootle_fs.response import ProjectFSResponse
class DummyResponse(ProjectFSResponse):
made_changes = True
response_types = [
"remove", "remove_args",
"added_from_fs", "added_from_fs_args",
"added_from_pootle", "added_from_pootle_args", "staged_for_merge_fs",
"staged_for_merge_pootle", "staged_for_merge_pootle_args",
"merged_from_pootle", "merged_from_pootle_args"]
class DummyCommandPlugin(Plugin):
@cached_property
def dummy_response(self):
return DummyResponse(State(self))
def _api_called(self, call_type, **kwargs):
add_dummy_api_call(
self.dummy_response,
call_type,
**kwargs)
def add(self, **kwargs):
self._api_called("add", **kwargs)
return self.dummy_response
def resolve(self, **kwargs):
self._api_called("resolve", **kwargs)
return self.dummy_response
def rm(self, **kwargs):
self._api_called("rm", **kwargs)
return self.dummy_response
def sync(self, **kwargs):
self._api_called("sync", **kwargs)
return self.dummy_response
return DummyResponse, DummyCommandPlugin
@pytest.fixture
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
@lru_cache()
def _get_dummy_state_plugin():
from pootle.core.state import State
from pootle_fs.plugin import Plugin
class DummyState(State):
@property
def states(self):
return ["pootle_staged"]
def state_pootle_staged(self, **kwargs):
yield dict(
pootle_path=kwargs.get("pootle_path"),
fs_path=kwargs.get("fs_path"))
class DummyCommandPlugin(Plugin):
def state(self, **kwargs):
return DummyState(self, **kwargs)
return DummyState, DummyCommandPlugin
@pytest.fixture
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
| 4,251
|
Python
|
.py
| 106
| 32.377358
| 81
| 0.660906
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,913
|
conftest.py
|
translate_pootle/tests/conftest.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
from django import setup
from django.conf import settings
import logging
logging.getLogger("factory").setLevel(logging.WARN)
def pytest_configure():
if not settings.configured:
from pootle import syspath_override # Needed for monkey-patching
syspath_override
os.environ['DJANGO_SETTINGS_MODULE'] = 'pootle.settings'
WORKING_DIR = os.path.abspath(os.path.dirname(__file__))
os.environ['POOTLE_SETTINGS'] = os.path.join(WORKING_DIR,
'settings.py')
# The call to `setup()` was needed before a fix for
# pytest-dev/pytest-django#146 was available. This happened in version
# 2.9; unfortunately upgrading to 2.9+ is not possible yet because a fix
# for pytest-dev/pytest-django#289 is needed too, and this is not part
# of any releases for the time being.
setup()
| 1,196
|
Python
|
.py
| 26
| 39.192308
| 80
| 0.68299
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,914
|
settings.py
|
translate_pootle/tests/settings.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
"""Test settings."""
import os
SECRET_KEY = "test_secret_key"
# Ideally this setting would be set in a per-test basis, unfortunately some code
# such as `django.utils.timezone.get_default_timezone` read from this setting
# and at the same time are behind a `lru_cache` decorator, which makes it
# impossible to alter the value at runtime because decorators are applied at
# function definition time.
TIME_ZONE = 'Pacific/Honolulu'
ROOT_DIR = os.path.dirname(os.path.abspath(os.path.dirname(__file__)))
POOTLE_TRANSLATION_DIRECTORY = os.path.join(ROOT_DIR, 'pytest_pootle', 'data', 'po')
MIDDLEWARE = [
#: Resolves paths
'pootle.middleware.baseurl.BaseUrlMiddleware',
#: Must be as high as possible (see above)
'django.middleware.cache.UpdateCacheMiddleware',
#: Avoids caching for authenticated users
'pootle.middleware.cache.CacheAnonymousOnly',
#: Protect against clickjacking and numerous xss attack techniques
'django.middleware.clickjacking.XFrameOptionsMiddleware',
#: Support for e-tag
'django.middleware.http.ConditionalGetMiddleware',
#: Protection against cross-site request forgery
'django.middleware.csrf.CsrfViewMiddleware',
#: Must be before authentication
'django.contrib.sessions.middleware.SessionMiddleware',
#: Must be before anything user-related
'pootle.middleware.auth.AuthenticationMiddleware',
#: User-related
'django.middleware.locale.LocaleMiddleware',
#: Nice 500 and 403 pages (must be after locale to have translated versions)
'pootle.middleware.errorpages.ErrorPagesMiddleware',
'django.middleware.common.CommonMiddleware',
#: Must be early in the response cycle (close to bottom)
'pootle.middleware.captcha.CaptchaMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
]
# Using the only Redis DB for testing
CACHES = {
# Must set up entries for persistent stores here because we have a check in
# place that will abort everything otherwise
'default': {
'BACKEND': 'django_redis.cache.RedisCache',
'LOCATION': 'redis://redis:6379/13',
'TIMEOUT': 604800, # 1 week
},
'redis': {
'BACKEND': 'django_redis.cache.RedisCache',
'LOCATION': 'redis://redis:6379/14',
'TIMEOUT': None,
},
'lru': {
'BACKEND': 'django_redis.cache.RedisCache',
'LOCATION': 'redis://redis:6379/15',
'TIMEOUT': 604800, # 1 week
},
'exports': {
'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
'LOCATION': os.path.join(ROOT_DIR, 'tests', 'exports'),
'TIMEOUT': 259200, # 3 days.
},
}
# Using synchronous mode for testing
RQ_QUEUES = {
'default': {
'USE_REDIS_CACHE': 'redis',
'DEFAULT_TIMEOUT': 360,
'ASYNC': False,
},
}
# Mail server settings
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
POOTLE_EMAIL_FEEDBACK_ENABLED = True
# Faster password hasher
PASSWORD_HASHERS = (
'django.contrib.auth.hashers.MD5PasswordHasher',
)
SCRIPT_NAME = '/'
SILENCED_SYSTEM_CHECKS = [
'pootle.C005', # Silence the RedisCache check as we use a dummy cache
'pootle.C017', # Distinct redis DB numbers for default, redis, stats
'pootle.W004', # Pootle requires a working mail server
'pootle.W005', # DEBUG = True
'pootle.W010', # DEFAULT_FROM_EMAIL has default setting
'pootle.W011', # POOTLE_CONTACT_EMAIL has default setting
'pootle.W020', # POOTLE_CANONICAL_URL has default setting
]
try:
if "pootle_fs" not in INSTALLED_APPS:
INSTALLED_APPS = INSTALLED_APPS + ["pootle_fs"]
except NameError:
INSTALLED_APPS = ["pootle_fs"]
POOTLE_TM_SERVER = {
'local': {
'ENGINE': 'pootle.core.search.backends.ElasticSearchBackend',
'HOST': 'elasticsearch',
'PORT': 9200,
# Every TM server must have its own unique index.
'INDEX_NAME': 'translations',
# Provides a weighting factor to alter the final score for TM results
# from this TM server. Valid values are between ``0.0`` and ``1.0``,
# both included. Defaults to ``1.0`` if not provided.
'WEIGHT': 1.0,
},
'external': {
'ENGINE': 'pootle.core.search.backends.ElasticSearchBackend',
'HOST': 'elasticsearch',
'PORT': 9200,
'INDEX_NAME': 'translations-external',
'WEIGHT': 0.9,
},
}
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'USER': '',
'HOST': '',
'PORT': '',
'PASSWORD': 'CHANGEME',
'ATOMIC_REQUESTS': True,
'TEST': {
'NAME': '',
'CHARSET': 'utf8'}}}
if os.environ.get("APP_DB_ENV") == 'mariadb':
DATABASES['default']['ENGINE'] = 'django.db.backends.mysql'
DATABASES['default']['NAME'] = 'pootledb'
DATABASES['default']['HOST'] = 'mariadb'
DATABASES['default']['USER'] = 'root'
DATABASES['default']['TEST']['COLLATION'] = 'utf8_general_ci'
DATABASES['default']['OPTIONS'] = {
'init_command': "SET sql_mode='STRICT_ALL_TABLES'"}
elif os.environ.get("APP_DB_ENV") == 'postgres':
DATABASES['default']['ENGINE'] = 'django.db.backends.postgresql'
DATABASES['default']['NAME'] = 'pootledb'
DATABASES['default']['USER'] = 'pootle'
DATABASES['default']['HOST'] = 'postgres'
| 5,643
|
Python
|
.py
| 143
| 34.300699
| 84
| 0.672814
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,915
|
database.py
|
translate_pootle/tests/database.py
|
import pytest
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
@pytest.mark.django_db
def test_backend_db():
"""Ensure that we are always testing sqlite on fast in memory DB"""
from django.db import connection, connections
if connection.vendor == "sqlite":
assert connections.databases["default"]["NAME"] == ":memory:"
| 568
|
Python
|
.py
| 14
| 37.928571
| 77
| 0.733212
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,916
|
export.py
|
translate_pootle/tests/import_export/export.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.urls import reverse
from import_export.utils import TPTMXExporter
@pytest.mark.django_db
def test_download_exported_tmx(client, tp0):
args = [tp0.language.code, tp0.project.code]
response = client.get(reverse('pootle-offline-tm-tp', args=args))
assert response.status_code == 404
exporter = TPTMXExporter(tp0)
exporter.export()
response = client.get(reverse('pootle-offline-tm-tp', args=args))
assert response.status_code == 302
assert response.url == exporter.get_url()
@pytest.mark.django_db
def test_view_context_with_exported_tmx(exported_tp_view_response):
assert exported_tp_view_response.status_code == 200
assert exported_tp_view_response.context['has_offline_tm']
@pytest.mark.django_db
def test_exported_tmx_url(client, tp0):
args = [tp0.language.code, tp0.project.code]
response = client.get(reverse('pootle-offline-tm-tp', args=args))
assert response.status_code == 404
exporter = TPTMXExporter(tp0)
exporter.export()
response = client.get(reverse('pootle-offline-tm-tp', args=args))
assert response.status_code == 302
exported_url = exporter.get_url()
assert response.url == exported_url
unit = tp0.stores.first().units.first()
unit.target_f += ' CHANGED'
unit.save()
response = client.get(reverse('pootle-offline-tm-tp', args=args))
assert response.status_code == 302
assert response.url == exported_url
@pytest.mark.django_db
def test_wrong_language_exported_tmx_url(client):
args = ('language_foo', 'project0')
response = client.get(reverse('pootle-offline-tm-tp', args=args))
assert response.status_code == 404
| 1,954
|
Python
|
.py
| 46
| 38.76087
| 77
| 0.732454
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,917
|
import.py
|
translate_pootle/tests/import_export/import.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
import pytest
from django.core.files.uploadedfile import SimpleUploadedFile
import pytest_pootle
from pytest_pootle.utils import create_store
from import_export.exceptions import UnsupportedFiletypeError
from import_export.utils import import_file
from pootle_app.models.permissions import check_user_permission
from pootle_statistics.models import SubmissionTypes
from pootle_store.constants import NEW, OBSOLETE, PARSED, TRANSLATED
from pootle_store.models import Store, Unit
IMPORT_SUCCESS = "headers_correct.po"
IMPORT_UNSUPP_FILE = "tutorial.ts"
def _import_file(file_name, file_dir=None,
content_type="text/x-gettext-translation",
user=None):
if not file_dir:
file_dir = os.path.join(
os.path.dirname(pytest_pootle.__file__),
"data/po/tutorial/en")
with open(os.path.join(file_dir, file_name), "r") as f:
import_file(
SimpleUploadedFile(file_name, f.read(), content_type),
user=user)
@pytest.mark.django_db
def test_import_success(project0_nongnu, store0, admin):
assert store0.state == NEW
_import_file(IMPORT_SUCCESS, user=admin)
store = Store.objects.get(pk=store0.pk)
assert store.state == PARSED
@pytest.mark.django_db
def test_import_failure(po_directory, en_tutorial_po,
file_import_failure, member):
filename, exception = file_import_failure
with pytest.raises(exception):
_import_file(filename, user=member)
@pytest.mark.django_db
def test_import_unsupported(po_directory, en_tutorial_ts,
ts_directory, member):
with pytest.raises(UnsupportedFiletypeError):
_import_file(IMPORT_UNSUPP_FILE,
file_dir=os.path.join(ts_directory, "tutorial/en"),
content_type="text/vnd.trolltech.linguist",
user=member)
@pytest.mark.django_db
def test_import_new_file(project0_nongnu, import_tps, site_users):
tp = import_tps
user = site_users["user"]
store_pootle_path = tp.pootle_path + "import_new_file.po"
filestore = create_store(store_pootle_path, "0",
[("Unit Source", "Unit Target", False)])
# New store can't be created via current import command. This test will
# need to be adjusted if we allow to create new stores via import command.
from import_export.exceptions import FileImportError
with pytest.raises(FileImportError):
import_file(SimpleUploadedFile("import_new_file.po",
str(filestore),
"text/x-gettext-translation"), user)
@pytest.mark.django_db
def test_import_to_empty(project0_nongnu, import_tps, site_users):
from pytest_pootle.factories import StoreDBFactory
tp = import_tps
user = site_users["user"]
store = StoreDBFactory(translation_project=tp, name="import_to_empty.po")
filestore = create_store(store.pootle_path, "0",
[("Unit Source", "Unit Target", False)])
import_file(SimpleUploadedFile(store.name,
str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
if allow_add_and_obsolete:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 1
unit_source = store.units[0].unit_source
assert unit_source.created_with == SubmissionTypes.UPLOAD
assert unit_source.created_by == user
assert store.units[0].change.changed_with == SubmissionTypes.UPLOAD
assert store.units[0].change.submitted_by == user
else:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 0
@pytest.mark.django_db
def test_import_add_and_obsolete_units(project0_nongnu, import_tps,
site_users):
from pytest_pootle.factories import StoreDBFactory, UnitDBFactory
tp = import_tps
user = site_users["user"]
store = StoreDBFactory(translation_project=tp)
unit = UnitDBFactory(store=store, state=TRANSLATED)
filestore = create_store(
store.pootle_path,
"0",
[(unit.source_f + " REPLACED", unit.target_f + " REPLACED", False)])
import_file(SimpleUploadedFile("import_add_and_obsolete.po",
str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
if allow_add_and_obsolete:
assert Unit.objects.filter(store=store, state=OBSOLETE).count() == 1
assert store.units.filter(state=TRANSLATED).count() == 1
unit_source = store.units[0].unit_source
assert unit_source.created_with == SubmissionTypes.UPLOAD
assert unit_source.created_by == user
assert store.units[0].change.changed_with == SubmissionTypes.UPLOAD
assert store.units[0].change.submitted_by == user
assert Unit.objects.filter(store=store).count() == 2
else:
assert store.units.all().count() == 1
| 5,978
|
Python
|
.py
| 121
| 38.31405
| 78
| 0.63036
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,918
|
user.py
|
translate_pootle/tests/pootle_log/user.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.delegate import log
from pootle_log.utils import UserLog
@pytest.mark.django_db
def test_user_log(admin):
user_log = log.get(admin.__class__)(admin)
assert isinstance(user_log, UserLog)
assert list(user_log.get_events())
suggestions = admin.suggestions.all() | admin.reviews.all()
assert (
list(user_log.suggestion_qs.values_list("pk", flat=True))
== list(suggestions.values_list("pk", flat=True)))
assert (
list(user_log.submission_qs.values_list("pk", flat=True))
== list(admin.submission_set.values_list("pk", flat=True)))
| 893
|
Python
|
.py
| 22
| 36.818182
| 77
| 0.712471
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,919
|
event.py
|
translate_pootle/tests/pootle_log/event.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from datetime import datetime
import pytest
from pootle_log.utils import LogEvent
@pytest.mark.django_db
def test_log_event(store0, member):
unit = store0.units.first()
ts = datetime.now()
log_event = LogEvent(unit, member, ts, "do_foo", "FOO")
assert log_event.unit == unit
assert log_event.timestamp == ts
assert log_event.user == member
assert log_event.action == "do_foo"
assert log_event.value == "FOO"
assert log_event.old_value is None
assert log_event.revision is None
| 797
|
Python
|
.py
| 22
| 33.181818
| 77
| 0.727273
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,920
|
log.py
|
translate_pootle/tests/pootle_log/log.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from datetime import timedelta
from django.contrib.auth import get_user_model
from django.utils import timezone
from pytest_pootle.utils import create_store
from pootle.core.delegate import (comparable_event, grouped_events,
lifecycle, log, review)
from pootle_log.utils import (ComparableLogEvent, GroupedEvents, Log,
LogEvent, StoreLog, UnitLog)
from pootle_statistics.models import (
Submission, SubmissionFields, SubmissionTypes)
from pootle_store.constants import TRANSLATED, UNTRANSLATED
from pootle_store.models import Suggestion, UnitSource
def _get_mid_times(qs, field="creation_time"):
qs_start = qs.order_by(
field).values_list(
field, flat=True).first()
qs_end = qs.order_by(
field).values_list(
field, flat=True).last()
qs_delta = (qs_end - qs_start) / 3
qs_start += qs_delta
qs_end -= qs_delta
return qs_start, qs_end
def test_log_base():
base_log = Log()
assert base_log.event == LogEvent
assert (
base_log.subtypes
== {getattr(SubmissionTypes, n): n.lower()
for n in ["WEB", "UPLOAD", "SYSTEM"]})
assert (
base_log.subfields
== {getattr(SubmissionFields, n): n.lower()
for n
in ["SOURCE", "TARGET", "STATE", "COMMENT", "CHECK"]})
@pytest.mark.django_db
def test_log_filter_store(store0):
subs = Submission.objects.all()
suggestions = Suggestion.objects.all()
unit_sources = UnitSource.objects.all()
for qs in [subs, suggestions, unit_sources]:
assert (
list(
Log().filter_store(
qs,
store0.pk))
== list(qs.filter(unit__store=store0)))
# None should return original qs
assert (
Log().filter_store(qs, None)
== qs)
@pytest.mark.django_db
def test_log_filter_path(tp0, store0):
subs = Submission.objects.all()
suggestions = Suggestion.objects.all()
unit_sources = UnitSource.objects.all()
for path in [tp0.pootle_path, store0.pootle_path]:
for qs in [subs, suggestions, unit_sources]:
assert (
list(Log().filter_path(qs, path))
== list(
qs.filter(
unit__store__pootle_path__startswith=path)))
# None should return original qs
assert Log().filter_path(qs, None) == qs
@pytest.mark.django_db
def test_log_filter_users(member):
subs = Submission.objects.all()
suggestions = Suggestion.objects.all()
unit_sources = UnitSource.objects.all()
assert (
list(Log().filter_users(subs, [member.id]))
== list(
subs.filter(submitter=member)))
assert (
list(Log().filter_users(suggestions, [member.id], field="user_id"))
== list(
suggestions.filter(user=member)))
assert (
list(Log().filter_users(suggestions, [member.id], field="reviewer_id"))
== list(
suggestions.filter(reviewer=member)))
assert (
list(Log().filter_users(unit_sources, [member.id], field="created_by_id"))
== list(
unit_sources.filter(created_by=member)))
# None should filter system users
assert (
list(Log().filter_users(unit_sources, None, field="created_by_id"))
== list(
unit_sources.exclude(
created_by__username__in=get_user_model().objects.META_USERS)))
# or return original qs otherwise
assert (
Log().filter_users(
unit_sources, None, field="created_by_id", include_meta=True)
== unit_sources)
# None should filter system users
assert (
list(Log().filter_users(suggestions, None, field="user_id"))
== list(
suggestions.exclude(
user__username__in=get_user_model().objects.META_USERS)))
# or return original qs otherwise
assert (
Log().filter_users(suggestions, None, field="user_id", include_meta=True)
== suggestions)
# None should filter system users
assert (
list(Log().filter_users(subs, None, field="submitter_id"))
== list(
subs.exclude(
submitter__username__in=get_user_model().objects.META_USERS)))
# or return original qs otherwise
assert (
Log().filter_users(subs, None, field="submitter_id", include_meta=True)
== subs)
@pytest.mark.django_db
def test_log_filter_sub_timestamps(member):
subs = Submission.objects.all()
sub_start, sub_end = _get_mid_times(subs)
assert (
list(Log().filter_timestamps(subs, start=sub_start))
== list(
subs.filter(creation_time__gte=sub_start)))
assert (
list(Log().filter_timestamps(subs, end=sub_end))
== list(
subs.filter(creation_time__lt=sub_end)))
assert (
list(Log().filter_timestamps(
subs, start=sub_start, end=sub_end))
== list(
subs.filter(
creation_time__lt=sub_end).filter(
creation_time__gte=sub_start)))
# None should return original qs
assert Log().filter_timestamps(subs, start=None, end=None) == subs
@pytest.mark.django_db
def test_log_filter_sugg_timestamps(member):
suggs = Suggestion.objects.all()
sugg_start, sugg_end = _get_mid_times(suggs)
assert (
list(Log().filter_timestamps(suggs, start=sugg_start))
== list(
suggs.filter(creation_time__gte=sugg_start)))
assert (
list(Log().filter_timestamps(suggs, end=sugg_end))
== list(
suggs.filter(creation_time__lt=sugg_end)))
assert (
list(Log().filter_timestamps(suggs, start=sugg_start, end=sugg_end))
== list(
suggs.filter(
creation_time__lt=sugg_end).filter(
creation_time__gte=sugg_start)))
# None should return original qs
assert Log().filter_timestamps(suggs, start=None, end=None) == suggs
@pytest.mark.django_db
def test_log_filter_unit_create_timestamps(member):
unit_creates = UnitSource.objects.all()
unit_create_start, unit_create_end = _get_mid_times(
unit_creates, field="unit__creation_time")
assert (
list(Log().filter_timestamps(
unit_creates,
start=unit_create_start,
field="unit__creation_time"))
== list(
unit_creates.filter(
unit__creation_time__gte=unit_create_start)))
assert (
list(Log().filter_timestamps(
unit_creates,
end=unit_create_end,
field="unit__creation_time"))
== list(
unit_creates.filter(
unit__creation_time__lt=unit_create_end)))
assert (
list(Log().filter_timestamps(
unit_creates,
start=unit_create_start,
end=unit_create_end,
field="unit__creation_time"))
== list(
unit_creates.filter(
unit__creation_time__lt=unit_create_end).filter(
unit__creation_time__gte=unit_create_start)))
# None should return original qs
assert (
Log().filter_timestamps(
unit_creates,
start=None,
end=None,
field="unit__creation_time")
== unit_creates)
@pytest.mark.django_db
def test_log_filtered_suggestions(member, tp0, store0):
suggs = Suggestion.objects.all()
sugg_start, sugg_end = _get_mid_times(suggs)
sugg_log = Log()
# no filtering
assert (
sugg_log.filtered_suggestions().count()
== sugg_log.suggestions.count()
== suggs.count())
user_suggestions = (
sugg_log.filter_users(
sugg_log.suggestions,
[member],
field="user_id")
| sugg_log.filter_users(
sugg_log.suggestions,
[member],
field="reviewer_id"))
assert user_suggestions
assert (
list(user_suggestions.order_by("id"))
== list(sugg_log.filtered_suggestions(
users=[member]).order_by("id")))
time_suggestions = (
sugg_log.filter_timestamps(
sugg_log.suggestions,
start=sugg_start,
end=sugg_end)
| sugg_log.filter_timestamps(
sugg_log.suggestions,
start=sugg_start,
end=sugg_end,
field="review_time"))
assert time_suggestions
assert (
list(time_suggestions.order_by("id"))
== list(sugg_log.filtered_suggestions(
start=sugg_start, end=sugg_end).order_by("id")))
user_time_suggestions = (
(sugg_log.filter_users(
sugg_log.suggestions,
[member],
field="user_id")
& sugg_log.filter_timestamps(
sugg_log.suggestions,
start=sugg_start,
end=sugg_end))
| (sugg_log.filter_users(
sugg_log.suggestions,
[member],
field="reviewer_id")
& sugg_log.filter_timestamps(
sugg_log.suggestions,
start=sugg_start,
end=sugg_end,
field="review_time")))
assert user_time_suggestions
assert (
list(user_time_suggestions.order_by("id"))
== list(sugg_log.filtered_suggestions(
start=sugg_start, end=sugg_end, users=[member]).order_by("id")))
store_suggestions = sugg_log.filter_store(
sugg_log.suggestions, store0.pk)
assert store_suggestions
assert (
list(store_suggestions.order_by("id"))
== list(sugg_log.filtered_suggestions(
store=store0.id).order_by("id")))
path_suggestions = sugg_log.filter_path(
sugg_log.suggestions, tp0.pootle_path)
assert path_suggestions.count()
assert (
path_suggestions.count()
== sugg_log.filtered_suggestions(path=tp0.pootle_path).count())
@pytest.mark.django_db
def test_log_filtered_submissions(member, tp0, store0):
subs = Submission.objects.all()
sub_start, sub_end = _get_mid_times(subs)
sub_log = Log()
# no filtering
assert (
sub_log.filtered_submissions().count()
== sub_log.submissions.count()
== subs.count())
user_subs = (
sub_log.filter_users(
sub_log.submissions,
users=[member]))
assert user_subs.count()
assert (
list(user_subs)
== list(sub_log.filtered_submissions(users=[member])))
time_subs = (
sub_log.filter_timestamps(
sub_log.submissions,
start=sub_start,
end=sub_end))
assert time_subs.count()
assert (
list(time_subs)
== list(sub_log.filtered_submissions(
start=sub_start, end=sub_end)))
store_subs = (
sub_log.filter_store(
sub_log.submissions,
store0.pk))
assert store_subs.count()
assert (
list(sub_log.submissions.filter(unit__store_id=store0.pk))
== list(store_subs))
path_subs = (
sub_log.filter_path(
sub_log.submissions,
tp0.pootle_path))
assert path_subs.count()
assert (
sub_log.submissions.filter(
unit__store__pootle_path__startswith=tp0.pootle_path).count()
== path_subs.count())
@pytest.mark.django_db
def test_log_filtered_created_units(system, tp0, store0):
created_units = UnitSource.objects.all()
created_unit_start, created_unit_end = _get_mid_times(
created_units, field="unit__creation_time")
created_unit_log = Log()
# no filtering
assert (
created_unit_log.filtered_created_units(include_meta=True).count()
== created_unit_log.created_units.count()
== created_units.count())
user_created_units = created_unit_log.filter_users(
created_unit_log.created_units,
[system.id],
field="created_by_id",
include_meta=True)
assert user_created_units.count()
assert (
list(user_created_units)
== list(created_unit_log.filtered_created_units(
users=[system])))
# using start and end seems to create empty - so only testing start
time_created_units = created_unit_log.filter_timestamps(
created_unit_log.created_units,
start=created_unit_start,
field="unit__creation_time")
assert time_created_units.count()
assert (
list(time_created_units)
== list(created_unit_log.filtered_created_units(
start=created_unit_start, include_meta=True)))
store_created_units = created_unit_log.filter_store(
created_unit_log.created_units,
store0.pk)
assert store_created_units.count()
assert (
list(created_unit_log.filtered_created_units(
store=store0.pk, include_meta=True))
== list(store_created_units))
path_created_units = created_unit_log.filter_path(
created_unit_log.created_units,
tp0.pootle_path)
assert path_created_units.count()
assert (
created_unit_log.filtered_created_units(
path=tp0.pootle_path, include_meta=True).count()
== path_created_units.count())
@pytest.mark.django_db
def test_log_get_created_units(system, store0):
created_units = UnitSource.objects.all()
created_unit_log = Log()
created = created_unit_log.get_created_unit_events(
include_meta=True)
assert type(created).__name__ == "generator"
assert len(list(created)) == created_units.count()
expected = created_units.filter(
created_by=system).filter(
unit__store=store0).in_bulk()
result = created_unit_log.get_created_unit_events(
store=store0.pk, users=[system])
for event in result:
created_unit = expected[event.value.pk]
assert isinstance(event, created_unit_log.event)
assert event.unit == created_unit.unit
assert event.user == created_unit.created_by
assert event.timestamp == created_unit.unit.creation_time
assert event.action == "unit_created"
assert event.value == created_unit
@pytest.mark.django_db
def test_log_get_submissions(member, store0):
submissions = Submission.objects.all()
submission_log = Log()
sub_events = submission_log.get_submission_events()
unit0 = store0.units[0]
unit0.source = "new source"
unit0.save(user=member)
lifecycle.get(unit0.__class__)(unit0).change()
unit1 = store0.units[0]
unit1.translator_comment = "new comment"
unit1.save(user=member)
lifecycle.get(unit1.__class__)(unit1).change()
qc = store0.units.filter(
qualitycheck__isnull=False)[0].qualitycheck_set.all()[0]
lifecycle.get(qc.unit.__class__)(qc.unit).sub_mute_qc(
submitter=member, quality_check=qc).save()
assert type(sub_events).__name__ == "generator"
assert len(list(sub_events)) == submissions.count()
expected = submissions.filter(
submitter=member).filter(
unit__store=store0).in_bulk()
result = submission_log.get_submission_events(
store=store0.pk, users=[member])
for event in result:
sub = expected[event.value.pk]
event_name = "state_changed"
if sub.field == SubmissionFields.CHECK:
event_name = (
"check_muted"
if sub.new_value == "0"
else "check_unmuted")
elif sub.field == SubmissionFields.TARGET:
event_name = "target_updated"
elif sub.field == SubmissionFields.SOURCE:
event_name = "source_updated"
elif sub.field == SubmissionFields.COMMENT:
event_name = "comment_updated"
assert isinstance(event, submission_log.event)
assert event.unit == sub.unit
assert event.user == sub.submitter
assert event.timestamp == sub.creation_time
assert event.action == event_name
assert event.value == sub
assert event.revision == sub.revision
@pytest.mark.django_db
def test_log_get_suggestions(member, store0):
suggestions = Suggestion.objects.all()
sugg_start, sugg_end = _get_mid_times(suggestions)
sugg_log = Log()
sugg_events = sugg_log.get_suggestion_events()
assert type(sugg_events).__name__ == "generator"
user_time_suggestions = (
(sugg_log.filter_users(
sugg_log.suggestions,
[member],
field="user_id")
& sugg_log.filter_timestamps(
sugg_log.suggestions,
start=sugg_start,
end=sugg_end))
| (sugg_log.filter_users(
sugg_log.suggestions,
[member],
field="reviewer_id")
& sugg_log.filter_timestamps(
sugg_log.suggestions,
start=sugg_start,
end=sugg_end,
field="review_time")))
assert user_time_suggestions
pending = suggestions.filter(
creation_time__gte=sugg_start,
creation_time__lt=sugg_end,
state__name="pending").first()
review.get(Suggestion)([pending], member).accept()
pending = suggestions.filter(
creation_time__gte=sugg_start,
creation_time__lt=sugg_end,
state__name="pending").first()
review.get(Suggestion)([pending], member).reject()
pending.review_time = sugg_start
pending.save()
expected = {}
for suggestion in user_time_suggestions.all():
add_event = (
(suggestion.creation_time >= sugg_start)
and (suggestion.creation_time < sugg_end)
and (suggestion.user == member))
review_event = (
(suggestion.review_time >= sugg_start)
and (suggestion.review_time < sugg_end)
and (suggestion.reviewer == member))
expected[suggestion.id] = {}
if add_event:
expected[suggestion.id]["suggestion_created"] = (
sugg_log.event(
suggestion.unit,
suggestion.user,
suggestion.creation_time,
"suggestion_created",
suggestion))
if review_event:
event_name = (
"suggestion_accepted"
if suggestion.state.name == "accepted"
else "suggestion_rejected")
expected[suggestion.id][event_name] = (
sugg_log.event(
suggestion.unit,
suggestion.reviewer,
suggestion.review_time,
event_name,
suggestion))
result = sugg_log.get_suggestion_events(
start=sugg_start, end=sugg_end, users=[member.id])
for event in result:
assert isinstance(event, sugg_log.event)
sugg_review = expected[event.value.pk][event.action]
assert event.unit == sugg_review.unit
assert event.action in [
"suggestion_created", "suggestion_accepted", "suggestion_rejected"]
assert event.user == (
sugg_review.value.user
if event.action == "suggestion_created"
else sugg_review.value.reviewer)
assert event.timestamp == (
sugg_review.value.creation_time
if event.action == "suggestion_created"
else sugg_review.value.review_time)
assert event.value == sugg_review.value
@pytest.mark.django_db
def test_log_get_events(site_users, store0):
user = site_users["user"]
event_log = Log()
kwargs = dict(users=[user], store=store0)
result = sorted(
event_log.get_events(**kwargs),
key=(lambda ev: (ev.timestamp, ev.unit.pk)))
expected = sorted(
list(event_log.get_created_unit_events(**kwargs))
+ list(event_log.get_suggestion_events(**kwargs))
+ list(event_log.get_submission_events(**kwargs)),
key=(lambda ev: (ev.timestamp, ev.unit.pk)))
assert (
[(x.timestamp, x.unit, x.action)
for x in result]
== [(x.timestamp, x.unit, x.action)
for x in expected])
@pytest.mark.django_db
def test_log_store(store0):
store_log = log.get(store0.__class__)(store0)
assert isinstance(store_log, StoreLog)
assert store_log.store == store0
assert all(
x == store0.id
for x
in store_log.submissions.values_list(
"unit__store_id", flat=True))
assert (
store_log.submissions.count()
== Submission.objects.filter(
unit__store_id=store0.id).count())
assert all(
x == store0.id
for x
in store_log.suggestions.values_list(
"unit__store_id", flat=True))
assert (
store_log.suggestions.count()
== Suggestion.objects.filter(
unit__store_id=store0.id).count())
assert (
store_log.created_units.count()
== UnitSource.objects.filter(
unit__store_id=store0.id).count())
assert all(
x == store0.id
for x
in store_log.created_units.values_list(
"unit__store_id", flat=True))
subs = store_log.submissions
assert (
store_log.filter_store(subs, store=store0.id)
== subs)
@pytest.mark.django_db
def test_log_unit(store0):
unit = store0.units.filter(state=TRANSLATED).first()
unit_log = log.get(unit.__class__)(unit)
assert isinstance(unit_log, UnitLog)
assert unit_log.unit == unit
assert all(
x == unit.id
for x
in unit_log.submissions.values_list(
"unit_id", flat=True))
assert (
unit_log.submissions.count()
== Submission.objects.filter(
unit_id=unit.id).count())
assert all(
x == unit.id
for x
in unit_log.suggestions.values_list(
"unit_id", flat=True))
assert (
unit_log.suggestions.count()
== Suggestion.objects.filter(
unit_id=unit.id).count())
assert (
unit_log.created_units.count()
== UnitSource.objects.filter(
unit_id=unit.id).count())
assert all(
x == unit.id
for x
in unit_log.created_units.values_list(
"unit_id", flat=True))
subs = unit_log.submissions
assert (
unit_log.filter_store(subs, store=unit.store.id)
== subs)
@pytest.mark.django_db
def test_comparable_log(member, store0, store_po):
assert comparable_event.get(Log) == ComparableLogEvent
start = timezone.now().replace(microsecond=0)
unit = store0.units.filter(state=TRANSLATED).first()
unit.target += 'UPDATED IN TEST'
unit.save(user=member)
unit = store0.units.filter(state=TRANSLATED).first()
unit.target += 'UPDATED IN TEST AGAIN'
unit.save(user=member)
unit_log = log.get(unit.__class__)(unit)
event1, event2 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)]
assert (event1 < event2) == (event1.revision < event2.revision)
assert (event2 < event1) == (event2.revision < event1.revision)
unit = store0.units.filter(state=UNTRANSLATED).first()
sugg1, created_ = review.get(Suggestion)().add(
unit,
unit.source_f + 'SUGGESTION',
user=member)
sugg2, created_ = review.get(Suggestion)().add(
unit,
unit.source_f + 'SUGGESTION AGAIN',
user=member)
Suggestion.objects.filter(id=sugg2.id).update(creation_time=sugg1.creation_time)
unit_log = log.get(unit.__class__)(unit)
event1, event2 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)]
assert (event1 < event2) == (event1.value.pk < event2.value.pk)
assert (event2 < event1) == (event2.value.pk < event1.value.pk)
Suggestion.objects.filter(id=sugg2.id).update(creation_time=None)
sugg2 = Suggestion.objects.get(id=sugg2.id)
event1 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)][0]
event2 = ComparableLogEvent(unit_log.event(sugg2.unit,
sugg2.user,
sugg2.creation_time,
"suggestion_created",
sugg2))
assert event2 < event1
assert not (event1 < event2)
units = [
('Unit 0 Source', 'Unit 0 Target', False),
('Unit 1 Source', '', False),
]
store_po.update(create_store(units=units))
unit1, unit2 = store_po.units
unit2.__class__.objects.filter(id=unit2.id).update(
creation_time=unit1.creation_time)
store_log = log.get(store_po.__class__)(store_po)
event1, event2 = [ComparableLogEvent(x)
for x in
store_log.get_events()]
assert (event1 < event2) == (event1.unit.id < event2.unit.id)
assert (event2 < event1) == (event2.unit.id < event1.unit.id)
creation_time = unit1.creation_time + timedelta(seconds=1)
unit2.__class__.objects.filter(id=unit2.id).update(creation_time=creation_time)
event1, event2 = [ComparableLogEvent(x)
for x in
store_log.get_events()]
assert (event1 < event2) == (event1.timestamp < event2.timestamp)
assert (event2 < event1) == (event2.timestamp < event1.timestamp)
unit = store_po.units.filter(state=UNTRANSLATED)[0]
unit.target = 'Unit 1 Target'
unit.save()
unit_log = log.get(unit.__class__)(unit)
event1, event2 = [ComparableLogEvent(x)
for x in unit_log.get_submission_events()]
assert not (event1 < event2) and not (event2 < event1)
assert not (event1 < event1) and not (event1 > event1)
@pytest.mark.django_db
def test_grouped_events(store_po):
assert grouped_events.get(Log) == GroupedEvents
units = [
('Unit 0 Source', 'Unit 0 Target', False),
('Unit 1 Source', '', False),
('Unit 2 Source', 'Unit 2 Fuzzy Target', True),
]
store_po.update(create_store(units=units))
units = [
('Unit 0 Source', 'Unit 0 Target', False),
('Unit 1 Source', 'Unit 1 Target', False),
('Unit 2 Source', 'Unit 2 Target', False),
]
store_po.update(create_store(units=units))
store_log = log.get(store_po.__class__)(store_po)
expected = [
(x.unit, x.user, x.timestamp, x.action, x.value, x.old_value, x.revision)
for x in sorted([
ComparableLogEvent(ev)
for ev in store_log.get_events()])]
result = [
(x.unit, x.user, x.timestamp, x.action, x.value, x.old_value, x.revision)
for x in GroupedEvents(store_log).sorted_events()]
assert expected == result
| 27,245
|
Python
|
.py
| 713
| 29.28331
| 84
| 0.603625
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,921
|
models.py
|
translate_pootle/tests/pootle_project/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_project.models import Project
@pytest.mark.django_db
def test_project_create_defaults(settings, english):
foo0 = Project.objects.create(
code="foo0",
fullname="Project Foo 0",
source_language=english)
assert foo0.config["pootle_fs.fs_type"] == "localfs"
assert "{POOTLE_TRANSLATION_DIRECTORY}%s" % foo0.code
| 649
|
Python
|
.py
| 17
| 34.823529
| 77
| 0.734076
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,922
|
utils.py
|
translate_pootle/tests/pootle_project/utils.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.delegate import paths
from pootle_project.utils import ProjectPaths
from pootle_store.models import Store
@pytest.mark.django_db
def test_paths_project_util(project0):
project_paths = paths.get(project0.__class__)(project0, "1")
assert isinstance(project_paths, ProjectPaths)
assert project_paths.context == project0
assert (
sorted(project_paths.store_qs.values_list("pk", flat=True))
== sorted(
Store.objects.filter(
translation_project__project=project0).values_list(
"pk", flat=True)))
| 880
|
Python
|
.py
| 22
| 35.181818
| 77
| 0.715457
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,923
|
panels.py
|
translate_pootle/tests/pootle_project/panels.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.template import loader
from pootle.core.browser import get_table_headings
from pootle.core.delegate import panels
from pootle_app.models.permissions import get_matching_permissions
from pootle_app.panels import ChildrenPanel
from pootle_project.views import ProjectBrowseView, ProjectsBrowseView
@pytest.mark.django_db
def test_panel_project_table(project0, rf, member):
request = rf.get('/projects/project0/')
request.user = member
request.permissions = get_matching_permissions(
request.user,
project0.directory)
view = ProjectBrowseView(
kwargs=dict(
project_code=project0.code,
dir_path=None,
filename=None))
view.request = request
view.object = view.get_object()
lang_panels = panels.gather(ProjectBrowseView)
assert lang_panels.keys() == ["children"]
assert lang_panels["children"] == ChildrenPanel
panel = ChildrenPanel(view)
assert panel.panel_name == "children"
assert (
panel.cache_key
== ("panel.%s.%s"
% (panel.panel_name, view.cache_key)))
table = {
'id': view.view_name,
'fields': panel.table_fields,
'headings': get_table_headings(panel.table_fields),
'rows': view.object_children}
assert panel.table == table
assert panel.get_context_data() == dict(
table=table, can_translate=view.can_translate)
content = loader.render_to_string(
panel.template_name, context=panel.get_context_data())
assert (
panel.content
== panel.update_times(content))
@pytest.mark.django_db
def test_panel_projects_table(rf, member, project0):
request = rf.get('/projects/')
request.user = member
request.permissions = get_matching_permissions(
request.user,
project0.directory.parent)
view = ProjectsBrowseView()
view.request = request
view.object = view.get_object()
lang_panels = panels.gather(ProjectsBrowseView)
assert lang_panels.keys() == ["children"]
assert lang_panels["children"] == ChildrenPanel
panel = ChildrenPanel(view)
assert panel.panel_name == "children"
assert (
panel.cache_key
== ("panel.%s.%s"
% (panel.panel_name, view.cache_key)))
table = {
'id': view.view_name,
'fields': panel.table_fields,
'headings': get_table_headings(panel.table_fields),
'rows': view.object_children}
assert panel.table == table
assert panel.get_context_data() == dict(
table=table, can_translate=view.can_translate)
content = loader.render_to_string(
panel.template_name, context=panel.get_context_data())
assert (
panel.content
== panel.update_times(content))
@pytest.mark.django_db
def test_panel_project_store_table(project0, store0, rf, member):
request = rf.get('/projects/project0/store0')
request.user = member
request.permissions = get_matching_permissions(
request.user,
project0.directory.parent)
view = ProjectBrowseView(
kwargs=dict(
project_code=project0.code,
dir_path="",
filename=store0.name))
view.request = request
view.object = view.get_object()
lang_panels = panels.gather(ProjectBrowseView)
assert lang_panels.keys() == ["children"]
assert lang_panels["children"] == ChildrenPanel
panel = ChildrenPanel(view)
assert panel.panel_name == "children"
assert (
panel.cache_key
== ("panel.%s.%s"
% (panel.panel_name, view.cache_key)))
table = {
'id': view.view_name,
'fields': panel.table_fields,
'headings': get_table_headings(panel.table_fields),
'rows': view.object_children}
assert panel.table == table
assert panel.get_context_data() == dict(
table=table, can_translate=view.can_translate)
content = loader.render_to_string(
panel.template_name, context=panel.get_context_data())
assert (
panel.content
== panel.update_times(content))
| 4,376
|
Python
|
.py
| 118
| 30.737288
| 77
| 0.669573
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,924
|
forms.py
|
translate_pootle/tests/pootle_project/forms.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_language.models import Language
from pootle_project.forms import TranslationProjectForm
@pytest.mark.django_db
def test_form_project_tp(tp0):
form = TranslationProjectForm(
instance=tp0,
data=dict(
project=tp0.project.pk,
language=tp0.language.pk))
assert form.is_valid()
assert form.cleaned_data["project"] == tp0.project
assert form.cleaned_data["language"] == tp0.language
assert form.cleaned_data["fs_code"] == ""
form = TranslationProjectForm(
instance=tp0,
data=dict(
project=tp0.project.pk,
language=tp0.language.pk,
fs_code="foo"))
assert form.is_valid()
assert form.cleaned_data["fs_code"] == "foo"
form.save()
project = tp0.project
del project.__dict__["config"]
assert (
tp0.project.config[
"pootle.core.lang_mapping"]["foo"]
== tp0.language.code)
tp1 = project.translationproject_set.get(
language__code="language1")
form = TranslationProjectForm(
instance=tp1,
data=dict(
project=tp1.project.pk,
language=tp1.language.pk,
fs_code="foo"))
assert not form.is_valid()
assert form.errors.keys() == ["fs_code"]
form = TranslationProjectForm(
instance=tp1,
data=dict(
project=tp1.project.pk,
language=tp1.language.pk,
fs_code=tp0.language.code))
assert not form.is_valid()
assert form.errors.keys() == ["fs_code"]
new_language = Language.objects.create(code="foo")
form = TranslationProjectForm(
initial=dict(project=project.pk),
data=dict(
project=tp1.project.pk,
language=new_language.pk))
assert not form.is_valid()
assert form.errors.keys() == ["language"]
form = TranslationProjectForm(
instance=tp0,
data=dict(
project=tp0.project.pk,
language=tp0.language.pk,
fs_code=""))
assert form.is_valid()
assert form.cleaned_data["fs_code"] == ""
form.save()
del project.__dict__["config"]
assert (
"foo" not in
project.config[
"pootle.core.lang_mapping"])
| 2,536
|
Python
|
.py
| 76
| 26.144737
| 77
| 0.628513
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,925
|
views.py
|
translate_pootle/tests/pootle_project/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import json
import pytest
from django.core.urlresolvers import reverse
from pootle.core.browser import (
make_language_item, make_project_list_item, make_xlanguage_item)
from pootle.core.forms import PathsSearchForm
from pootle.core.signals import update_revisions
from pootle.core.views.browse import StatsDisplay
from pootle_app.models import Directory
from pootle_misc.util import cmp_by_last_activity
from pootle_project.models import Project, ProjectResource, ProjectSet
from pootle_project.views import ProjectBrowseView, ProjectsBrowseView
from pootle_store.models import Store
def _test_view_project_children(view, project):
request = view.request
kwargs = view.kwargs
resource_path = (
"%(dir_path)s%(filename)s" % kwargs)
project_path = (
"%s/%s"
% (kwargs["project_code"], resource_path))
if not (kwargs["dir_path"] or kwargs["filename"]):
obj = project
elif not kwargs["filename"]:
obj = ProjectResource(
Directory.objects.live().filter(
pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path)
else:
obj = ProjectResource(
Store.objects.live().filter(
pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path)
item_func = (
make_xlanguage_item
if (kwargs["dir_path"]
or kwargs["filename"])
else make_language_item)
items = [
item_func(item)
for item
in obj.get_children_for_user(request.user)
]
stats = obj.data_tool.get_stats(user=request.user)
stats = StatsDisplay(obj, stats=stats).stats
for item in items:
if item["code"] in stats["children"]:
item["stats"] = stats["children"][item["code"]]
items.sort(cmp_by_last_activity)
assert view.object_children == items
@pytest.mark.django_db
def test_view_project_children(project0, rf, request_users):
request = rf.get('/projects/project0/')
request.user = request_users["user"]
view = ProjectBrowseView(
kwargs=dict(
project_code=project0.code,
dir_path="",
filename=""))
view.request = request
view.object = view.get_object()
assert view.object == project0
_test_view_project_children(view, project0)
@pytest.mark.django_db
def test_view_project_subdir_children(project0, subdir0, rf, request_users):
request = rf.get('/projects/project0/subdir0/')
request.user = request_users["user"]
view = ProjectBrowseView(
kwargs=dict(
project_code=project0.code,
dir_path=subdir0.tp_path[1:],
filename=""))
view.request = request
view.object = view.get_object()
assert isinstance(view.object, ProjectResource)
_test_view_project_children(view, project0)
@pytest.mark.django_db
def test_view_project_store_children(project0, store0, rf, request_users):
request = rf.get('/projects/project0/store0.po')
request.user = request_users["user"]
view = ProjectBrowseView(
kwargs=dict(
project_code=project0.code,
dir_path="",
filename=store0.name))
view.request = request
view.object = view.get_object()
assert isinstance(view.object, ProjectResource)
_test_view_project_children(view, project0)
@pytest.mark.django_db
def test_view_project_set_children(project0, store0, rf, request_users):
request = rf.get('/projects/')
request.user = request_users["user"]
view = ProjectsBrowseView()
view.request = request
view.object = view.get_object()
assert isinstance(view.object, ProjectSet)
items = [
make_project_list_item(project)
for project
in view.object.children]
view.add_child_stats(items)
items.sort(cmp_by_last_activity)
assert view.object_children == items
@pytest.mark.django_db
def test_view_project_paths_bad(project0, client, request_users):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
url = reverse(
"pootle-project-paths",
kwargs=dict(project_code=project0.code))
# no xhr header
response = client.post(url)
assert response.status_code == 400
# no query
response = client.post(
url, HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 400
# query too short
response = client.post(
url,
data=dict(q="xy"),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 400
@pytest.mark.django_db
def test_view_project_paths(project0, store0, client, request_users):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
url = reverse(
"pootle-project-paths",
kwargs=dict(project_code=project0.code))
response = client.post(
url,
data=dict(q="tore"),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 200
result = json.loads(response.content)
path_form = PathsSearchForm(context=project0, data=dict(q="tore"))
assert path_form.is_valid()
assert result["items"] == path_form.search(show_all=user.is_superuser)
assert "store0.po" in result["items"]["results"]
stores = Store.objects.filter(name=store0.name)
for store in stores:
store.obsolete = True
store.save()
update_revisions.send(
store.__class__,
instance=store,
keys=["stats"])
response = client.post(
url,
data=dict(q="tore"),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 200
result = json.loads(response.content)
assert "store0.po" not in result["items"]["results"]
@pytest.mark.django_db
def test_view_projects_api(project0, client, request_users):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get(reverse('pootle-xhr-admin-projects'))
if not user.is_superuser:
assert response.status_code == 403
return
result = json.loads(response.content)
assert result["count"] == Project.objects.count()
for project in result["models"]:
if project["code"] == project0.code:
assert project["pk"] == project0.pk
assert project["checkstyle"] == project0.checkstyle
assert (
project["screenshot_search_prefix"]
== project0.screenshot_search_prefix)
assert project["ignoredfiles"] == project0.ignoredfiles
assert project["source_language"] == project0.source_language.pk
assert project["disabled"] == project0.disabled
assert project["report_email"] == project0.report_email
assert project["fs_plugin"] == project0.config["pootle_fs.fs_type"]
assert project["fs_url"] == project0.config["pootle_fs.fs_url"]
assert (
project["fs_mapping"]
== project0.config[
"pootle_fs.translation_mappings"]["default"])
assert (
project["filetypes"]
== [str(x)
for x
in project0.filetypes.values_list("pk", flat=True)])
| 7,746
|
Python
|
.py
| 201
| 31.333333
| 79
| 0.65355
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,926
|
models.py
|
translate_pootle/tests/pootle_word/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.core.exceptions import ValidationError
from django.db.utils import IntegrityError
from pootle_word.models import Stem
@pytest.mark.django_db
def test_word_stem_repr(store0):
stem = Stem.objects.create(root="foo")
assert repr(stem) == "<Stem: \"foo\", units: []>"
unit_stem = stem.units.through
unit_stem.objects.bulk_create(
unit_stem(stem=stem, unit_id=unit)
for unit
in store0.units[:5].values_list("id", flat=True))
assert (
repr(stem)
== ("<Stem: \"foo\", units: %s>"
% list(stem.units.values_list("id", flat=True))))
@pytest.mark.django_db
def test_word_stem_instance(store0):
stem1 = Stem.objects.create(root="foo")
unit_stem = stem1.units.through
unit_stem.objects.bulk_create(
unit_stem(stem=stem1, unit_id=unit)
for unit
in store0.units[:5].values_list("id", flat=True))
stem2 = Stem.objects.create(root="brows")
unit_stem = stem2.units.through
unit_stem.objects.bulk_create(
unit_stem(stem=stem2, unit_id=unit)
for unit
in store0.units[:5].values_list("id", flat=True))
for unit in store0.units[:5]:
stems = unit.stems.all()
assert stem1 in stems
assert stem2 in stems
@pytest.mark.django_db
def test_word_stem_bad_no_root(store0):
with pytest.raises(ValidationError):
Stem.objects.create()
@pytest.mark.django_db
def test_word_stem_bad_dupe(store0):
Stem.objects.create(root="foo")
with pytest.raises(ValidationError):
Stem.objects.create(root="foo")
@pytest.mark.django_db
def test_word_stem_bad_dupe_unit(store0):
stem = Stem.objects.create(root="foo")
stem.units.through.objects.create(
stem=stem, unit=store0.units[0])
with pytest.raises(IntegrityError):
stem.units.through.objects.create(
stem=stem, unit=store0.units[0])
| 2,192
|
Python
|
.py
| 59
| 31.864407
| 77
| 0.684434
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,927
|
utils.py
|
translate_pootle/tests/pootle_word/utils.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
import Levenshtein
from stemming.porter2 import stem
import translate
import pytest
from pootle.core.delegate import stemmer, stopwords, text_comparison
from pootle_word.utils import TextComparison
def test_stemmer():
assert stemmer.get() is stem
def test_stopwords():
ttk_path = translate.__path__[0]
fpath = (
os.path.join(ttk_path, "share", "stoplist-en")
if "share" in os.listdir(ttk_path)
else os.path.join(ttk_path, "..", "share", "stoplist-en"))
words = set()
with open(fpath) as f:
for line in f.read().split("\n"):
if not line:
continue
if line[0] in "<>=@":
words.add(line[1:].strip().lower())
stops = stopwords.get()
assert stops.words == words
@pytest.mark.django_db
def test_text_comparer():
comparer = text_comparison.get()("Cycling through the examples")
assert isinstance(comparer, TextComparison)
assert comparer.context == "Cycling through the examples"
assert comparer.text == comparer.context
assert comparer.tokens == [
word for word
in comparer.split(comparer.text.lower())
if word not in comparer.stopwords]
assert comparer.stems == set(comparer.stemmer(t) for t in comparer.tokens)
other_text = "cycle home"
other = text_comparison.get()(other_text)
assert (
comparer.jaccard_similarity(other)
== (len(other.stems.intersection(comparer.stems))
/ float(len(set(other.stems).union(comparer.stems)))))
assert (
comparer.levenshtein_distance(other)
== (Levenshtein.distance(comparer.text, other.text)
/ max(len(comparer.text), len(other.text))))
assert (
comparer.tokens_present(other)
== (len(set(comparer.tokens).intersection(other.tokens))
/ float(len(other.tokens))))
assert (
comparer.stems_present(other)
== (len(set(comparer.stems).intersection(other.stems))
/ float(len(other.stems))))
assert (
comparer.similarity(other_text)
== ((comparer.jaccard_similarity(other)
+ comparer.levenshtein_distance(other)
+ comparer.tokens_present(other)
+ comparer.stems_present(other))
/ 4))
| 2,574
|
Python
|
.py
| 67
| 31.701493
| 78
| 0.655711
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,928
|
formats.py
|
translate_pootle/tests/models/formats.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.db import IntegrityError
from pootle.core.delegate import formats
from pootle_format.default import POOTLE_FORMATS
from pootle_format.models import FileExtension, Format
from pootle_format.registry import FormatRegistry
def _test_formats(registry, keys):
formats = registry.formats
assert formats.keys() == keys
assert (
list(Format.objects.filter(enabled=True).values_list("name", flat=True))
== keys)
assert list(registry) == keys
assert registry.keys() == keys
assert registry.items() == formats.items()
assert registry.values() == formats.values()
for key in keys:
filetype = Format.objects.get(name=key)
assert formats[key] == registry[key]
assert (
sorted(formats[key].items())
== sorted(
dict(
pk=filetype.pk,
name=filetype.name,
display_title=str(filetype),
title=filetype.title,
extension=str(filetype.extension),
template_extension=str(filetype.template_extension)).items()))
@pytest.mark.django_db
def test_file_extension_instance():
"""Tests the creation of a file extension
"""
ext = FileExtension.objects.create(name="foo")
assert ext.name == "foo"
assert str(ext) == "foo"
@pytest.mark.django_db
def test_file_extension_bad():
"""Test that you cant add a duplicate file extension
"""
FileExtension.objects.create(name="foo")
with pytest.raises(IntegrityError):
FileExtension.objects.create(name="foo")
@pytest.mark.django_db
def test_format_instance():
"""Tests the creation of a file extension
"""
ext = FileExtension.objects.create(name="foo")
filetype = Format.objects.create(
extension=ext, template_extension=ext)
assert str(filetype.template_extension) == str(ext)
assert str(filetype) == "%s (%s/%s)" % (filetype.title, ext, ext)
@pytest.mark.django_db
def test_format_registry_instance(no_formats):
"""Tests the creation of a file extension
"""
registry = FormatRegistry()
_test_formats(registry, [])
filetype = registry.register("foo", "foo")
assert isinstance(filetype, Format)
assert filetype.name == "foo"
assert filetype.title == "Foo"
assert str(filetype.extension) == "foo"
_test_formats(registry, ["foo"])
@pytest.mark.django_db
def test_format_registry_reregister(no_formats):
"""Tests the creation of a file extension
"""
registry = FormatRegistry()
filetype = registry.register("foo", "foo")
# you can re-register the same format
new_filetype = registry.register("foo", "foo")
assert new_filetype == filetype
_test_formats(registry, ["foo"])
# but if you change anything it will be updated
new_filetype = registry.register("foo", "foo", title="Bar")
assert new_filetype == filetype
assert new_filetype.title == "Bar"
_test_formats(registry, ["foo"])
new_filetype = registry.register("foo", "bar")
assert new_filetype == filetype
assert new_filetype.title == "Bar"
assert str(new_filetype.extension) == "bar"
_test_formats(registry, ["foo"])
@pytest.mark.django_db
def test_format_registry_extensions(no_formats):
"""Tests the creation of a file extension
"""
registry = FormatRegistry()
filetype = registry.register("foo", "foo")
# 2 filetypes can have the same extension
filetype2 = registry.register("special_foo", "foo")
assert str(filetype.extension) == "foo"
assert str(filetype2.extension) == "foo"
_test_formats(registry, ["foo", "special_foo"])
@pytest.mark.django_db
def test_format_registry_template_extension(no_formats):
"""Tests the creation of a file extension
"""
registry = FormatRegistry()
filetype = registry.register(
"foo", "foo", template_extension="bar")
assert str(filetype.template_extension) == "bar"
_test_formats(registry, ["foo"])
# 2 filetypes can have the same template extensions
filetype2 = registry.register(
"special_foo", "foo", template_extension="bar")
assert str(filetype.template_extension) == "bar"
assert str(filetype2.template_extension) == "bar"
_test_formats(registry, ["foo", "special_foo"])
@pytest.mark.django_db
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]
| 5,014
|
Python
|
.py
| 126
| 34.222222
| 82
| 0.682922
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,929
|
project.py
|
translate_pootle/tests/models/project.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.core.exceptions import ValidationError
from pytest_pootle.factories import UserFactory
from pytest_pootle.fixtures.models.permission_set import _require_permission_set
from pytest_pootle.utils import items_equal
from pootle_format.models import Format
from pootle_project.models import Project, RESERVED_PROJECT_CODES
@pytest.mark.django_db
def test_create_project_good(english):
"""Tests projects are created with valid arguments only."""
proj = Project(code="hello", fullname="world", source_language=english)
proj.save()
proj.delete()
code_with_padding = " hello "
fullname_with_padding = " world "
proj = Project(code=code_with_padding, fullname="world",
source_language=english)
proj.save()
assert proj.code == code_with_padding.strip()
proj.delete()
proj = Project(code="hello", fullname=fullname_with_padding,
source_language=english)
proj.save()
assert proj.fullname == fullname_with_padding.strip()
proj.delete()
proj = Project(code=code_with_padding, fullname=fullname_with_padding,
source_language=english)
proj.save()
assert proj.code == code_with_padding.strip()
assert proj.fullname == fullname_with_padding.strip()
proj.delete()
@pytest.mark.django_db
def test_create_project_bad(english):
"""Tests projects are not created with bad arguments."""
with pytest.raises(ValidationError):
Project().save()
with pytest.raises(ValidationError):
Project(code="hello").save()
with pytest.raises(ValidationError):
Project(fullname="world").save()
with pytest.raises(ValidationError):
Project(source_language=english).save()
with pytest.raises(ValidationError):
Project(code="hello", fullname="world").save()
with pytest.raises(ValidationError):
Project(code="hello", source_language=english).save()
with pytest.raises(ValidationError):
Project(fullname="world", source_language=english).save()
with pytest.raises(ValidationError):
Project(code="", fullname="world", source_language=english).save()
with pytest.raises(ValidationError):
Project(code="hello", fullname="", source_language=english).save()
with pytest.raises(ValidationError):
Project(code=" ", fullname="world", source_language=english).save()
with pytest.raises(ValidationError):
Project(code="hello", fullname=" ", source_language=english).save()
@pytest.mark.parametrize('reserved_code', RESERVED_PROJECT_CODES)
@pytest.mark.django_db
def test_create_project_reserved_code(english, reserved_code):
"""Tests projects are not created with reserved project codes."""
with pytest.raises(ValidationError):
Project(
code=reserved_code,
fullname="whatever",
source_language=english
).save()
reserved_code_with_padding = " %s " % reserved_code
with pytest.raises(ValidationError):
Project(
code=reserved_code_with_padding,
fullname="whatever",
source_language=english
).save()
@pytest.mark.django_db
def test_project_save_no_code(project0):
"""Test that an existing project can't be removed its code."""
project0.code = ""
with pytest.raises(ValidationError):
project0.save()
@pytest.mark.django_db
def test_project_save_wrong_checker(project0):
"""Test that an existing project can't be removed its code."""
project0.checkstyle = "foobar"
with pytest.raises(ValidationError):
project0.save()
@pytest.mark.django_db
def test_project_save_no_fullname(project0):
"""Test that an existing project can't be removed its fullname."""
project0.fullname = ""
with pytest.raises(ValidationError):
project0.save()
@pytest.mark.django_db
def test_no_root_view_permissions(po_directory, nobody, default, admin, view,
no_permission_sets, no_projects,
project_foo, project_bar):
"""Tests user-accessible projects when there are no permissions set at
the root.
"""
ALL_PROJECTS = [project_foo.code, project_bar.code]
foo_user = UserFactory.create(username='foo')
bar_user = UserFactory.create(username='bar')
# By setting explicit `view` permissions for `foo_user` in `project_foo`,
# only `foo_user` will be able to access that project
_require_permission_set(foo_user, project_foo.directory, [view])
assert items_equal(Project.accessible_by_user(admin), ALL_PROJECTS)
assert items_equal(
Project.accessible_by_user(foo_user),
[project_foo.code])
assert items_equal(Project.accessible_by_user(bar_user), [])
assert items_equal(Project.accessible_by_user(default), [])
assert items_equal(Project.accessible_by_user(nobody), [])
# Now let's allow showing `project_bar` to all registered users, but keep
# `project_foo` visible only to `foo_user`.
_require_permission_set(default, project_bar.directory, [view])
assert items_equal(Project.accessible_by_user(admin), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(foo_user), ALL_PROJECTS)
assert items_equal(
Project.accessible_by_user(bar_user),
[project_bar.code])
assert items_equal(Project.accessible_by_user(default), [project_bar.code])
assert items_equal(Project.accessible_by_user(nobody), [])
@pytest.mark.django_db
def test_root_view_permissions(po_directory, nobody, default, admin, view,
no_projects, no_permission_sets,
project_foo, project_bar, root):
"""Tests user-accessible projects with view permissions at the root."""
ALL_PROJECTS = [project_foo.code, project_bar.code]
foo_user = UserFactory.create(username='foo')
bar_user = UserFactory.create(username='bar')
# We'll only give `bar_user` access to all projects server-wide
_require_permission_set(bar_user, root, [view])
assert items_equal(Project.accessible_by_user(admin), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(bar_user), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(foo_user), [])
assert items_equal(Project.accessible_by_user(default), [])
assert items_equal(Project.accessible_by_user(nobody), [])
# Now we'll also allow `foo_user` access `project_foo`
_require_permission_set(foo_user, project_foo.directory, [view])
assert items_equal(
Project.accessible_by_user(foo_user),
[project_foo.code])
# Let's change server-wide defaults: all registered users have access to
# all projects. `foo_user`, albeit having explicit access for
# `project_foo`, will be able to access any project because they fall back
# and extend with the defaults.
_require_permission_set(default, root, [view])
assert items_equal(Project.accessible_by_user(admin), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(foo_user), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(bar_user), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(default), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(nobody), [])
# Let's give anonymous users access to all projects too
_require_permission_set(nobody, root, [view])
assert items_equal(Project.accessible_by_user(nobody), ALL_PROJECTS)
@pytest.mark.django_db
def test_no_root_hide_permissions(po_directory, nobody, default, admin, hide,
view, no_projects, no_permission_sets,
project_foo, project_bar, root):
"""Tests user-accessible projects when there are no `hide` permissions
set at the root.
"""
ALL_PROJECTS = [project_foo.code, project_bar.code]
foo_user = UserFactory.create(username='foo')
bar_user = UserFactory.create(username='bar')
# By default everyone has access to projects
_require_permission_set(default, root, [view])
_require_permission_set(nobody, root, [view])
# At the same time, `project_foo` is inaccessible registered users...
_require_permission_set(default, project_foo.directory,
negative_permissions=[hide])
assert items_equal(Project.accessible_by_user(admin), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(default), [project_bar.code])
assert items_equal(Project.accessible_by_user(nobody), [project_bar.code])
assert items_equal(
Project.accessible_by_user(foo_user),
[project_bar.code])
assert items_equal(
Project.accessible_by_user(bar_user),
[project_bar.code])
# ...and anonymous users as well
_require_permission_set(nobody, project_foo.directory,
negative_permissions=[hide])
assert items_equal(Project.accessible_by_user(nobody), [project_bar.code])
# Let's make `project_foo` accessible for `foo_user`
_require_permission_set(foo_user, project_foo.directory, [view])
assert items_equal(Project.accessible_by_user(foo_user), ALL_PROJECTS)
# `project_bar` is now inaccessible for anonymous users
_require_permission_set(nobody, project_bar.directory,
negative_permissions=[hide])
assert items_equal(Project.accessible_by_user(nobody), [])
@pytest.mark.django_db
def test_root_hide_permissions(po_directory, nobody, default, admin, hide,
view, no_permission_sets, no_projects,
project_foo, project_bar, root):
"""Tests user-accessible projects when there are `hide` permissions
set at the root.
"""
ALL_PROJECTS = [project_foo.code, project_bar.code]
foo_user = UserFactory.create(username='foo')
bar_user = UserFactory.create(username='bar')
# By default all projects are not accessible
_require_permission_set(default, root, negative_permissions=[hide])
_require_permission_set(nobody, root, negative_permissions=[hide])
assert items_equal(Project.accessible_by_user(admin), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(default), [])
assert items_equal(Project.accessible_by_user(nobody), [])
assert items_equal(Project.accessible_by_user(foo_user), [])
assert items_equal(Project.accessible_by_user(bar_user), [])
# Now let's make `project_foo` accessible to `foo_user`.
_require_permission_set(foo_user, project_foo.directory, [view])
assert items_equal(Project.accessible_by_user(admin), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(default), [])
assert items_equal(Project.accessible_by_user(nobody), [])
assert items_equal(
Project.accessible_by_user(foo_user),
[project_foo.code])
assert items_equal(Project.accessible_by_user(bar_user), [])
# Making projects accessible for anonymous users should open the door for
# everyone
_require_permission_set(nobody, root, [view])
assert items_equal(Project.accessible_by_user(admin), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(default), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(nobody), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(foo_user), ALL_PROJECTS)
assert items_equal(Project.accessible_by_user(bar_user), ALL_PROJECTS)
@pytest.mark.django_db
def test_file_belongs_to_project(english, templates, settings):
project = Project.objects.get(code="project0")
# ensure the project has po and only po
assert (
list(project.filetypes.values_list("extension__name", flat=True))
== ["po"])
# po/pot matches, ts doesnt
assert project.file_belongs_to_project("foo.po")
assert project.file_belongs_to_project("foo.pot")
assert not project.file_belongs_to_project("foo.ts")
# if match_templates is False, only po matches
assert project.file_belongs_to_project("foo.po", match_templates=False)
assert not project.file_belongs_to_project("foo.pot", match_templates=False)
assert not project.file_belongs_to_project("foo.ts", match_templates=False)
# lets add ts
ts = Format.objects.get(name="ts")
project.filetypes.add(ts)
# now ts/po/pot all match
assert project.file_belongs_to_project("foo.po")
assert project.file_belongs_to_project("foo.pot")
assert project.file_belongs_to_project("foo.ts")
# and remove po...
po = Format.objects.get(name="po")
project.filetypes.remove(po)
# only ts matches
assert project.file_belongs_to_project("foo.ts")
assert not project.file_belongs_to_project("foo.po")
assert not project.file_belongs_to_project("foo.pot")
| 13,122
|
Python
|
.py
| 261
| 43.528736
| 80
| 0.702144
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,930
|
datatables.py
|
translate_pootle/tests/models/datatables.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pytest_pootle.factories import (
LanguageDBFactory, ProjectDBFactory,
StoreDBFactory, TranslationProjectFactory)
from django.db import IntegrityError
from pootle_data.models import StoreChecksData, StoreData, TPChecksData, TPData
@pytest.mark.django_db
def test_data_store_bad(store0):
"""Test that you cant add a duplicate file extension
"""
# needs a store
with pytest.raises(IntegrityError):
StoreData.objects.create()
@pytest.mark.django_db
def test_data_store(tp0):
"""Test that you cant add a duplicate file extension
"""
store = StoreDBFactory(
name="foo.po",
parent=tp0.directory,
translation_project=tp0)
assert (
repr(store.data)
== '<StoreData: %s>' % store.pootle_path)
@pytest.mark.django_db
def test_data_store_checks(tp0):
"""Test that you cant add a duplicate file extension
"""
store = StoreDBFactory(
name="foo.po",
parent=tp0.directory,
translation_project=tp0)
check_data = StoreChecksData.objects.create(store=store)
assert (
repr(check_data)
== '<StoreChecksData: %s>' % store.pootle_path)
@pytest.mark.django_db
def test_data_tp_bad():
"""Test that you cant add a duplicate file extension
"""
# needs a TP
with pytest.raises(IntegrityError):
TPData.objects.create()
@pytest.mark.django_db
def test_data_tp(english):
"""Test that you cant add a duplicate file extension
"""
tp = TranslationProjectFactory(
project=ProjectDBFactory(source_language=english),
language=LanguageDBFactory())
assert (
repr(tp.data)
== '<TPData: %s>' % tp.pootle_path)
@pytest.mark.django_db
def test_data_tp_checks(english):
"""Test that you cant add a duplicate file extension
"""
tp = TranslationProjectFactory(
project=ProjectDBFactory(source_language=english),
language=LanguageDBFactory())
check_data = TPChecksData.objects.create(tp=tp)
assert (
repr(check_data)
== '<TPChecksData: %s>' % tp.pootle_path)
| 2,393
|
Python
|
.py
| 71
| 28.647887
| 79
| 0.696444
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,931
|
user.py
|
translate_pootle/tests/models/user.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from django.core.validators import ValidationError
import pytest
from allauth.account.models import EmailAddress
from pytest_pootle.fixtures.models.permission_set import _require_permission_set
from pytest_pootle.fixtures.models.store import (_create_submission_and_suggestion,
_create_comment_on_unit)
import accounts
from pootle.core.delegate import review
from pootle_app.models.directory import Directory
from pootle_app.models.permissions import PermissionSet, check_user_permission
from pootle_language.models import Language
from pootle_project.models import Project
from pootle_store.constants import FUZZY, TRANSLATED
from pootle_store.models import Suggestion
from pootle_translationproject.models import TranslationProject
def _make_evil_member_updates(store, evil_member):
# evil_member makes following changes:
# - rejects member's suggestion on unit
# - changes unit
# - adds another suggestion on unit
# - accepts their own suggestion
# - adds a comment on unit
# - adds another unit
member_suggestion = store.units[0].get_suggestions().first()
evil_units = [
("Hello, world", "Hello, world EVIL", False),
("Goodbye, world", "Goodbye, world EVIL", False)]
review.get(Suggestion)([member_suggestion], evil_member).reject()
_create_submission_and_suggestion(store,
evil_member,
units=evil_units,
suggestion="EVIL SUGGESTION")
evil_suggestion = store.units[0].get_suggestions().first()
review.get(Suggestion)([evil_suggestion], evil_member).accept()
_create_comment_on_unit(store.units[0], evil_member, "EVIL COMMENT")
def _test_user_merged(unit, src_user, target_user):
# TODO: test reviews and comments
if src_user.id:
assert src_user.submitted.count() == 0
assert src_user.suggestions.count() == 0
assert unit.change in list(target_user.submitted.all())
assert (
unit.get_suggestions().first()
in list(target_user.suggestions.all()))
def _test_before_evil_user_updated(store, member, teststate=False):
unit = store.units[0]
# Unit state is fuzzy
assert unit.state == FUZZY
# Unit target was updated.
assert unit.target_f == "Hello, world UPDATED"
assert unit.change.submitted_by == member
# But member also added a suggestion to the unit.
assert unit.get_suggestions().count() == 1
assert unit.get_suggestions().first().user == member
# And added a comment on the unit.
assert unit.translator_comment == "NICE COMMENT"
assert unit.change.commented_by == member
# Only 1 unit round here.
assert store.units.count() == 1
def _test_after_evil_user_updated(store, evil_member):
unit = store.units[0]
# Unit state is TRANSLATED
assert unit.state == TRANSLATED
# Evil member has accepted their own suggestion.
assert unit.target_f == "EVIL SUGGESTION"
assert unit.change.submitted_by == evil_member
# And rejected member's.
assert unit.get_suggestions().count() == 0
# And added their own comment.
assert unit.translator_comment == "EVIL COMMENT"
assert unit.change.commented_by == evil_member
# Evil member has added another unit.
assert store.units.count() == 2
assert store.units[1].target_f == "Goodbye, world EVIL"
assert store.units[1].change.submitted_by == evil_member
def _test_user_purging(store, member, evil_member, purge):
first_revision = store.get_max_unit_revision()
unit = store.units[0]
# Get intitial change times
initial_submission_time = unit.change.submitted_on
initial_comment_time = unit.change.commented_on
initial_review_time = unit.change.reviewed_on
# Test state before evil user has updated.
_test_before_evil_user_updated(store, member, True)
# Update as evil member
_make_evil_member_updates(store, evil_member)
# Revision has increased
latest_revision = store.get_max_unit_revision()
assert latest_revision > first_revision
unit = store.units[0]
original_revision = unit.store.parent.revisions.get(
key="stats").value
# Test submitted/commented/reviewed times on the unit. This is an
# unreliable test on MySQL due to datetime precision
if unit.change.submitted_on.time().microsecond != 0:
# Times have changed
assert unit.change.submitted_on != initial_submission_time
assert unit.change.commented_on != initial_comment_time
assert unit.change.reviewed_on != initial_review_time
# Test state after evil user has updated.
_test_after_evil_user_updated(store, evil_member)
# Purge evil_member
purge(evil_member)
# Revision has increased again.
assert store.get_max_unit_revision() > latest_revision
unit = store.units[0]
# Times are back to previous times - by any precision
assert unit.change.submitted_on == initial_submission_time
assert unit.change.commented_on == initial_comment_time
assert unit.change.reviewed_on == initial_review_time
# Revision has been expired for unit's directory
assert (
unit.store.parent.revisions.get(key="stats").value
!= original_revision)
# State is be back to how it was before evil user updated.
_test_before_evil_user_updated(store, member)
@pytest.mark.django_db
def test_merge_user(en_tutorial_po, member, member2):
"""Test merging user to another user."""
unit = _create_submission_and_suggestion(en_tutorial_po, member)
accounts.utils.UserMerger(member, member2).merge()
_test_user_merged(unit, member, member2)
@pytest.mark.django_db
def test_delete_user(en_tutorial_po):
"""Test default behaviour of User.delete - merge to nobody"""
User = get_user_model()
member = User.objects.get(username="member")
nobody = User.objects.get(username="nobody")
unit = _create_submission_and_suggestion(en_tutorial_po, member)
member.delete()
_test_user_merged(unit, member, nobody)
@pytest.mark.django_db
def test_purge_user(en_tutorial_po_member_updated,
member, evil_member):
"""Test purging user using `purge_user` function"""
_test_user_purging(en_tutorial_po_member_updated,
member, evil_member,
lambda m: accounts.utils.UserPurger(m).purge())
@pytest.mark.django_db
def test_delete_purge_user(en_tutorial_po_member_updated,
member, evil_member):
"""Test purging user using `User.delete(purge=True)`"""
_test_user_purging(en_tutorial_po_member_updated,
member, evil_member,
lambda m: m.delete(purge=True))
@pytest.mark.django_db
def test_verify_user(member_with_email):
"""Test verifying user using `verify_user` function"""
# Member is not currently verified
with pytest.raises(EmailAddress.DoesNotExist):
EmailAddress.objects.get(user=member_with_email, verified=True)
# Verify user
accounts.utils.verify_user(member_with_email)
# Get the verified email object
EmailAddress.objects.get(user=member_with_email,
email="member_with_email@this.test",
primary=True, verified=True)
@pytest.mark.django_db
def test_verify_user_empty_email(trans_member):
"""Test verifying user using `verify_user` function"""
# Member has no EmailAddress set
with pytest.raises(EmailAddress.DoesNotExist):
EmailAddress.objects.get(user=trans_member)
# Email is not set on User either
assert trans_member.email == ''
# Verify user - raises ValidationError
with pytest.raises(ValidationError):
accounts.utils.verify_user(trans_member)
# User still has no email
with pytest.raises(EmailAddress.DoesNotExist):
EmailAddress.objects.get(user=trans_member)
@pytest.mark.django_db
def test_verify_user_after_update_email(trans_member):
"""Test verifying user using `verify_user` function"""
# Member has no EmailAddress set
with pytest.raises(EmailAddress.DoesNotExist):
EmailAddress.objects.get(user=trans_member)
# Email is not set on User either
assert trans_member.email == ''
# Use util to set email
accounts.utils.update_user_email(trans_member,
"trans_member@this.test")
# Verify user
accounts.utils.verify_user(trans_member)
# Email verified
EmailAddress.objects.get(user=trans_member,
primary=True, verified=True)
@pytest.mark.django_db
def test_verify_user_duplicate_email(trans_member, member_with_email):
"""Test verifying user using `verify_user` function"""
# trans_member steals member_with_email's email
trans_member.email = member_with_email.email
# And can't verify with it
with pytest.raises(ValidationError):
accounts.utils.verify_user(trans_member)
# Email not verified
with pytest.raises(EmailAddress.DoesNotExist):
EmailAddress.objects.get(user=trans_member,
primary=True, verified=True)
@pytest.mark.django_db
def test_verify_user_without_existing_email(trans_member):
"""Test verifying user using `verify_user` function"""
member = trans_member
# Member has no allauth.EmailAddress object
with pytest.raises(EmailAddress.DoesNotExist):
EmailAddress.objects.get(user=member)
# Give member an email - but don't save, as this would trigger
# allauth.EmailAddress creation
member.email = "member@this.test"
# Verify user
accounts.utils.verify_user(member)
# Get the verified email object
EmailAddress.objects.get(user=member, email="member@this.test",
primary=True, verified=True)
# This does not update the member object!
assert get_user_model().objects.get(pk=member.pk).email == ""
@pytest.mark.django_db
def test_verify_user_with_primary_and_non_primary_email_object(trans_member):
"""Test verifying user using `verify_user` function that has an
allauth.EmailAddress object but is not yet verified
"""
member = trans_member
# Give member an email
member.email = "member@this.test"
# Create the unverified non-primary email object
EmailAddress.objects.create(user=member, email=member.email,
primary=False, verified=False)
# Create unverified primary email object
EmailAddress.objects.create(user=member, email="otheremail@this.test",
primary=True, verified=False)
# Verify user
accounts.utils.verify_user(member)
# Get the verified email object - the primary address is used
EmailAddress.objects.get(user=member, email="otheremail@this.test",
primary=True, verified=True)
@pytest.mark.django_db
def test_verify_user_already_verified(member_with_email):
"""Test verifying user using `verify_user` function that has an
allauth.EmailAddress object but is not yet verified
"""
# Verify user
accounts.utils.verify_user(member_with_email)
# Verify user again - raises ValueError
with pytest.raises(ValueError):
accounts.utils.verify_user(member_with_email)
# Get the verified email object
EmailAddress.objects.get(user=member_with_email,
email=member_with_email.email,
primary=True, verified=True)
@pytest.mark.django_db
def test_update_user_email_without_existing_email(trans_member):
"""Test updating user email using `update_user_email` function"""
assert trans_member.email == ""
# Trans_Member has no EmailAddress object
with pytest.raises(EmailAddress.DoesNotExist):
EmailAddress.objects.get(user=trans_member)
accounts.utils.update_user_email(trans_member, "trans_member@this.test")
# User.email has been set
assert trans_member.email == "trans_member@this.test"
# member still has no EmailAddress object
with pytest.raises(EmailAddress.DoesNotExist):
EmailAddress.objects.get(user=trans_member)
@pytest.mark.django_db
def test_update_user_email_with_unverified_acc(member_with_email):
"""Test updating user email using `update_user_email` function"""
# Create an unverified primary email object
EmailAddress.objects.create(user=member_with_email,
email=member_with_email.email,
primary=True, verified=False).save()
accounts.utils.update_user_email(member_with_email,
"new_email_address@this.test")
# Both User.email and EmailAddress.email should be updated for user
email_address = EmailAddress.objects.get(user=member_with_email)
assert member_with_email.email == "new_email_address@this.test"
assert email_address.email == "new_email_address@this.test"
# Doesnt affect verification
assert email_address.verified is False
@pytest.mark.django_db
def test_update_user_email_with_multiple_email_addresses(member_with_email):
"""Test updating user email using `update_user_email` function"""
# Create primary/secondary email addresses
EmailAddress.objects.create(user=member_with_email,
email=member_with_email.email,
primary=True, verified=True).save()
EmailAddress.objects.create(user=member_with_email,
email="alt_email@this.test",
primary=False, verified=False).save()
accounts.utils.update_user_email(member_with_email,
"new_email@this.test")
# Both User.email and EmailAddress.email should be updated for user
email_address = EmailAddress.objects.get(user=member_with_email,
primary=True)
assert member_with_email.email == "new_email@this.test"
assert email_address.email == "new_email@this.test"
# Doesnt affect other email address tho
alt_email_address = EmailAddress.objects.get(user=member_with_email,
primary=False)
assert alt_email_address.email == "alt_email@this.test"
@pytest.mark.django_db
def test_update_user_email_bad_invalid_email(member_with_email):
with pytest.raises(ValidationError):
accounts.utils.update_user_email(member_with_email,
"NOT_AN_EMAIL_ADDRESS")
@pytest.mark.django_db
def test_update_user_email_bad_invalid_duplicate(member_with_email):
memberX = get_user_model().objects.create(username="memberX")
# Create 2 emails for memberX
memberX.email = "memberX@this.test"
memberX.save()
(EmailAddress.objects
.create(user=memberX,
email=memberX.email,
primary=True, verified=True)).save()
(EmailAddress.objects
.create(user=memberX,
email="alt_email@this.test",
primary=False,
verified=False)).save()
# Member cannot update with either of memberX's emails
with pytest.raises(ValidationError):
accounts.utils.update_user_email(member_with_email,
memberX.email)
with pytest.raises(ValidationError):
accounts.utils.update_user_email(member_with_email,
"alt_email@this.test")
@pytest.mark.django_db
def test_user_has_manager_permissions(no_perms_user, administrate, tp0):
"""Test user `has_manager_permissions` method."""
language0 = tp0.language
project0 = tp0.project
# User has no permissions, so can't be manager.
assert not no_perms_user.has_manager_permissions()
# Assign 'administrate' right for 'Language0 (Project0)' TP and check user
# is manager.
criteria = {
'user': no_perms_user,
'directory': tp0.directory,
}
ps = PermissionSet.objects.get_or_create(**criteria)[0]
ps.positive_permissions.set([administrate])
ps.save()
assert no_perms_user.has_manager_permissions()
ps.positive_permissions.clear()
assert not no_perms_user.has_manager_permissions()
# Assign 'administrate' right for 'Language0' and check user is manager.
criteria['directory'] = language0.directory
ps = PermissionSet.objects.get_or_create(**criteria)[0]
ps.positive_permissions.set([administrate])
ps.save()
assert no_perms_user.has_manager_permissions()
ps.positive_permissions.clear()
assert not no_perms_user.has_manager_permissions()
# Assign 'administrate' right for 'Project0' and check user is manager.
criteria['directory'] = project0.directory
ps = PermissionSet.objects.get_or_create(**criteria)[0]
ps.positive_permissions.set([administrate])
ps.save()
assert no_perms_user.has_manager_permissions()
ps.positive_permissions.clear()
assert not no_perms_user.has_manager_permissions()
@pytest.mark.django_db
def test_get_users_with_permission(default, translate):
language = Language.objects.get(code='language0')
project = Project.objects.get(code='project0')
User = get_user_model()
memberX = User.objects.create(username="memberX")
directory = TranslationProject.objects.get(
project=project,
language=language
).directory
memberX.email = "memberX@poot.le"
memberX.save()
accounts.utils.verify_user(memberX)
_require_permission_set(memberX, directory, [translate])
# remove "Can submit translation" permission for default user
ps = PermissionSet.objects.filter(user=default,
directory=Directory.objects.root)[0]
ps.positive_permissions.set(ps.positive_permissions.exclude(id=translate.id))
ps.save()
users = User.objects.get_users_with_permission('translate', project, language)
for user in users:
assert check_user_permission(user, 'translate', directory)
| 18,600
|
Python
|
.py
| 390
| 39.728205
| 83
| 0.686466
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,932
|
legalpage.py
|
translate_pootle/tests/models/legalpage.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pytest_pootle.factories import (AgreementFactory, LegalPageFactory,
UserFactory)
from pootle.core.utils.timezone import aware_datetime
from staticpages.models import LegalPage
@pytest.mark.django_db
@pytest.mark.xfail(reason="this will be dropped")
def test_pending_agreements():
"""Tests proper user pending agreements are returned."""
foo_user = UserFactory.create(username='foo')
privacy_policy = LegalPageFactory.create(
active=True,
modified_on=aware_datetime(2014, 1, 1),
)
# `foo_user` hasn't agreed the privacy policy yet
pending = list(LegalPage.objects.pending_user_agreement(foo_user))
assert len(pending) == 1
assert privacy_policy in pending
# `foo_user` agreed the privacy policy
AgreementFactory.create(
user=foo_user,
document=privacy_policy,
agreed_on=aware_datetime(2014, 2, 2),
)
pending = list(LegalPage.objects.pending_user_agreement(foo_user))
assert len(pending) == 0
# Let's add a new ToS
tos = LegalPageFactory.create(
active=True,
modified_on=aware_datetime(2015, 1, 1),
)
pending = list(LegalPage.objects.pending_user_agreement(foo_user))
assert len(pending) == 1
assert tos in pending
# `foo_user` also accepted the ToS
AgreementFactory.create(
user=foo_user,
document=tos,
agreed_on=aware_datetime(2015, 2, 2),
)
pending = list(LegalPage.objects.pending_user_agreement(foo_user))
assert len(pending) == 0
# The ToS were modified, `foo_user` must agree it
tos.modified_on = aware_datetime(2015, 3, 3)
tos.save()
pending = list(LegalPage.objects.pending_user_agreement(foo_user))
assert len(pending) == 1
assert tos in pending
# Same with the privacy policy
privacy_policy.modified_on = aware_datetime(2015, 4, 4)
privacy_policy.save()
pending = list(LegalPage.objects.pending_user_agreement(foo_user))
assert len(pending) == 2
assert privacy_policy in pending
assert tos in pending
# Let's disable the ToS
tos.active = False
tos.save()
pending = list(LegalPage.objects.pending_user_agreement(foo_user))
assert len(pending) == 1
assert privacy_policy in pending
| 2,591
|
Python
|
.py
| 68
| 32.573529
| 77
| 0.700479
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,933
|
config.py
|
translate_pootle/tests/models/config.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from collections import OrderedDict
import pytest
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import ValidationError
from pootle.core.delegate import config
from pootle.core.plugin import getter
from pootle_config.delegate import (
config_should_not_be_set, config_should_not_be_appended)
from pootle_config.exceptions import ConfigurationError
from pootle_config.models import Config
from pootle_config.utils import (
ConfigDict, ModelConfig, ObjectConfig, SiteConfig)
from pootle_project.models import Project
def _test_config_bad_create(create_func):
# a config object must have a key
with pytest.raises(ValidationError):
create_func().save()
# you cant set object_pk if content_type is not set
with pytest.raises(ValidationError):
create_func(
key="foo4", value="bar", object_pk="23").save()
def _test_config_ob(**kwargs):
conf = Config.objects.get(
content_type=kwargs["content_type"],
object_pk=kwargs["object_pk"])
for k, v in kwargs.items():
if isinstance(v, tuple):
v = list(v)
assert getattr(conf, k) == v
def _test_config_create(create_func):
# Create a site config
create_func(key="foo")
_test_config_ob(
key=u"foo",
value="",
content_object=None,
content_type=None,
object_pk=None)
project = Project.objects.get(code="project0")
project_pk = str(project.pk)
project_ct = ContentType.objects.get_for_model(project)
# Create config for all projects
create_func(
key="foo",
value="bar",
content_type=project_ct)
_test_config_ob(
key=u"foo",
value=u"bar",
content_object=None,
content_type=project_ct,
object_pk=None)
# Create config for a project
create_func(
key="foo",
value="bar",
content_object=project)
_test_config_ob(
key=u"foo",
value=u"bar",
content_object=project,
content_type=project_ct,
object_pk=project_pk)
def _test_config_clear(**kwargs):
Config.objects.set_config(**kwargs)
if kwargs.get("model"):
conf = Config.objects.config_for(
kwargs["model"]).get(key=kwargs["key"])
else:
conf = Config.objects.site_config().get(key=kwargs["key"])
assert conf.pk in Config.objects.values_list("pk", flat=True)
Config.objects.clear_config(**kwargs)
assert conf.pk not in Config.objects.values_list("pk", flat=True)
@pytest.mark.django_db
def test_config_create(no_config_env):
_test_config_create(Config.objects.create)
_test_config_create(Config)
@pytest.mark.django_db
def test_config_bad_create(no_config_env):
_test_config_bad_create(Config.objects.create)
_test_config_bad_create(Config)
@pytest.mark.django_db
def test_config_bad_getter(no_config_env):
project = Project.objects.get(code="project0")
with pytest.raises(ConfigurationError):
config.get(instance=project)
with pytest.raises(ConfigurationError):
config.get(str, instance=project)
@pytest.mark.django_db
def test_config_set(no_config_env):
# set site-wide config
Config.objects.set_config("foo")
_test_config_ob(
key=u"foo",
value="",
content_type=None,
object_pk=None)
Config.objects.set_config("foo", "bar")
_test_config_ob(
key=u"foo",
value="bar",
content_type=None,
object_pk=None)
project = Project.objects.get(code="project0")
project_pk = project.pk
project_ct = ContentType.objects.get_for_model(project)
# set config for all projects
Config.objects.set_config(key="foo", model=Project)
_test_config_ob(
key="foo",
value="",
content_type=project_ct,
object_pk=None,
content_object=None)
Config.objects.set_config(key="foo", value="bar", model=Project)
_test_config_ob(
key="foo",
value="bar",
content_type=project_ct,
object_pk=None,
content_object=None)
# set config for project
Config.objects.set_config(key="foo", model=project)
_test_config_ob(
key="foo",
value="",
content_type=project_ct,
object_pk=str(project_pk),
content_object=project)
# reset config for project
Config.objects.set_config(key="foo", value="bar", model=project)
_test_config_ob(
key="foo",
value="bar",
content_type=project_ct,
object_pk=str(project_pk),
content_object=project)
@pytest.mark.django_db
def test_config_clear(no_config_env):
_test_config_clear(**dict(key="foo"))
_test_config_clear(**dict(key="foo", model=Project))
project = Project.objects.get(code="project0")
_test_config_clear(**dict(key="foo", model=project))
@pytest.mark.django_db
def test_config_get(no_config_env):
Config.objects.set_config("foo", ["bar"])
assert Config.objects.get_config("foo") == ["bar"]
Config.objects.set_config("foo", ["bar2"], Project)
assert Config.objects.get_config("foo") == ["bar"]
assert Config.objects.get_config("foo", Project) == ["bar2"]
project = Project.objects.get(code="project0")
Config.objects.set_config("foo", ["bar3"], project)
assert Config.objects.get_config("foo") == ["bar"]
assert Config.objects.get_config("foo", Project) == ["bar2"]
assert Config.objects.get_config("foo", project) == ["bar3"]
@pytest.mark.django_db
def test_config_list(no_config_env):
Config.objects.set_config("foo", ["bar"])
assert Config.objects.list_config("foo") == [("foo", ["bar"])]
Config.objects.set_config("foo", ["bar2"], Project)
assert Config.objects.list_config("foo") == [("foo", ["bar"])]
assert Config.objects.list_config("foo", Project) == [("foo", ["bar2"])]
project = Project.objects.get(code="project0")
Config.objects.set_config("foo", ["bar3"], project)
assert Config.objects.list_config("foo") == [("foo", ["bar"])]
assert Config.objects.list_config("foo", Project) == [("foo", ["bar2"])]
assert Config.objects.list_config("foo", project) == [("foo", ["bar3"])]
@pytest.mark.django_db
def test_config_append(no_config_env):
Config.objects.append_config("foo", ["bar"])
assert Config.objects.list_config("foo") == [("foo", ["bar"])]
Config.objects.append_config("foo", ["bar"])
assert Config.objects.list_config("foo") == [
("foo", ["bar"]), ("foo", ["bar"])]
Config.objects.set_config("foo", ["bar2"], Project)
assert Config.objects.list_config("foo") == [
("foo", ["bar"]), ("foo", ["bar"])]
assert Config.objects.list_config("foo", Project) == [
("foo", ["bar2"])]
Config.objects.append_config("foo", ["bar2"], Project)
assert Config.objects.list_config("foo") == [
("foo", ["bar"]), ("foo", ["bar"])]
assert Config.objects.list_config("foo", Project) == [
("foo", ["bar2"]), ("foo", ["bar2"])]
project = Project.objects.get(code="project0")
Config.objects.set_config("foo", ["bar3"], project)
assert Config.objects.list_config("foo") == [
("foo", ["bar"]), ("foo", ["bar"])]
assert Config.objects.list_config("foo", Project) == [
("foo", ["bar2"]), ("foo", ["bar2"])]
assert Config.objects.list_config("foo", project) == [
("foo", ["bar3"])]
Config.objects.append_config("foo", ["bar3"], project)
assert Config.objects.list_config("foo") == [
("foo", ["bar"]), ("foo", ["bar"])]
assert Config.objects.list_config("foo", Project) == [
("foo", ["bar2"]), ("foo", ["bar2"])]
assert Config.objects.list_config("foo", project) == [
("foo", ["bar3"]), ("foo", ["bar3"])]
@pytest.mark.django_db
def test_config_getter(no_config_env):
# getting a non-existent key returns None
assert config.get(key="DOESNT_EXIST") is None
Config.objects.set_config("foo", ["bar"])
# if key is not specified to the getter it returns the qs
assert config.get().get(key="foo").value == ["bar"]
# you can use get_config(key) with the qs
assert config.get().get_config("foo") == ["bar"]
# if key is specified it returns the key value
assert config.get(key="foo") == ["bar"]
Config.objects.set_config("foo", ["bar2"], Project)
# previous tests still work
assert config.get().get(key="foo").value == ["bar"]
assert config.get().get_config("foo") == ["bar"]
assert config.get(key="foo") == ["bar"]
# specifying only model gets the queryset
assert config.get(Project).get(key="foo").value == ["bar2"]
# which we can use get_config with
assert config.get(Project).get_config("foo") == ["bar2"]
# specifying key also gets the value
assert config.get(Project, key="foo") == ["bar2"]
project = Project.objects.get(code="project0")
Config.objects.set_config("foo", ["bar3"], project)
# previous tests still work
assert config.get().get(key="foo").value == ["bar"]
assert config.get().get_config("foo") == ["bar"]
assert config.get(key="foo") == ["bar"]
assert config.get(Project).get(key="foo").value == ["bar2"]
assert config.get(Project).get_config("foo") == ["bar2"]
assert config.get(Project, key="foo") == ["bar2"]
# we can get settings for an indiv project like so...
assert config.get(Project, instance=project).get(key="foo").value == ["bar3"]
assert config.get(Project, instance=project).get_config("foo") == ["bar3"]
assert config.get(Project, instance=project, key="foo") == ["bar3"]
@pytest.mark.django_db
def test_config_getter_list(no_config_env):
assert config.get(key=[]) == []
config.get().set_config("foo", ["bar0"])
config.get().append_config("foo", ["bar0"])
with pytest.raises(ConfigurationError):
config.get(key="foo")
# if we pass a list as key we get a k, v list mapping
assert config.get(key=["foo"]) == [
(u'foo', [u'bar0']), (u'foo', [u'bar0'])]
assert config.get(key=[]) == [
(u'foo', [u'bar0']), (u'foo', [u'bar0'])]
config.get().set_config("foo2", ["bar1"])
# this still works
assert config.get(key=["foo"]) == [
(u'foo', [u'bar0']), (u'foo', [u'bar0'])]
# this still works
assert config.get(key=["foo2"]) == [(u'foo2', [u'bar1'])]
# both keys are returned for key=[]
assert config.get(key=[]) == [
(u'foo', [u'bar0']),
(u'foo', [u'bar0']),
(u'foo2', [u'bar1'])]
assert config.get(Project, key=[]) == []
config.get(Project).set_config("foo", ["bar2"])
config.get(Project).append_config("foo", ["bar2"])
with pytest.raises(ConfigurationError):
config.get(Project, key="foo")
# if we pass a list as key we get a k, v list mapping
assert config.get(Project, key=["foo"]) == [
(u'foo', [u'bar2']), (u'foo', [u'bar2'])]
assert config.get(Project, key=[]) == [
(u'foo', [u'bar2']), (u'foo', [u'bar2'])]
config.get(Project).set_config("foo2", ["bar3"])
# this still works
assert config.get(Project, key=["foo"]) == [
(u'foo', [u'bar2']), (u'foo', [u'bar2'])]
# this still works
assert config.get(
Project, key=["foo2"]) == [(u'foo2', [u'bar3'])]
# both keys are returned for key=[]
assert config.get(Project, key=[]) == [
(u'foo', [u'bar2']),
(u'foo', [u'bar2']),
(u'foo2', [u'bar3'])]
# site config still works
assert config.get(key=[]) == [
(u'foo', [u'bar0']),
(u'foo', [u'bar0']),
(u'foo2', [u'bar1'])]
project = Project.objects.get(code="project0")
assert config.get(
Project, instance=project, key=[]) == []
config.get(
Project,
instance=project).set_config("foo", ["bar3"])
config.get(
Project,
instance=project).append_config("foo", ["bar3"])
with pytest.raises(ConfigurationError):
config.get(Project, instance=project, key="foo")
# if we pass a list as key we get a k, v list mapping
assert config.get(Project, instance=project, key=["foo"]) == [
(u'foo', [u'bar3']), (u'foo', [u'bar3'])]
assert config.get(Project, instance=project, key=[]) == [
(u'foo', [u'bar3']), (u'foo', [u'bar3'])]
config.get(Project, instance=project).set_config("foo2", ["bar4"])
# this still works
assert config.get(Project, instance=project, key=["foo"]) == [
(u'foo', [u'bar3']), (u'foo', [u'bar3'])]
# this still works
assert config.get(
Project,
instance=project,
key=["foo2"]) == [(u'foo2', [u'bar4'])]
# both keys are returned for key=[]
assert config.get(Project, instance=project, key=[]) == [
(u'foo', [u'bar3']),
(u'foo', [u'bar3']),
(u'foo2', [u'bar4'])]
# model config still works
assert config.get(Project, key=[]) == [
(u'foo', [u'bar2']),
(u'foo', [u'bar2']),
(u'foo2', [u'bar3'])]
# site config still works
assert config.get(key=[]) == [
(u'foo', [u'bar0']),
(u'foo', [u'bar0']),
(u'foo2', [u'bar1'])]
@pytest.mark.django_db
def test_config_setter(no_config_env):
config.get().set_config("foo", ["bar"])
assert config.get(key="foo") == ["bar"]
config.get(Project).set_config("foo", ["bar2"])
assert config.get(Project, key="foo") == ["bar2"]
project = Project.objects.get(code="project0")
config.get(Project).set_config("foo", ["bar3"], project)
assert config.get(Project, instance=project, key="foo") == ["bar3"]
@pytest.mark.django_db
def test_config_set_json(no_config_env, json_objects):
# set site-wide config
Config.objects.set_config("foo", json_objects)
_test_config_ob(
key=u"foo",
value=json_objects,
content_type=None,
object_pk=None)
project = Project.objects.get(code="project0")
project_pk = project.pk
project_ct = ContentType.objects.get_for_model(project)
# set config for all projects
Config.objects.set_config("foo", json_objects, model=Project)
_test_config_ob(
key="foo",
value=json_objects,
content_type=project_ct,
object_pk=None,
content_object=None)
# set config for project
Config.objects.set_config("foo", json_objects, model=project)
_test_config_ob(
key="foo",
value=json_objects,
content_type=project_ct,
object_pk=str(project_pk),
content_object=project)
@pytest.mark.django_db
def test_config_no_set(no_config_env):
@getter(config_should_not_be_set)
def config_should_be_set_checker(**kwargs):
if kwargs["key"] == "foo":
return True
with pytest.raises(ConfigurationError):
config.get().set_config("foo", "bar")
config.get().set_config("foo2", "bar")
@getter(config_should_not_be_set, sender=Project)
def config_should_be_set_model_checker(**kwargs):
if kwargs["key"] == "foo2":
return True
config.get().set_config("foo2", "bar")
with pytest.raises(ConfigurationError):
config.get(Project).set_config("foo2", "bar")
config.get(Project).set_config("foo3", "bar")
@pytest.mark.django_db
def test_config_no_append(no_config_env):
@getter(config_should_not_be_appended)
def config_should_be_appended_checker(**kwargs):
if kwargs["key"] == "foo":
return True
with pytest.raises(ConfigurationError):
config.get().append_config("foo", "bar")
config.get().append_config("foo2", "bar")
@getter(config_should_not_be_appended, sender=Project)
def config_should_be_appended_model_checker(**kwargs):
if kwargs["key"] == "foo2":
return True
config.get().append_config("foo2", "bar")
with pytest.raises(ConfigurationError):
config.get(Project).append_config("foo2", "bar")
config.get(Project).append_config("foo3", "bar")
@pytest.mark.django_db
def test_config_site_util(no_config_env):
conf = SiteConfig()
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 SiteConfig().items() == other_dict.items()
assert SiteConfig().values() == other_dict.values()
assert SiteConfig().keys() == other_dict.keys()
assert [x for x in SiteConfig()] == other_dict.keys()
assert all(x in SiteConfig() for x in other_dict)
assert all(SiteConfig()[k] == v for k, v in other_dict.items())
assert all(SiteConfig().get(k) == v for k, v in other_dict.items())
assert SiteConfig().get("DOESNOTEXIST") is None
assert SiteConfig().get("DOESNOTEXIST", "foo") == "foo"
with pytest.raises(KeyError):
SiteConfig()["DOESNOTEXIST"]
@pytest.mark.django_db
def test_config_model_util(no_config_env):
conf = ModelConfig(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 ModelConfig(Project).items() == other_dict.items()
assert ModelConfig(Project).values() == other_dict.values()
assert ModelConfig(Project).keys() == other_dict.keys()
assert [x for x in ModelConfig(Project)] == other_dict.keys()
assert all(x in ModelConfig(Project) for x in other_dict)
assert all(ModelConfig(Project)[k] == v for k, v in other_dict.items())
assert all(ModelConfig(Project).get(k) == v for k, v in other_dict.items())
assert ModelConfig(Project).get("DOESNOTEXIST") is None
assert ModelConfig(Project).get("DOESNOTEXIST", "foo") == "foo"
with pytest.raises(KeyError):
ModelConfig(Project)["DOESNOTEXIST"]
@pytest.mark.django_db
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"]
@pytest.mark.django_db
def test_config_util_dict(no_config_env):
with pytest.raises(NotImplementedError):
ConfigDict("foo")["bar"]
@pytest.mark.django_db
def test_config_qs_chaining(no_config_env):
config.get().set_config("foo", "bar")
assert config.get().none().get_config("foo") == "bar"
config.get(Project).set_config("foo", "bar2")
assert config.get(Project).none().get_config("foo") == "bar2"
project = Project.objects.get(code="project0")
config.get(Project, instance=project).set_config("foo", "bar3")
assert config.get(
Project, instance=project).none().get_config("foo") == "bar3"
| 21,790
|
Python
|
.py
| 519
| 36.046243
| 81
| 0.630507
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,934
|
virtualfolder.py
|
translate_pootle/tests/models/virtualfolder.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from __future__ import absolute_import
from django.core.exceptions import ValidationError
import pytest
from pytest_pootle.factories import VirtualFolderDBFactory
from pootle_language.models import Language
from pootle_store.models import Store
from virtualfolder.models import VirtualFolder
@pytest.mark.django_db
def test_vfolder_priority_not_greater_than_zero(tp0):
"""Tests that the creation of a virtual folder fails if the provided
priority is not greater than zero.
"""
# Test priority less than zero.
vfolder_item = {
'name': "whatever",
'priority': -3,
'is_public': True,
'filter_rules': "browser/defines.po",
}
with pytest.raises(ValidationError) as excinfo:
VirtualFolder.objects.create(**vfolder_item)
assert u'Priority must be greater than zero.' in str(excinfo.value)
# Test zero priority.
vfolder_item['priority'] = 1
vfolder = VirtualFolder.objects.create(**vfolder_item)
vfolder.priority = 0
with pytest.raises(ValidationError) as excinfo:
vfolder.save()
assert u'Priority must be greater than zero.' in str(excinfo.value)
@pytest.mark.django_db
def test_vfolder_with_no_filter_rules():
"""Tests that the creation of a virtual folder fails if it doesn't have any
filter rules.
"""
vfolder_item = {
'name': "whatever",
'priority': 4,
'is_public': True,
'filter_rules': "",
}
with pytest.raises(ValidationError) as excinfo:
VirtualFolder.objects.create(**vfolder_item)
assert u'Some filtering rule must be specified.' in str(excinfo.value)
vfolder_item["filter_rules"] = "FOO"
vf = VirtualFolder.objects.create(**vfolder_item)
vf.filter_rules = ""
with pytest.raises(ValidationError) as excinfo:
vf.save()
assert u'Some filtering rule must be specified.' in str(excinfo.value)
@pytest.mark.django_db
def test_vfolder_membership(tp0, store0):
tp0_stores = ",".join(
p[len(tp0.pootle_path):]
for p in tp0.stores.values_list("pootle_path", flat=True))
vf0 = VirtualFolder.objects.create(
name="vf0",
title="the vf0",
filter_rules=store0.name)
vf0.projects.add(tp0.project)
vf0.languages.add(tp0.language)
vf0.save()
assert vf0.stores.count() == 1
assert vf0.stores.first() == store0
vf1 = VirtualFolder.objects.create(
name="vf1",
title="the vf1",
filter_rules=tp0_stores)
vf1.projects.add(tp0.project)
vf1.languages.add(tp0.language)
vf1.save()
assert (
list(vf1.stores.order_by("pk"))
== list(tp0.stores.order_by("pk")))
store_name = vf1.filter_rules.split(",")[0]
vf1.filter_rules = ",".join(vf1.filter_rules.split(",")[1:])
store = vf1.stores.get(name=store_name)
vf1.save()
assert store not in vf1.stores.all()
vf1.filter_rules = ",".join([store_name, vf1.filter_rules])
vf1.save()
assert store in vf1.stores.all()
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_store_priorities(project0):
# remove the default vfolders and update units to reset priorities
VirtualFolder.objects.all().delete()
assert all(
priority == 1
for priority
in Store.objects.values_list("priority", flat=True))
vfolder0 = VirtualFolderDBFactory(filter_rules="store0.po", name="FOO")
vfolder0.priority = 3
vfolder0.save()
vfolder0_stores = vfolder0.stores.values_list("pk", flat=True)
assert all(
priority == 3
for priority
in Store.objects.filter(id__in=vfolder0_stores)
.values_list("priority", flat=True))
assert all(
priority == 1.0
for priority
in Store.objects.exclude(id__in=vfolder0_stores)
.values_list("priority", flat=True))
vfolder0.filter_rules = "store1.po"
vfolder0.save()
vfolder0_stores = vfolder0.stores.values_list("pk", flat=True)
assert all(
priority == 3
for priority
in Store.objects.filter(id__in=vfolder0_stores)
.values_list("priority", flat=True))
assert all(
priority == 1.0
for priority
in Store.objects.exclude(id__in=vfolder0_stores)
.values_list("priority", flat=True))
vfolder1 = VirtualFolderDBFactory(
filter_rules="store1.po")
vfolder1.languages.add(*Language.objects.all())
vfolder1.projects.add(project0)
vfolder1.priority = 4
vfolder1.save()
vfolder1_stores = vfolder1.stores.values_list("pk", flat=True)
assert all(
priority == 4.0
for priority
in Store.objects.filter(id__in=vfolder1_stores)
.values_list("priority", flat=True))
assert all(
priority == 3.0
for priority
in Store.objects.filter(id__in=vfolder0_stores)
.exclude(id__in=vfolder1_stores)
.values_list("priority", flat=True))
assert all(
priority == 1.0
for priority
in Store.objects.exclude(id__in=vfolder0_stores)
.exclude(id__in=vfolder1_stores)
.values_list("priority", flat=True))
@pytest.mark.django_db
def test_virtualfolder_repr():
vf = VirtualFolderDBFactory(filter_rules="store0.po")
assert (
"<VirtualFolder: %s>" % (vf.name)
== repr(vf))
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_calc_priority(settings, store0):
vf = store0.vfolders.first()
vf.priority = 5
vf.save()
assert store0.calculate_priority() == 5.0
settings.INSTALLED_APPS.remove("virtualfolder")
assert store0.calculate_priority() == 1.0
settings.INSTALLED_APPS.append("virtualfolder")
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_membership_new_store(tp0):
vf0 = VirtualFolder.objects.create(
name="vf0",
title="the vf0",
priority=7.0,
all_languages=True,
all_projects=True,
filter_rules="wierd.po")
wierd_store = Store.objects.create(
parent=tp0.directory,
translation_project=tp0,
name="wierd.po")
wierd_store.set_priority()
assert wierd_store in vf0.stores.all()
assert Store.objects.get(pk=wierd_store.pk).priority == 7
normal_store = Store.objects.create(
parent=tp0.directory,
translation_project=tp0,
name="normal.po")
assert normal_store not in vf0.stores.all()
assert Store.objects.get(pk=normal_store.pk).priority == 1.0
vf0.delete()
assert Store.objects.get(pk=wierd_store.pk).priority == 1.0
| 7,012
|
Python
|
.py
| 189
| 30.328042
| 79
| 0.66043
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,935
|
statistics.py
|
translate_pootle/tests/models/statistics.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_statistics.models import Submission
@pytest.mark.django_db
def test_submission_repr():
submission = Submission.objects.first()
assert (
"<Submission: %s (%s)>"
% (submission.creation_time.strftime("%Y-%m-%d %H:%M"),
unicode(submission.submitter))
== repr(submission))
| 616
|
Python
|
.py
| 17
| 32.470588
| 77
| 0.705882
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,936
|
language.py
|
translate_pootle/tests/models/language.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from translate.lang.data import get_language_iso_fullname
from django.utils import translation
from pootle.core.delegate import site_languages
from pootle.i18n.gettext import tr_lang
from pootle_language.models import Language
@pytest.mark.django_db
def test_language_repr():
language = Language.objects.first()
assert (
"<Language: %s - %s>" % (language.name, language.code)
== repr(language))
@pytest.mark.django_db
def test_language_specialchars_uniqueness():
language = Language.objects.first()
language.specialchars = u" æ ø å Æ Ø Å é è É È Ô ô"
language.save()
assert language.specialchars == u" æøåÆØÅéèÉÈÔô"
language.specialchars = u" Čč Ḍḍ Ɛɛ Ǧǧ Ɣɣ Ḥḥ Ṣṣ ṬṬṭ Ẓẓ Ţţ ṚṛṚṛ"
language.save()
assert language.specialchars == u" ČčḌḍƐɛǦǧƔɣḤḥṢṣṬṭẒẓŢţṚṛ"
@pytest.mark.django_db
def test_language_display_name(english):
english.fullname = ""
english.save()
# as fullname is not set - this should default to the pycountry name
assert (
english.name
== get_language_iso_fullname(english.code))
# lets give english a custom name in db
english.fullname = "English (bristol twang)"
english.save()
# as we are translating to server lang, we use lang.fullname
# and not the one from pycountry/iso translation
assert (
english.name
== english.fullname)
with translation.override("fr"):
# now request lang has changed (and != server lang)
# so we get the translated name
assert (
english.name
== site_languages.get().capitalize(
tr_lang(get_language_iso_fullname(english.code))))
with translation.override("en-GB"):
# as request lang is also a dialect of english
# it uses the lang.fullname
assert (
english.name
== english.fullname)
| 2,286
|
Python
|
.py
| 57
| 32.666667
| 77
| 0.690883
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,937
|
store_fs.py
|
translate_pootle/tests/models/store_fs.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.core.exceptions import ValidationError
from pytest_pootle.factories import (
LanguageDBFactory, ProjectDBFactory, StoreDBFactory,
TranslationProjectFactory)
from pytest_pootle.utils import setup_store
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.models import StoreFS
from pootle_project.models import Project
@pytest.mark.django_db
def test_add_new_store_fs(settings, project0):
"""Add a store_fs for a store that doesnt exist yet
"""
pootle_path = "/language0/%s/example.po" % project0.code
fs_path = "/some/fs/example.po"
store_fs = StoreFS.objects.create(
pootle_path=pootle_path,
path=fs_path)
assert store_fs.project == project0
assert store_fs.store is None
assert store_fs.pootle_path == pootle_path
assert store_fs.path == fs_path
assert store_fs.last_sync_hash is None
assert store_fs.last_sync_mtime is None
assert store_fs.last_sync_revision is None
@pytest.mark.django_db
def test_add_store_fs_by_path(po_directory, english):
"""Add a store_fs for pootle_path
"""
project = ProjectDBFactory(source_language=english)
language = LanguageDBFactory()
tp = TranslationProjectFactory(project=project, language=language)
store = StoreDBFactory(
translation_project=tp,
parent=tp.directory,
name="example_store.po")
tp.project.config["pootle_fs.fs_type"] = "localfs"
tp.project.config["pootle_fs.fs_url"] = "/foo"
fs_path = "/some/fs/example_store.po"
pootle_path = store.pootle_path
store_fs = StoreFS.objects.create(
pootle_path=pootle_path,
path=fs_path)
assert store_fs.project == project
assert store_fs.store == store
assert store_fs.pootle_path == pootle_path
assert store_fs.path == fs_path
assert store_fs.last_sync_hash is None
assert store_fs.last_sync_mtime is None
assert store_fs.last_sync_revision is None
@pytest.mark.django_db
def test_add_store_fs_by_store(po_directory, english):
"""Add a store_fs using store= rather than pootle_path
"""
fs_path = "/some/fs/example_store.po"
project = ProjectDBFactory(source_language=english)
language = LanguageDBFactory()
tp = TranslationProjectFactory(project=project, language=language)
store = StoreDBFactory(
translation_project=tp,
parent=tp.directory,
name="example_store.po")
tp.project.config["pootle_fs.fs_type"] = "localfs"
tp.project.config["pootle_fs.fs_url"] = "/foo"
store_fs = StoreFS.objects.create(
store=store,
path=fs_path)
assert store_fs.project == project
assert store_fs.store == store
assert store_fs.pootle_path == store.pootle_path
assert store_fs.path == fs_path
assert store_fs.last_sync_hash is None
assert store_fs.last_sync_mtime is None
assert store_fs.last_sync_revision is None
@pytest.mark.django_db
def test_add_store_bad(po_directory, english):
"""Try to create a store_fs by pootle_path for a non existent project
"""
project0 = Project.objects.get(code="project0")
project = ProjectDBFactory(source_language=english)
# project doesnt exist
with pytest.raises(ValidationError):
StoreFS.objects.create(
pootle_path="/en/project0_BAD/example.po",
path="/some/fs/example.po")
# pootle_path must match project_code
with pytest.raises(ValidationError):
StoreFS.objects.create(
project=project0,
pootle_path="/en/%s/en.po" % project.code,
path="/locales/en.po")
# need both pootle_path and fs_path - somehow
with pytest.raises(ValidationError):
StoreFS.objects.create(
project=project0,
pootle_path="/language0/%s/en.po" % project0.code)
with pytest.raises(ValidationError):
StoreFS.objects.create(
project=project0,
path="/locales/en.po")
store = setup_store("/language0/project0/en.po")
with pytest.raises(ValidationError):
StoreFS.objects.create(
store=store,
pootle_path=store.pootle_path)
@pytest.mark.django_db
def test_add_store_bad_lang(project0):
"""Try to create a store_fs by pootle_path for a non existent language
"""
with pytest.raises(ValidationError):
StoreFS.objects.create(
pootle_path="/fr/%s/example.po" % project0.code,
path="/some/fs/example.po")
@pytest.mark.django_db
def test_add_store_bad_path(po_directory, english):
"""Try to create a store_fs where pootle_path and store.pootle_path dont
match.
"""
fs_path = "/some/fs/example.po"
project = ProjectDBFactory(source_language=english)
language = LanguageDBFactory()
tp = TranslationProjectFactory(project=project, language=language)
tp.project.config["pootle_fs.fs_type"] = "localfs"
tp.project.config["pootle_fs.fs_url"] = "/foo"
store = StoreDBFactory(
translation_project=tp,
parent=tp.directory,
name="example_store.po")
with pytest.raises(ValidationError):
StoreFS.objects.create(
store=store,
pootle_path="/some/other/path.po",
path=fs_path)
@pytest.mark.django_db
def test_save_store_fs_change_pootle_path_or_store(po_directory, tp0_store_fs):
"""You cant change a pootle_path if a store is associated
unless you also remove the store association - and vice versa
"""
fs_store = tp0_store_fs
store = fs_store.store
other_path = "/en/project0/other.po"
fs_store.pootle_path = other_path
with pytest.raises(ValidationError):
fs_store.save()
fs_store.store = None
fs_store.save()
assert fs_store.store is None
assert fs_store.pootle_path == other_path
fs_store.store = store
with pytest.raises(ValidationError):
fs_store.save()
fs_store.pootle_path = store.pootle_path
fs_store.save()
assert fs_store.store == store
assert fs_store.pootle_path == store.pootle_path
@pytest.mark.django_db
def test_save_store_fs_bad_lang(po_directory, tp0_store_fs):
"""Try to save a store with a non-existent lang code"""
tp0_store_fs.store = None
tp0_store_fs.pootle_path = "/fr/project0/example.po"
with pytest.raises(ValidationError):
tp0_store_fs.save()
@pytest.mark.django_db
def test_save_store_fs_bad_lang_with_store(po_directory, tp0_store, tp0_store_fs):
"""Try to save a store with a pootle_path that is different from the
associated Store.
"""
tp0_store_fs.store = tp0_store
tp0_store_fs.pootle_path = "/language1/project0/example.po"
with pytest.raises(ValidationError):
tp0_store_fs.save()
@pytest.mark.django_db
def test_save_store_fs_bad_project(po_directory, tp0_store_fs):
"""Try to create a store_fs by pootle_path for a non existent project
"""
tp0_store_fs.store = None
tp0_store_fs.pootle_path = "/en/project0_BAD/example.po"
with pytest.raises(ValidationError):
tp0_store_fs.save()
@pytest.mark.django_db
def test_store_fs_plugin(po_directory, tp0_store_fs, no_fs_plugins, no_fs_files):
store_fs = tp0_store_fs
class DummyPlugin(object):
file_class = FSFile
def __init__(self, project):
self.project = project
def foo(self):
return "bar"
project = store_fs.project
with no_fs_plugins():
with no_fs_files():
@provider(fs_plugins, weak=False, sender=Project)
def provide_plugin(**kwargs):
return dict(dummyfs=DummyPlugin)
@getter(fs_file, weak=False, sender=DummyPlugin)
def fs_files_getter(**kwargs):
return FSFile
project.config["pootle_fs.fs_type"] = "dummyfs"
project.config["pootle_fs.fs_url"] = "/foo/bar"
assert store_fs.plugin.project == project
assert store_fs.plugin.foo() == "bar"
assert isinstance(store_fs.file, FSFile)
| 8,437
|
Python
|
.py
| 212
| 33.613208
| 82
| 0.685896
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,938
|
suggestion.py
|
translate_pootle/tests/models/suggestion.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.template.defaultfilters import escape
from pootle.core.delegate import review
from pootle_store.models import Suggestion
@pytest.mark.django_db
def test_hash(store0):
"""Tests that target hash changes when suggestion is modified"""
unit = store0.units[0]
suggestions = review.get(Suggestion)()
suggestion, created_ = suggestions.add(unit, "gras")
first_hash = suggestion.target_hash
suggestion.target = "gras++"
second_hash = suggestion.target_hash
assert first_hash != second_hash
@pytest.mark.django_db
def test_accept_suggestion_with_comment_email_escaped(store0, mailoutbox, member2):
"""Tests that email sent on accept suggestions with comment is escaped."""
unit = store0.units[0]
suggestion_review_cls = review.get(Suggestion)
review_instance = suggestion_review_cls()
suggestion, created_ = review_instance.add(unit, "gras", user=member2)
comment = "Very nice"
suggestion_review_cls([suggestion]).accept(comment=comment)
assert len(mailoutbox) == 1
message = mailoutbox[0]
assert comment in message.body
suggestion, created_ = review_instance.add(unit, "gras++", user=member2)
comment = "Good job not translating <tag> tags"
suggestion_review_cls([suggestion]).accept(comment=comment)
assert len(mailoutbox) == 2
message = mailoutbox[1]
assert comment not in message.body
assert escape(comment) in message.body
@pytest.mark.django_db
def test_reject_suggestion_with_comment_email_escaped(store0, mailoutbox, member2):
"""Tests that email sent on reject suggestions with comment is escaped."""
unit = store0.units[0]
suggestion_review_cls = review.get(Suggestion)
review_instance = suggestion_review_cls()
suggestion, created_ = review_instance.add(unit, "gras", user=member2)
comment = "It is wrong"
suggestion_review_cls([suggestion]).reject(comment=comment)
assert len(mailoutbox) == 1
message = mailoutbox[0]
assert comment in message.body
suggestion, created_ = review_instance.add(unit, "gras++", user=member2)
comment = "The <tag> must not be translated"
suggestion_review_cls([suggestion]).reject(comment=comment)
assert len(mailoutbox) == 2
message = mailoutbox[1]
assert comment not in message.body
assert escape(comment) in message.body
| 2,638
|
Python
|
.py
| 59
| 40.627119
| 83
| 0.739571
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,939
|
translationproject.py
|
translate_pootle/tests/models/translationproject.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
import pytest
from translate.filters import checks
from django.db import IntegrityError
from pytest_pootle.factories import LanguageDBFactory
from pootle.core.delegate import revision
from pootle_app.models import Directory
from pootle_language.models import Language
from pootle_project.models import Project
from pootle_store.models import Store
from pootle_translationproject.models import TranslationProject
@pytest.mark.django_db
def test_tp_create_fail(po_directory, tutorial, english):
# Trying to create a TP with no Language raises a RelatedObjectDoesNotExist
# which can be caught with Language.DoesNotExist
with pytest.raises(Language.DoesNotExist):
TranslationProject.objects.create()
# TP needs a project set too...
with pytest.raises(Project.DoesNotExist):
TranslationProject.objects.create(language=english)
# There is already an english tutorial was automagically set up
with pytest.raises(IntegrityError):
TranslationProject.objects.create(project=tutorial, language=english)
@pytest.mark.django_db
def test_tp_create_parent_dirs(tp0):
parent = tp0.create_parent_dirs("%sfoo/bar/baz.po" % tp0.pootle_path)
assert (
parent
== Directory.objects.get(
pootle_path="%sfoo/bar/" % tp0.pootle_path))
@pytest.mark.django_db
def test_tp_create_templates(project0_nongnu, project0,
templates, no_templates_tps, complex_ttk):
# As there is a tutorial template it will automatically create stores for
# our new TP
template_tp = TranslationProject.objects.create(
language=templates, project=project0)
template = Store.objects.create(
name="foo.pot",
translation_project=template_tp,
parent=template_tp.directory)
template.update(complex_ttk)
tp = TranslationProject.objects.create(
project=project0, language=LanguageDBFactory())
tp.init_from_templates()
assert tp.stores.count() == template_tp.stores.count()
assert (
[(s, t)
for s, t
in template_tp.stores.first().units.values_list("source_f",
"target_f")]
== [(s, t)
for s, t
in tp.stores.first().units.values_list("source_f",
"target_f")])
@pytest.mark.django_db
def test_tp_init_from_template_po(project0, templates,
no_templates_tps, complex_ttk):
# When initing a tp from a file called `template.pot` the resulting
# store should be called `langcode.po` if the project is gnuish
project0.config["pootle_fs.translation_mappings"] = dict(
default="/<dir_path>/<language_code>.<ext>")
template_tp = TranslationProject.objects.create(
language=templates, project=project0)
template = Store.objects.create(
name="template.pot",
translation_project=template_tp,
parent=template_tp.directory)
template.update(complex_ttk)
tp = TranslationProject.objects.create(
project=project0, language=LanguageDBFactory())
tp.init_from_templates()
store = tp.stores.get()
assert store.name == "%s.po" % tp.language.code
@pytest.mark.django_db
def test_tp_create_with_files(project0_directory, project0, store0, settings):
# lets add some files by hand
trans_dir = settings.POOTLE_TRANSLATION_DIRECTORY
language = LanguageDBFactory()
tp_dir = os.path.join(trans_dir, "%s/project0" % language.code)
os.makedirs(tp_dir)
with open(os.path.join(tp_dir, "store0.po"), "w") as f:
f.write(store0.serialize())
TranslationProject.objects.create(project=project0, language=language)
@pytest.mark.django_db
def test_tp_stats_created_from_template(po_directory, templates, tutorial):
language = LanguageDBFactory(code="foolang")
tp = TranslationProject.objects.create(language=language, project=tutorial)
tp.init_from_templates()
assert tp.stores.all().count() == 1
stats = tp.data_tool.get_stats()
assert stats['total'] == 2 # there are 2 words in test template
assert stats['translated'] == 0
assert stats['fuzzy'] == 0
assert stats['suggestions'] == 0
assert stats['critical'] == 0
@pytest.mark.django_db
def test_can_be_inited_from_templates(po_directory, tutorial, templates):
language = LanguageDBFactory()
tp = TranslationProject(project=tutorial, language=language)
assert tp.can_be_inited_from_templates()
@pytest.mark.django_db
def test_cannot_be_inited_from_templates(project0, no_templates_tps):
language = LanguageDBFactory()
tp = TranslationProject(project=project0, language=language)
assert not tp.can_be_inited_from_templates()
@pytest.mark.django_db
def test_tp_checker(po_directory, tp_checker_tests):
language = Language.objects.get(code="language0")
checker_name_, project = tp_checker_tests
tp = TranslationProject.objects.create(project=project, language=language)
checkerclasses = [
checks.projectcheckers.get(tp.project.checkstyle,
checks.StandardChecker)
]
assert [x.__class__ for x in tp.checker.checkers] == checkerclasses
@pytest.mark.django_db
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)
| 5,854
|
Python
|
.py
| 133
| 37.496241
| 79
| 0.7016
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,940
|
revision.py
|
translate_pootle/tests/models/revision.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.models import Revision
from pootle_store.models import Unit
@pytest.mark.django_db
def test_max_revision(revision, project0_nongnu, store0):
"""Tests `max_revision()` gets the latest revision."""
initial_max_revision = Unit.max_revision()
initial_revision = Revision.get()
assert initial_max_revision == initial_revision
# Let's make 10 translation updates, this must also update their revision
# numbers
unit = store0.units.first()
for i in range(10):
unit.target = str(i)
unit.save()
unit.refresh_from_db()
end_max_revision = Unit.max_revision()
end_revision = Revision.get()
assert end_max_revision == end_revision
assert end_max_revision != initial_max_revision
assert end_revision != initial_revision
assert end_revision == 10 + initial_revision
@pytest.mark.django_db
def test_revision_incr(store0):
"""Tests revision is incremented when units change."""
previous_revision = Revision.get()
db_unit = store0.units.exclude(target_f="").first()
db_unit.target = "CHANGED"
db_unit.save()
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
db_unit.refresh_from_db()
previous_revision = Revision.get()
db_unit.target = ""
db_unit.save()
assert db_unit.revision != previous_revision
assert Revision.get() != previous_revision
assert db_unit.revision == Revision.get()
| 1,803
|
Python
|
.py
| 46
| 34.913043
| 77
| 0.713631
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,941
|
unit.py
|
translate_pootle/tests/models/unit.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import os
import pytest
from translate.storage.factory import getclass
from translate.storage.pypo import pounit
from translate.storage.statsdb import wordcount as counter
from django.contrib.auth import get_user_model
from pootle.core.delegate import review, wordcount
from pootle.core.plugin import getter
from pootle_fs.utils import FSPlugin
from pootle_store.constants import FUZZY, OBSOLETE, TRANSLATED, UNTRANSLATED
from pootle_store.models import Suggestion, Unit
from pootle_store.syncer import UnitSyncer
User = get_user_model()
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
@pytest.mark.django_db
def test_getorig(project0_nongnu, af_tutorial_po):
"""Tests that the in-DB Store and on-disk Store match by checking that
units match in order.
"""
file_store, __ = _sync_translations(af_tutorial_po.units.first())
for i, db_unit in enumerate(af_tutorial_po.units.iterator()):
file_unit = file_store.units[i + 1]
assert db_unit.getid() == file_unit.getid()
@pytest.mark.django_db
def test_convert(project0_nongnu, af_tutorial_po):
"""Tests that in-DB and on-disk units match after format conversion."""
# db unit doesnt have plural form by default, so add
plural_unit = af_tutorial_po.units.last()
plural_unit.target = [u'samaka', u'samak']
plural_unit.save()
file_store, __ = _sync_translations(af_tutorial_po.units.first())
for db_unit in af_tutorial_po.units.iterator():
file_unit = file_store.findid(db_unit.getid())
newunit = db_unit.convert(file_store.UnitClass)
assert str(newunit) == str(file_unit)
@pytest.mark.django_db
def test_sync_target(project0_nongnu, af_tutorial_po):
"""Tests that target changes are properly sync'ed to disk."""
db_unit = af_tutorial_po.units.first()
db_unit.target = u'samaka'
db_unit.save()
file_store, file_unit = _sync_translations(db_unit)
assert (
db_unit.target
== file_unit.target
== u'samaka')
@pytest.mark.django_db
def test_empty_plural_target(af_tutorial_po):
"""Tests empty plural targets are not deleted."""
db_unit = af_tutorial_po.units.get(unitid="%d fish")
db_unit.target = ["samaka"]
db_unit.save()
file_store, file_unit = _sync_translations(db_unit)
assert file_unit.target == "samaka"
assert len(file_unit.target.strings) == 2
db_unit.refresh_from_db()
db_unit.target = ""
db_unit.save()
file_store, file_unit = _sync_translations(db_unit)
assert file_unit.target == ""
assert len(file_unit.target.strings) == 2
@pytest.mark.django_db
def test_sync_plural_target(af_tutorial_po):
"""Tests plural translations are stored and sync'ed."""
db_unit = af_tutorial_po.units.get(unitid="%d fish")
db_unit.target = [u'samaka', u'samak']
db_unit.save()
file_store, file_unit = _sync_translations(db_unit)
assert (
db_unit.target.strings
== file_unit.target.strings
== [u'samaka', u'samak']
== file_store.units[db_unit.index].target.strings)
assert (
db_unit.target
== file_unit.target
== u'samaka'
== file_store.units[db_unit.index].target)
@pytest.mark.django_db
def test_sync_plural_target_dict(af_tutorial_po):
"""Tests plural translations are stored and sync'ed (dict version)."""
db_unit = af_tutorial_po.units.get(unitid="%d fish")
db_unit.target = {0: u'samaka', 1: u'samak'}
db_unit.save()
file_store, file_unit = _sync_translations(db_unit)
assert (
db_unit.target.strings
== file_unit.target.strings
== [u'samaka', u'samak']
== file_store.units[db_unit.index].target.strings)
assert (
db_unit.target
== file_unit.target
== u'samaka'
== file_store.units[db_unit.index].target)
@pytest.mark.django_db
def test_sync_fuzzy(project0_nongnu, af_tutorial_po):
"""Tests fuzzy state changes are stored and sync'ed."""
db_unit = af_tutorial_po.units.first()
db_unit.target = u'samaka'
db_unit.markfuzzy()
db_unit.save()
file_store, file_unit = _sync_translations(db_unit)
assert (
db_unit.isfuzzy()
== file_unit.isfuzzy()
is True)
db_unit.refresh_from_db()
db_unit.markfuzzy(False)
db_unit.save()
file_store, file_unit = _sync_translations(db_unit)
assert (
db_unit.isfuzzy()
== file_unit.isfuzzy()
is False)
@pytest.mark.django_db
def test_sync_comment(project0_nongnu, af_tutorial_po):
"""Tests translator comments are stored and sync'ed."""
db_unit = af_tutorial_po.units.first()
db_unit.translator_comment = u'7amada'
db_unit.save()
file_store, file_unit = _sync_translations(db_unit)
assert (
db_unit.getnotes(origin='translator')
== file_unit.getnotes(origin='translator')
== u'7amada')
@pytest.mark.django_db
def test_add_suggestion(store0, system):
"""Tests adding new suggestions to units."""
untranslated_unit = store0.units.filter(state=UNTRANSLATED)[0]
translated_unit = store0.units.filter(state=TRANSLATED)[0]
suggestion_text = 'foo bar baz'
initial_suggestions = len(untranslated_unit.get_suggestions())
suggestions = review.get(Suggestion)()
# Empty suggestion is not recorded
sugg, added = suggestions.add(untranslated_unit, "")
assert sugg is None
assert not added
# Existing translation can't be added as a suggestion
sugg, added = suggestions.add(translated_unit, translated_unit.target)
assert sugg is None
assert not added
# Add new suggestion
sugg, added = suggestions.add(untranslated_unit, suggestion_text)
assert sugg is not None
assert added
assert len(untranslated_unit.get_suggestions()) == initial_suggestions + 1
# Already-suggested text can't be suggested again
assert suggestions.add(untranslated_unit, suggestion_text) == (None, False)
assert len(untranslated_unit.get_suggestions()) == initial_suggestions + 1
# Removing a suggestion should allow suggesting the same text again
review.get(Suggestion)([sugg], system).reject()
assert len(untranslated_unit.get_suggestions()) == initial_suggestions
sugg, added = suggestions.add(untranslated_unit, suggestion_text)
assert sugg is not None
assert added
assert len(untranslated_unit.get_suggestions()) == initial_suggestions + 1
@pytest.mark.django_db
def test_accept_suggestion_changes_state(issue_2401_po, system):
"""Tests that accepting a suggestion will change the state of the unit."""
suggestions = review.get(Suggestion)()
# First test with an untranslated unit
unit = issue_2401_po.units[0]
assert unit.state == UNTRANSLATED
suggestion, created_ = suggestions.add(unit, "foo")
assert unit.state == UNTRANSLATED
review.get(Suggestion)([suggestion], system).accept()
assert unit.state == TRANSLATED
# Let's try with a translated unit now
unit = issue_2401_po.units[1]
assert unit.state == TRANSLATED
suggestion, created_ = suggestions.add(unit, "bar")
assert unit.state == TRANSLATED
review.get(Suggestion)([suggestion], system).accept()
assert unit.state == TRANSLATED
# And finally a fuzzy unit
unit = issue_2401_po.units[2]
assert unit.state == FUZZY
suggestion, created_ = suggestions.add(unit, "baz")
assert unit.state == FUZZY
review.get(Suggestion)([suggestion], system).accept()
assert unit.state == TRANSLATED
@pytest.mark.django_db
def test_accept_suggestion_update_wordcount(it_tutorial_po, system):
"""Tests that accepting a suggestion for an untranslated unit will
change the wordcount stats of the unit's store.
"""
orig_translated = it_tutorial_po.data.translated_words
suggestions = review.get(Suggestion)()
untranslated_unit = it_tutorial_po.units[0]
suggestion_text = 'foo bar baz'
sugg, added = suggestions.add(untranslated_unit, suggestion_text)
assert sugg is not None
assert added
assert len(untranslated_unit.get_suggestions()) == 1
assert untranslated_unit.state == UNTRANSLATED
review.get(Suggestion)([sugg], system).accept()
assert untranslated_unit.state == TRANSLATED
assert it_tutorial_po.data.translated_words > orig_translated
@pytest.mark.django_db
def test_unit_repr():
unit = Unit.objects.first()
assert str(unit) == str(unit.convert())
assert unicode(unit) == unicode(unit.source)
@pytest.mark.django_db
def test_unit_po_plurals(store_po):
unit = Unit(store=store_po)
unit_po = pounit('bar')
unit_po.msgid_plural = ['bars']
unit.update(unit_po)
assert unit.hasplural()
unit.save()
assert unit.hasplural()
@pytest.mark.django_db
def test_unit_ts_plurals(store_po, test_fs):
with test_fs.open(['data', 'ts', 'add_plurals.ts']) as f:
file_store = getclass(f)(f.read())
unit = Unit(store=store_po)
unit_ts = file_store.units[0]
unit.update(unit_ts)
assert unit.hasplural()
unit.save()
unit = Unit.objects.get(id=unit.id)
assert unit.hasplural()
unit.save()
unit = Unit.objects.get(id=unit.id)
assert unit.hasplural()
def _test_unit_syncer(unit, newunit):
assert newunit.source == unit.source
assert newunit.target == unit.target
assert newunit.getid() == unit.getid()
assert newunit.istranslated() == unit.istranslated()
assert (
newunit.getnotes(origin="developer")
== unit.getnotes(origin="developer"))
assert (
newunit.getnotes(origin="translator")
== unit.getnotes(origin="translator"))
assert newunit.isobsolete() == unit.isobsolete()
assert newunit.isfuzzy() == unit.isfuzzy()
@pytest.mark.django_db
def test_unit_syncer(unit_syncer):
unit, unit_class = unit_syncer
syncer = UnitSyncer(unit)
newunit = syncer.convert(unit_class)
assert newunit.istranslated()
assert not newunit.isfuzzy()
assert not newunit.isobsolete()
_test_unit_syncer(unit, newunit)
@pytest.mark.django_db
def test_unit_syncer_fuzzy(unit_syncer):
unit, unit_class = unit_syncer
syncer = UnitSyncer(unit)
unit.state = FUZZY
unit.save()
newunit = syncer.convert(unit_class)
assert newunit.isfuzzy()
assert not newunit.isobsolete()
assert not newunit.istranslated()
_test_unit_syncer(unit, newunit)
@pytest.mark.django_db
def test_unit_syncer_untranslated(unit_syncer):
unit, unit_class = unit_syncer
syncer = UnitSyncer(unit)
unit.state = UNTRANSLATED
unit.target = ""
unit.save()
newunit = syncer.convert(unit_class)
assert not newunit.isfuzzy()
assert not newunit.isobsolete()
assert not newunit.istranslated()
_test_unit_syncer(unit, newunit)
@pytest.mark.django_db
def test_unit_syncer_obsolete(unit_syncer):
unit, unit_class = unit_syncer
syncer = UnitSyncer(unit)
unit.state = OBSOLETE
unit.save()
newunit = syncer.convert(unit_class)
assert newunit.isobsolete()
assert not newunit.isfuzzy()
assert not newunit.istranslated()
_test_unit_syncer(unit, newunit)
@pytest.mark.django_db
def test_unit_syncer_notes(unit_syncer):
unit, unit_class = unit_syncer
syncer = UnitSyncer(unit)
unit.addnote(origin="developer", text="hello")
newunit = syncer.convert(unit_class)
assert newunit.getnotes(origin="developer") == "hello"
_test_unit_syncer(unit, newunit)
unit.addnote(origin="translator", text="world")
newunit = syncer.convert(unit_class)
assert newunit.getnotes(origin="translator") == "world"
_test_unit_syncer(unit, newunit)
@pytest.mark.django_db
def test_unit_syncer_locations(unit_syncer):
unit, unit_class = unit_syncer
unit.addlocation("FOO")
syncer = UnitSyncer(unit)
newunit = syncer.convert(unit_class)
assert newunit.getlocations() == ["FOO"]
_test_unit_syncer(unit, newunit)
@pytest.mark.django_db
def test_add_autotranslated_unit(settings, store0, admin, no_wordcount):
class DummyWordcount(object):
def count(self, value):
return counter(value) - value.count('Pootle')
def count_words(self, strings):
return sum(self.count(string) for string in strings)
wc = DummyWordcount()
with no_wordcount():
@getter(wordcount, sender=Unit)
def temp_wc_getter(**kwargs_):
return wc
unit = store0.addunit(
store0.UnitClass(source_f='Pootle Pootle'),
user=admin)
dbunit = store0.units.get(id=unit.id)
assert dbunit.state == FUZZY
assert dbunit.target_f == unit.source_f
| 13,351
|
Python
|
.py
| 342
| 33.856725
| 79
| 0.696698
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,942
|
store.py
|
translate_pootle/tests/models/store.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import io
import os
import six
import pytest
from pytest_pootle.factories import (
LanguageDBFactory, ProjectDBFactory, StoreDBFactory,
TranslationProjectFactory)
from pytest_pootle.utils import update_store
from translate.storage.factory import getclass
from django.db.models import Max
from django.core.exceptions import ValidationError
from django.core.files.uploadedfile import SimpleUploadedFile
from pootle.core.delegate import (
config, format_classes, format_diffs, formats)
from pootle.core.models import Revision
from pootle.core.delegate import deserializers, serializers
from pootle.core.url_helpers import to_tp_relative_path
from pootle.core.plugin import provider
from pootle.core.serializers import Serializer, Deserializer
from pootle_app.models import Directory
from pootle_config.exceptions import ConfigurationError
from pootle_format.exceptions import UnrecognizedFiletype
from pootle_format.formats.po import PoStoreSyncer
from pootle_format.models import Format
from pootle_fs.utils import FSPlugin
from pootle_language.models import Language
from pootle_project.models import Project
from pootle_statistics.models import (
SubmissionFields, SubmissionTypes)
from pootle_store.constants import (
NEW, OBSOLETE, PARSED, POOTLE_WINS, TRANSLATED)
from pootle_store.diff import DiffableStore, StoreDiff
from pootle_store.models import Store
from pootle_store.util import parse_pootle_revision
from pootle_translationproject.models import TranslationProject
def _update_from_upload_file(store, update_file,
content_type="text/x-gettext-translation",
user=None, submission_type=None):
with open(update_file, "r") as f:
upload = SimpleUploadedFile(os.path.basename(update_file),
f.read(),
content_type)
test_store = getclass(upload)(upload.read())
store_revision = parse_pootle_revision(test_store)
store.update(test_store, store_revision=store_revision,
user=user, submission_type=submission_type)
def _store_as_string(store):
ttk = store.syncer.convert(store.syncer.file_class)
if hasattr(ttk, "updateheader"):
# FIXME We need those headers on import
# However some formats just don't support setting metadata
ttk.updateheader(
add=True, X_Pootle_Path=store.pootle_path)
ttk.updateheader(
add=True, X_Pootle_Revision=store.get_max_unit_revision())
return str(ttk)
def _sync_store(settings, store, resolve=None, update="all", force_add=None):
tp = store.translation_project
project = tp.project
language = tp.language
plugin = FSPlugin(project)
project.config["pootle_fs.fs_url"] = os.path.join(
settings.POOTLE_TRANSLATION_DIRECTORY,
project.code)
plugin.fetch()
if force_add:
plugin.add(update=update, force=True)
else:
plugin.add(update=update)
if resolve == "pootle_wins":
plugin.resolve(pootle_wins=True)
elif resolve == "fs_wins":
plugin.resolve(pootle_wins=False)
plugin.sync(update=update)
return os.path.join(
plugin.fs_url,
language.code,
store.name)
@pytest.mark.django_db
def test_sync(project0_nongnu, project0, store0, settings):
"""Tests that the new on-disk file is created after sync for existing
in-DB Store if the corresponding on-disk file ceased to exist.
"""
tp = TranslationProjectFactory(
project=project0, language=LanguageDBFactory())
store = StoreDBFactory(
translation_project=tp,
parent=tp.directory)
store.update(store.deserialize(store0.serialize()))
file_path = _sync_store(settings, store)
assert os.path.exists(file_path)
os.remove(file_path)
@pytest.mark.django_db
def test_update_from_ts(store0, test_fs, member):
store0.parsed = True
orig_units = store0.units.count()
existing_created_at = store0.units.aggregate(
Max("creation_time"))["creation_time__max"]
existing_mtime = store0.units.aggregate(
Max("mtime"))["mtime__max"]
old_revision = store0.data.max_unit_revision
with test_fs.open(['data', 'ts', 'tutorial', 'en', 'tutorial.ts']) as f:
store = getclass(f)(f.read())
store0.update(
store,
submission_type=SubmissionTypes.UPLOAD,
user=member)
assert not store0.units[orig_units].hasplural()
unit = store0.units[orig_units + 1]
assert unit.submission_set.count() == 0
assert unit.hasplural()
assert unit.creation_time >= existing_created_at
assert unit.creation_time >= existing_mtime
unit_source = unit.unit_source
assert unit_source.created_with == SubmissionTypes.UPLOAD
assert unit_source.created_by == member
assert unit.change.changed_with == SubmissionTypes.UPLOAD
assert unit.change.submitted_by == member
assert unit.change.submitted_on >= unit.creation_time
assert unit.change.reviewed_by is None
assert unit.change.reviewed_on is None
assert unit.revision > old_revision
@pytest.mark.django_db
def test_update_ts_plurals(store_po, test_fs, ts):
project = store_po.translation_project.project
filetype_tool = project.filetype_tool
project.filetypes.add(ts)
filetype_tool.set_store_filetype(store_po, ts)
with test_fs.open(['data', 'ts', 'add_plurals.ts']) as f:
file_store = getclass(f)(f.read())
store_po.update(file_store)
unit = store_po.units[0]
assert unit.hasplural()
assert unit.submission_set.count() == 0
with test_fs.open(['data', 'ts', 'update_plurals.ts']) as f:
file_store = getclass(f)(f.read())
store_po.update(
file_store,
store_revision=store_po.data.max_unit_revision)
unit = store_po.units[0]
assert unit.hasplural()
assert unit.submission_set.count() == 1
update_sub = unit.submission_set.first()
assert update_sub.revision == unit.revision
assert update_sub.creation_time == unit.change.submitted_on
assert update_sub.submitter == unit.change.submitted_by
assert update_sub.new_value == unit.target
assert update_sub.type == unit.change.changed_with
assert update_sub.field == SubmissionFields.TARGET
# this fails 8(
# from pootle.core.utils.multistring import unparse_multistring
# assert (
# unparse_multistring(update_sub.new_value)
# == unparse_multistring(unit.target))
@pytest.mark.django_db
def test_update_with_non_ascii(store0, test_fs):
store0.state = PARSED
orig_units = store0.units.count()
path = 'data', 'po', 'tutorial', 'en', 'tutorial_non_ascii.po'
with test_fs.open(path) as f:
store = getclass(f)(f.read())
store0.update(store)
last_unit = store0.units[orig_units]
updated_target = "Hèḽḽě, ŵôrḽḓ"
assert last_unit.target == updated_target
assert last_unit.submission_set.count() == 0
# last_unit.target = "foo"
# last_unit.save()
# this should now have a submission with the old target
# but it fails
# assert last_unit.submission_set.count() == 1
# update_sub = last_unit.submission_set.first()
# assert update_sub.old_value == updated_target
# assert update_sub.new_value == "foo"
@pytest.mark.django_db
def test_update_unit_order(project0_nongnu, ordered_po,
ordered_update_ttk, settings):
"""Tests unit order after a specific update.
"""
# Set last sync revision
file_path = _sync_store(settings, ordered_po)
assert os.path.exists(file_path)
expected_unit_list = ['1->2', '2->4', '3->3', '4->5']
updated_unit_list = [unit.unitid for unit in ordered_po.units]
assert expected_unit_list == updated_unit_list
original_revision = ordered_po.get_max_unit_revision()
ordered_po.update(
ordered_update_ttk,
store_revision=original_revision)
expected_unit_list = [
'X->1', '1->2', '3->3', '2->4',
'4->5', 'X->6', 'X->7', 'X->8']
updated_unit_list = [unit.unitid for unit in ordered_po.units]
assert expected_unit_list == updated_unit_list
unit = ordered_po.units.first()
assert unit.revision > original_revision
assert unit.submission_set.count() == 0
@pytest.mark.django_db
def test_update_save_changed_units(project0_nongnu, store0, test_fs,
member, system, settings):
"""Tests that any update saves changed units only.
"""
# not sure if this is testing anything
store = store0
# Set last sync revision
store.fs.all().delete()
file_path = _sync_store(settings, store0)
store.update(store.deserialize(open(file_path).read()))
unit_list = list(store.units)
update_file = test_fs.open(
"data/po/tutorial/ru/update_save_changed_units_updated.po",
"r")
with update_file as sourcef:
store.update(
store.deserialize(sourcef.read()),
user=member)
updated_unit_list = list(store.units)
# nothing changed except revisions of unsynced units
# to ensure its synced back to fs
for index in range(0, len(unit_list)):
unit = unit_list[index]
updated_unit = updated_unit_list[index]
if unit.revision > 0:
assert unit.revision < updated_unit.revision
assert unit.mtime == updated_unit.mtime
assert unit.target == updated_unit.target
@pytest.mark.django_db
def test_update_set_last_sync_revision(project0_nongnu, tp0, store0,
test_fs, settings):
"""Tests setting last_sync_revision after store creation.
"""
unit = store0.units.first()
unit.target = "UPDATED TARGET"
unit.save()
file_path = _sync_store(settings, store0, resolve="pootle_wins")
# Store is already parsed and store.last_sync_revision should be equal to
# max unit revision
fs = store0.fs.get()
assert fs.last_sync_revision == store0.get_max_unit_revision()
# store.last_sync_revision is not changed after empty update
saved_last_sync_revision = fs.last_sync_revision
# store0.updater.update_from_disk()
_sync_store(settings, store0)
fs.refresh_from_db()
assert fs.last_sync_revision == saved_last_sync_revision
update_file = test_fs.open(
"data/po/tutorial/ru/update_set_last_sync_revision_updated.po",
"r")
with update_file as sourcef:
with open(file_path, "wb") as targetf:
targetf.write(sourcef.read())
store0.refresh_from_db()
# any non-empty update sets last_sync_revision to next global revision
next_revision = Revision.get() + 1
_sync_store(settings, store0)
fs.refresh_from_db()
assert fs.last_sync_revision == next_revision
# store.last_sync_revision is not changed after empty update (even if it
# has unsynced units)
next_unit_revision = Revision.get() + 1
dbunit = store0.units.first()
dbunit.target = "ANOTHER DB TARGET UPDATE"
dbunit.save()
assert dbunit.revision == next_unit_revision
_sync_store(settings, store0, update="pootle")
fs.refresh_from_db()
assert fs.last_sync_revision == next_revision
# Non-empty update sets store.last_sync_revision to next global revision
# (even the store has unsynced units). There is only one unsynced unit in
# this case so its revision should be set next to store.last_sync_revision
dbunit = store0.units.first()
dbunit.target = "ANOTHER DB TARGET UPDATE AGAIN"
dbunit.save()
next_revision = Revision.get() + 1
orig = store0.deserialize(store0.serialize())
orig.units[2].target = "SOMETHING ELSE"
with open(file_path, "wb") as targetf:
targetf.write(str(orig))
_sync_store(settings, store0, resolve="fs_wins", update="pootle")
fs.refresh_from_db()
assert fs.last_sync_revision == next_revision
# Get unsynced unit in DB. Its revision should be greater
# than store.last_sync_revision to allow to keep this change during
# update from a file
dbunit.refresh_from_db()
store0.data.refresh_from_db()
assert store0.data.max_unit_revision == dbunit.revision
assert dbunit.revision == fs.last_sync_revision + 1
@pytest.mark.django_db
def test_update_upload_defaults(store0, system):
store0.state = PARSED
unit = store0.units.first()
original_revision = unit.revision
last_sub_pk = unit.submission_set.order_by(
"id").values_list("id", flat=True).last() or 0
update_store(
store0,
[(unit.source, "%s UPDATED" % unit.source, False)],
store_revision=Revision.get() + 1)
unit = store0.units[0]
assert unit.change.submitted_by == system
assert unit.change.submitted_on >= unit.creation_time
assert unit.change.submitted_by == system
assert (
unit.submission_set.last().type
== SubmissionTypes.SYSTEM)
assert unit.revision > original_revision
new_subs = unit.submission_set.filter(id__gt=last_sub_pk).order_by("id")
# there should be 2 new subs - state_change and target_change
new_subs = unit.submission_set.filter(id__gt=last_sub_pk).order_by("id")
assert new_subs.count() == 2
target_sub = new_subs[0]
assert target_sub.old_value == ""
assert target_sub.new_value == unit.target
assert target_sub.field == SubmissionFields.TARGET
assert target_sub.type == SubmissionTypes.SYSTEM
assert target_sub.submitter == system
assert target_sub.revision == unit.revision
assert target_sub.creation_time == unit.change.submitted_on
state_sub = new_subs[1]
assert state_sub.old_value == "0"
assert state_sub.new_value == "200"
assert state_sub.field == SubmissionFields.STATE
assert state_sub.type == SubmissionTypes.SYSTEM
assert state_sub.submitter == system
assert state_sub.revision == unit.revision
assert state_sub.creation_time == unit.change.submitted_on
@pytest.mark.django_db
def test_update_upload_member_user(store0, system, member):
store0.state = PARSED
original_unit = store0.units.first()
original_revision = original_unit.revision
last_sub_pk = original_unit.submission_set.order_by(
"id").values_list("id", flat=True).last() or 0
update_store(
store0,
[(original_unit.source, "%s UPDATED" % original_unit.source, False)],
user=member,
store_revision=Revision.get() + 1,
submission_type=SubmissionTypes.UPLOAD)
unit = store0.units[0]
assert unit.change.submitted_by == member
assert unit.change.changed_with == SubmissionTypes.UPLOAD
assert unit.change.submitted_on >= unit.creation_time
assert unit.change.reviewed_on is None
assert unit.revision > original_revision
unit_source = unit.unit_source
unit_source.created_by == system
unit_source.created_with == SubmissionTypes.SYSTEM
# there should be 2 new subs - state_change and target_change
new_subs = unit.submission_set.filter(id__gt=last_sub_pk).order_by("id")
assert new_subs.count() == 2
target_sub = new_subs[0]
assert target_sub.old_value == ""
assert target_sub.new_value == unit.target
assert target_sub.field == SubmissionFields.TARGET
assert target_sub.type == SubmissionTypes.UPLOAD
assert target_sub.submitter == member
assert target_sub.revision == unit.revision
assert target_sub.creation_time == unit.change.submitted_on
state_sub = new_subs[1]
assert state_sub.old_value == "0"
assert state_sub.new_value == "200"
assert state_sub.field == SubmissionFields.STATE
assert state_sub.type == SubmissionTypes.UPLOAD
assert state_sub.submitter == member
assert state_sub.revision == unit.revision
assert state_sub.creation_time == unit.change.submitted_on
@pytest.mark.django_db
def test_update_upload_submission_type(store0):
store0.state = PARSED
unit = store0.units.first()
last_sub_pk = unit.submission_set.order_by(
"id").values_list("id", flat=True).last() or 0
update_store(
store0,
[(unit.source, "%s UPDATED" % unit.source, False)],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1)
unit_source = store0.units[0].unit_source
unit_change = store0.units[0].change
assert unit_source.created_with == SubmissionTypes.SYSTEM
assert unit_change.changed_with == SubmissionTypes.UPLOAD
# there should be 2 new subs - state_change and target_change
# and both should show as by UPLOAD
new_subs = unit.submission_set.filter(id__gt=last_sub_pk)
assert (
list(new_subs.values_list("type", flat=True))
== [SubmissionTypes.UPLOAD] * 2)
@pytest.mark.django_db
def test_update_upload_new_revision(store0, member):
original_revision = store0.data.max_unit_revision
old_unit = store0.units.first()
update_store(
store0,
[("Hello, world", "Hello, world UPDATED", False)],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1,
user=member)
old_unit.refresh_from_db()
assert old_unit.state == OBSOLETE
assert len(store0.units) == 1
unit = store0.units[0]
unit_source = unit.unit_source
assert unit.revision > original_revision
assert unit_source.created_by == member
assert unit.change.submitted_by == member
assert unit.creation_time == unit.change.submitted_on
assert unit.change.reviewed_by is None
assert unit.change.reviewed_on is None
assert unit.target == "Hello, world UPDATED"
assert unit.submission_set.count() == 0
@pytest.mark.django_db
def test_update_upload_again_new_revision(store0, member, member2):
store = store0
assert store.state == NEW
original_unit = store0.units[0]
update_store(
store,
[("Hello, world", "Hello, world UPDATED", False)],
submission_type=SubmissionTypes.UPLOAD,
store_revision=Revision.get() + 1,
user=member)
original_unit.refresh_from_db()
assert original_unit.state == OBSOLETE
store = Store.objects.get(pk=store0.pk)
assert store.state == PARSED
created_unit = store.units[0]
assert created_unit.target == "Hello, world UPDATED"
assert created_unit.state == TRANSLATED
assert created_unit.submission_set.count() == 0
old_unit_revision = store.data.max_unit_revision
update_store(
store0,
[("Hello, world", "Hello, world UPDATED AGAIN", False)],
submission_type=SubmissionTypes.WEB,
user=member2,
store_revision=Revision.get() + 1)
assert created_unit.submission_set.count() == 1
update_sub = created_unit.submission_set.first()
store = Store.objects.get(pk=store0.pk)
assert store.state == PARSED
unit = store.units[0]
unit_source = unit.unit_source
assert unit.revision > old_unit_revision
assert unit.target == "Hello, world UPDATED AGAIN"
assert unit_source.created_by == member
assert unit_source.created_with == SubmissionTypes.UPLOAD
assert unit.change.submitted_by == member2
assert unit.change.submitted_on >= unit.creation_time
assert unit.change.reviewed_by is None
assert unit.change.reviewed_on is None
assert unit.change.changed_with == SubmissionTypes.WEB
assert update_sub.creation_time == unit.change.submitted_on
assert update_sub.type == unit.change.changed_with
assert update_sub.field == SubmissionFields.TARGET
assert update_sub.submitter == unit.change.submitted_by
assert update_sub.old_value == created_unit.target
assert update_sub.new_value == unit.target
assert update_sub.revision == unit.revision
@pytest.mark.django_db
def test_update_upload_old_revision_unit_conflict(store0, admin, member):
original_revision = Revision.get()
original_unit = store0.units[0]
update_store(
store0,
[("Hello, world", "Hello, world UPDATED", False)],
submission_type=SubmissionTypes.UPLOAD,
store_revision=original_revision + 1,
user=admin)
unit = store0.units[0]
unit_source = unit.unit_source
assert unit_source.created_by == admin
updated_revision = unit.revision
assert (
unit_source.created_with
== SubmissionTypes.UPLOAD)
assert unit.change.submitted_by == admin
assert (
unit.change.changed_with
== SubmissionTypes.UPLOAD)
last_submit_time = unit.change.submitted_on
assert last_submit_time >= unit.creation_time
# load update with expired revision and conflicting unit
unit = store0.units[0]
unit.target = "Hello, world KEEP"
unit.save()
updated_revision = unit.revision
subs_count = unit.submission_set.count()
update_store(
store0,
[("Hello, world", "Hello, world CONFLICT", False)],
submission_type=SubmissionTypes.WEB,
store_revision=original_revision,
user=member)
assert subs_count == unit.submission_set.count()
unit_source = unit.unit_source
# unit target is not updated and revision is incremented
# to force update to fs on next sync
unit.refresh_from_db()
assert store0.units[0].target == "Hello, world KEEP"
assert unit.revision > updated_revision
unit_source = original_unit.unit_source
unit_source.created_by == admin
assert unit_source.created_with == SubmissionTypes.SYSTEM
unit.change.changed_with == SubmissionTypes.UPLOAD
unit.change.submitted_by == admin
unit.change.submitted_on == last_submit_time
unit.change.reviewed_by is None
unit.change.reviewed_on is None
# but suggestion is added
suggestion = store0.units[0].get_suggestions()[0]
assert suggestion.target == "Hello, world CONFLICT"
assert suggestion.user == member
@pytest.mark.django_db
def test_update_upload_new_revision_new_unit(store0, member):
file_name = "pytest_pootle/data/po/tutorial/en/tutorial_update_new_unit.po"
store0.state = PARSED
old_unit_revision = store0.data.max_unit_revision
_update_from_upload_file(
store0,
file_name,
user=member,
submission_type=SubmissionTypes.WEB)
unit = store0.units.last()
unit_source = unit.unit_source
# the new unit has been added
assert unit.submission_set.count() == 0
assert unit.revision > old_unit_revision
assert unit.target == 'Goodbye, world'
assert unit_source.created_by == member
assert unit_source.created_with == SubmissionTypes.WEB
assert unit.change.submitted_by == member
assert unit.change.changed_with == SubmissionTypes.WEB
@pytest.mark.django_db
def test_update_upload_old_revision_new_unit(store0, member2):
store0.units.delete()
store0.state = PARSED
old_unit_revision = store0.data.max_unit_revision
# load initial update
_update_from_upload_file(
store0,
"pytest_pootle/data/po/tutorial/en/tutorial_update.po")
# load old revision with new unit
file_name = "pytest_pootle/data/po/tutorial/en/tutorial_update_old_unit.po"
_update_from_upload_file(
store0,
file_name,
user=member2,
submission_type=SubmissionTypes.WEB)
# the unit has been added because its not already obsoleted
assert store0.units.count() == 2
unit = store0.units.last()
unit_source = unit.unit_source
# the new unit has been added
assert unit.submission_set.count() == 0
assert unit.revision > old_unit_revision
assert unit.target == 'Goodbye, world'
assert unit_source.created_by == member2
assert unit_source.created_with == SubmissionTypes.WEB
assert unit.change.submitted_by == member2
assert unit.change.changed_with == SubmissionTypes.WEB
def _test_store_update_indexes(store, *test_args):
# make sure indexes are not fooed indexes only have to be unique
indexes = [x.index for x in store.units]
assert len(indexes) == len(set(indexes))
def _test_store_update_units_before(*test_args):
# test what has happened to the units that were present before the update
(store, units_update, store_revision, resolve_conflict,
units_before, member_, member2) = test_args
updates = {unit[0]: unit[1] for unit in units_update}
from pootle.core.delegate import versioned
vers = versioned.get(store.__class__)(store)
old_store = vers.at_revision(store_revision or 0)
for unit, change in units_before:
updated_unit = store.unit_set.get(unitid=unit.unitid)
if unit.source not in updates:
# unit is not in update, target should be left unchanged
assert updated_unit.target == unit.target
assert updated_unit.change.submitted_by == change.submitted_by
# depending on unit/store_revision should be obsoleted
if unit.isobsolete() or store_revision >= unit.revision:
assert updated_unit.isobsolete()
else:
assert not updated_unit.isobsolete()
else:
# unit is in update
if store_revision >= unit.revision:
assert not updated_unit.isobsolete()
elif unit.isobsolete():
# the unit has been obsoleted since store_revision
assert updated_unit.isobsolete()
else:
assert not updated_unit.isobsolete()
if not updated_unit.isobsolete():
if store_revision >= unit.revision:
# file store wins outright
assert updated_unit.target == updates[unit.source]
if unit.target != updates[unit.source]:
# unit has changed, or was resurrected
assert updated_unit.change.submitted_by == member2
# damn mysql microsecond precision
if change.submitted_on.time().microsecond != 0:
assert (
updated_unit.change.submitted_on
!= change.submitted_on)
elif unit.isobsolete():
# unit has changed, or was resurrected
assert updated_unit.change.reviewed_by == member2
# damn mysql microsecond precision
if change.reviewed_on.time().microsecond != 0:
assert (
updated_unit.change.reviewed_on
!= change.reviewed_on)
else:
assert (
updated_unit.change.submitted_by
== change.submitted_by)
assert (
updated_unit.change.submitted_on
== change.submitted_on)
assert updated_unit.get_suggestions().count() == 0
else:
# conflict found
old_unit = old_store.findid(unit.getid())
target_conflict = False
if not old_unit or old_unit.target != unit.target:
suggestion = updated_unit.get_suggestions()[0]
target_conflict = True
if target_conflict and resolve_conflict == POOTLE_WINS:
assert updated_unit.target == unit.target
assert (
updated_unit.change.submitted_by
== change.submitted_by)
assert suggestion.target == updates[unit.source]
assert suggestion.user == member2
elif target_conflict:
assert updated_unit.target == updates[unit.source]
assert updated_unit.change.submitted_by == member2
assert suggestion.target == unit.target
assert suggestion.user == change.submitted_by
def _test_store_update_ordering(*test_args):
(store, units_update, store_revision, resolve_conflict_,
units_before, member_, member2_) = test_args
updates = {unit[0]: unit[1] for unit in units_update}
old_units = {unit.source: unit for unit, change in units_before}
# test ordering
new_unit_list = []
for unit, change_ in units_before:
add_unit = (not unit.isobsolete()
and unit.source not in updates
and unit.revision > store_revision)
if add_unit:
new_unit_list.append(unit.source)
for source, target_, is_fuzzy_ in units_update:
if source in old_units:
old_unit = old_units[source]
should_add = (not old_unit.isobsolete()
or old_unit.revision <= store_revision)
if should_add:
new_unit_list.append(source)
else:
new_unit_list.append(source)
assert new_unit_list == [x.source for x in store.units]
def _test_store_update_units_now(*test_args):
(store, units_update, store_revision, resolve_conflict_,
units_before, member_, member2_) = test_args
# test that all the current units should be there
updates = {unit[0]: unit[1] for unit in units_update}
old_units = {unit.source: unit for unit, change in units_before}
for unit in store.units:
assert (
unit.source in updates
or (old_units[unit.source].revision > store_revision
and not old_units[unit.source].isobsolete()))
@pytest.mark.django_db
def test_store_update(param_update_store_test):
_test_store_update_indexes(*param_update_store_test)
_test_store_update_units_before(*param_update_store_test)
_test_store_update_units_now(*param_update_store_test)
_test_store_update_ordering(*param_update_store_test)
@pytest.mark.django_db
def test_store_file_diff(store_diff_tests):
diff, store, update_units, store_revision = store_diff_tests
assert diff.target_store == store
assert diff.source_revision == store_revision
assert (
update_units
== [(x.source, x.target, x.isfuzzy())
for x in diff.source_store.units[1:]]
== [(v['source'], v['target'], v['state'] == 50)
for v in diff.source_units.values()])
assert diff.active_target_units == [x.source for x in store.units]
assert diff.target_revision == store.get_max_unit_revision()
assert (
diff.target_units
== {unit["source_f"]: unit
for unit
in store.unit_set.values("source_f", "index", "target_f",
"state", "unitid", "id", "revision",
"developer_comment", "translator_comment",
"locations", "context")})
diff_diff = diff.diff()
if diff_diff is not None:
assert (
sorted(diff_diff.keys())
== ["add", "index", "obsolete", "update"])
# obsoleted units have no index - so just check they are all they match
obsoleted = (store.unit_set.filter(state=OBSOLETE)
.filter(revision__gt=store_revision)
.values_list("source_f", flat=True))
assert len(diff.obsoleted_target_units) == obsoleted.count()
assert all(x in diff.obsoleted_target_units for x in obsoleted)
assert (
diff.updated_target_units
== list(store.units.filter(revision__gt=store_revision)
.values_list("source_f", flat=True)))
@pytest.mark.django_db
def test_store_repr():
store = Store.objects.first()
assert str(store) == str(store.syncer.convert(store.syncer.file_class))
assert repr(store) == u"<Store: %s>" % store.pootle_path
@pytest.mark.django_db
def test_store_po_deserializer(test_fs, store_po):
with test_fs.open("data/po/complex.po") as test_file:
test_string = test_file.read()
ttk_po = getclass(test_file)(test_string)
store_po.update(store_po.deserialize(test_string))
assert len(ttk_po.units) - 1 == store_po.units.count()
@pytest.mark.django_db
def test_store_po_serializer(test_fs, store_po):
with test_fs.open("data/po/complex.po") as test_file:
test_string = test_file.read()
ttk_po = getclass(test_file)(test_string)
store_po.update(store_po.deserialize(test_string))
store_io = io.BytesIO(store_po.serialize())
store_ttk = getclass(store_io)(store_io.read())
assert len(store_ttk.units) == len(ttk_po.units)
@pytest.mark.django_db
def test_store_po_serializer_custom(test_fs, store_po):
class SerializerCheck(object):
original_data = None
context = None
checker = SerializerCheck()
class EGSerializer(Serializer):
@property
def output(self):
checker.original_data = self.original_data
checker.context = self.context
@provider(serializers, sender=Project)
def provide_serializers(**kwargs):
return dict(eg_serializer=EGSerializer)
with test_fs.open("data/po/complex.po") as test_file:
test_string = test_file.read()
# ttk_po = getclass(test_file)(test_string)
store_po.update(store_po.deserialize(test_string))
# add config to the project
project = store_po.translation_project.project
config.get(project.__class__, instance=project).set_config(
"pootle.core.serializers",
["eg_serializer"])
store_po.serialize()
assert checker.context == store_po
assert (
not isinstance(checker.original_data, six.text_type)
and isinstance(checker.original_data, str))
assert checker.original_data == _store_as_string(store_po)
@pytest.mark.django_db
def test_store_po_deserializer_custom(test_fs, store_po):
class DeserializerCheck(object):
original_data = None
context = None
checker = DeserializerCheck()
class EGDeserializer(Deserializer):
@property
def output(self):
checker.context = self.context
checker.original_data = self.original_data
return self.original_data
@provider(deserializers, sender=Project)
def provide_deserializers(**kwargs):
return dict(eg_deserializer=EGDeserializer)
with test_fs.open("data/po/complex.po") as test_file:
test_string = test_file.read()
# add config to the project
project = store_po.translation_project.project
config.get().set_config(
"pootle.core.deserializers",
["eg_deserializer"],
project)
store_po.deserialize(test_string)
assert checker.original_data == test_string
assert checker.context == store_po
@pytest.mark.django_db
def test_store_base_serializer(store_po):
original_data = "SOME DATA"
serializer = Serializer(store_po, original_data)
assert serializer.context == store_po
assert serializer.data == original_data
@pytest.mark.django_db
def test_store_base_deserializer(store_po):
original_data = "SOME DATA"
deserializer = Deserializer(store_po, original_data)
assert deserializer.context == store_po
assert deserializer.data == original_data
@pytest.mark.django_db
def test_store_set_bad_deserializers(store_po):
project = store_po.translation_project.project
with pytest.raises(ConfigurationError):
config.get(project.__class__, instance=project).set_config(
"pootle.core.deserializers",
["DESERIALIZER_DOES_NOT_EXIST"])
class EGDeserializer(object):
pass
@provider(deserializers)
def provide_deserializers(**kwargs):
return dict(eg_deserializer=EGDeserializer)
# must be list
with pytest.raises(ConfigurationError):
config.get(project.__class__, instance=project).set_config(
"pootle.core.deserializers",
"eg_deserializer")
with pytest.raises(ConfigurationError):
config.get(project.__class__, instance=project).set_config(
"pootle.core.deserializers",
dict(serializer="eg_deserializer"))
config.get(project.__class__, instance=project).set_config(
"pootle.core.deserializers",
["eg_deserializer"])
@pytest.mark.django_db
def test_store_set_bad_serializers(store_po):
project = store_po.translation_project.project
with pytest.raises(ConfigurationError):
config.get(project.__class__, instance=project).set_config(
"pootle.core.serializers",
["SERIALIZER_DOES_NOT_EXIST"])
class EGSerializer(Serializer):
pass
@provider(serializers)
def provide_serializers(**kwargs):
return dict(eg_serializer=EGSerializer)
# must be list
with pytest.raises(ConfigurationError):
config.get(project.__class__, instance=project).set_config(
"pootle.core.serializers",
"eg_serializer")
with pytest.raises(ConfigurationError):
config.get(project.__class__, instance=project).set_config(
"pootle.core.serializers",
dict(serializer="eg_serializer"))
config.get(project.__class__, instance=project).set_config(
"pootle.core.serializers",
["eg_serializer"])
@pytest.mark.django_db
def test_store_create_by_bad_path(project0):
# bad project name
with pytest.raises(Project.DoesNotExist):
Store.objects.create_by_path(
"/language0/does/not/exist.po")
# bad language code
with pytest.raises(Language.DoesNotExist):
Store.objects.create_by_path(
"/does/project0/not/exist.po")
# project and project code dont match
with pytest.raises(ValueError):
Store.objects.create_by_path(
"/language0/project1/store.po",
project=project0)
# bad store.ext
with pytest.raises(ValueError):
Store.objects.create_by_path(
"/language0/project0/store_by_path.foo")
# subdir doesnt exist
path = '/language0/project0/path/to/subdir.po'
with pytest.raises(Directory.DoesNotExist):
Store.objects.create_by_path(
path, create_directory=False)
path = '/%s/project0/notp.po' % LanguageDBFactory().code
with pytest.raises(TranslationProject.DoesNotExist):
Store.objects.create_by_path(
path, create_tp=False)
@pytest.mark.django_db
def test_store_create_by_path(po_directory):
# create in tp
path = '/language0/project0/path.po'
store = Store.objects.create_by_path(path)
assert store.pootle_path == path
# "create" in tp again - get existing store
store = Store.objects.create_by_path(path)
assert store.pootle_path == path
# create in existing subdir
path = '/language0/project0/subdir0/exists.po'
store = Store.objects.create_by_path(path)
assert store.pootle_path == path
# create in new subdir
path = '/language0/project0/path/to/subdir.po'
store = Store.objects.create_by_path(path)
assert store.pootle_path == path
@pytest.mark.django_db
def test_store_create_by_path_with_project(project0):
# create in tp with project
path = '/language0/project0/path2.po'
store = Store.objects.create_by_path(
path, project=project0)
assert store.pootle_path == path
# create in existing subdir with project
path = '/language0/project0/subdir0/exists2.po'
store = Store.objects.create_by_path(
path, project=project0)
assert store.pootle_path == path
# create in new subdir with project
path = '/language0/project0/path/to/subdir2.po'
store = Store.objects.create_by_path(
path, project=project0)
assert store.pootle_path == path
@pytest.mark.django_db
def test_store_create_by_new_tp_path(po_directory):
language = LanguageDBFactory()
path = '/%s/project0/tp.po' % language.code
store = Store.objects.create_by_path(path)
assert store.pootle_path == path
assert store.translation_project.language == language
language = LanguageDBFactory()
path = '/%s/project0/with/subdir/tp.po' % language.code
store = Store.objects.create_by_path(path)
assert store.pootle_path == path
assert store.translation_project.language == language
@pytest.mark.django_db
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)
@pytest.mark.django_db
def test_store_create_name_with_slashes_or_backslashes(tp0):
"""Test Stores are not created with (back)slashes on their name."""
with pytest.raises(ValidationError):
Store.objects.create(name="slashed/name.po", parent=tp0.directory,
translation_project=tp0)
with pytest.raises(ValidationError):
Store.objects.create(name="backslashed\\name.po", parent=tp0.directory,
translation_project=tp0)
@pytest.mark.django_db
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)
@pytest.mark.django_db
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)
@pytest.mark.django_db
def test_store_create_templates(po_directory, templates):
project = ProjectDBFactory(source_language=templates)
tp = TranslationProjectFactory(language=templates, project=project)
po = Format.objects.get(name="po")
store = Store.objects.create(
name="mystore.pot",
translation_project=tp,
parent=tp.directory)
assert store.filetype == po
assert store.is_template
@pytest.mark.django_db
def test_store_get_or_create_templates(po_directory, templates):
project = ProjectDBFactory(source_language=templates)
tp = TranslationProjectFactory(language=templates, project=project)
po = Format.objects.get(name="po")
store = Store.objects.get_or_create(
name="mystore.pot",
translation_project=tp,
parent=tp.directory)[0]
assert store.filetype == po
assert store.is_template
@pytest.mark.django_db
def test_store_diff(diffable_stores):
target_store, source_store = diffable_stores
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision() + 1)
# no changes
assert not differ.diff()
assert differ.target_store == target_store
assert differ.source_store == source_store
@pytest.mark.django_db
def test_store_diff_delete_target_unit(diffable_stores):
target_store, source_store = diffable_stores
# delete a unit in the target store
remove_unit = target_store.units.first()
remove_unit.delete()
# the unit will always be re-added (as its not obsolete)
# with source_revision to the max
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision())
result = differ.diff()
assert result["add"][0][0].source_f == remove_unit.source_f
assert len(result["add"]) == 1
assert len(result["index"]) == 0
assert len(result["obsolete"]) == 0
assert result['update'] == (set(), {})
# and source_revision to 0
differ = StoreDiff(
target_store,
source_store,
0)
result = differ.diff()
assert result["add"][0][0].source_f == remove_unit.source_f
assert len(result["add"]) == 1
assert len(result["index"]) == 0
assert len(result["obsolete"]) == 0
assert result['update'] == (set(), {})
@pytest.mark.django_db
def test_store_diff_delete_source_unit(diffable_stores):
target_store, source_store = diffable_stores
# delete a unit in the source store
remove_unit = source_store.units.first()
remove_unit.delete()
# set the source_revision to max and the unit will be obsoleted
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision())
result = differ.diff()
to_remove = target_store.units.get(unitid=remove_unit.unitid)
assert result["obsolete"] == [to_remove.pk]
assert len(result["obsolete"]) == 1
assert len(result["add"]) == 0
assert len(result["index"]) == 0
@pytest.mark.django_db
def test_store_diff_delete_obsoleted_target_unit(diffable_stores):
target_store, source_store = diffable_stores
# delete a unit in the source store
remove_unit = source_store.units.first()
remove_unit.delete()
# and obsolete the same unit in the target
obsolete_unit = target_store.units.get(unitid=remove_unit.unitid)
obsolete_unit.makeobsolete()
obsolete_unit.save()
# as the unit is already obsolete - nothing
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision() + 1)
assert not differ.diff()
@pytest.mark.django_db
def test_store_diff_obsoleted_target_unit(diffable_stores):
target_store, source_store = diffable_stores
# obsolete a unit in target
obsolete_unit = target_store.units.first()
obsolete_unit.makeobsolete()
obsolete_unit.save()
# as the revision is higher it gets unobsoleted
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision() + 1)
result = differ.diff()
assert result["update"][0] == set([obsolete_unit.pk])
assert len(result["update"][1]) == 1
assert result["update"][1][obsolete_unit.unitid]["dbid"] == obsolete_unit.pk
# if the revision is less - no change
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision() - 1)
assert not differ.diff()
@pytest.mark.django_db
def test_store_diff_update_target_unit(diffable_stores):
target_store, source_store = diffable_stores
# update a unit in target
update_unit = target_store.units.first()
update_unit.target_f = "Some other string"
update_unit.save()
# the unit is always marked for update
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision() + 1)
result = differ.diff()
assert result["update"][0] == set([update_unit.pk])
assert result["update"][1] == {}
assert len(result["add"]) == 0
assert len(result["index"]) == 0
differ = StoreDiff(
target_store,
source_store,
0)
result = differ.diff()
assert result["update"][0] == set([update_unit.pk])
assert result["update"][1] == {}
assert len(result["add"]) == 0
assert len(result["index"]) == 0
@pytest.mark.django_db
def test_store_diff_update_source_unit(diffable_stores):
target_store, source_store = diffable_stores
# update a unit in source
update_unit = source_store.units.first()
update_unit.target_f = "Some other string"
update_unit.save()
target_unit = target_store.units.get(
unitid=update_unit.unitid)
# the unit is always marked for update
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision() + 1)
result = differ.diff()
assert result["update"][0] == set([target_unit.pk])
assert result["update"][1] == {}
assert len(result["add"]) == 0
assert len(result["index"]) == 0
differ = StoreDiff(
target_store,
source_store,
0)
result = differ.diff()
assert result["update"][0] == set([target_unit.pk])
assert result["update"][1] == {}
assert len(result["add"]) == 0
assert len(result["index"]) == 0
@pytest.mark.django_db
def test_store_diff_custom(diffable_stores):
target_store, source_store = diffable_stores
class CustomDiffableStore(DiffableStore):
pass
@provider(format_diffs)
def format_diff_provider(**kwargs):
return {
target_store.filetype.name: CustomDiffableStore}
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision() + 1)
assert isinstance(
differ.diffable, CustomDiffableStore)
@pytest.mark.django_db
def test_store_diff_delete_obsoleted_source_unit(diffable_stores):
target_store, source_store = diffable_stores
# delete a unit in the target store
remove_unit = target_store.units.first()
remove_unit.delete()
# and obsolete the same unit in the target
obsolete_unit = source_store.units.get(unitid=remove_unit.unitid)
obsolete_unit.makeobsolete()
obsolete_unit.save()
# as the unit is already obsolete - nothing
differ = StoreDiff(
target_store,
source_store,
target_store.get_max_unit_revision() + 1)
assert not differ.diff()
@pytest.mark.django_db
def test_store_syncer(tp0):
store = tp0.stores.live().first()
assert isinstance(store.syncer, PoStoreSyncer)
assert store.syncer.file_class == getclass(store)
assert store.syncer.translation_project == store.translation_project
assert (
store.syncer.language
== store.translation_project.language)
assert (
store.syncer.project
== store.translation_project.project)
assert (
store.syncer.source_language
== store.translation_project.project.source_language)
@pytest.mark.django_db
def test_store_syncer_obsolete_unit(tp0):
store = tp0.stores.live().first()
unit = store.units.filter(state=TRANSLATED).first()
unit_syncer = store.syncer.unit_sync_class(unit)
newunit = unit_syncer.create_unit(store.syncer.file_class.UnitClass)
# unit is untranslated, its always just deleted
obsolete, deleted = store.syncer.obsolete_unit(newunit, True)
assert not obsolete
assert deleted
obsolete, deleted = store.syncer.obsolete_unit(newunit, False)
assert not obsolete
assert deleted
# set unit to translated
newunit.target = unit.target
# if conservative, nothings changed
obsolete, deleted = store.syncer.obsolete_unit(newunit, True)
assert not obsolete
assert not deleted
# not conservative and the unit is deleted
obsolete, deleted = store.syncer.obsolete_unit(newunit, False)
assert obsolete
assert not deleted
@pytest.mark.django_db
def test_store_syncer_sync_store(tp0, dummy_store_syncer):
store = tp0.stores.live().first()
DummyStoreSyncer, __, expected = dummy_store_syncer
disk_store = store.syncer.convert()
dummy_syncer = DummyStoreSyncer(store, expected=expected)
result = dummy_syncer.sync(
disk_store,
expected["last_revision"],
update_structure=expected["update_structure"],
conservative=expected["conservative"])
assert result[0] is True
assert result[1]["updated"] == expected["changes"]
# conservative makes no diff here
expected["conservative"] = False
dummy_syncer = DummyStoreSyncer(store, expected=expected)
result = dummy_syncer.sync(
disk_store,
expected["last_revision"],
update_structure=expected["update_structure"],
conservative=expected["conservative"])
assert result[0] is True
assert result[1]["updated"] == expected["changes"]
@pytest.mark.django_db
def test_store_syncer_sync_store_no_changes(tp0, dummy_store_syncer):
store = tp0.stores.live().first()
DummyStoreSyncer, __, expected = dummy_store_syncer
disk_store = store.syncer.convert()
dummy_syncer = DummyStoreSyncer(store, expected=expected)
# no changes
expected["changes"] = []
expected["conservative"] = True
dummy_syncer = DummyStoreSyncer(store, expected=expected)
result = dummy_syncer.sync(
disk_store,
expected["last_revision"],
expected["update_structure"],
expected["conservative"])
assert result[0] is False
assert not result[1].get("updated")
# conservative makes no diff here
expected["conservative"] = False
dummy_syncer = DummyStoreSyncer(store, expected=expected)
result = dummy_syncer.sync(
disk_store,
expected["last_revision"],
expected["update_structure"],
expected["conservative"])
assert result[0] is False
assert not result[1].get("updated")
@pytest.mark.django_db
def test_store_syncer_sync_store_structure(tp0, dummy_store_syncer):
store = tp0.stores.live().first()
DummyStoreSyncer, DummyDiskStore, expected = dummy_store_syncer
disk_store = DummyDiskStore(expected)
expected["update_structure"] = True
expected["changes"] = []
dummy_syncer = DummyStoreSyncer(store, expected=expected)
result = dummy_syncer.sync(
disk_store,
expected["last_revision"],
expected["update_structure"],
expected["conservative"])
assert result[0] is True
assert result[1]["updated"] == []
assert result[1]["obsolete"] == 8
assert result[1]["deleted"] == 9
assert result[1]["added"] == 10
expected["obsolete_units"] = []
expected["new_units"] = []
expected["changes"] = []
dummy_syncer = DummyStoreSyncer(store, expected=expected)
result = dummy_syncer.sync(
disk_store,
expected["last_revision"],
expected["update_structure"],
expected["conservative"])
assert result[0] is False
@pytest.mark.django_db
def test_store_syncer_sync_update_structure(dummy_store_structure_syncer, tp0):
store = tp0.stores.live().first()
DummyStoreSyncer, DummyDiskStore, DummyUnit = dummy_store_structure_syncer
expected = dict(
unit_class="FOO",
conservative=True,
obsolete_delete=(True, True),
obsolete_units=["a", "b", "c"])
expected["new_units"] = [
DummyUnit(unit, expected=expected)
for unit in ["5", "6", "7"]]
syncer = DummyStoreSyncer(store, expected=expected)
disk_store = DummyDiskStore(expected)
result = syncer.update_structure(
disk_store,
expected["obsolete_units"],
expected["new_units"],
expected["conservative"])
obsolete_units = (
len(expected["obsolete_units"])
if expected["obsolete_delete"][0]
else 0)
deleted_units = (
len(expected["obsolete_units"])
if expected["obsolete_delete"][1]
else 0)
new_units = len(expected["new_units"])
assert result == (obsolete_units, deleted_units, new_units)
def _test_get_new(results, syncer, old_ids, new_ids):
assert list(results) == list(
syncer.store.findid_bulk(
[syncer.dbid_index.get(uid)
for uid
in new_ids - old_ids]))
def _test_get_obsolete(results, disk_store, syncer, old_ids, new_ids):
assert list(results) == list(
disk_store.findid(uid)
for uid
in old_ids - new_ids
if (disk_store.findid(uid)
and not disk_store.findid(uid).isobsolete()))
@pytest.mark.django_db
def test_store_syncer_obsolete_units(dummy_store_syncer_units, tp0):
store = tp0.stores.live().first()
disk_store = store.syncer.convert()
expected = dict(
old_ids=set(),
new_ids=set(),
disk_ids={})
syncer = dummy_store_syncer_units(store, expected=expected)
results = syncer.get_units_to_obsolete(
disk_store, expected["old_ids"], expected["new_ids"])
_test_get_obsolete(
results, disk_store, syncer,
expected["old_ids"], expected["new_ids"])
expected = dict(
old_ids=set(["2", "3", "4"]),
new_ids=set(["3", "4", "5"]),
disk_ids={"3": "foo", "4": "bar", "5": "baz"})
results = syncer.get_units_to_obsolete(
disk_store, expected["old_ids"], expected["new_ids"])
_test_get_obsolete(
results, disk_store, syncer, expected["old_ids"], expected["new_ids"])
@pytest.mark.django_db
def test_store_syncer_new_units(dummy_store_syncer_units, tp0):
store = tp0.stores.live().first()
expected = dict(
old_ids=set(),
new_ids=set(),
disk_ids={},
db_ids={})
syncer = dummy_store_syncer_units(store, expected=expected)
results = syncer.get_new_units(
expected["old_ids"], expected["new_ids"])
_test_get_new(
results, syncer, expected["old_ids"], expected["new_ids"])
expected = dict(
old_ids=set(["2", "3", "4"]),
new_ids=set(["3", "4", "5"]),
db_ids={"3": "foo", "4": "bar", "5": "baz"})
syncer = dummy_store_syncer_units(store, expected=expected)
results = syncer.get_new_units(
expected["old_ids"], expected["new_ids"])
_test_get_new(
results, syncer, expected["old_ids"], expected["new_ids"])
@pytest.mark.django_db
def test_store_path(store0):
assert store0.path == to_tp_relative_path(store0.pootle_path)
@pytest.mark.django_db
def test_store_sync_empty(project0_nongnu, tp0, caplog, settings):
store = StoreDBFactory(
name="empty.po",
translation_project=tp0,
parent=tp0.directory)
file_path = _sync_store(settings, store)
assert os.path.exists(file_path)
modified = os.stat(file_path).st_mtime
file_path = _sync_store(settings, store)
assert modified == os.stat(file_path).st_mtime
# warning message - nothing changes
file_path = _sync_store(settings, store)
assert modified == os.stat(file_path).st_mtime
@pytest.mark.django_db
def test_store_sync_template(project0_nongnu, templates_project0, caplog, settings):
template = templates_project0.stores.first()
file_path = _sync_store(settings, template, force_add=True)
modified = os.stat(file_path).st_mtime
unit = template.units.first()
unit.target = "NEW TARGET"
unit.save()
_sync_store(settings, template)
assert modified <= os.stat(file_path).st_mtime
@pytest.mark.django_db
def test_store_update_with_state_change(store0, admin):
units = dict([(x.id, (x.source, x.target, not x.isfuzzy()))
for x in store0.units])
update_store(
store0,
units=units.values(),
store_revision=store0.data.max_unit_revision,
user=admin)
for unit_id, unit in units.items():
assert unit[2] == store0.units.get(id=unit_id).isfuzzy()
@pytest.mark.django_db
def test_roundtrip_xliff(store_po, test_fs, xliff):
project = store_po.translation_project.project
filetype_tool = project.filetype_tool
project.filetypes.add(xliff)
filetype_tool.set_store_filetype(store_po, xliff)
with test_fs.open(['data', 'xliff', 'manyfiles.xliff']) as f:
file_store = getclass(f)(f.read())
store_po.update(file_store)
serialized = store_po.deserialize(store_po.serialize())
assert serialized.units[0].getid() == u'file0\x04hello'
assert serialized.units[1].getid() == u'file1\x04world'
@pytest.mark.django_db
def test_update_xliff(store_po, test_fs, xliff):
project = store_po.translation_project.project
filetype_tool = project.filetype_tool
project.filetypes.add(xliff)
filetype_tool.set_store_filetype(store_po, xliff)
with test_fs.open(['data', 'xliff', 'welcome.xliff']) as f:
file_store = getclass(f)(f.read())
store_po.update(file_store)
unit = store_po.units[0]
assert unit.istranslated()
with test_fs.open(['data', 'xliff', 'updated_welcome.xliff']) as f:
file_store = getclass(f)(f.read())
store_po.update(file_store)
updated_unit = store_po.units.get(id=unit.id)
assert unit.source != updated_unit.source
@pytest.mark.django_db
def test_update_resurrect(store_po, test_fs):
with test_fs.open(['data', 'po', 'obsolete.po']) as f:
file_store = getclass(f)(f.read())
store_po.update(file_store)
obsolete_units = store_po.unit_set.filter(state=OBSOLETE)
obsolete_ids = list(obsolete_units.values_list('id', flat=True))
assert len(obsolete_ids) > 0
with test_fs.open(['data', 'po', 'resurrected.po']) as f:
file_store = getclass(f)(f.read())
store_revision = store_po.data.max_unit_revision
# set store_revision as we do in update_stores cli command
store_po.update(file_store, store_revision=store_revision - 1)
obsolete_units = store_po.unit_set.filter(state=OBSOLETE)
assert obsolete_units.count() == len(obsolete_ids)
for unit in obsolete_units.filter(id__in=obsolete_ids):
assert unit.isobsolete()
# set store_revision as we do in update_stores cli command
store_po.update(file_store, store_revision=store_revision)
units = store_po.units.filter(id__in=obsolete_ids)
assert units.count() == len(obsolete_ids)
for unit in units:
assert not unit.isobsolete()
@pytest.mark.django_db
def test_store_comment_update(store0, member):
ttk = store0.deserialize(store0.serialize())
fileunit = ttk.units[-1]
fileunit.removenotes()
fileunit.addnote("A new comment")
unit = store0.findid(fileunit.getid())
last_sub_pk = unit.submission_set.order_by(
"id").values_list("id", flat=True).last() or 0
store0.update(
ttk, store_revision=store0.data.max_unit_revision + 1,
user=member
)
assert ttk.units[-1].getnotes("translator") == "A new comment"
unit = store0.units.get(id=unit.id)
assert unit.translator_comment == "A new comment"
assert unit.change.commented_by == member
new_subs = unit.submission_set.filter(id__gt=last_sub_pk).order_by("id")
assert new_subs.count() == 1
comment_sub = new_subs[0]
assert comment_sub.old_value == ""
assert comment_sub.new_value == "A new comment"
assert comment_sub.field == SubmissionFields.COMMENT
assert comment_sub.type == SubmissionTypes.SYSTEM
assert comment_sub.submitter == member
assert comment_sub.revision == unit.revision
assert comment_sub.creation_time == unit.change.commented_on
| 65,776
|
Python
|
.py
| 1,572
| 34.944656
| 84
| 0.672851
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,943
|
directory.py
|
translate_pootle/tests/models/directory.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.core.exceptions import ValidationError
from pootle_app.models.directory import Directory
@pytest.mark.django_db
def test_directory_create_name_with_slashes_or_backslashes(root):
"""Test Directories are not created with (back)slashes on their name."""
with pytest.raises(ValidationError):
Directory.objects.create(name="slashed/name", parent=root)
with pytest.raises(ValidationError):
Directory.objects.create(name="backslashed\\name", parent=root)
@pytest.mark.django_db
def test_directory_create_bad(root):
"""Test directory cannot be created with name and no parent or without name
but no parent.
"""
with pytest.raises(ValidationError):
Directory.objects.create(name="name", parent=None)
with pytest.raises(ValidationError):
Directory.objects.create(name="", parent=root)
@pytest.mark.django_db
def test_dir_get_or_make_subdir(project0, language0, tp0, subdir0):
foo = project0.directory.get_or_make_subdir("foo")
assert not foo.tp
assert foo == project0.directory.get_or_make_subdir("foo")
foo = language0.directory.get_or_make_subdir("foo")
assert not foo.tp
assert foo == language0.directory.get_or_make_subdir("foo")
foo = tp0.directory.get_or_make_subdir("foo")
assert foo.tp == tp0
assert foo == tp0.directory.get_or_make_subdir("foo")
foo = subdir0.get_or_make_subdir("foo")
assert foo.tp == subdir0.tp
assert foo == subdir0.get_or_make_subdir("foo")
| 1,789
|
Python
|
.py
| 40
| 40.55
| 79
| 0.735871
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,944
|
submission.py
|
translate_pootle/tests/models/submission.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.utils import timezone
from pytest_pootle.utils import create_store
from pootle_app.models.permissions import check_permission
from pootle_statistics.models import (Submission, SubmissionFields,
SubmissionTypes)
from pootle_store.constants import UNTRANSLATED
from pootle_store.models import Suggestion, Unit
def _create_comment_submission(unit, user, creation_time, comment):
sub = Submission(
creation_time=creation_time,
translation_project=unit.store.translation_project,
submitter=user,
unit=unit,
field=SubmissionFields.COMMENT,
type=SubmissionTypes.WEB,
new_value=comment,
)
sub.save()
return sub
@pytest.mark.django_db
def test_submission_ordering(store0, member):
"""Submissions with same creation_time should order by pk
"""
at_time = timezone.now()
unit = store0.units[0]
last_sub_pk = unit.submission_set.order_by(
"-pk").values_list("pk", flat=True).first() or 0
_create_comment_submission(unit, member, at_time, "Comment 3")
_create_comment_submission(unit, member, at_time, "Comment 2")
_create_comment_submission(unit, member, at_time, "Comment 1")
new_subs = unit.submission_set.filter(pk__gt=last_sub_pk)
# Object manager test
assert new_subs.count() == 3
assert (new_subs.first().creation_time
== new_subs.last().creation_time)
assert (new_subs.latest().pk
> new_subs.earliest().pk)
# Passing field_name test
assert (new_subs.earliest("new_value").new_value
== "Comment 1")
assert (new_subs.latest("new_value").new_value
== "Comment 3")
assert (new_subs.earliest("pk").new_value
== "Comment 3")
assert (new_subs.latest("pk").new_value
== "Comment 1")
@pytest.mark.django_db
def test_update_submission_ordering():
unit = Unit.objects.filter(state=UNTRANSLATED).first()
unit.markfuzzy()
unit.target = "Fuzzy Translation for " + unit.source_f
unit.save()
store = create_store(
unit.store.pootle_path,
"0",
[(unit.source_f, "Translation for " + unit.source_f, False)]
)
unit.store.update(store)
submission_field = Submission.objects.filter(unit=unit).latest().field
assert submission_field == SubmissionFields.STATE
@pytest.mark.django_db
def test_new_translation_submission_ordering(client, request_users, settings):
unit = Unit.objects.filter(state=UNTRANSLATED).first()
settings.POOTLE_CAPTCHA_ENABLED = False
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/' % unit.id
response = client.post(
url,
{'is_fuzzy': "0",
'target_f_0': "Translation for " + unit.source_f},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
if check_permission('translate', response.wsgi_request):
assert response.status_code == 200
submission_field = Submission.objects.filter(unit=unit).latest().field
assert submission_field == SubmissionFields.STATE
else:
assert response.status_code == 403
@pytest.mark.django_db
def test_accept_sugg_submission_ordering(client, request_users, settings):
"""Tests suggestion can be accepted with a comment."""
settings.POOTLE_CAPTCHA_ENABLED = False
unit = Unit.objects.filter(suggestion__state__name='pending',
state=UNTRANSLATED)[0]
unit.markfuzzy()
unit.target = "Fuzzy Translation for " + unit.source_f
unit.save()
sugg = Suggestion.objects.filter(unit=unit, state__name='pending')[0]
user = request_users["user"]
last_sub_pk = unit.submission_set.order_by(
"-pk").values_list("pk", flat=True).first() or 0
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/suggestions/%d/' % (unit.id, sugg.id)
response = client.post(
url,
HTTP_X_REQUESTED_WITH='XMLHttpRequest'
)
new_subs = unit.submission_set.filter(pk__gt=last_sub_pk)
if check_permission('review', response.wsgi_request):
assert response.status_code == 200
assert new_subs.count() == 2
target_sub = new_subs.order_by("pk").first()
assert target_sub.field == SubmissionFields.TARGET
state_sub = new_subs.order_by("pk").last()
assert state_sub.field == SubmissionFields.STATE
else:
assert response.status_code == 404
assert new_subs.count() == 0
| 4,993
|
Python
|
.py
| 122
| 34.303279
| 78
| 0.667904
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,945
|
staticpage.py
|
translate_pootle/tests/models/staticpage.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from staticpages.models import StaticPage
@pytest.mark.django_db
def test_staticpage_repr():
staticpage = StaticPage.objects.first()
assert (
"<StaticPage: %s>" % staticpage.virtual_path
== repr(staticpage))
| 525
|
Python
|
.py
| 15
| 32.133333
| 77
| 0.73913
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,946
|
profile.py
|
translate_pootle/tests/pootle_profile/profile.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from datetime import timedelta
import pytest
from django.utils import timezone
from pootle.core.delegate import profile
from pootle.core.utils.templates import render_as_template
from pootle_log.utils import ComparableLogEvent, UserLog
from pootle_profile.utils import UserMembership, UserProfile
from pootle_score.utils import UserScores
@pytest.mark.django_db
def test_profile_user(member):
user_profile = profile.get(member.__class__)(member)
assert isinstance(user_profile, UserProfile)
assert user_profile.user == member
user_membership = user_profile.membership
assert isinstance(user_membership, UserMembership)
assert user_membership.user == member
user_scores = user_profile.scores
assert isinstance(user_scores, UserScores)
assert user_scores.context == member
assert user_profile.display_name == member.display_name
avatar = render_as_template(
"{% load common_tags %}{% avatar username email_hash 20 %}",
context=dict(
username=member.username,
email_hash=member.email_hash))
assert user_profile.avatar == avatar
user_log = user_profile.log
assert isinstance(user_log, UserLog)
all_events = list(user_profile.get_events())
assert all(
(ev.user == member
or ev.value.user == member)
for ev in all_events)
# default is to get events from last 30 days
thirty_days_ago = timezone.now() - timedelta(days=30)
assert all(
(ev.timestamp > thirty_days_ago)
for ev in all_events)
events = list(user_profile.get_events(n=2))
assert all(
(ev.user == member
or ev.value.user == member)
for ev in events)
assert len(events) == 2
sorted_events = sorted(ComparableLogEvent(ev) for ev in all_events)
# last 2 events in the sorted events matches "events"
assert sorted_events[-1].timestamp == events[0].timestamp
assert sorted_events[-2].timestamp == events[1].timestamp
latest_events = list(user_profile.get_events(start=sorted_events[1].timestamp))
event = latest_events[0]
no_microseconds = (event.timestamp == event.timestamp.replace(microsecond=0))
if not no_microseconds:
assert len(latest_events) == len(all_events) - 1
assert all(
(ev.timestamp >= sorted_events[1].timestamp)
for ev in latest_events)
| 2,638
|
Python
|
.py
| 63
| 36.746032
| 83
| 0.713507
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,947
|
membership.py
|
translate_pootle/tests/pootle_profile/membership.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.delegate import language_team, membership
from pootle_profile.utils import UserMembership
@pytest.mark.django_db
def test_membership_user(member, member2, language0, language1):
lang_team = language_team.get()
user_member = membership.get(member.__class__)(member)
assert isinstance(user_member, UserMembership)
assert user_member.user == member
assert user_member.teams == []
assert user_member.teams_and_roles == {}
lang_team(language0).add_member(member, "admin")
user_member = membership.get(member.__class__)(member)
assert user_member.teams == [language0.code]
assert user_member.teams_and_permissions == {
language0.code: set(['administrate', 'review', 'suggest', 'translate'])}
user_member.teams_and_roles[language0.code]["role"] == "Admin"
user_member.teams_and_roles[language0.code]["name"] == language0.name
lang_team(language1).add_member(member, "submitter")
user_member = membership.get(member.__class__)(member)
assert sorted(user_member.teams) == [language0.code, language1.code]
assert user_member.teams_and_permissions == {
language0.code: set(['administrate', 'review', 'suggest', 'translate']),
language1.code: set(['suggest', 'translate'])}
user_member.teams_and_roles[language0.code]["role"] == "Admin"
user_member.teams_and_roles[language0.code]["name"] == language0.name
user_member.teams_and_roles[language1.code]["role"] == "Translater"
user_member.teams_and_roles[language1.code]["name"] == language1.name
lang_team(language0).add_member(member2, "reviewer")
user_member = membership.get(member2.__class__)(member2)
assert user_member.teams == [language0.code]
assert user_member.teams_and_permissions == {
language0.code: set(['review', 'suggest', 'translate'])}
user_member.teams_and_roles[language0.code]["role"] == "Reviewer"
user_member.teams_and_roles[language0.code]["name"] == language0.name
lang_team(language1).add_member(member2, "member")
user_member = membership.get(member2.__class__)(member2)
assert sorted(user_member.teams) == [language0.code, language1.code]
assert user_member.teams_and_permissions == {
language0.code: set(['review', 'suggest', 'translate']),
language1.code: set(['suggest'])}
user_member.teams_and_roles[language0.code]["role"] == "Reviewer"
user_member.teams_and_roles[language0.code]["name"] == language0.name
user_member.teams_and_roles[language1.code]["role"] == ""
user_member.teams_and_roles[language1.code]["name"] == language1.name
| 2,903
|
Python
|
.py
| 52
| 51.134615
| 80
| 0.70911
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,948
|
templatetags.py
|
translate_pootle/tests/pootle_profile/templatetags.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from urllib import quote_plus
import pytest
from django.core.urlresolvers import reverse
from pootle.core.delegate import language_team, profile
from pootle.core.utils.templates import render_as_template
@pytest.mark.django_db
def test_templatetag_profile_ranking(member, rf, nobody):
user_profile = profile.get(member.__class__)(member)
request = rf.get("")
request.user = nobody
top_lang = user_profile.scores.top_language
rendered = render_as_template(
"{% load profile_tags %}{% profile_ranking request profile %}",
dict(profile=user_profile, request=request))
assert (
("#%s contributor in %s in the last 30 days"
% (top_lang[0], top_lang[1].name))
in rendered)
assert (
quote_plus(
"I am #%s contributor in %s in the last 30 days"
% (top_lang[0], top_lang[1].name))
not in rendered)
request.user = member
rendered = render_as_template(
"{% load profile_tags %}{% profile_ranking request profile %}",
dict(profile=user_profile, request=request))
assert (
quote_plus(
"I am #%s contributor in %s in the last 30 days"
% (top_lang[0], top_lang[1].name))
in rendered)
nobody_profile = profile.get(nobody.__class__)(nobody)
rendered = render_as_template(
"{% load profile_tags %}{% profile_ranking request profile %}",
dict(profile=nobody_profile, request=request))
assert "contributor in" not in rendered
@pytest.mark.django_db
def test_templatetag_profile_scores(member, rf, nobody, settings):
user_profile = profile.get(member.__class__)(member)
request = rf.get("")
request.user = nobody
rendered = render_as_template(
"{% load profile_tags %}{% profile_score request profile %}",
dict(profile=user_profile, request=request))
assert "Total score:" in rendered
score = str(int(round(member.score)))
assert score in rendered
assert(
quote_plus(
"My current score at %s is %s"
% (settings.POOTLE_TITLE, score))
not in rendered)
request.user = member
rendered = render_as_template(
"{% load profile_tags %}{% profile_score request profile %}",
dict(profile=user_profile, request=request))
assert "Total score:" in rendered
assert score in rendered
assert(
quote_plus(
"My current score at %s is %s"
% (settings.POOTLE_TITLE, score))
in rendered)
nobody_profile = profile.get(nobody.__class__)(nobody)
rendered = render_as_template(
"{% load profile_tags %}{% profile_score request profile %}",
dict(profile=nobody_profile, request=request))
assert "0" in rendered
assert (
quote_plus("My current score at")
not in rendered)
@pytest.mark.django_db
def test_templatetag_profile_social(member):
user_profile = profile.get(member.__class__)(member)
rendered = render_as_template(
"{% load profile_tags %}{% profile_social profile %}",
dict(profile=user_profile))
assert not rendered.strip()
member.website = "http://foobar.baz"
rendered = render_as_template(
"{% load profile_tags %}{% profile_social profile %}",
dict(profile=user_profile))
assert "My Website" in rendered
assert "http://foobar.baz" in rendered
member.twitter = "foomember"
rendered = render_as_template(
"{% load profile_tags %}{% profile_social profile %}",
dict(profile=user_profile))
assert "@foomember" in rendered
assert "https://twitter.com/foomember" in rendered
member.linkedin = "https://linked.in/in/foomember"
rendered = render_as_template(
"{% load profile_tags %}{% profile_social profile %}",
dict(profile=user_profile))
assert "My LinkedIn Profile" in rendered
assert member.linkedin in rendered
@pytest.mark.django_db
def test_templatetag_profile_teams(rf, admin, member, language0, request_users):
request_user = request_users["user"]
lang_team = language_team.get()
user_profile = profile.get(member.__class__)(member)
request = rf.get("")
request.user = request_user
rendered = render_as_template(
"{% load profile_tags %}{% profile_teams request profile %}",
dict(profile=user_profile, request=request))
assert (
("%s is not a member of any language teams"
% member.display_name)
in rendered)
lang_team(language0).add_member(member, "member")
user_profile = profile.get(member.__class__)(member)
rendered = render_as_template(
"{% load profile_tags %}{% profile_teams request profile %}",
dict(profile=user_profile, request=request))
assert language0.name in rendered
lang_link = reverse(
"pootle-language-browse",
kwargs=dict(language_code=language0.code))
assert lang_link in rendered
assert ("/%s/" % lang_link) not in rendered
assert "Admin" not in rendered
assert "Site administrator" not in rendered
lang_team(language0).add_member(member, "admin")
user_profile = profile.get(member.__class__)(member)
rendered = render_as_template(
"{% load profile_tags %}{% profile_teams request profile %}",
dict(profile=user_profile, request=request))
assert language0.name in rendered
assert lang_link in rendered
if request_user.is_anonymous:
assert "Admin" not in rendered
else:
assert "Admin" in rendered
admin_profile = profile.get(admin.__class__)(admin)
rendered = render_as_template(
"{% load profile_tags %}{% profile_teams request profile %}",
dict(profile=admin_profile, request=request))
if request_user.is_anonymous:
assert "Site administrator" not in rendered
else:
assert "Site administrator" in rendered
@pytest.mark.django_db
def test_templatetag_profile_user(member, rf, nobody, system, request_users):
request_user = request_users["user"]
member.email = "foo@bar.baz"
user_profile = profile.get(member.__class__)(member)
request = rf.get("")
request.user = request_user
rendered = render_as_template(
"{% load profile_tags %}{% profile_user request profile %}",
dict(profile=user_profile, request=request))
assert member.display_name in rendered
if request_user.is_superuser:
assert member.email in rendered
else:
assert member.email not in rendered
if request_user == member:
assert "Show others who you are" in rendered
assert "js-user-profile-edit" in rendered
else:
assert "Show others who you are" not in rendered
assert "js-user-profile-edit" not in rendered
member.bio = "my life story"
member.website = "http://foobar.baz"
rendered = render_as_template(
"{% load profile_tags %}{% profile_user request profile %}",
dict(profile=user_profile, request=request))
assert "my life story" in rendered
if request_user == member:
assert "Show others who you are" not in rendered
assert "js-user-profile-edit" in rendered
assert "You can set or change your avatar" in rendered
else:
assert "Show others who you are" not in rendered
assert "js-user-profile-edit" not in rendered
assert "You can set or change your avatar" not in rendered
nobody_profile = profile.get(nobody.__class__)(nobody)
rendered = render_as_template(
"{% load profile_tags %}{% profile_user request profile %}",
dict(profile=nobody_profile, request=request))
assert "Show others who you are" not in rendered
assert "js-user-profile-edit" not in rendered
assert "Some translations are provided by anonymous volunteers" in rendered
assert "You can set or change your avatar" not in rendered
system_profile = profile.get(system.__class__)(system)
rendered = render_as_template(
"{% load profile_tags %}{% profile_user request profile %}",
dict(profile=system_profile, request=request))
assert "Show others who you are" not in rendered
assert "js-user-profile-edit" not in rendered
assert "Some translations are imported from external files. " in rendered
assert "You can set or change your avatar" not in rendered
@pytest.mark.django_db
def test_templatetag_profile_activity(member, rf, nobody, system, request_users):
request_user = request_users["user"]
user_profile = profile.get(member.__class__)(member)
request = rf.get("")
request.user = request_user
rendered = render_as_template(
"{% load profile_tags %}{% profile_activity profile %}",
dict(profile=user_profile))
last_event = member.last_event()
assert last_event.message in rendered
assert "user-last-activity" in rendered
nobody_profile = profile.get(nobody.__class__)(nobody)
rendered = render_as_template(
"{% load profile_tags %}{% profile_activity profile %}",
dict(profile=nobody_profile))
assert "user-last-activity" not in rendered
system_profile = profile.get(system.__class__)(system)
rendered = render_as_template(
"{% load profile_tags %}{% profile_activity profile %}",
dict(profile=system_profile))
assert "user-last-activity" not in rendered
| 9,644
|
Python
|
.py
| 223
| 36.93722
| 81
| 0.672445
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,949
|
views.py
|
translate_pootle/tests/pootle_profile/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.urls import reverse
from pootle_profile.utils import UserProfile
from pootle_profile.views import UserDetailView
@pytest.mark.django_db
def test_view_user_detail(client, member, system):
response = client.get(
reverse(
'pootle-user-profile',
kwargs=dict(username=member.username)))
assert isinstance(response.context["view"], UserDetailView)
profile = response.context["profile"]
assert isinstance(profile, UserProfile)
assert profile.user == member
| 808
|
Python
|
.py
| 21
| 34.761905
| 77
| 0.750639
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,950
|
vf.py
|
translate_pootle/tests/views/vf.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import json
from collections import OrderedDict
import pytest
from pytest_pootle.search import calculate_search_results
from django.urls import resolve, reverse
from pootle_app.models.permissions import check_permission
from pootle.core.url_helpers import get_previous_url, get_path_parts
from pootle_checks.constants import CATEGORY_IDS, CHECK_NAMES
from pootle_checks.utils import get_qualitychecks, get_qualitycheck_schema
from pootle_misc.forms import make_search_form
from virtualfolder.models import VirtualFolder
from virtualfolder.utils import DirectoryVFDataTool
def _test_vf_translate_view(tp, request, response, kwargs, settings):
from .tp import view_context_test
ctx = response.context
obj = ctx["object"]
kwargs["project_code"] = tp.project.code
kwargs["language_code"] = tp.language.code
resource_path = "%(dir_path)s%(filename)s" % kwargs
request_path = "%s%s" % (tp.pootle_path, resource_path)
checks = get_qualitychecks()
schema = {sc["code"]: sc for sc in get_qualitycheck_schema()}
vfolder_pk = response.context["current_vfolder_pk"]
check_data = DirectoryVFDataTool(obj).get_checks(
user=request.user).get(vfolder_pk, {})
_checks = {}
for check, checkid in checks.items():
if check not in check_data:
continue
_checkid = schema[checkid]["name"]
_checks[_checkid] = _checks.get(
_checkid, dict(checks=[], title=schema[checkid]["title"]))
_checks[_checkid]["checks"].append(
dict(
code=check,
title=CHECK_NAMES[check],
count=check_data[check]))
_checks = OrderedDict(
(k, _checks[k])
for k in CATEGORY_IDS.keys()
if _checks.get(k))
vfolder = VirtualFolder.objects.get(
name=request.resolver_match.kwargs["vfolder_name"])
current_vfolder_pk = vfolder.pk
display_priority = False
unit_api_root = reverse(
"vfolder-pootle-xhr-units",
kwargs=dict(vfolder_name=vfolder.name))
resource_path = (
"/".join(
["++vfolder",
vfolder.name,
ctx['object'].pootle_path.replace(tp.pootle_path, "")]))
assertions = dict(
page="translate",
translation_project=tp,
language=tp.language,
project=tp.project,
has_admin_access=check_permission('administrate', request),
ctx_path=tp.pootle_path,
pootle_path=request_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
editor_extends="translation_projects/base.html",
checks=_checks,
previous_url=get_previous_url(request),
current_vfolder_pk=current_vfolder_pk,
display_priority=display_priority,
cantranslate=check_permission("translate", request),
cansuggest=check_permission("suggest", request),
canreview=check_permission("review", request),
search_form=make_search_form(request=request),
unit_api_root=unit_api_root,
POOTLE_MT_BACKENDS=settings.POOTLE_MT_BACKENDS,
AMAGAMA_URL=settings.AMAGAMA_URL)
view_context_test(ctx, **assertions)
@pytest.mark.django_db
def test_view_vf_tp_translate_reverse():
# tp translate views
tp_translate_view = reverse(
"pootle-vfolder-tp-translate",
kwargs=dict(
vfolder_name="VF_NAME",
language_code="LANG_CODE",
project_code="PROJ_CODE"))
assert (
tp_translate_view
== u'/++vfolder/VF_NAME/LANG_CODE/PROJ_CODE/translate/')
tp_translate_subdir_view = reverse(
"pootle-vfolder-tp-translate",
kwargs=dict(
vfolder_name="VF_NAME",
language_code="LANG_CODE",
project_code="PROJ_CODE",
dir_path="SOME/SUBDIR/"))
assert (
tp_translate_subdir_view
== u'/++vfolder/VF_NAME/LANG_CODE/PROJ_CODE/translate/SOME/SUBDIR/')
@pytest.mark.django_db
def test_view_vf_xhr_units():
xhr_units = reverse(
"vfolder-pootle-xhr-units",
kwargs=dict(vfolder_name="VF_NAME"))
assert xhr_units == "/++vfolder/VF_NAME/xhr/units/"
@pytest.mark.django_db
def test_view_vf_xhr_units_resolve():
assert (
resolve("/++vfolder/VF_NAME/xhr/units/12345/edit").func.__name__
== "UnitEditJSON")
@pytest.mark.django_db
def test_view_vf_xhr_edit_unit():
xhr_units = reverse(
"vfolder-pootle-xhr-units",
kwargs=dict(vfolder_name="VF_NAME"))
assert xhr_units == "/++vfolder/VF_NAME/xhr/units/"
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_views_vf_translate(vfolder_views, settings):
test_type, tp, request, response, kwargs = vfolder_views
_test_vf_translate_view(tp, request, response, kwargs, settings)
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_views_vf_get_units(get_vfolder_units_views):
(user, vfolder, search_params,
url_params, response) = get_vfolder_units_views
result = json.loads(response.content)
assert "unitGroups" in result
assert isinstance(result["unitGroups"], list)
for k in "start", "end", "total":
assert k in result
assert isinstance(result[k], int)
search_params["vfolder"] = vfolder
if result["unitGroups"]:
total, start, end, expected_units = calculate_search_results(
search_params, user)
assert result["total"] == total
assert result["start"] == start
assert result["end"] == end
for i, group in enumerate(expected_units):
result_group = result["unitGroups"][i]
for store, data in group.items():
result_data = result_group[store]
assert (
[u["id"] for u in result_data["units"]]
== [u["id"] for u in data["units"]])
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_views_vf_get_units_bad(request, client, vfolder0):
response = client.get(
reverse(
"vfolder-pootle-xhr-units",
kwargs=dict(vfolder_name="NO_SUCH_VFOLDER")),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 404
# path not set
response = client.get(
reverse(
"vfolder-pootle-xhr-units",
kwargs=dict(vfolder_name=vfolder0.name)),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 400
# path too long
response = client.get(
"%s?path=%s"
% (reverse("vfolder-pootle-xhr-units",
kwargs=dict(vfolder_name=vfolder0.name)),
("x" * 3000)),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 400
# unrecognized path
response = client.get(
"%s?path=%s"
% (reverse("vfolder-pootle-xhr-units",
kwargs=dict(vfolder_name=vfolder0.name)),
("x" * 100)),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 404
| 7,335
|
Python
|
.py
| 184
| 32.478261
| 77
| 0.650934
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,951
|
project.py
|
translate_pootle/tests/views/project.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from collections import OrderedDict
import pytest
from django.urls import reverse
from pytest_pootle.suite import view_context_test
from pootle_app.models import Directory
from pootle_app.models.permissions import check_permission
from pootle.core.delegate import scores
from pootle.core.helpers import get_sidebar_announcements_context
from pootle.core.url_helpers import get_previous_url, get_path_parts
from pootle.core.utils.stats import (
TOP_CONTRIBUTORS_CHUNK_SIZE, get_translation_states)
from pootle.core.views.display import ChecksDisplay
from pootle.core.views.browse import StatsDisplay
from pootle_checks.constants import CATEGORY_IDS, CHECK_NAMES
from pootle_checks.utils import get_qualitychecks, get_qualitycheck_schema
from pootle_misc.forms import make_search_form
from pootle_project.models import Project, ProjectResource, ProjectSet
from pootle_store.models import Store
def _test_translate_view(project, request, response, kwargs, settings):
if not request.user.is_superuser:
assert response.status_code == 403
return
ctx = response.context
kwargs["project_code"] = project.code
ctx_path = (
"/projects/%(project_code)s/" % kwargs)
resource_path = (
"%(dir_path)s%(filename)s" % kwargs)
pootle_path = "%s%s" % (ctx_path, resource_path)
display_priority = False
checks = get_qualitychecks()
schema = {sc["code"]: sc for sc in get_qualitycheck_schema()}
check_data = ctx["object"].data_tool.get_checks()
_checks = {}
for check, checkid in checks.items():
if check not in check_data:
continue
_checkid = schema[checkid]["name"]
_checks[_checkid] = _checks.get(
_checkid, dict(checks=[], title=schema[checkid]["title"]))
_checks[_checkid]["checks"].append(
dict(
code=check,
title=CHECK_NAMES[check],
count=check_data[check]))
_checks = OrderedDict(
(k, _checks[k])
for k in CATEGORY_IDS.keys()
if _checks.get(k))
view_context_test(
ctx,
**dict(
page="translate",
has_admin_access=request.user.is_superuser,
language=None,
project=project,
pootle_path=pootle_path,
ctx_path=ctx_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
editor_extends="projects/base.html",
checks=_checks,
previous_url=get_previous_url(request),
display_priority=display_priority,
cantranslate=check_permission("translate", request),
cansuggest=check_permission("suggest", request),
canreview=check_permission("review", request),
search_form=make_search_form(request=request),
current_vfolder_pk="",
POOTLE_MT_BACKENDS=settings.POOTLE_MT_BACKENDS,
AMAGAMA_URL=settings.AMAGAMA_URL))
def _test_browse_view(project, request, response, kwargs):
assert (request.user.is_anonymous
or "announcements/projects/%s" % project.code in request.session)
ctx = response.context
kwargs["project_code"] = project.code
resource_path = (
"%(dir_path)s%(filename)s" % kwargs)
project_path = (
"%s/%s"
% (kwargs["project_code"], resource_path))
if not (kwargs["dir_path"] or kwargs["filename"]):
obj = project
elif not kwargs["filename"]:
obj = ProjectResource(
Directory.objects.live().filter(
pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path)
else:
obj = ProjectResource(
Store.objects.live().filter(
pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path)
stats = obj.data_tool.get_stats(user=request.user)
if request.user.is_superuser or kwargs.get("language_code"):
url_action_continue = obj.get_translate_url(state='incomplete')
url_action_fixcritical = obj.get_critical_url()
url_action_review = obj.get_translate_url(state='suggestions')
url_action_view_all = obj.get_translate_url(state='all')
else:
(url_action_continue,
url_action_fixcritical,
url_action_review,
url_action_view_all) = [None] * 4
checks = ChecksDisplay(obj).checks_by_category
stats = StatsDisplay(obj, stats=stats).stats
del stats["children"]
chunk_size = TOP_CONTRIBUTORS_CHUNK_SIZE
score_data = scores.get(Project)(project)
def scores_to_json(score):
score["user"] = score["user"].to_dict()
return score
top_scorers = score_data.display(
limit=chunk_size,
formatter=scores_to_json)
top_scorer_data = dict(
items=list(top_scorers),
has_more_items=len(score_data.top_scorers) > chunk_size)
assertions = dict(
page="browse",
project=project,
browser_extends="projects/base.html",
pootle_path="/projects/%s" % project_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
url_action_continue=url_action_continue,
url_action_fixcritical=url_action_fixcritical,
url_action_review=url_action_review,
url_action_view_all=url_action_view_all,
translation_states=get_translation_states(obj),
top_scorers=top_scorer_data,
checks=checks,
stats=stats)
sidebar = get_sidebar_announcements_context(
request, (project, ))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[k]
view_context_test(ctx, **assertions)
@pytest.mark.django_db
def test_views_project(project_views, settings):
test_type, project, request, response, kwargs = project_views
if test_type == "browse":
_test_browse_view(project, request, response, kwargs)
elif test_type == "translate":
_test_translate_view(project, request, response, kwargs, settings)
@pytest.mark.django_db
def test_view_projects_browse(client, request_users):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get(reverse("pootle-projects-browse"))
assert response.cookies["pootle-language"].value == "projects"
ctx = response.context
request = response.wsgi_request
user_projects = Project.accessible_by_user(request.user)
user_projects = (
Project.objects.for_user(request.user)
.filter(code__in=user_projects))
obj = ProjectSet(user_projects)
stats = obj.data_tool.get_stats(user=request.user)
if request.user.is_superuser:
url_action_continue = obj.get_translate_url(state='incomplete')
url_action_fixcritical = obj.get_critical_url()
url_action_review = obj.get_translate_url(state='suggestions')
url_action_view_all = obj.get_translate_url(state='all')
else:
(url_action_continue,
url_action_fixcritical,
url_action_review,
url_action_view_all) = [None] * 4
checks = ChecksDisplay(obj).checks_by_category
stats = StatsDisplay(obj, stats=stats).stats
del stats["children"]
chunk_size = TOP_CONTRIBUTORS_CHUNK_SIZE
score_data = scores.get(ProjectSet)(obj)
def scores_to_json(score):
score["user"] = score["user"].to_dict()
return score
top_scorers = score_data.display(
limit=chunk_size,
formatter=scores_to_json)
top_scorer_data = dict(
items=list(top_scorers),
has_more_items=len(score_data.top_scorers) > chunk_size)
assertions = dict(
page="browse",
pootle_path="/projects/",
resource_path="",
resource_path_parts=[],
object=obj,
browser_extends="projects/all/base.html",
top_scorers=top_scorer_data,
translation_states=get_translation_states(obj),
url_action_continue=url_action_continue,
url_action_fixcritical=url_action_fixcritical,
url_action_review=url_action_review,
url_action_view_all=url_action_view_all,
checks=checks,
stats=stats)
view_context_test(ctx, **assertions)
@pytest.mark.django_db
def test_view_projects_translate(client, settings, request_users):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get(reverse("pootle-projects-translate"))
if not user.is_superuser:
assert response.status_code == 403
return
ctx = response.context
request = response.wsgi_request
user_projects = Project.accessible_by_user(request.user)
user_projects = (
Project.objects.for_user(request.user)
.filter(code__in=user_projects))
obj = ProjectSet(user_projects)
checks = get_qualitychecks()
schema = {sc["code"]: sc for sc in get_qualitycheck_schema()}
check_data = obj.data_tool.get_checks()
_checks = {}
for check, checkid in checks.items():
if check not in check_data:
continue
_checkid = schema[checkid]["name"]
_checks[_checkid] = _checks.get(
_checkid, dict(checks=[], title=schema[checkid]["title"]))
_checks[_checkid]["checks"].append(
dict(
code=check,
title=CHECK_NAMES[check],
count=check_data[check]))
_checks = OrderedDict(
(k, _checks[k])
for k in CATEGORY_IDS.keys()
if _checks.get(k))
assertions = dict(
page="translate",
has_admin_access=user.is_superuser,
language=None,
project=None,
pootle_path="/projects/",
ctx_path="/projects/",
resource_path="",
resource_path_parts=[],
editor_extends="projects/all/base.html",
checks=_checks,
previous_url=get_previous_url(request),
display_priority=False,
cantranslate=check_permission("translate", request),
cansuggest=check_permission("suggest", request),
canreview=check_permission("review", request),
search_form=make_search_form(request=request),
current_vfolder_pk="",
POOTLE_MT_BACKENDS=settings.POOTLE_MT_BACKENDS,
AMAGAMA_URL=settings.AMAGAMA_URL)
view_context_test(ctx, **assertions)
| 10,827
|
Python
|
.py
| 265
| 33.10566
| 77
| 0.653507
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,952
|
get_alt_src_langs.py
|
translate_pootle/tests/views/get_alt_src_langs.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_store.views import get_alt_src_langs
def do_test_get_altsrclangs_nobody(nobody, language, unit, client):
tp = unit.store.translation_project
response = client.get(
"/xhr/units/%s/edit/" % unit.id,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
request = response.wsgi_request
# User has no altsrclangs and no HTTP_ACCEPT_LANGUAGE.
nobody.alt_src_langs.clear()
alt_src_langs = get_alt_src_langs(request, nobody, tp)
assert alt_src_langs is None
# User has altsrclangs and no HTTP_ACCEPT_LANGUAGE.
nobody.alt_src_langs.clear()
nobody.alt_src_langs.add(language)
alt_src_langs = get_alt_src_langs(request, nobody, tp)
assert alt_src_langs is None
# HTTP_ACCEPT_LANGUAGE and no user's altsrclangs.
nobody.alt_src_langs.clear()
response = client.get(
"/xhr/units/%s/edit/" % unit.id,
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
HTTP_ACCEPT_LANGUAGE=language.code)
request = response.wsgi_request
alt_src_langs = get_alt_src_langs(request, nobody, tp)
assert alt_src_langs is None
# HTTP_ACCEPT_LANGUAGE and user has altsrclangs.
nobody.alt_src_langs.add(language)
alt_src_langs = get_alt_src_langs(request, nobody, tp)
assert alt_src_langs is None
@pytest.mark.django_db
def test_get_altsrclangs(request_users, language0, get_edit_unit, client):
user = request_users["user"]
if user.username == "nobody":
do_test_get_altsrclangs_nobody(user, language0, get_edit_unit, client)
return
client.login(
username=user.username,
password=request_users["password"])
unit = get_edit_unit
tp = unit.store.translation_project
tp_lang = tp.language
proj_source_lang = tp.project.source_language
client_get_kwargs = {
'path': "/xhr/units/%s/edit/" % unit.id,
'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest',
}
request = client.get(**client_get_kwargs).wsgi_request
# User has altsrclang different to TP or Project.
user.alt_src_langs.clear()
user.alt_src_langs.add(language0)
alt_src_langs = get_alt_src_langs(request, user, tp)
assert language0 in alt_src_langs
# User altsrclang is TP language.
user.alt_src_langs.clear()
user.alt_src_langs.add(tp_lang)
alt_src_langs = get_alt_src_langs(request, user, tp)
assert alt_src_langs is None
assert tp.project.translationproject_set.filter(language=tp_lang).exists()
# User altsrclang is Project's source language.
user.alt_src_langs.clear()
user.alt_src_langs.add(proj_source_lang)
prev_tp_lang = tp.language
tp.language = proj_source_lang
tp.save()
alt_src_langs = get_alt_src_langs(request, user, tp)
assert alt_src_langs is None
assert tp.project.translationproject_set.filter(
language=proj_source_lang).exists()
tp.language = prev_tp_lang
tp.save()
# User has no altsrclangs and no HTTP_ACCEPT_LANGUAGE is provided.
user.alt_src_langs.clear()
alt_src_langs = get_alt_src_langs(request, user, tp)
assert alt_src_langs is None
# Test scenarios for HTTP_ACCEPT_LANGUAGE and no user's altsrclangs.
user.alt_src_langs.clear()
def set_accept_lang_and_get_altsrclangs(lang_code):
client_get_kwargs['HTTP_ACCEPT_LANGUAGE'] = lang_code
request = client.get(**client_get_kwargs).wsgi_request
return get_alt_src_langs(request, user, tp)
language0.code = "zz"
language0.save()
alt_src_langs = set_accept_lang_and_get_altsrclangs(language0.code)
assert language0 in alt_src_langs
alt_src_langs = set_accept_lang_and_get_altsrclangs('%s-COUNTRY' %
language0.code)
assert language0 in alt_src_langs
alt_src_langs = set_accept_lang_and_get_altsrclangs(tp_lang.code)
assert alt_src_langs is None
alt_src_langs = set_accept_lang_and_get_altsrclangs(proj_source_lang.code)
assert alt_src_langs is None
alt_src_langs = set_accept_lang_and_get_altsrclangs('*')
assert alt_src_langs is None
alt_src_langs = set_accept_lang_and_get_altsrclangs('templates')
assert alt_src_langs is None
alt_src_langs = set_accept_lang_and_get_altsrclangs('en')
assert alt_src_langs is None
alt_src_langs = set_accept_lang_and_get_altsrclangs('en_US')
assert alt_src_langs is None
alt_src_langs = set_accept_lang_and_get_altsrclangs('DOES_NOT_EXIST')
assert alt_src_langs is None
| 4,784
|
Python
|
.py
| 109
| 38.045872
| 78
| 0.698946
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,953
|
get_units.py
|
translate_pootle/tests/views/get_units.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import json
from urlparse import parse_qs
import pytest
from pytest_pootle.search import calculate_search_results
from pootle_app.models import Directory
from pootle_app.models.permissions import check_user_permission
from pootle_project.models import Project
from pootle_store.models import Unit
@pytest.mark.django_db
def test_get_units(get_units_views):
(user, search_params, url_params, response) = get_units_views
result = json.loads(response.content)
path = parse_qs(url_params)["path"][0]
permission_context = None
if path.strip("/") in ["", "projects"]:
permission_context = Directory.objects.get(pootle_path="/projects/")
elif path.startswith("/projects/"):
try:
permission_context = Project.objects.get(
code=path[10:].split("/")[0]).directory
except Project.DoesNotExist:
assert response.status_code == 404
assert "unitGroups" not in result
return
user_cannot_view = (
permission_context
and not check_user_permission(
user, "administrate", permission_context))
if user_cannot_view:
assert response.status_code == 404
assert "unitGroups" not in result
return
assert "unitGroups" in result
assert isinstance(result["unitGroups"], list)
for k in "start", "end", "total":
assert k in result
assert isinstance(result[k], int)
if result["unitGroups"]:
total, start, end, expected_units = calculate_search_results(
search_params, user)
assert result["total"] == total
assert result["start"] == start
assert result["end"] == end
for i, group in enumerate(expected_units):
result_group = result["unitGroups"][i]
for store, data in group.items():
result_data = result_group[store]
assert (
[u["id"] for u in result_data["units"]]
== [u["id"] for u in data["units"]])
@pytest.mark.django_db
def test_get_previous_slice(client, request_users):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
resp = client.get(
"/xhr/units/?filter=all&count=5&path=/&offset=80",
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
if not request_users.get("is_superuser", False):
assert resp.status_code == 404
return
result = json.loads(resp.content)
qs = Unit.objects.get_translatable(
user=resp.wsgi_request.user).order_by("store__pootle_path", "index")
uids = []
for group in result["unitGroups"]:
for group_data in group.values():
for unit in group_data["units"]:
uids.append(unit["id"])
assert result["start"] == 80
assert result["end"] == 98
assert result["total"] == qs.count()
assert uids == list(qs[80:98].values_list("pk", flat=True))
resp2 = client.get(
"/xhr/units/",
dict(
filter="all",
path="/",
offset=62),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
result2 = json.loads(resp2.content)
uids2 = []
for group in result2["unitGroups"]:
for group_data in group.values():
for unit in group_data["units"]:
uids2.append(unit["id"])
assert result2["start"] == 62
assert result2["end"] == 80
assert result2["total"] == qs.count()
assert uids2 == list(qs[62:80].values_list("pk", flat=True))
expected = list(qs[44:62].values_list("pk", flat=True))
to_obsolete = [uid for i, uid in enumerate(uids2) if i % 2]
for unit in Unit.objects.filter(id__in=to_obsolete):
unit.makeobsolete()
unit.save()
assert expected == list(qs.all()[44:62].values_list("pk", flat=True))
resp3 = client.get(
"/xhr/units/",
dict(
filter="all",
path="/",
offset=44),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
result3 = json.loads(resp3.content)
uids3 = []
for group in result3["unitGroups"]:
for group_data in group.values():
for unit in group_data["units"]:
uids3.append(unit["id"])
# obsoleting the units makes no difference when paginating backwards
assert result3["start"] == 44
assert result3["end"] == 62
assert result3["total"] == qs.count()
assert uids3 == list(
qs[44:62].values_list("pk", flat=True))
@pytest.mark.django_db
def test_get_next_slice(client, request_users):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
resp = client.get(
"/xhr/units/?filter=all&count=5&path=/",
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
if not request_users.get("is_superuser", False):
assert resp.status_code == 404
return
result = json.loads(resp.content)
qs = Unit.objects.get_translatable(
user=resp.wsgi_request.user).order_by("store__pootle_path", "index")
uids = []
for group in result["unitGroups"]:
for group_data in group.values():
for unit in group_data["units"]:
uids.append(unit["id"])
assert result["start"] == 0
assert result["end"] == 18
assert result["total"] == qs.count()
assert uids == list(qs[:18].values_list("pk", flat=True))
resp2 = client.get(
"/xhr/units/",
dict(
filter="all",
path="/",
offset=18,
previous_uids=uids),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
result2 = json.loads(resp2.content)
uids2 = []
for group in result2["unitGroups"]:
for group_data in group.values():
for unit in group_data["units"]:
uids2.append(unit["id"])
assert result2["start"] == 18
assert result2["end"] == 36
assert result2["total"] == qs.count()
assert uids2 == list(qs[18:36].values_list("pk", flat=True))
expected = list(qs[36:54].values_list("pk", flat=True))
to_obsolete = [uid for i, uid in enumerate(uids2) if i % 2]
for unit in Unit.objects.filter(id__in=to_obsolete):
unit.makeobsolete()
unit.save()
assert expected == list(qs.all()[27:45].values_list("pk", flat=True))
resp3 = client.get(
"/xhr/units/",
dict(
filter="all",
path="/",
offset=36,
previous_uids=uids2),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
result3 = json.loads(resp3.content)
uids3 = []
for group in result3["unitGroups"]:
for group_data in group.values():
for unit in group_data["units"]:
uids3.append(unit["id"])
assert result3["start"] == 36 - len(to_obsolete)
assert result3["end"] == 54 - len(to_obsolete)
assert result3["total"] == qs.count()
start = 36 - len(to_obsolete)
end = 54 - len(to_obsolete)
assert uids3 == list(
qs[start:end].values_list("pk", flat=True))
| 7,488
|
Python
|
.py
| 194
| 30.664948
| 77
| 0.609722
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,954
|
disabled_project.py
|
translate_pootle/tests/views/disabled_project.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.urls import reverse
@pytest.mark.django_db
def test_views_disabled_project(client, dp_view_urls, request_users):
url = dp_view_urls
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
response = client.get(url)
if user.is_superuser:
assert response.status_code == 200
else:
assert response.status_code == 404
@pytest.mark.django_db
def test_disabled_project_in_lang_browse_view(client, request_users):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
response = client.get(reverse("pootle-language-browse",
kwargs={"language_code": "language0"}))
disabled_project_exists = "language0-disabled_project0" in response.content
assert response.status_code == 200
assert (user.is_superuser is disabled_project_exists)
| 1,351
|
Python
|
.py
| 34
| 33.647059
| 79
| 0.688361
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,955
|
language.py
|
translate_pootle/tests/views/language.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from collections import OrderedDict
import pytest
from pytest_pootle.suite import view_context_test
from pootle_app.models.permissions import check_permission
from pootle.core.browser import make_project_item
from pootle.core.delegate import scores
from pootle.core.helpers import get_sidebar_announcements_context
from pootle.core.url_helpers import get_previous_url
from pootle.core.utils.stats import (
TOP_CONTRIBUTORS_CHUNK_SIZE, get_translation_states)
from pootle.core.views.browse import StatsDisplay
from pootle.core.views.display import ChecksDisplay
from pootle_checks.constants import CATEGORY_IDS, CHECK_NAMES
from pootle_checks.utils import get_qualitychecks, get_qualitycheck_schema
from pootle_misc.forms import make_search_form
def _test_browse_view(language, request, response, kwargs):
assert response.cookies["pootle-language"].value == language.code
assert (request.user.is_anonymous
or "announcements/%s" % language.code in request.session)
ctx = response.context
user_tps = language.get_children_for_user(request.user)
stats = language.data_tool.get_stats(user=request.user)
items = [make_project_item(tp) for tp in user_tps]
for item in items:
if item["code"] in stats["children"]:
item["stats"] = stats["children"][item["code"]]
checks = ChecksDisplay(language).checks_by_category
stats = StatsDisplay(language, stats=stats).stats
del stats["children"]
score_data = scores.get(language.__class__)(language)
chunk_size = TOP_CONTRIBUTORS_CHUNK_SIZE
def scores_to_json(score):
score["user"] = score["user"].to_dict()
return score
top_scorers = score_data.display(
limit=chunk_size,
formatter=scores_to_json)
top_scorer_data = dict(
items=list(top_scorers),
has_more_items=len(score_data.top_scorers) > chunk_size)
assertions = dict(
page="browse",
object=language,
language={
'code': language.code,
'name': language.name},
browser_extends="languages/base.html",
pootle_path="/%s/" % language.code,
resource_path="",
resource_path_parts=[],
url_action_continue=language.get_translate_url(state='incomplete'),
url_action_fixcritical=language.get_critical_url(),
url_action_review=language.get_translate_url(state='suggestions'),
url_action_view_all=language.get_translate_url(state='all'),
# check_categories=get_qualitycheck_schema(language),
translation_states=get_translation_states(language),
top_scorers=top_scorer_data,
checks=checks,
stats=stats)
sidebar = get_sidebar_announcements_context(request, (language, ))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[k]
view_context_test(ctx, **assertions)
def _test_translate_view(language, request, response, kwargs, settings):
ctx = response.context
checks = get_qualitychecks()
schema = {sc["code"]: sc for sc in get_qualitycheck_schema()}
check_data = language.data_tool.get_checks()
_checks = {}
for check, checkid in checks.items():
if check not in check_data:
continue
_checkid = schema[checkid]["name"]
_checks[_checkid] = _checks.get(
_checkid, dict(checks=[], title=schema[checkid]["title"]))
_checks[_checkid]["checks"].append(
dict(
code=check,
title=CHECK_NAMES[check],
count=check_data[check]))
_checks = OrderedDict(
(k, _checks[k])
for k in CATEGORY_IDS.keys()
if _checks.get(k))
view_context_test(
ctx,
**dict(
project=None,
language=language,
page="translate",
ctx_path=language.directory.pootle_path,
pootle_path=language.directory.pootle_path,
resource_path="",
resource_path_parts=[],
editor_extends="languages/base.html",
checks=_checks,
previous_url=get_previous_url(request),
display_priority=False,
has_admin_access=check_permission('administrate', request),
cantranslate=check_permission("translate", request),
cansuggest=check_permission("suggest", request),
canreview=check_permission("review", request),
search_form=make_search_form(request=request),
current_vfolder_pk="",
POOTLE_MT_BACKENDS=settings.POOTLE_MT_BACKENDS,
AMAGAMA_URL=settings.AMAGAMA_URL))
@pytest.mark.django_db
def test_views_language(language_views, settings):
test_type, language, request, response, kwargs = language_views
if test_type == "browse":
_test_browse_view(language, request, response, kwargs)
if test_type == "translate":
_test_translate_view(language, request, response, kwargs, settings)
| 5,264
|
Python
|
.py
| 120
| 36.408333
| 77
| 0.673485
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,956
|
get_edit_unit.py
|
translate_pootle/tests/views/get_edit_unit.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import json
import unicodedata
import pytest
from pootle_app.models.permissions import check_user_permission
from pootle_store.util import find_altsrcs
from pootle_store.views import CHARACTERS_NAMES, get_alt_src_langs
@pytest.mark.django_db
def test_get_edit_unit(project0_nongnu, get_edit_unit, client,
request_users, settings):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
unit = get_edit_unit
store = unit.store
filetype = unit.store.filetype.name
directory = store.parent
translation_project = store.translation_project
project = translation_project.project
language = translation_project.language
response = client.get(
"/xhr/units/%s/edit/" % unit.id,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
request = response.wsgi_request
result = json.loads(response.content)
special_characters = []
for specialchar in language.specialchars:
code = ord(specialchar)
special_characters.append({
'display': CHARACTERS_NAMES.get(code, specialchar),
'code': code,
'hex_code': "U+" + hex(code)[2:].upper(),
'name': unicodedata.name(specialchar, ''),
})
src_lang = unit.store.translation_project.project.source_language
alt_src_langs = get_alt_src_langs(request, user, translation_project)
altsrcs = find_altsrcs(unit, alt_src_langs, store=store, project=project)
altsrcs = {x.id: x.data for x in altsrcs}
sources = {altsrcs[x]['language_code']: altsrcs[x]['target'] for x in altsrcs}
sources[src_lang.code] = unit.source
suggestions_dict = {x.id: dict(id=x.id, target=x.target.strings)
for x in unit.get_suggestions()}
assert result["is_obsolete"] is False
assert result["sources"] == sources
assert response.context["unit"] == unit
accepted_suggestion = None
submission = unit.get_latest_target_submission()
if submission:
accepted_suggestion = submission.suggestion
assert response.context["accepted_suggestion"] == accepted_suggestion
assert response.context["priority"] == store.priority
assert response.context["store"] == store
assert response.context["filetype"] == filetype
assert response.context["directory"] == directory
assert response.context["project"] == project
assert response.context["language"] == language
assert response.context["special_characters"] == special_characters
assert response.context["source_language"] == src_lang
assert response.context["altsrcs"] == altsrcs
assert response.context["suggestions_dict"] == suggestions_dict
assert response.context["cantranslate"] == check_user_permission(
user, "translate", directory)
assert response.context["cansuggest"] == check_user_permission(
user, "suggest", directory)
assert response.context["canreview"] == check_user_permission(
user, "review", directory)
assert response.context["has_admin_access"] == check_user_permission(
user, "administrate", directory)
assert (
response.context["critical_checks"]
== list(unit.get_critical_qualitychecks()))
assert (
response.context["warning_checks"]
== list(unit.get_warning_qualitychecks()))
assert (
response.context["terms"]
== unit.get_terminology())
failing_checks = any(
not check.false_positive
for check
in list(unit.get_warning_qualitychecks()))
assert response.context["failing_checks"] == failing_checks
| 3,966
|
Python
|
.py
| 90
| 37.766667
| 82
| 0.690636
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,957
|
tp.py
|
translate_pootle/tests/views/tp.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from collections import OrderedDict
import pytest
from pytest_pootle.suite import view_context_test
from django.urls import reverse
from pootle_app.models import Directory
from pootle_app.models.permissions import check_permission
from pootle.core.browser import get_parent
from pootle.core.delegate import scores
from pootle.core.helpers import (
SIDEBAR_COOKIE_NAME, get_sidebar_announcements_context)
from pootle.core.url_helpers import get_previous_url, get_path_parts
from pootle.core.utils.stats import (
TOP_CONTRIBUTORS_CHUNK_SIZE, get_translation_states)
from pootle.core.views.display import ChecksDisplay
from pootle_checks.constants import CATEGORY_IDS, CHECK_NAMES
from pootle_checks.utils import get_qualitychecks, get_qualitycheck_schema
from pootle.core.views.browse import StatsDisplay
from pootle_misc.forms import make_search_form
from pootle_store.models import Store
from virtualfolder.delegate import vfolders_data_view
def _test_browse_view(tp, request, response, kwargs):
assert (request.user.is_anonymous
or "announcements/projects/%s" % tp.project.code in request.session)
assert (request.user.is_anonymous
or "announcements/%s" % tp.language.code in request.session)
assert (request.user.is_anonymous
or "announcements/%s/%s" % (tp.language.code, tp.project.code)
in request.session)
ctx = response.context
kwargs["project_code"] = tp.project.code
kwargs["language_code"] = tp.language.code
resource_path = "%(dir_path)s%(filename)s" % kwargs
pootle_path = "%s%s" % (tp.pootle_path, resource_path)
if not (kwargs["dir_path"] or kwargs.get("filename")):
obj = tp.directory
elif not kwargs.get("filename"):
obj = Directory.objects.get(
pootle_path=pootle_path)
else:
obj = Store.objects.get(
pootle_path=pootle_path)
if obj.tp_path == "/":
data_obj = obj.tp
else:
data_obj = obj
stats = StatsDisplay(
data_obj,
stats=data_obj.data_tool.get_stats(user=request.user)).stats
if not kwargs.get("filename"):
vfolders = True
else:
vfolders = None
filters = {}
if vfolders:
filters['sort'] = 'priority'
checks = ChecksDisplay(obj).checks_by_category
del stats["children"]
score_data = scores.get(tp.__class__)(tp)
chunk_size = TOP_CONTRIBUTORS_CHUNK_SIZE
top_scorers = score_data.top_scorers
def scores_to_json(score):
score["user"] = score["user"].to_dict()
return score
top_scorers = score_data.display(
limit=chunk_size,
formatter=scores_to_json)
top_scorer_data = dict(
items=list(top_scorers),
has_more_items=len(score_data.top_scorers) > chunk_size)
assertions = dict(
page="browse",
object=obj,
translation_project=tp,
language=tp.language,
project=tp.project,
has_admin_access=check_permission('administrate', request),
is_store=(kwargs.get("filename") and True or False),
browser_extends="translation_projects/base.html",
pootle_path=pootle_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
translation_states=get_translation_states(obj),
checks=checks,
top_scorers=top_scorer_data,
url_action_continue=obj.get_translate_url(
state='incomplete', **filters),
url_action_fixcritical=obj.get_critical_url(**filters),
url_action_review=obj.get_translate_url(
state='suggestions', **filters),
url_action_view_all=obj.get_translate_url(state='all'),
stats=stats,
parent=get_parent(obj))
sidebar = get_sidebar_announcements_context(
request, (tp.project, tp.language, tp))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[k]
view_context_test(ctx, **assertions)
assert (('display_download' in ctx and ctx['display_download']) ==
(request.user.is_authenticated
and check_permission('translate', request)))
def _test_translate_view(tp, request, response, kwargs, settings):
ctx = response.context
obj = ctx["object"]
kwargs["project_code"] = tp.project.code
kwargs["language_code"] = tp.language.code
resource_path = "%(dir_path)s%(filename)s" % kwargs
request_path = "%s%s" % (tp.pootle_path, resource_path)
checks = get_qualitychecks()
schema = {sc["code"]: sc for sc in get_qualitycheck_schema()}
check_data = obj.data_tool.get_checks()
_checks = {}
for check, checkid in checks.items():
if check not in check_data:
continue
_checkid = schema[checkid]["name"]
_checks[_checkid] = _checks.get(
_checkid, dict(checks=[], title=schema[checkid]["title"]))
_checks[_checkid]["checks"].append(
dict(
code=check,
title=CHECK_NAMES[check],
count=check_data[check]))
_checks = OrderedDict(
(k, _checks[k])
for k in CATEGORY_IDS.keys()
if _checks.get(k))
current_vfolder_pk = ""
display_priority = False
if not kwargs["filename"]:
vf_view = vfolders_data_view.get(obj.__class__)(obj, request.user)
display_priority = vf_view.has_data
unit_api_root = "/xhr/units/"
assertions = dict(
page="translate",
translation_project=tp,
language=tp.language,
project=tp.project,
has_admin_access=check_permission('administrate', request),
ctx_path=tp.pootle_path,
pootle_path=request_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
editor_extends="translation_projects/base.html",
checks=_checks,
previous_url=get_previous_url(request),
current_vfolder_pk=current_vfolder_pk,
display_priority=display_priority,
cantranslate=check_permission("translate", request),
cansuggest=check_permission("suggest", request),
canreview=check_permission("review", request),
search_form=make_search_form(request=request),
unit_api_root=unit_api_root,
POOTLE_MT_BACKENDS=settings.POOTLE_MT_BACKENDS,
AMAGAMA_URL=settings.AMAGAMA_URL)
view_context_test(ctx, **assertions)
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_views_tp(tp_views, settings):
test_type, tp, request, response, kwargs = tp_views
if test_type == "browse":
_test_browse_view(tp, request, response, kwargs)
elif test_type == "translate":
_test_translate_view(tp, request, response, kwargs, settings)
@pytest.mark.django_db
def test_view_tp_browse_sidebar_cookie(client, member):
# - ensure that when a sidebar cookie is sent the session is changed
# - ensure that the cookie is deleted
from pootle_translationproject.models import TranslationProject
tp = TranslationProject.objects.first()
args = [tp.language.code, tp.project.code]
client.login(username=member.username, password=member.password)
response = client.get(reverse("pootle-tp-browse", args=args))
assert SIDEBAR_COOKIE_NAME not in response
assert client.session.get('is_sidebar_open', True) is True
client.cookies[SIDEBAR_COOKIE_NAME] = 1
response = client.get(reverse("pootle-tp-browse", args=args))
assert SIDEBAR_COOKIE_NAME not in response
assert client.session.get('is_sidebar_open', True) is True
del client.cookies[SIDEBAR_COOKIE_NAME]
response = client.get(reverse("pootle-tp-browse", args=args))
assert SIDEBAR_COOKIE_NAME not in response
assert client.session.get('is_sidebar_open', True) is True
client.cookies[SIDEBAR_COOKIE_NAME] = 0
response = client.get(reverse("pootle-tp-browse", args=args))
assert SIDEBAR_COOKIE_NAME not in response
assert client.session.get('is_sidebar_open', True) is False
@pytest.mark.django_db
def test_view_tp_browse_sidebar_cookie_nonsense(client, member):
# - ensure that sending nonsense in a cookie does the right thing
from pootle_translationproject.models import TranslationProject
tp = TranslationProject.objects.first()
args = [tp.language.code, tp.project.code]
client.login(username=member.username, password=member.password)
client.cookies[SIDEBAR_COOKIE_NAME] = "complete jibberish"
client.get(reverse("pootle-tp-browse", args=args))
assert client.session.get('is_sidebar_open', True) is True
@pytest.mark.django_db
def test_view_tp_browse_sidebar_openness_in_anonymous_session(client):
from pootle_translationproject.models import TranslationProject
tp = TranslationProject.objects.first()
args = [tp.language.code, tp.project.code]
client.cookies[SIDEBAR_COOKIE_NAME] = 1
response = client.get(reverse("pootle-tp-browse", args=args))
session = response.wsgi_request.session
assert "announcements/projects/%s" % tp.project.code not in session
assert "announcements/%s" % tp.language.code not in session
assert (
"announcements/%s/%s" % (tp.language.code, tp.project.code)
not in session)
assert "is_sidebar_open" in session
@pytest.mark.django_db
def test_view_user_choice(client):
client.cookies["user-choice"] = "language"
response = client.get("/foo/bar/baz")
assert response.status_code == 302
assert response.get("location") == "/foo/"
assert "user-choice" not in response
client.cookies["user-choice"] = "project"
response = client.get("/foo/bar/baz")
assert response.status_code == 302
assert response.get("location") == "/projects/bar/"
assert "user-choice" not in response
client.cookies["user-choice"] = "foo"
response = client.get("/foo/bar/baz")
assert response.status_code == 404
assert "user-choice" not in response
@pytest.mark.django_db
def test_uploads_tp(revision, tp_uploads):
tp_, request_, response, kwargs_, errors = tp_uploads
assert response.status_code == 200
assert errors.keys() == response.context['upload_form'].errors.keys()
| 10,481
|
Python
|
.py
| 238
| 37.756303
| 80
| 0.692074
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,958
|
get_contributors.py
|
translate_pootle/tests/views/get_contributors.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import json
import pytest
from pootle.core.delegate import scores
from pootle_app.models.directory import Directory
from pootle_language.models import Language
from pootle_project.models import Project, ProjectSet
from pootle_store.models import Store
from pootle_translationproject.models import TranslationProject
from pootle.core.utils.stats import TOP_CONTRIBUTORS_CHUNK_SIZE
def get_top_scorers_test_data(obj, offset=0):
score_data = scores.get(obj.__class__)(obj)
chunk_size = TOP_CONTRIBUTORS_CHUNK_SIZE
def scores_to_json(score):
score["user"] = score["user"].to_dict()
return score
top_scorers = score_data.display(
offset=offset,
limit=chunk_size,
formatter=scores_to_json)
return dict(
items=list(top_scorers),
has_more_items=len(score_data.top_scorers) > (offset + chunk_size))
@pytest.mark.django_db
def test_get_contributors_store(client, request_users):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
store = Store.objects.get(pootle_path="/language0/project0/store0.po")
response = client.get(
"/xhr/stats/contributors/?path=%s" % store.pootle_path,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 200
result = json.loads(response.content)
top_scorers_data = get_top_scorers_test_data(store.translation_project)
for k, v in result.items():
assert json.loads(json.dumps(top_scorers_data[k])) == v
@pytest.mark.django_db
def test_get_contributors_tp(client, request_users):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
tp = TranslationProject.objects.get(pootle_path="/language0/project0/")
response = client.get(
"/xhr/stats/contributors/?path=%s" % tp.pootle_path,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 200
result = json.loads(response.content)
top_scorers_data = get_top_scorers_test_data(tp)
for k, v in result.items():
assert json.loads(json.dumps(top_scorers_data[k])) == v
@pytest.mark.django_db
def test_get_contributors_project(client, request_users):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
project = Project.objects.get(code="project0")
response = client.get(
"/xhr/stats/contributors/?path=%s" % project.pootle_path,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 200
result = json.loads(response.content)
top_scorers_data = get_top_scorers_test_data(project)
for k, v in result.items():
assert json.loads(json.dumps(top_scorers_data[k])) == v
@pytest.mark.django_db
def test_get_contributors_language(client, request_users):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
language = Language.objects.get(code="language0")
response = client.get(
"/xhr/stats/contributors/?path=%s" % language.pootle_path,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 200
result = json.loads(response.content)
top_scorers_data = get_top_scorers_test_data(language)
for k, v in result.items():
assert json.loads(json.dumps(top_scorers_data[k])) == v
@pytest.mark.django_db
def test_get_contributors_projects_offset(client, request_users):
offset = 3
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
directory = Directory.objects.projects
response = client.get(
("/xhr/stats/contributors/?path=%s&offset=%d"
% (directory.pootle_path, offset)),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 200
result = json.loads(response.content)
user_projects = Project.accessible_by_user(user)
user_projects = (
Project.objects.for_user(user)
.filter(code__in=user_projects))
top_scorers_data = get_top_scorers_test_data(
ProjectSet(user_projects),
offset=offset)
for k, v in result.items():
assert json.loads(json.dumps(top_scorers_data[k])) == v
@pytest.mark.django_db
def test_get_contributors_projects(client, request_users):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
directory = Directory.objects.projects
response = client.get(
"/xhr/stats/contributors/?path=%s" % directory.pootle_path,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 200
result = json.loads(response.content)
user_projects = Project.accessible_by_user(user)
user_projects = (
Project.objects.for_user(user)
.filter(code__in=user_projects))
top_scorers_data = get_top_scorers_test_data(ProjectSet(user_projects))
for k, v in result.items():
assert json.loads(json.dumps(top_scorers_data[k])) == v
@pytest.mark.parametrize('path, offset', [
("/TOO_LONG_PATH" * 200, 0),
("/language0/", 'WRONG_OFFSET'),
])
@pytest.mark.django_db
def test_get_contributors_wrong_params(client, request_users, path, offset):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
response = client.get(
"/xhr/stats/contributors/?path=%s&offset=%s" % (path, offset),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 404
| 6,343
|
Python
|
.py
| 152
| 35.335526
| 77
| 0.681183
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,959
|
timeline.py
|
translate_pootle/tests/views/timeline.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from hashlib import md5
import json
import pytest
from django.template import loader
from django.urls import reverse
from django.utils.encoding import force_bytes
from pootle.core.delegate import grouped_events, review
from pootle_comment.forms import UnsecuredCommentForm
from pootle_store.constants import (
FUZZY, OBSOLETE, TRANSLATED, UNTRANSLATED)
from pootle_store.models import (
Suggestion, QualityCheck, Unit)
from pootle_store.unit.timeline import EventGroup, UnitTimelineLog
class ProxyTimelineLanguage(object):
def __init__(self, code):
self.code = code
class ProxyTimelineUser(object):
def __init__(self, submission):
self.submission = submission
@property
def username(self):
return self.submission["submitter__username"]
@property
def email_hash(self):
return md5(force_bytes(self.submission['submitter__email'])).hexdigest()
@property
def display_name(self):
return (
self.submission["submitter__full_name"].strip()
if self.submission["submitter__full_name"].strip()
else self.submission["submitter__username"])
def _calculate_timeline(request, unit):
groups = []
log = UnitTimelineLog(unit)
grouped_events_class = grouped_events.get(log.__class__)
target_event = None
for _key, group in grouped_events_class(log).grouped_events():
event_group = EventGroup(group, target_event)
if event_group.target_event:
target_event = event_group.target_event
if event_group.events:
groups.append(event_group.context)
context = dict(event_groups=groups)
context.setdefault(
'language', ProxyTimelineLanguage(
unit.store.translation_project.language.code))
t = loader.get_template('editor/units/xhr_timeline.html')
return t.render(context=context, request=request)
def _timeline_test(client, request_user, unit):
url = reverse("pootle-xhr-units-timeline", kwargs=dict(uid=unit.id))
user = request_user["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_user["password"])
response = client.get(
url, HTTP_X_REQUESTED_WITH='XMLHttpRequest')
no_permission = (
unit not in Unit.objects.get_translatable(user))
if no_permission:
assert response.status_code == 404
assert "timeline" not in response
return
request = response.wsgi_request
result = json.loads(response.content)
assert result["uid"] == unit.id
assert result["timeline"] == _calculate_timeline(request, unit)
@pytest.mark.django_db
def test_timeline_view_units(client, request_users, system, admin):
_timeline_test(
client,
request_users,
Unit.objects.filter(state=TRANSLATED).first())
_timeline_test(
client,
request_users,
Unit.objects.filter(state=UNTRANSLATED).first())
@pytest.mark.django_db
def test_timeline_view_unit_obsolete(client, request_users, system, admin):
_timeline_test(
client,
request_users,
Unit.objects.filter(state=OBSOLETE).first())
@pytest.mark.django_db
def test_timeline_view_unit_disabled_project(client, request_users,
system, admin):
unit = Unit.objects.filter(
store__translation_project__project__disabled=True,
store__obsolete=False,
state=TRANSLATED).first()
_timeline_test(
client,
request_users,
unit)
@pytest.mark.django_db
def test_timeline_view_unit_with_suggestion(client, request_users,
system, admin, store0):
# test with "state change" subission - apparently this is what is required
# to get one
suggestion = Suggestion.objects.filter(
unit__store=store0,
state__name="pending",
unit__state=UNTRANSLATED).first()
unit = suggestion.unit
unit.state = FUZZY
unit.save()
review.get(Suggestion)([suggestion], admin).accept()
_timeline_test(
client,
request_users,
unit)
@pytest.mark.django_db
def test_timeline_view_unit_with_qc(client, request_users, system, admin, store0):
# check a Unit with a quality check
qc_filter = dict(
unit__store=store0,
unit__state=TRANSLATED,
unit__store__translation_project__project__disabled=False,
unit__store__obsolete=False)
qc = QualityCheck.objects.filter(**qc_filter).first()
unit = qc.unit
unit.toggle_qualitycheck(qc.id, True, admin)
_timeline_test(
client,
request_users,
unit)
@pytest.mark.django_db
def test_timeline_view_unit_with_suggestion_and_comment(client, request_users,
system, admin, store0):
# test with "state change" subission - apparently this is what is required
# to get one
suggestion = Suggestion.objects.filter(
unit__store=store0,
state__name="pending",
unit__state=UNTRANSLATED).first()
unit = suggestion.unit
unit.state = FUZZY
unit.save()
review.get(Suggestion)([suggestion], admin).accept()
form = UnsecuredCommentForm(suggestion, dict(
comment='This is a comment!',
user=admin,
))
if form.is_valid():
form.save()
_timeline_test(
client,
request_users,
unit)
@pytest.mark.django_db
def test_timeline_view_unit_with_creation(client, request_users,
system, admin, store0):
# add a creation submission for a unit and test with that
unit = Unit.objects.create(
state=TRANSLATED, source_f="Foo", target_f="Bar",
store=store0)
# save and get the unit to deal with mysql's microsecond issues
unit.save()
unit = Unit.objects.get(pk=unit.pk)
_timeline_test(
client,
request_users,
unit)
@pytest.mark.django_db
def test_timeline_view_unit_without_creation(client, request_users,
system, admin, store0):
# add a creation submission for a unit and test with that
unit = Unit.objects.create(
state=TRANSLATED, source_f="Foo", target_f="Bar",
store=store0)
unit.creation_time = None
# save and get the unit to deal with mysql's microsecond issues
unit.save()
unit = Unit.objects.get(pk=unit.pk)
_timeline_test(
client,
request_users,
unit)
| 6,860
|
Python
|
.py
| 185
| 29.859459
| 82
| 0.66305
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,960
|
contact.py
|
translate_pootle/tests/views/contact.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from __future__ import absolute_import
import pytest
from django.urls import reverse
from pootle_store.models import Unit
@pytest.mark.django_db
def test_contact_report_form_view(client, request_users, rf):
unit = Unit.objects.last()
url = '%s?report=%s' % (reverse('pootle-contact-report-error'), unit.pk)
user = request_users["user"]
if user.username != "nobody":
client.login(username=user.username, password=user.password)
response = client.get(url)
assert response.status_code == 200
assert 'contact_form_title' in response.context
assert response.context['contact_form_url'] == url
assert response.context['form'].unit == unit
assert response.context['view'].unit == unit
@pytest.mark.django_db
def test_contact_report_form_view_no_unit(client, member, rf):
url = reverse('pootle-contact-report-error')
client.login(username=member.username, password=member.password)
response = client.get(url)
assert response.status_code == 200
assert response.context['view'].unit is None
assert 'context' not in response.context['view'].get_initial()
@pytest.mark.django_db
def test_contact_report_form_view_blank_unit(client, member, rf):
url = '%s?report=' % reverse('pootle-contact-report-error')
client.login(username=member.username, password=member.password)
response = client.get(url)
assert response.status_code == 200
assert response.context['view'].unit is None
@pytest.mark.django_db
def test_contact_report_form_view_no_numeric_unit(client, member, rf):
url = '%s?report=STRING' % reverse('pootle-contact-report-error')
client.login(username=member.username, password=member.password)
response = client.get(url)
assert response.status_code == 200
assert response.context['view'].unit is None
@pytest.mark.django_db
def test_contact_report_form_view_unexisting_unit(client, member, rf):
unit_pk = 99999999
Unit.objects.filter(id=unit_pk).delete() # Ensure unit doesn't exist.
url = '%s?report=%s' % (reverse('pootle-contact-report-error'), unit_pk)
client.login(username=member.username, password=member.password)
response = client.get(url)
assert response.status_code == 200
assert response.context['view'].unit is None
| 2,560
|
Python
|
.py
| 55
| 42.654545
| 77
| 0.73572
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,961
|
admin.py
|
translate_pootle/tests/views/admin.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.core.exceptions import ImproperlyConfigured, PermissionDenied
from django.urls import reverse_lazy, reverse
from django.utils.safestring import mark_safe
from pytest_pootle.fixtures.models.user import TEST_USERS
from pytest_pootle.factories import LanguageDBFactory, TranslationProjectFactory
from pootle.core.delegate import formats
from pootle.core.paginator import paginate
from pootle.core.url_helpers import split_pootle_path
from pootle.core.views.admin import PootleAdminFormView, PootleAdminView
from pootle_app.models import PermissionSet
from pootle_app.views.admin.util import form_set_as_table
from pootle_format.models import Format
from pootle_fs.delegate import fs_plugins
from pootle_fs.presets import FS_PRESETS
from pootle_language.models import Language
from pootle_project.models import PROJECT_CHECKERS, Project
from pootle_translationproject.models import TranslationProject
ADMIN_URL = reverse_lazy('pootle-admin')
@pytest.mark.django_db
def test_core_admin_view(request_users, rf):
request = rf.get("/foo/bar")
request.user = request_users["user"]
if not request.user.is_superuser:
with pytest.raises(PermissionDenied):
PootleAdminView.as_view()(request)
else:
with pytest.raises(ImproperlyConfigured):
# no template
assert PootleAdminView.as_view()(request)
@pytest.mark.django_db
def test_core_admin_form_view(request_users, rf):
request = rf.get("/foo/bar")
request.user = request_users["user"]
if not request.user.is_superuser:
with pytest.raises(PermissionDenied):
PootleAdminFormView.as_view()(request)
else:
with pytest.raises(TypeError):
# no form
assert PootleAdminFormView.as_view()(request)
def _test_admin_view(response, project):
request = response.wsgi_request
qs = TranslationProject.objects.filter(
project=project).order_by('pootle_path')
page = paginate(request, qs)
url_kwargs = {
'project_code': project.code,
'dir_path': '',
'filename': ''}
assert page.number == response.context["objects"].number
assert page.start_index() == response.context["objects"].start_index()
assert page.end_index() == response.context["objects"].end_index()
assert (
list(response.context["objects"].object_list.values_list("pk", flat=True))
== list(qs.values_list("pk", flat=True)))
assert (
response.context["formset"].__class__.__name__
== "TranslationProjectFormFormSet")
assert response.context["page"] == "admin-languages"
assert response.context["browse_url"] == reverse(
'pootle-project-browse',
kwargs=url_kwargs)
assert response.context["translate_url"] == reverse(
'pootle-project-translate',
kwargs=url_kwargs)
assert (
response.context['project']
== {'code': project.code,
'name': project.fullname})
assert (
response.context["formset_text"]
== mark_safe(
form_set_as_table(
response.context["formset"],
lambda tp: (
u'<a href="%s">%s</a>'
% (reverse('pootle-tp-admin-permissions',
args=split_pootle_path(tp.pootle_path)[:2]),
tp.language)),
"language")))
def _admin_view_get(client, project):
return client.get(
reverse(
"pootle-project-admin-languages",
kwargs=dict(project_code=project.code)))
def _admin_view_post(client, project, **kwargs):
return client.post(
reverse(
"pootle-project-admin-languages",
kwargs=dict(project_code=project.code)),
kwargs)
@pytest.mark.django_db
def test_admin_not_logged_in(client):
"""Checks logged-out users cannot access the admin site."""
response = client.get(ADMIN_URL)
assert response.status_code == 403
@pytest.mark.django_db
def test_admin_regular_user(client, default):
"""Checks regular users cannot access the admin site."""
client.login(username=default.username, password='')
response = client.get(ADMIN_URL)
assert response.status_code == 403
@pytest.mark.django_db
def test_admin_access(client):
"""Tests that admin users can access the admin site."""
client.login(username="admin", password="admin")
response = client.get(ADMIN_URL)
assert response.status_code == 200
@pytest.mark.django_db
def test_admin_view_project(client, request_users):
user = request_users["user"]
project = Project.objects.get(code="project0")
client.login(
username=user.username,
password=request_users["password"])
response = _admin_view_get(client, project)
if not user.is_superuser:
assert response.status_code == 403
return
_test_admin_view(response, project)
@pytest.mark.django_db
def test_admin_view_project_manager(client, member, administrate):
project = Project.objects.get(code="project0")
criteria = {
'user': member,
'directory': project.directory}
ps = PermissionSet.objects.create(**criteria)
ps.positive_permissions.set([administrate])
client.login(
username=member.username,
password=TEST_USERS[member.username]["password"])
response = _admin_view_get(client, project)
assert response.status_code == 200
_test_admin_view(response, project)
response = _admin_view_post(client, project)
assert response.status_code == 200
_test_admin_view(response, project)
@pytest.mark.django_db
def test_admin_view_project_post(client, request_users):
project = Project.objects.get(code="project0")
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
if user.is_superuser:
return
response = _admin_view_post(client, project)
assert response.status_code == 403
@pytest.mark.django_db
def test_admin_view_project_add_tp(project_foo, english, client, admin):
user = admin
new_language = LanguageDBFactory()
TranslationProjectFactory(language=english, project=project_foo)
client.login(
username=user.username,
password=TEST_USERS["admin"]["password"])
get_response = _admin_view_get(client, project_foo)
post_data = {}
formset = get_response.context["formset"]
forms = formset.forms + formset.extra_forms + [formset.management_form]
for form in forms:
for field in form.fields:
post_data["%s-%s" % (form.prefix, field)] = (
form.fields[field].initial
or form.initial.get(field, ""))
post_data["%s-language" % formset.extra_forms[0].prefix] = new_language.id
post_data["%s-project" % formset.extra_forms[0].prefix] = project_foo.id
response = _admin_view_post(client, project_foo, **post_data)
new_tp = TranslationProject.objects.get(language=new_language,
project=project_foo)
assert new_tp in response.context["objects"].object_list
_test_admin_view(response, project_foo)
@pytest.mark.django_db
def test_admin_view_project_add_pootle_fs_tp(project0, client, admin):
client.login(
username=admin.username,
password=TEST_USERS["admin"]["password"])
get_response = _admin_view_get(client, project0)
formset = get_response.context["formset"]
assert len(formset.extra_forms) == 1
@pytest.mark.django_db
def test_admin_view_project_delete_tp(english, client, admin):
user = admin
project = Project.objects.get(code="project0")
tp = TranslationProject.objects.create(language=english, project=project)
project.config["pootle.core.lang_mapping"] = {tp.language.code: "foo"}
client.login(
username=user.username,
password=TEST_USERS["admin"]["password"])
get_response = _admin_view_get(client, project)
post_data = {}
formset = get_response.context["formset"]
forms = formset.forms + formset.extra_forms + [formset.management_form]
for form in forms:
for field in form.fields:
post_data["%s-%s" % (form.prefix, field)] = (
form.fields[field].initial
or form.initial.get(field, ""))
tp_pk = post_data["form-0-id"]
post_data["form-0-DELETE"] = "true"
response = _admin_view_post(client, project, **post_data)
assert (
tp_pk
not in project.translationproject_set.values_list("pk", flat=True))
_test_admin_view(response, project)
assert project.config["pootle.core.lang_mapping"] == {}
@pytest.mark.django_db
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.values(),
'source_language': language_choices,
'defaults': {
'source_language': english.id}}}
for k, v in expected.items():
assert response.context_data[k] == v
@pytest.mark.django_db
def test_admin_view_project_templates(client, admin, project0, templates):
client.login(
username=admin.username,
password=TEST_USERS["admin"]["password"])
response = _admin_view_get(client, project0)
assert response.context["can_add"] is True
assert not response.context["template_path"]
assert not response.context["layout_style"]
project0.translationproject_set.get(
language__code="templates").delete()
response = _admin_view_get(client, project0)
assert response.context["can_add"] is False
assert response.context["layout_style"] == "nongnu"
assert response.context["template_path"] == '"templates"'
project0.config["pootle_fs.translation_mappings"] = dict(
default="/<language_code>.<ext>")
response = _admin_view_get(client, project0)
assert response.context["layout_style"] == "gnu"
assert response.context["template_path"] == '"templates.pot"'
project0.filetypes.add(Format.objects.get(name="xliff"))
response = _admin_view_get(client, project0)
assert response.context["layout_style"] == "gnu"
assert (
response.context["template_path"]
== u'"templates.pot", "templates.xliff"')
| 11,518
|
Python
|
.py
| 275
| 35.112727
| 82
| 0.67496
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,962
|
core.py
|
translate_pootle/tests/views/core.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from pootle.core.views import PootleJSON
def test_view_pootle_json():
json_test = PootleJSON()
ctx = dict(foo="bar")
assert json_test.get_response_data(ctx) == ctx
| 454
|
Python
|
.py
| 12
| 35.583333
| 77
| 0.738041
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,963
|
bad.py
|
translate_pootle/tests/views/bad.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
@pytest.mark.django_db
def test_views_bad(bad_views):
path_, response, test = bad_views
assert response.status_code == test["code"]
if test.get("location"):
assert response.get("location") == test["location"]
| 521
|
Python
|
.py
| 14
| 34.571429
| 77
| 0.724206
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,964
|
unit.py
|
translate_pootle/tests/views/unit.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import json
import pytest
from django.http import Http404, QueryDict
from pytest_pootle.utils import create_api_request
from translate.misc.multistring import multistring
from pootle.core.exceptions import Http400
from pootle_app.models.permissions import check_permission
from pootle_comment import get_model as get_comment_model
from pootle_statistics.models import SubmissionFields, SubmissionTypes
from pootle_store.constants import FUZZY, TRANSLATED, UNTRANSLATED
from pootle_store.models import QualityCheck, Suggestion, Unit, UnitChange
from pootle_store.views import get_units, toggle_qualitycheck
@pytest.mark.django_db
def test_get_units(rf, default):
"""Tests units can be retrieved."""
view = get_units
# `path` query parameter missing
request = create_api_request(rf, user=default)
with pytest.raises(Http400):
view(request)
# `path` query parameter present
request = create_api_request(rf, url='/?path=foo', user=default)
with pytest.raises(Http404):
view(request)
@pytest.mark.django_db
def test_get_units_ordered(rf, default, admin, numbered_po):
"""Tests units can be retrieved while applying order filters."""
view = get_units
tp = numbered_po.translation_project
url = (
'/?path=/%s/%s/&filter=incomplete&sort=newest&initial=true'
% (tp.language.code, tp.project.code))
request = create_api_request(rf, url=url, user=default)
response = view(request)
assert response.status_code == 200
request = create_api_request(rf, url=url, user=admin)
response = view(request)
assert response.status_code == 200
@pytest.mark.django_db
def test_submit_with_suggestion_and_comment(client, request_users,
settings, system):
"""Tests translation can be applied after suggestion is accepted."""
settings.POOTLE_CAPTCHA_ENABLED = False
Comment = get_comment_model()
unit = Unit.objects.filter(
suggestion__state__name='pending',
state=UNTRANSLATED)[0]
last_sub_pk = unit.submission_set.order_by(
"id").values_list("id", flat=True).last() or 0
sugg = Suggestion.objects.filter(unit=unit, state__name='pending')[0]
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/' % unit.id
edited_target = "Edited %s" % sugg.target_f
comment = 'This is a comment!'
qdict = QueryDict(mutable=True)
qdict.update(
{'state': False,
'target_f_0': edited_target,
'suggestion': sugg.id,
'comment': comment})
qdict._mutable = False
response = client.post(
url,
qdict,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
suggestion = Suggestion.objects.get(id=sugg.id)
unit = Unit.objects.get(id=unit.id)
new_subs = unit.submission_set.filter(id__gt=last_sub_pk).order_by("id")
if check_permission('translate', response.wsgi_request):
assert response.status_code == 200
content = json.loads(response.content)
assert content['newtargets'] == [edited_target]
assert content['user_score'] == response.wsgi_request.user.public_score
assert content['checks'] is None
unit_source = unit.unit_source
assert unit_source.created_by == system
assert unit_source.created_with == SubmissionTypes.SYSTEM
assert unit.change.submitted_by == suggestion.user
if user == suggestion.user:
assert unit.change.reviewed_by is None
assert unit.change.reviewed_on is None
else:
assert unit.change.reviewed_by == user
assert unit.change.reviewed_on == unit.mtime
assert unit.change.changed_with == SubmissionTypes.WEB
assert suggestion.state.name == 'accepted'
assert suggestion.is_accepted
assert str(unit.target) == edited_target
assert (Comment.objects
.for_model(suggestion)
.get().comment == comment)
assert new_subs.count() == 2
target_sub = new_subs[0]
assert target_sub.old_value == ""
assert target_sub.new_value == unit.target
assert target_sub.field == SubmissionFields.TARGET
assert target_sub.type == SubmissionTypes.WEB
assert target_sub.submitter == unit.change.submitted_by
assert target_sub.suggestion == suggestion
assert target_sub.revision == unit.revision
assert target_sub.creation_time == unit.mtime
state_sub = new_subs[1]
assert state_sub.old_value == str(UNTRANSLATED)
assert state_sub.new_value == str(unit.state)
assert state_sub.suggestion == suggestion
assert state_sub.field == SubmissionFields.STATE
assert state_sub.type == SubmissionTypes.WEB
assert state_sub.submitter == unit.change.submitted_by
assert state_sub.revision == unit.revision
assert state_sub.creation_time == unit.mtime
else:
assert response.status_code == 403
assert suggestion.state.name == "pending"
assert suggestion.is_pending
assert unit.target == ""
assert new_subs.count() == 0
with pytest.raises(UnitChange.DoesNotExist):
unit.change
@pytest.mark.django_db
def test_submit_with_suggestion(client, request_users, settings, system):
"""Tests translation can be applied after suggestion is accepted."""
settings.POOTLE_CAPTCHA_ENABLED = False
unit = Unit.objects.filter(suggestion__state__name='pending',
state=UNTRANSLATED).first()
last_sub_pk = unit.submission_set.order_by(
"-pk").values_list("pk", flat=True).first() or 0
sugg = Suggestion.objects.filter(unit=unit, state__name='pending').first()
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/' % unit.id
response = client.post(
url,
{
'state': False,
'target_f_0': sugg.target_f,
'suggestion': sugg.id,
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest'
)
suggestion = Suggestion.objects.get(id=sugg.id)
unit = Unit.objects.get(id=unit.id)
new_subs = unit.submission_set.filter(id__gt=last_sub_pk)
if check_permission('translate', response.wsgi_request):
assert response.status_code == 200
unit_source = unit.unit_source
assert unit_source.created_by == system
assert unit_source.created_with == SubmissionTypes.SYSTEM
assert unit.change.submitted_by == suggestion.user
if user == suggestion.user:
assert unit.change.reviewed_by is None
else:
assert unit.change.reviewed_by == user
assert unit.change.changed_with == SubmissionTypes.WEB
assert suggestion.state.name == 'accepted'
assert suggestion.is_accepted
assert str(unit.target) == sugg.target_f
assert new_subs.count() == 2
target_sub = new_subs[0]
assert target_sub.suggestion == suggestion
assert target_sub.field == SubmissionFields.TARGET
assert target_sub.type == SubmissionTypes.WEB
assert target_sub.submitter == suggestion.user
state_sub = new_subs[1]
assert state_sub.suggestion == suggestion
assert state_sub.field == SubmissionFields.STATE
assert state_sub.type == SubmissionTypes.WEB
assert state_sub.submitter == suggestion.user
else:
assert response.status_code == 403
assert new_subs.count() == 0
assert suggestion.state.name == "pending"
assert suggestion.is_pending
assert unit.target == ""
with pytest.raises(UnitChange.DoesNotExist):
unit.change
@pytest.mark.django_db
def test_accept_suggestion_with_comment(client, request_users, settings, system):
"""Tests suggestion can be accepted with a comment."""
settings.POOTLE_CAPTCHA_ENABLED = False
Comment = get_comment_model()
unit = Unit.objects.filter(suggestion__state__name='pending',
state=UNTRANSLATED)[0]
sugg = Suggestion.objects.filter(unit=unit, state__name='pending')[0]
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/suggestions/%d/' % (unit.id, sugg.id)
comment = 'This is a comment!'
response = client.post(
url,
{
'comment': comment
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest'
)
suggestion = Suggestion.objects.get(id=sugg.id)
unit = Unit.objects.get(id=unit.id)
if check_permission('review', response.wsgi_request):
assert response.status_code == 200
unit_source = unit.unit_source
assert unit_source.created_by == system
assert unit_source.created_with == SubmissionTypes.SYSTEM
assert unit.change.submitted_by == suggestion.user
assert unit.change.reviewed_by == user
assert unit.change.changed_with == SubmissionTypes.WEB
assert suggestion.state.name == 'accepted'
assert suggestion.is_accepted
assert str(unit.target) == str(suggestion.target)
assert (Comment.objects
.for_model(suggestion)
.get().comment == comment)
else:
assert response.status_code == 404
assert suggestion.state.name == "pending"
assert suggestion.is_pending
assert unit.target == ""
with pytest.raises(UnitChange.DoesNotExist):
unit.change
@pytest.mark.django_db
def test_reject_suggestion_with_comment(client, request_users):
"""Tests suggestion can be rejected with a comment."""
Comment = get_comment_model()
unit = Unit.objects.filter(suggestion__state__name='pending',
state=UNTRANSLATED)[0]
sugg = Suggestion.objects.filter(unit=unit, state__name='pending')[0]
comment = 'This is a comment!'
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/suggestions/%d/' % (unit.id, sugg.id)
response = client.delete(
url,
'comment=%s' % comment,
HTTP_X_REQUESTED_WITH='XMLHttpRequest'
)
can_reject = (
check_permission('review', response.wsgi_request)
or sugg.user.id == user.id
)
suggestion = Suggestion.objects.get(id=sugg.id)
if can_reject:
assert response.status_code == 200
assert suggestion.state.name == 'rejected'
assert suggestion.is_rejected
assert unit.target == ""
# unit is untranslated so no change
with pytest.raises(UnitChange.DoesNotExist):
unit.change
assert (Comment.objects
.for_model(suggestion)
.get().comment == comment)
else:
assert response.status_code == 404
assert unit.target == ""
assert suggestion.state.name == "pending"
assert suggestion.is_pending
with pytest.raises(UnitChange.DoesNotExist):
unit.change
@pytest.mark.django_db
def test_non_pending_suggestion(client, request_users, member, system):
unit = Unit.objects.filter(
suggestion__state__name='accepted')[0]
unit.target = "EXISTING TARGET"
unit.save(
user=member,
changed_with=SubmissionTypes.UPLOAD)
suggestion = Suggestion.objects.filter(
unit=unit,
state__name='accepted')[0]
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = (
'/xhr/units/%d/suggestions/%d/'
% (unit.id, suggestion.id))
response = client.delete(
url,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
can_review = (
check_permission('review', response.wsgi_request)
or suggestion.user.id == user.id)
if can_review:
assert response.status_code == 400
else:
assert response.status_code == 404
@pytest.mark.django_db
def test_reject_translated_suggestion(client, request_users, member, system):
"""Tests suggestion can be rejected with a comment."""
unit = Unit.objects.filter(
suggestion__state__name='pending',
state=UNTRANSLATED)[0]
unit.target = "EXISTING TARGET"
unit.save(
user=member,
changed_with=SubmissionTypes.UPLOAD)
suggestion = Suggestion.objects.filter(
unit=unit,
state__name='pending')[0]
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = (
'/xhr/units/%d/suggestions/%d/'
% (unit.id, suggestion.id))
response = client.delete(
url,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
can_reject = (
check_permission('review', response.wsgi_request)
or suggestion.user.id == user.id)
unit.refresh_from_db()
unit.change.refresh_from_db()
unit_source = unit.unit_source
suggestion.refresh_from_db()
if can_reject:
assert response.status_code == 200
assert suggestion.state.name == 'rejected'
assert suggestion.is_rejected
assert unit_source.created_by == system
assert unit.change.changed_with == SubmissionTypes.UPLOAD
assert unit.change.submitted_by == member
assert unit.change.reviewed_by == user
else:
assert response.status_code == 404
assert unit.target == "EXISTING TARGET"
assert suggestion.state.name == "pending"
assert suggestion.is_pending
@pytest.mark.django_db
def test_toggle_quality_check(rf, admin, member):
"""Tests the view that mutes/unmutes quality checks."""
qc_filter = dict(
false_positive=False,
unit__state=TRANSLATED,
unit__store__translation_project__project__disabled=False,
)
qc = QualityCheck.objects.filter(**qc_filter).first()
unit = qc.unit
unit.change.reviewed_by = member
unit.change.save()
# Explicit POST data present, mute
data = 'mute='
request = create_api_request(rf, method='post', user=admin, data=data,
encode_as_json=False)
response = toggle_qualitycheck(request, unit.id, qc.id)
assert response.status_code == 200
assert QualityCheck.objects.get(id=qc.id).false_positive is True
sub = unit.submission_set.get(quality_check=qc)
assert sub.submitter == admin
unit.change.refresh_from_db()
assert unit.change.reviewed_by == admin
unit.change.reviewed_by = member
unit.change.save()
# No POST data present, unmute
request = create_api_request(rf, method='post', user=admin)
response = toggle_qualitycheck(request, unit.id, qc.id)
assert response.status_code == 200
assert QualityCheck.objects.get(id=qc.id).false_positive is False
sub = unit.submission_set.get(id__gt=sub.id, quality_check=qc)
assert sub.submitter == admin
unit.change.refresh_from_db()
assert unit.change.reviewed_by == admin
@pytest.mark.django_db
def test_submit_unit_plural(client, unit_plural, request_users, settings):
"""Tests translation can be applied after suggestion is accepted."""
settings.POOTLE_CAPTCHA_ENABLED = False
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/' % unit_plural.id
original_target = unit_plural.target
target = [
"%s" % unit_plural.target.strings[0],
"%s changed" % unit_plural.target.strings[1]
]
response = client.post(
url,
{'target_f_0': target[0],
'target_f_1': target[1],
'is_fuzzy': "0"},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
unit = Unit.objects.get(id=unit_plural.id)
if check_permission('translate', response.wsgi_request):
assert response.status_code == 200
assert unit.target == multistring(target)
else:
assert response.status_code == 403
assert unit.target == original_target
with pytest.raises(UnitChange.DoesNotExist):
unit.change
@pytest.mark.django_db
def test_add_suggestion(client, request_users, settings):
"""Tests translation can be applied after suggestion is accepted."""
settings.POOTLE_CAPTCHA_ENABLED = False
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
unit = Unit.objects.all().first()
url = '/xhr/units/%d/suggestions' % unit.id
target = "%s TEST SUGGESTION" % unit.source
response = client.post(
url,
{
'target_f_0': target,
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest'
)
assert response.status_code == 200
changed = Unit.objects.get(id=unit.id)
suggestion = changed.get_suggestions().order_by('id').last()
assert suggestion.target == multistring(target)
with pytest.raises(UnitChange.DoesNotExist):
unit.change
@pytest.mark.django_db
def test_add_suggestion_same_as_target(client, request_users, settings):
"""Tests suggestion equal to target cannot be added."""
settings.POOTLE_CAPTCHA_ENABLED = False
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
unit = Unit.objects.filter(state=TRANSLATED).first()
suggestion_count = unit.suggestion_set.count()
url = '/xhr/units/%d/suggestions' % unit.id
response = client.post(
url,
{
'target_f_0': unit.target,
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest'
)
assert response.status_code == 400
assert suggestion_count == unit.suggestion_set.count()
@pytest.mark.django_db
def test_add_suggestion_same_as_pending(client, request_users, settings):
"""Tests suggestion equal to target cannot be added."""
settings.POOTLE_CAPTCHA_ENABLED = False
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
suggestion = Suggestion.objects.filter(state__name='pending').first()
unit = suggestion.unit
suggestion_count = unit.suggestion_set.count()
url = '/xhr/units/%d/suggestions' % unit.id
response = client.post(
url,
{
'target_f_0': suggestion.target,
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest'
)
assert response.status_code == 400
assert suggestion_count == unit.suggestion_set.count()
@pytest.mark.django_db
def test_submit_unit(client, store0, request_users, settings, system):
"""Tests translation can be applied after suggestion is accepted."""
settings.POOTLE_CAPTCHA_ENABLED = False
user = request_users["user"]
unit = store0.units.filter(state=UNTRANSLATED).first()
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/' % unit.id
old_target = unit.target
response = client.post(
url,
dict(target_f_0=("%s changed" % unit.target),
is_fuzzy="0",
sfn="PTL.editor.processSubmission"),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
unit.refresh_from_db()
if user.username == "nobody":
assert response.status_code == 403
assert unit.target == ""
with pytest.raises(UnitChange.DoesNotExist):
unit.change
return
assert response.status_code == 200
assert unit.target == "%s changed" % old_target
assert unit.state == TRANSLATED
unit.store.data.refresh_from_db()
assert unit.store.data.last_submission.unit == unit
unit_source = unit.unit_source
unit.refresh_from_db()
assert unit_source.created_by == system
assert unit_source.created_with == SubmissionTypes.SYSTEM
assert unit.change.changed_with == SubmissionTypes.WEB
assert unit.change.submitted_by == user
assert unit.change.reviewed_by is None
@pytest.mark.django_db
def test_submit_fuzzy_unit(client, store0, request_users, settings, system):
"""Test un/fuzzying units."""
settings.POOTLE_CAPTCHA_ENABLED = False
user = request_users["user"]
unit = store0.units.filter(state=UNTRANSLATED).first()
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/' % unit.id
old_target = unit.target
new_target = "%s changed" % unit.target
response = client.post(
url,
dict(target_f_0=(new_target),
is_fuzzy="1",
sfn="PTL.editor.processSubmission"),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
unit.refresh_from_db()
if check_permission('translate', response.wsgi_request):
assert response.status_code == 200
assert unit.state == FUZZY
assert unit.target == new_target
else:
assert response.status_code == 403
assert unit.state == UNTRANSLATED
assert unit.target == old_target
response = client.post(
url,
dict(target_f_0=(new_target),
is_fuzzy="0",
sfn="PTL.editor.processSubmission"),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
unit.refresh_from_db()
if check_permission('translate', response.wsgi_request):
assert response.status_code == 200
assert unit.state == TRANSLATED
assert unit.target == new_target
else:
assert response.status_code == 403
assert unit.state == UNTRANSLATED
assert unit.target == old_target
# state is always untranslated if target is empty
response = client.post(
url,
dict(target_f_0="",
is_fuzzy="1",
sfn="PTL.editor.processSubmission"),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
unit.refresh_from_db()
if check_permission('translate', response.wsgi_request):
assert response.status_code == 200
assert unit.target == ""
else:
assert response.status_code == 403
assert unit.target == old_target
assert unit.state == UNTRANSLATED
| 23,222
|
Python
|
.py
| 576
| 32.725694
| 81
| 0.653412
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,965
|
models.py
|
translate_pootle/tests/pootle_app/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.delegate import revision
from pootle_app.models import Directory
@pytest.mark.django_db
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")
| 1,376
|
Python
|
.py
| 30
| 42.3
| 84
| 0.730798
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,966
|
forms.py
|
translate_pootle/tests/pootle_app/forms.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_app.forms import PermissionsUsersSearchForm
from pootle_app.models.permissions import PermissionSet, get_pootle_permission
@pytest.mark.django_db
def test_form_permissions_users(project0, member, member2):
# must supply a directory
with pytest.raises(KeyError):
PermissionsUsersSearchForm()
form = PermissionsUsersSearchForm(
directory=project0.directory, data={})
assert not form.is_valid()
assert "q" in form.errors
form = PermissionsUsersSearchForm(
directory=project0.directory,
data=dict(q="mem"))
assert form.is_valid()
assert form.cleaned_data == dict(q="mem")
results = form.search()["results"]
assert results[0]['text'] == member.username
assert results[0]['id'] == member.pk
assert results[1]['text'] == member2.username
assert results[1]['id'] == member2.pk
# providing a user with permissions in this directory
# means they are excluded from search results
view = get_pootle_permission('view')
perm_set = PermissionSet.objects.create(
user=member,
directory=project0.directory)
perm_set.positive_permissions.add(view)
assert form.search() == {
'results': [
{'text': member2.username, 'id': member2.pk}]}
| 1,571
|
Python
|
.py
| 39
| 35.333333
| 78
| 0.710907
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,967
|
views.py
|
translate_pootle/tests/pootle_app/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import json
import pytest
from django.utils.translation import get_language
from django.urls import reverse
from pootle.core.decorators import Http400
from pootle.core.delegate import revision
from pootle_app.views.index.index import (
COOKIE_NAME, IndexView, WelcomeView)
from pootle_language.models import Language
from pootle_score.display import TopScoreDisplay
from pootle_translationproject.models import TranslationProject
@pytest.mark.django_db
def test_view_index(client, rf, request_users, language0):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get("")
if not user.is_authenticated:
assert response.status_code == 200
assert isinstance(response.context["view"], WelcomeView)
else:
assert response.status_code == 302
assert response["Location"] == reverse("pootle-projects-browse")
request = rf.get("")
request.user = user
request.COOKIES[COOKIE_NAME] = language0.code
response = IndexView.as_view()(request=request)
if not user.is_authenticated:
assert response.status_code == 200
else:
assert response.status_code == 302
assert response["Location"] == reverse(
"pootle-language-browse",
kwargs=dict(language_code=language0.code))
@pytest.mark.django_db
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())))
@pytest.mark.django_db
def test_view_index_redirect(client, language0, project0, request_users):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get("/")
if user.is_authenticated:
assert response.status_code == 302
assert response.url == "/projects/"
else:
assert response.status_code == 200
# cookie test
client.cookies["pootle-language"] = language0.code
response = client.get("/")
if user.is_authenticated:
assert response.status_code == 302
assert response.url == "/%s/" % language0.code
else:
assert response.status_code == 200
# accept lang test
del client.cookies["pootle-language"]
es = Language.objects.create(code="es")
TranslationProject.objects.create(language=es, project=project0)
response = client.get("/", HTTP_ACCEPT_LANGUAGE="es")
if user.is_authenticated:
assert response.status_code == 302
assert response.url == "/es/"
else:
assert response.status_code == 200
@pytest.mark.django_db
def test_view_user_permissions_json(client, request_users, project0,
member, member2):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get(
reverse(
'pootle-permissions-users',
kwargs=dict(directory=project0.directory.pk)))
if not user.is_superuser:
assert response.status_code == 403
return
result = json.loads(response.content)
assert result["items"] == []
with pytest.raises(Http400):
client.post(
reverse(
'pootle-permissions-users',
kwargs=dict(directory=project0.directory.pk)))
response = client.post(
reverse(
'pootle-permissions-users',
kwargs=dict(directory=project0.directory.pk)),
dict(q="mem"))
results = json.loads(response.content)["items"]["results"]
assert results[0]['text'] == member.username
assert results[0]['id'] == member.pk
assert results[1]['text'] == member2.username
assert results[1]['id'] == member2.pk
| 4,763
|
Python
|
.py
| 123
| 32.02439
| 77
| 0.670919
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,968
|
versioned.py
|
translate_pootle/tests/pootle_store/versioned.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.delegate import versioned
from pootle_store.models import Store
@pytest.mark.django_db
def test_versioned_store(store0):
versions = versioned.get(Store)(store0)
unit = store0.units[0]
rev0 = dict(
revision=store0.data.max_unit_revision,
translated=unit.istranslated(),
target=unit.target,
fuzzy=unit.isfuzzy(),
obsolete=unit.isobsolete())
unit.target = "changed target"
unit.save()
old_store = versions.at_revision(rev0["revision"])
old_unit = old_store.findid(unit.getid())
assert old_unit.target == rev0["target"]
assert old_unit.isfuzzy() == rev0["fuzzy"]
assert old_unit.istranslated() == rev0["translated"]
assert old_unit.isobsolete() == rev0["obsolete"]
unit = store0.units[0]
rev1 = dict(
revision=store0.data.max_unit_revision,
translated=unit.istranslated(),
target=unit.target,
fuzzy=unit.isfuzzy(),
obsolete=unit.isobsolete())
unit.target = "changed target again"
unit.save()
old_store = versions.at_revision(rev1["revision"])
old_unit = old_store.findid(unit.getid())
assert old_unit.target == rev1["target"]
assert old_unit.isfuzzy() == rev1["fuzzy"]
assert old_unit.istranslated() == rev1["translated"]
assert old_unit.isobsolete() == rev1["obsolete"]
unit = store0.units[0]
rev2 = dict(
revision=store0.data.max_unit_revision,
translated=unit.istranslated(),
target=unit.target,
fuzzy=unit.isfuzzy(),
obsolete=unit.isobsolete())
unit.markfuzzy()
unit.save()
old_store = versions.at_revision(rev2["revision"])
old_unit = old_store.findid(unit.getid())
assert old_unit.target == rev2["target"]
assert old_unit.isfuzzy() == rev2["fuzzy"]
assert old_unit.istranslated() == rev2["translated"]
assert old_unit.isobsolete() == rev2["obsolete"]
unit = store0.units[0]
rev3 = dict(
revision=store0.data.max_unit_revision,
translated=unit.istranslated(),
target=unit.target,
fuzzy=unit.isfuzzy(),
obsolete=unit.isobsolete())
unit.markfuzzy(False)
unit.save()
old_store = versions.at_revision(rev3["revision"])
old_unit = old_store.findid(unit.getid())
assert old_unit.target == rev3["target"]
assert old_unit.isfuzzy() == rev3["fuzzy"]
assert old_unit.istranslated() == rev3["translated"]
assert old_unit.isobsolete() == rev3["obsolete"]
old_store = versions.at_revision(rev2["revision"])
old_unit = old_store.findid(unit.getid())
assert old_unit.target == rev2["target"]
assert old_unit.isfuzzy() == rev2["fuzzy"]
assert old_unit.istranslated() == rev2["translated"]
assert old_unit.isobsolete() == rev2["obsolete"]
old_store = versions.at_revision(rev1["revision"])
old_unit = old_store.findid(unit.getid())
assert old_unit.target == rev1["target"]
assert old_unit.isfuzzy() == rev1["fuzzy"]
assert old_unit.istranslated() == rev1["translated"]
assert old_unit.isobsolete() == rev1["obsolete"]
old_store = versions.at_revision(rev0["revision"])
old_unit = old_store.findid(unit.getid())
assert old_unit.target == rev0["target"]
assert old_unit.isfuzzy() == rev0["fuzzy"]
assert old_unit.istranslated() == rev0["translated"]
assert old_unit.isobsolete() == rev0["obsolete"]
| 3,690
|
Python
|
.py
| 91
| 35.120879
| 77
| 0.673998
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,969
|
models.py
|
translate_pootle/tests/pootle_store/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_store.constants import UNTRANSLATED
@pytest.mark.django_db
def test_store_update_new_unit_revision(store0):
new_store = store0.deserialize(store0.serialize())
new_unit = new_store.units[1].copy()
new_unit.source = "INSERTED UNIT"
new_store.units = new_store.units + [new_unit]
store0.update(
new_store,
store_revision=store0.data.max_unit_revision + 1)
new_unit = store0.units.get(source_f="INSERTED UNIT")
creation_revision = new_unit.unit_source.creation_revision
assert creation_revision
assert creation_revision == store0.data.max_unit_revision
new_unit.source_f = "NEW SOURCE"
new_unit.save()
unit_source = new_unit.unit_source.__class__.objects.get(
pk=new_unit.unit_source.pk)
assert new_unit.revision > unit_source.creation_revision
assert unit_source.creation_revision == creation_revision
@pytest.mark.django_db
def test_store_update_source_change_subs(store0, member, system):
unit = store0.units.filter(state=UNTRANSLATED).first()
unit.source = "NEW SOURCE"
unit.save()
created_sub = unit.submission_set.latest()
assert created_sub.submitter == system
unit.source = "SOURCE CHANGED BY USER"
unit.save(user=member)
created_sub = unit.submission_set.latest()
assert created_sub.submitter == member
| 1,631
|
Python
|
.py
| 39
| 37.692308
| 77
| 0.7314
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,970
|
utils.py
|
translate_pootle/tests/pootle_store/utils.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from collections import OrderedDict
import pytest
from translate.filters.decorators import Category
from translate.misc.multistring import multistring
from pytest_pootle.utils import create_store
from pootle.core.delegate import frozen, lifecycle
from pootle.core.user import get_system_user
from pootle_statistics.models import (
MUTED, UNMUTED, Submission, SubmissionFields, SubmissionTypes)
from pootle_store.constants import FUZZY, TRANSLATED
from pootle_store.models import QualityCheck, Unit, UnitChange
from pootle_store.utils import UnitLifecycle
@pytest.mark.django_db
def test_frozen_unit(store0):
unit = store0.units.first()
frozen_unit = frozen.get(Unit)(unit)
assert frozen_unit.source == unit.source_f
assert frozen_unit.target == unit.target_f
assert frozen_unit.state == unit.state
assert frozen_unit.translator_comment == unit.translator_comment
assert frozen_unit.revision == unit.revision
@pytest.mark.django_db
def test_unit_create(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source = multistring("Foo")
unit.index = store0.max_index() + 1
unit.save()
assert unit.submission_set.count() == 0
source = unit.unit_source
assert source.created_by == get_system_user()
assert source.created_with == SubmissionTypes.SYSTEM
with pytest.raises(UnitChange.DoesNotExist):
unit.change
unit = store0.UnitClass()
unit.store = store0
unit.source = multistring("Foo2")
unit.index = store0.max_index() + 1
unit.save(user=member)
assert unit.submission_set.count() == 0
source = unit.unit_source
assert source.created_by == member
assert source.created_with == SubmissionTypes.SYSTEM
with pytest.raises(UnitChange.DoesNotExist):
unit.change
unit = store0.UnitClass()
unit.store = store0
unit.source = multistring("Foo3")
unit.index = store0.max_index() + 1
unit.save(changed_with=SubmissionTypes.UPLOAD)
assert unit.submission_set.count() == 0
source = unit.unit_source
assert source.created_by == get_system_user()
assert source.created_with == SubmissionTypes.UPLOAD
with pytest.raises(UnitChange.DoesNotExist):
unit.change
@pytest.mark.django_db
def test_unit_lifecycle_instance(store0):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
unit_lifecycle = lifecycle.get(Unit)(unit)
assert isinstance(unit_lifecycle, UnitLifecycle)
assert unit_lifecycle.original == unit._frozen
assert unit_lifecycle.unit == unit
assert unit_lifecycle.submission_model == unit.submission_set.model
@pytest.mark.django_db
def test_unit_lifecycle_create(store0):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
source = unit.unit_source
assert source.created_by == get_system_user()
assert source.created_with == SubmissionTypes.SYSTEM
with pytest.raises(UnitChange.DoesNotExist):
unit.change
@pytest.mark.django_db
def test_unit_lifecycle_update_state(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = TRANSLATED
unit.reviewed_by = member
unit.save(user=member)
sub_state_update = lifecycle.get(Unit)(unit).sub_state_update()
assert isinstance(sub_state_update, Submission)
assert sub_state_update.unit == unit
assert sub_state_update.translation_project == store0.translation_project
assert sub_state_update.revision == unit.revision
assert (
sub_state_update.submitter
== unit.change.submitted_by
== member)
assert sub_state_update.type == SubmissionTypes.SYSTEM
assert sub_state_update.field == SubmissionFields.STATE
assert sub_state_update.new_value == unit.state
assert sub_state_update.old_value == unit._frozen.state
assert not sub_state_update.pk
@pytest.mark.django_db
def test_unit_lifecycle_update_state_reviewed_by(store0, system, member2):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = FUZZY
unit.save(user=system)
# force the unit to be refrozen
unit = unit.__class__.objects.get(id=unit.id)
unit.state = TRANSLATED
unit.save(reviewed_by=member2)
sub_state_update = lifecycle.get(Unit)(unit).sub_state_update()
assert isinstance(sub_state_update, Submission)
assert sub_state_update.unit == unit
assert sub_state_update.translation_project == store0.translation_project
assert sub_state_update.revision == unit.revision
assert (
sub_state_update.submitter
== unit.change.reviewed_by
== member2)
assert sub_state_update.type == SubmissionTypes.SYSTEM
assert sub_state_update.field == SubmissionFields.STATE
assert sub_state_update.new_value == unit.state
assert sub_state_update.old_value == unit._frozen.state
assert not sub_state_update.pk
@pytest.mark.django_db
def test_unit_lifecycle_update_comment(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.translator_comment = "SOME COMMENT"
unit.save(user=member)
sub_comment_update = lifecycle.get(Unit)(unit).sub_comment_update()
assert isinstance(sub_comment_update, Submission)
assert sub_comment_update.unit == unit
assert sub_comment_update.translation_project == store0.translation_project
assert sub_comment_update.revision == unit.revision
assert sub_comment_update.submitter == member
assert sub_comment_update.type == SubmissionTypes.SYSTEM
assert sub_comment_update.field == SubmissionFields.COMMENT
assert sub_comment_update.new_value == unit.translator_comment
assert sub_comment_update.old_value == (
unit._frozen.translator_comment or "")
assert not sub_comment_update.pk
@pytest.mark.django_db
def test_unit_lifecycle_update_source(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.source_f = multistring("Bar")
unit.state = TRANSLATED
unit.save(user=member)
unit = Unit.objects.get(pk=unit.id)
unit.source = multistring("Foo23")
unit.save(user=member)
sub_source_update = lifecycle.get(Unit)(unit).sub_source_update()
assert isinstance(sub_source_update, Submission)
assert sub_source_update.unit == unit
assert sub_source_update.translation_project == store0.translation_project
assert sub_source_update.revision == unit.revision
assert sub_source_update.submitter == unit.change.submitted_by
assert sub_source_update.type == SubmissionTypes.SYSTEM
assert sub_source_update.field == SubmissionFields.SOURCE
assert sub_source_update.new_value == unit.source_f
assert sub_source_update.old_value == unit._frozen.source
assert not sub_source_update.pk
@pytest.mark.django_db
def test_unit_lifecycle_update_target(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = TRANSLATED
unit.save(user=member)
sub_target_update = lifecycle.get(Unit)(unit).sub_target_update()
assert isinstance(sub_target_update, Submission)
assert sub_target_update.unit == unit
assert sub_target_update.translation_project == store0.translation_project
assert sub_target_update.revision == unit.revision
assert (
sub_target_update.submitter
== unit.change.submitted_by
== member)
assert sub_target_update.type == SubmissionTypes.SYSTEM
assert sub_target_update.field == SubmissionFields.TARGET
assert sub_target_update.new_value == unit.target_f
assert sub_target_update.old_value == unit._frozen.target
assert not sub_target_update.pk
@pytest.mark.django_db
def test_unit_lifecycle_mute_qc(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
unit_lifecycle = lifecycle.get(Unit)(unit)
qc = QualityCheck(
unit=unit,
name="foo-check",
message="Check foo!",
category="Footile")
with pytest.raises(KeyError):
unit_lifecycle.sub_mute_qc()
with pytest.raises(KeyError):
unit_lifecycle.sub_mute_qc(submitter=member)
with pytest.raises(KeyError):
unit_lifecycle.sub_mute_qc(quality_check=qc)
sub_mute_qc = unit_lifecycle.sub_mute_qc(
quality_check=qc, submitter=member)
assert sub_mute_qc.unit == unit
assert sub_mute_qc.translation_project == store0.translation_project
assert sub_mute_qc.revision == unit.revision
assert sub_mute_qc.type == SubmissionTypes.WEB
assert sub_mute_qc.field == SubmissionFields.CHECK
assert sub_mute_qc.new_value == MUTED
assert sub_mute_qc.old_value == UNMUTED
assert not sub_mute_qc.pk
@pytest.mark.django_db
def test_unit_lifecycle_unmute_qc(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
unit_lifecycle = lifecycle.get(Unit)(unit)
qc = QualityCheck(
unit=unit,
name="foo-check",
message="Check foo!",
category="Footile")
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc()
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc(submitter=member)
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc(quality_check=qc)
sub_unmute_qc = unit_lifecycle.sub_unmute_qc(
quality_check=qc, submitter=member)
assert sub_unmute_qc.unit == unit
assert sub_unmute_qc.translation_project == store0.translation_project
assert sub_unmute_qc.revision == unit.revision
assert sub_unmute_qc.type == SubmissionTypes.WEB
assert sub_unmute_qc.field == SubmissionFields.CHECK
assert sub_unmute_qc.new_value == UNMUTED
assert sub_unmute_qc.old_value == MUTED
assert not sub_unmute_qc.pk
@pytest.mark.django_db
def test_unit_lifecycle_create_subs(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
class DummyUnitLifecycle(UnitLifecycle):
def sub_foo(self, **kwargs):
self._called_foo = kwargs
def sub_bar(self, **kwargs):
self._called_bar = kwargs
lc = DummyUnitLifecycle(unit)
kwargs = dict(x=1, y=2)
list(lc.create_subs(dict(foo=kwargs)))
assert lc._called_foo == kwargs
list(lc.create_subs(dict(bar=kwargs)))
assert lc._called_bar == kwargs
with pytest.raises(AttributeError):
lc.update(dict(baz=kwargs))
@pytest.mark.django_db
def test_unit_lifecycle_update(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
class DummyUnitLifecycle(UnitLifecycle):
def save_subs(self, subs):
self._called_save = subs
def create_subs(self, kwargs):
self._called_create = kwargs
return [kwargs]
lc = DummyUnitLifecycle(unit)
kwargs = OrderedDict((("x", 1), ("y", 2)))
lc.update(kwargs)
assert lc._called_create == kwargs
assert lc._called_save == [kwargs]
@pytest.mark.django_db
def test_unit_lifecycle_calc_change(store0, member):
unit = store0.units.first()
unit_lifecycle = lifecycle.get(Unit)(unit)
assert (
unit_lifecycle.calculate_change()
== OrderedDict())
original_target = unit.target
unit.state = 200
assert (
unit_lifecycle.calculate_change()
== OrderedDict((("state_update", {}),)))
unit.target = "changed target"
assert (
unit_lifecycle.calculate_change()
== OrderedDict(
(("target_update", {}),
("state_update", {}))))
unit.translator_comment = "changed comment"
assert (
unit_lifecycle.calculate_change()
== OrderedDict(
(("comment_update", {}),
("target_update", {}),
("state_update", {}))))
unit.source = "changed source"
assert (
unit_lifecycle.calculate_change()
== OrderedDict(
(("comment_update", {}),
("source_update", {}),
("target_update", {}),
("state_update", {}))))
assert (
unit_lifecycle.calculate_change(foo="bar")
== OrderedDict(
(("comment_update", dict(foo="bar")),
("source_update", dict(foo="bar")),
("target_update", dict(foo="bar")),
("state_update", dict(foo="bar")))))
unit.target = original_target
assert (
unit_lifecycle.calculate_change()
== OrderedDict(
(("comment_update", {}),
("source_update", {}),
("state_update", {}))))
@pytest.mark.django_db
def test_unit_lifecycle_change(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
class DummyUnitLifecycle(UnitLifecycle):
def update(self, updates):
self._called_update = updates
def calculate_change(self, **kwargs):
return kwargs
lc = DummyUnitLifecycle(unit)
lc.change()
assert lc._called_update == {}
lc.change(foo="bar")
assert lc._called_update == dict(foo="bar")
@pytest.mark.django_db
def test_mute_qualitycheck(store_po, member):
store = create_store(pootle_path=store_po.pootle_path, units=[
("Hello", "", False)
])
store.units[1].target = "Hello\n\nHello"
store_po.update(store)
unit = store_po.units.first()
unit.save()
check_qs = unit.qualitycheck_set.filter(
category=Category.CRITICAL,
false_positive=False)
assert check_qs.count() == 1
assert store_po.data.critical_checks == 1
check_id = check_qs[0].id
unit.toggle_qualitycheck(check_id=check_id, false_positive=True,
user=member)
assert unit.qualitycheck_set.get(id=check_id).false_positive
assert store_po.data.critical_checks == 0
sub = unit.submission_set.get(quality_check__id=check_id)
assert sub.submitter == member
| 14,727
|
Python
|
.py
| 374
| 33.572193
| 79
| 0.692609
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,971
|
timeline.py
|
translate_pootle/tests/pootle_store/timeline.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from datetime import timedelta
from translate.filters.decorators import Category
from django.urls import reverse
from django.utils import timezone
from django.utils.html import format_html
from accounts.proxy import DisplayUser
from pootle.core.delegate import comparable_event, grouped_events, review
from pootle_checks.constants import CHECK_NAMES
from pootle_comment.forms import UnsecuredCommentForm
from pootle_store.constants import (
FUZZY, STATES_MAP, TRANSLATED, UNTRANSLATED)
from pootle_statistics.models import Submission, SubmissionFields
from pootle_store.fields import to_python
from pootle_store.models import QualityCheck, Suggestion, Unit
from pootle_store.unit.timeline import (
ACTION_ORDER, ComparableUnitTimelineLogEvent as ComparableLogEvent,
UnitTimelineGroupedEvents as GroupedEvents, Timeline, UnitTimelineLog)
def _latest_submission(unit, limit):
return [
x for x in unit.submission_set.order_by('-id')[:limit]]
def _get_group_user(group):
for event in group:
if event.action == 'suggestion_accepted':
return event.user
return group[0].user
def _format_dt(dt, no_microseconds=False):
if no_microseconds:
return dt.strftime("%Y-%m-%d %H:%M:%S")
return dt.strftime("%Y-%m-%d %H:%M:%S:%f")
@pytest.mark.django_db
def test_timeline_groups(store0, admin, member, member2, system):
expected = []
# 8 - unit_created
unit = store0.addunit(store0.UnitClass(source="Foo"), user=system)
unit.refresh_from_db()
current_time = unit.creation_time.replace(microsecond=0)
no_microseconds = (unit.creation_time == current_time)
if no_microseconds:
Unit.objects.filter(id=unit.id).update(
creation_time=current_time)
unit.refresh_from_db()
expected[:0] = [(set(['unit_created']),
_format_dt(unit.creation_time, no_microseconds),
system)]
# 7 - suggestion_created
suggestion_0, __ = review.get(Suggestion)().add(
unit,
"Suggestion for Foo",
user=member)
if no_microseconds:
current_time += timedelta(seconds=1)
Suggestion.objects.filter(id=suggestion_0.id).update(
creation_time=current_time)
suggestion_0.refresh_from_db()
expected[:0] = [(set(['suggestion_created']),
_format_dt(suggestion_0.creation_time, no_microseconds),
member)]
# 6 - suggestion_created
suggestion_1, __ = review.get(Suggestion)().add(
unit,
"Another suggestion for Foo",
user=member2)
if no_microseconds:
current_time += timedelta(seconds=1)
Suggestion.objects.filter(id=suggestion_1.id).update(
creation_time=current_time)
suggestion_1.refresh_from_db()
expected[:0] = [(set(['suggestion_created']),
_format_dt(suggestion_1.creation_time, no_microseconds),
member2)]
# 5 - comment_updated
unit.translator_comment = "This is a comment!"
unit.save(user=member)
submission = _latest_submission(unit, 1)[0]
if no_microseconds:
current_time += timedelta(seconds=1)
Submission.objects.filter(id=submission.id).update(
creation_time=current_time)
submission.refresh_from_db()
unit.refresh_from_db()
expected[:0] = [(set(['comment_updated']),
_format_dt(submission.creation_time, no_microseconds),
member)]
# 4 - suggestion_accepted, target_updated, state_changed
review.get(Suggestion)([suggestion_0], admin).accept()
if no_microseconds:
current_time += timedelta(seconds=1)
Suggestion.objects.filter(id=suggestion_0.id).update(
review_time=current_time)
Submission.objects.filter(suggestion_id=suggestion_0.id).update(
creation_time=current_time)
suggestion_0.refresh_from_db()
unit.refresh_from_db()
expected[:0] = [(set(['suggestion_accepted', 'target_updated',
'state_changed']),
_format_dt(suggestion_0.review_time, no_microseconds),
admin)]
# 3 - target_updated
unit.target = "Overwritten translation for Foo"
unit.save(user=member2)
submission = _latest_submission(unit, 1)[0]
if no_microseconds:
current_time += timedelta(seconds=1)
Submission.objects.filter(id=submission.id).update(
creation_time=current_time)
submission.refresh_from_db()
unit.refresh_from_db()
expected[:0] = [(set(['target_updated']),
_format_dt(submission.creation_time, no_microseconds),
member2)]
# 2 - target_updated, state_changed
unit.target = ""
unit.save(user=admin)
submissions = _latest_submission(unit, 2)
if no_microseconds:
current_time += timedelta(seconds=1)
Submission.objects.filter(id__in=[x.id for x in submissions]).update(
creation_time=current_time)
for sub in submissions:
sub.refresh_from_db()
unit.refresh_from_db()
expected[:0] = [(set(['target_updated', 'state_changed']),
_format_dt(submissions[0].creation_time, no_microseconds),
admin)]
# 1 - suggestion_rejected
review.get(Suggestion)([suggestion_1], admin).reject()
if no_microseconds:
current_time += timedelta(seconds=1)
Suggestion.objects.filter(id=suggestion_1.id).update(
review_time=current_time)
suggestion_1.refresh_from_db()
expected[:0] = [(set(['suggestion_rejected']),
_format_dt(suggestion_1.review_time, no_microseconds),
admin)]
# 0 - comment_updated
unit.translator_comment = ""
unit.save(user=admin)
submission = _latest_submission(unit, 1)[0]
if no_microseconds:
current_time += timedelta(seconds=1)
Submission.objects.filter(id=submission.id).update(
creation_time=current_time)
submission.refresh_from_db()
unit.refresh_from_db()
expected[:0] = [(set(['comment_updated']),
_format_dt(submission.creation_time, no_microseconds),
admin)]
log = UnitTimelineLog(unit)
grouped_events_class = grouped_events.get(log.__class__)
assert grouped_events_class == GroupedEvents
groups = [list(x) for _j, x in grouped_events_class(log).grouped_events()]
result = [(set([y.action for y in x]),
_format_dt(x[0].timestamp, no_microseconds),
_get_group_user(x)) for x in groups]
assert expected == result
@pytest.mark.django_db
def test_comparable_unit_timelime_log(member, store0):
assert comparable_event.get(UnitTimelineLog) == ComparableLogEvent
start = timezone.now().replace(microsecond=0)
unit = store0.units.filter(state=TRANSLATED).first()
unit.target += 'UPDATED IN TEST'
unit.save(user=member)
unit = store0.units.filter(state=TRANSLATED).first()
unit.target += 'UPDATED IN TEST AGAIN'
unit.save(user=member)
unit_log = UnitTimelineLog(unit)
event1, event2 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)]
assert (event1 < event2) == (event1.revision < event2.revision)
assert (event2 < event1) == (event2.revision < event1.revision)
unit = store0.units.filter(state=UNTRANSLATED).first()
sugg1, created_ = review.get(Suggestion)().add(
unit,
unit.source_f + 'SUGGESTION',
user=member)
sugg2, created_ = review.get(Suggestion)().add(
unit,
unit.source_f + 'SUGGESTION AGAIN',
user=member)
unit_log = UnitTimelineLog(unit)
Suggestion.objects.filter(id=sugg2.id).update(
creation_time=sugg1.creation_time + timedelta(seconds=1))
event1, event2 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)]
assert (event1 < event2) == (event1.timestamp < event2.timestamp)
assert (event2 < event1) == (event2.timestamp < event1.timestamp)
Suggestion.objects.filter(id=sugg2.id).update(
creation_time=sugg1.creation_time)
event1, event2 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)]
assert (event1 < event2) == (event1.value.pk < event2.value.pk)
assert (event2 < event1) == (event2.value.pk < event1.value.pk)
Suggestion.objects.filter(id=sugg2.id).update(creation_time=None)
sugg2 = Suggestion.objects.get(id=sugg2.id)
event1 = [ComparableLogEvent(x)
for x in
unit_log.get_events(users=[member.id], start=start)][0]
event2 = ComparableLogEvent(unit_log.event(sugg2.unit,
sugg2.user,
sugg2.creation_time,
"suggestion_created",
sugg2))
assert event2 < event1
assert not (event1 < event2)
unit = store0.units.filter(state=UNTRANSLATED)[0]
unit.target = 'Unit Target'
unit.save()
unit_log = UnitTimelineLog(unit)
event1, event2 = [ComparableLogEvent(x)
for x in unit_log.get_submission_events()]
assert (event1 < event2) == (
ACTION_ORDER[event1.action] < ACTION_ORDER[event2.action])
assert (event2 < event1) == (
ACTION_ORDER[event2.action] < ACTION_ORDER[event1.action])
assert not (event1 < event1) and not (event1 > event1)
@pytest.mark.django_db
def test_timeline_translated_unit_creation(store0, member):
pounit = store0.UnitClass(source="Foo")
pounit.target = "Bar"
unit = store0.addunit(pounit, user=member)
unit.refresh_from_db()
groups = Timeline(unit).grouped_events()
assert len(groups) == 1
group = groups[0]
assert len(group['events']) == 1
assert group['events'][0]['value'] == unit.target
assert group['events'][0]['translation']
assert group['events'][0]['description'] == u"Unit created"
assert group['via_upload'] is False
assert group['datetime'] == unit.creation_time
assert group['user'].username == member.username
@pytest.mark.django_db
def test_timeline_untranslated_unit_creation(store0, member):
unit = store0.addunit(store0.UnitClass(source="Foo"), user=member)
unit.refresh_from_db()
groups = Timeline(unit).grouped_events()
assert len(groups) == 1
group = groups[0]
assert len(group['events']) == 1
assert 'value' not in group['events'][0]
assert 'translation' not in group['events'][0]
assert group['events'][0]['description'] == u"Unit created"
assert group['via_upload'] is False
assert group['datetime'] == unit.creation_time
assert group['user'].username == member.username
@pytest.mark.django_db
def test_timeline_untranslated_unit_creation_with_updates(store0, member):
unit = store0.addunit(store0.UnitClass(source="Foo"), user=member)
unit.refresh_from_db()
unit.target = 'Bar'
unit.save()
unit.refresh_from_db()
groups = Timeline(unit).grouped_events()
assert len(groups) == 2
group = groups[-1]
assert len(group['events']) == 1
assert 'value' not in group['events'][0]
assert 'translation' not in group['events'][0]
assert group['events'][0]['description'] == u"Unit created"
assert group['via_upload'] is False
assert group['datetime'] == unit.creation_time
assert group['user'].username == member.username
@pytest.mark.django_db
def test_timeline_translated_unit_creation_with_updates(store0, member):
pounit = store0.UnitClass(source="Foo")
pounit.target = "Bar"
unit = store0.addunit(pounit, user=member)
unit.refresh_from_db()
unit.target = "Bar UPDATED"
unit.save()
unit.refresh_from_db()
groups = Timeline(unit).grouped_events()
assert len(groups) == 2
group = groups[-1]
assert len(group['events']) == 1
assert group['events'][0]['value'] == "Bar"
assert group['events'][0]['translation']
assert group['events'][0]['description'] == u"Unit created"
assert group['via_upload'] is False
assert group['datetime'] == unit.creation_time
assert group['user'].username == member.username
def _get_sugg_accepted_desc(suggestion):
user = DisplayUser(suggestion.user.username, suggestion.user.full_name)
params = {'author': user.author_link}
return u'Accepted suggestion from %(author)s' % params
def _get_sugg_accepted_with_comment_desc(suggestion, comment):
user = DisplayUser(suggestion.user.username, suggestion.user.full_name)
params = {
'author': user.author_link,
'comment': format_html(u'<span class="comment">{}</span>',
comment)}
return (u'Accepted suggestion from %(author)s '
u'with comment: %(comment)s' % params)
def _get_state_changed_value(submission):
params = {
'old_value': STATES_MAP[int(to_python(submission.old_value))],
'new_value': STATES_MAP[int(to_python(submission.new_value))]}
return (
u"%(old_value)s "
u"<span class='timeline-arrow'></span> "
u"%(new_value)s" % params)
def _get_update_check_desc(submission):
check_name = submission.quality_check.name
check_url = u''.join(
[reverse('pootle-checks-descriptions'),
'#', check_name])
check_link = format_html("<a href='{}'>{}</a>", check_url,
CHECK_NAMES[check_name])
action = ''
if submission.old_value == '1' and submission.new_value == '0':
action = 'Muted'
if submission.old_value == '0' and submission.new_value == '1':
action = 'Unmuted'
return ("%(action)s %(check_link)s check" %
{'check_link': check_link, 'action': action})
@pytest.mark.django_db
def test_timeline_translated_unit_with_suggestion(store0, admin):
suggestion = Suggestion.objects.filter(
unit__store=store0,
state__name="pending",
unit__state=TRANSLATED).first()
unit = suggestion.unit
review.get(Suggestion)([suggestion], admin).accept()
suggestion.refresh_from_db()
unit.refresh_from_db()
timeline = Timeline(unit)
groups = timeline.grouped_events(start=suggestion.review_time)
assert len(groups) == 1
group = groups[0]
assert len(group['events']) == 1
assert group['events'][0]['value'] == unit.target
assert group['events'][0]['translation']
assert (group['events'][0]['description'] ==
_get_sugg_accepted_desc(suggestion))
assert group['via_upload'] is False
assert group['datetime'] == suggestion.review_time
assert group['user'].username == admin.username
@pytest.mark.django_db
def test_timeline_unit_with_suggestion_and_comment(store0, admin):
suggestion = Suggestion.objects.filter(
unit__store=store0,
state__name="pending",
unit__state=UNTRANSLATED).first()
unit = suggestion.unit
review.get(Suggestion)([suggestion], admin).accept()
comment = 'This is a comment!'
form = UnsecuredCommentForm(suggestion, admin, dict(
comment=comment))
assert form.is_valid()
form.save()
suggestion.refresh_from_db()
unit.refresh_from_db()
timeline = Timeline(unit)
groups = timeline.grouped_events(start=suggestion.review_time)
assert len(groups) == 1
group = groups[0]
assert len(group['events']) == 2
assert group['events'][0]['value'] == unit.target
assert group['events'][0]['translation']
assert (group['events'][0]['description'] ==
_get_sugg_accepted_with_comment_desc(suggestion, comment))
submission = Submission.objects.get(field=SubmissionFields.STATE,
unit=suggestion.unit,
creation_time=suggestion.review_time)
assert group['events'][1]['value'] == _get_state_changed_value(submission)
assert group['via_upload'] is False
assert group['datetime'] == suggestion.review_time
assert group['user'].username == admin.username
@pytest.mark.django_db
def test_timeline_unfuzzied_unit(member):
unit = Unit.objects.filter(state=FUZZY).first()
unit.markfuzzy(False)
unit.save(user=member)
last_submission = unit.store.data.last_submission
groups = Timeline(unit).grouped_events(
start=last_submission.creation_time)
assert len(groups) == 1
group = groups[0]
assert len(group['events']) == 1
assert (group['events'][0]['value'] ==
_get_state_changed_value(last_submission))
assert group['events'][0]['state']
assert 'description' not in group['events'][0]
assert group['via_upload'] is False
assert group['datetime'] == last_submission.creation_time
assert group['user'].username == member.username
@pytest.mark.django_db
def test_timeline_unit_with_qc(store0, admin, member):
qc_filter = dict(
unit__store=store0,
unit__state=TRANSLATED,
unit__store__translation_project__project__disabled=False,
unit__store__obsolete=False,
category=Category.CRITICAL)
qc = QualityCheck.objects.filter(**qc_filter).first()
unit = qc.unit
unit.toggle_qualitycheck(qc.id, True, member)
last_submission_0 = unit.store.data.last_submission
unit.toggle_qualitycheck(qc.id, False, admin)
unit.store.data.refresh_from_db()
last_submission_1 = unit.store.data.last_submission
groups = Timeline(unit).grouped_events(
start=last_submission_0.creation_time)
assert len(groups) == 2
group = groups[1]
assert len(group['events']) == 1
assert 'value' not in group['events'][0]
assert (group['events'][0]['description'] ==
_get_update_check_desc(last_submission_0))
assert group['via_upload'] is False
assert group['user'].username == member.username
assert group['datetime'] == last_submission_0.creation_time
group = groups[0]
assert len(group['events']) == 1
assert 'value' not in group['events'][0]
assert (group['events'][0]['description'] ==
_get_update_check_desc(last_submission_1))
assert group['via_upload'] is False
assert group['user'].username == admin.username
assert group['datetime'] == last_submission_1.creation_time
@pytest.mark.django_db
def test_timeline_translated_unit_comment(store0, admin, member):
unit = store0.units.filter(state=TRANSLATED).first()
comment = 'This is a comment!'
unit.translator_comment = comment
unit.save(user=member)
last_submission_0 = unit.store.data.last_submission
unit.translator_comment = ''
unit.save(user=admin)
unit.store.data.refresh_from_db()
last_submission_1 = unit.store.data.last_submission
groups = Timeline(unit).grouped_events(
start=last_submission_0.creation_time)
assert len(groups) == 2
group = groups[1]
assert len(group['events']) == 1
assert group['events'][0]['value'] == comment
assert group['events'][0]['comment']
assert 'description' not in group['events'][0]
assert group['via_upload'] is False
assert group['datetime'] == last_submission_0.creation_time
assert group['user'].username == member.username
group = groups[0]
assert len(group['events']) == 1
assert 'value' not in group['events'][0]
assert 'comment' not in group['events'][0]
assert group['events'][0]['description'] == 'Removed comment'
assert group['via_upload'] is False
assert group['datetime'] == last_submission_1.creation_time
assert group['user'].username == admin.username
| 20,165
|
Python
|
.py
| 461
| 36.370933
| 79
| 0.655429
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,972
|
qualitychecks.py
|
translate_pootle/tests/pootle_store/qualitychecks.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_store.models import QualityCheck
@pytest.mark.django_db
def test_qualitycheck(store0):
unit = store0.units.first()
qc = QualityCheck.objects.create(
unit=unit,
name="foo")
assert qc.unit == unit
assert qc.name == "foo"
assert qc.false_positive is False
assert str(qc) == "foo"
| 622
|
Python
|
.py
| 19
| 29.421053
| 77
| 0.719533
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,973
|
contextmanagers.py
|
translate_pootle/tests/pootle_store/contextmanagers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.dispatch import receiver
from pootle.core.signals import update_data
from pootle_store.contextmanagers import update_store_after
from pootle_store.models import Store
@pytest.mark.django_db
def test_contextmanager_keep_data_kwargs(store0, no_update_data):
result = []
with no_update_data():
@receiver(update_data, sender=Store)
def update_data_handler(**kwargs):
result.append(kwargs)
with update_store_after(store0):
update_data.send(Store, instance=store0)
# update_data was not called
assert result == []
# update_data called now
assert len(result) == 1
assert result[0]["instance"] == store0
# you can pass args to pass to the update receiver
result.remove(result[0])
with update_store_after(store0, foo="apples", bar="oranges"):
update_data.send(Store, instance=store0)
assert result == []
assert len(result) == 1
assert result[0]["instance"] == store0
assert result[0]["foo"] == "apples"
assert result[0]["bar"] == "oranges"
# you can control the kwargs passed to send inside the context
result.remove(result[0])
kwargs = dict(foo="apples", bar="oranges")
with update_store_after(store0, kwargs=kwargs):
update_data.send(Store, instance=store0)
kwargs["foo"] = "plums"
assert result == []
assert len(result) == 1
assert result[0]["instance"] == store0
assert result[0]["foo"] == "plums"
assert result[0]["bar"] == "oranges"
| 1,926
|
Python
|
.py
| 46
| 34.456522
| 77
| 0.645265
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,974
|
update.py
|
translate_pootle/tests/pootle_store/update.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import logging
import pytest
from pytest_pootle.utils import create_store
from pootle_store.constants import POOTLE_WINS, SOURCE_WINS
@pytest.mark.django_db
def test_store_update_new_unit_order(store0):
new_store = store0.deserialize(store0.serialize())
new_unit = new_store.units[1].copy()
new_unit.source = "INSERTED UNIT"
new_store.units = (
[new_store.units[0], new_unit]
+ new_store.units[2:])
store0.update(
new_store,
store_revision=store0.data.max_unit_revision + 1)
assert (
list(store0.units.values_list("unitid", flat=True))
== [u.getid() for u in new_store.units[1:]])
@pytest.mark.django_db
def test_store_update_with_obsolete(store_po):
units = [('source1', 'target1', False)]
file_store = create_store(store_po.pootle_path, units=units)
store_po.update(file_store)
unit = store_po.units[0]
assert not unit.isobsolete()
file_store.units[1].makeobsolete()
store_po.update(
file_store, store_revision=store_po.data.max_unit_revision)
unit = store_po.UnitClass.objects.get(id=unit.id)
assert unit.isobsolete()
@pytest.mark.django_db
def test_store_update_with_duplicate(store_po, caplog):
units = [
('source1', 'target1', False),
('source2', 'target2', False),
('source2', 'target2', False)]
file_store = create_store(store_po.pootle_path, units=units)
caplog.set_level(logging.WARN)
store_po.update(file_store)
assert (
caplog.records[0].message
== ('[diff] Duplicate unit found: %s source2'
% store_po.name))
@pytest.mark.django_db
def test_store_update_conflict_fs_wins(store0, caplog):
unit0 = store0.units[0]
unit0.target = "foo0"
unit0.save()
unit1 = store0.units[1]
unit1.target = "foo1"
unit1.save()
last_revision = store0.data.max_unit_revision
ttk = store0.deserialize(store0.serialize())
unit0.refresh_from_db()
unit0.target = "bar0"
unit0.save()
fsunit0 = ttk.findid(unit0.getid())
fsunit0.target = "baz0"
store0.update(ttk, store_revision=last_revision, resolve_conflict=SOURCE_WINS)
unit0.refresh_from_db()
unit1.refresh_from_db()
# only the fs change is updated
assert unit0.target == "baz0"
assert unit1.target == "foo1"
@pytest.mark.django_db
def test_store_update_conflict_pootle_wins(store0, caplog):
unit0 = store0.units[0]
unit0.target = "foo0"
unit0.save()
unit1 = store0.units[1]
unit1.target = "foo1"
unit1.save()
unit2 = store0.units[2]
last_revision = store0.data.max_unit_revision
ttk = store0.deserialize(store0.serialize())
unit0.refresh_from_db()
unit0.target = "bar0"
unit0.save()
fsunit0 = ttk.findid(unit0.getid())
fsunit0.target = "baz0"
fsunit2 = ttk.findid(unit2.getid())
fsunit2.target = "baz2"
store0.update(ttk, store_revision=last_revision, resolve_conflict=POOTLE_WINS)
unit0.refresh_from_db()
unit1.refresh_from_db()
unit2.refresh_from_db()
assert unit0.target == "bar0"
assert unit1.target == "foo1"
assert unit2.target == "baz2"
| 3,440
|
Python
|
.py
| 96
| 30.864583
| 82
| 0.684544
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,975
|
templatetags.py
|
translate_pootle/tests/pootle_misc/templatetags.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.template import Context, Template
from pootle.core.delegate import scores
def _render_str(string, context=None):
context = context or {}
context = Context(context)
return Template(string).render(context)
def test_templatetag_progress_bar():
rendered = _render_str("{% load common_tags %}{% progress_bar 0 0 0 %}")
assert "<span class='legend translated'></span>0%" in rendered
assert "<span class='legend fuzzy'></span>0%" in rendered
assert "<span class='legend untranslated'></span>0%" in rendered
rendered = _render_str(
"{% load common_tags %}{% progress_bar 123 23 73 %}")
assert "<span class='legend translated'></span>59.3%" in rendered
assert "<span class='legend fuzzy'></span>18.7%" in rendered
assert "<span class='legend untranslated'></span>22.0%" in rendered
assert '<td class="translated" style="width: 59.3%">' in rendered
assert '<td class="fuzzy" style="width: 18.7%">' in rendered
assert '<td class="untranslated" style="width: 22.0%">' in rendered
@pytest.mark.django_db
def test_inclusion_tag_top_scorers(project_set, member):
score_data = scores.get(project_set.__class__)(project_set)
rendered = _render_str(
"{% load common_tags %}{% top_scorers user score_data %}",
context=dict(
user=member,
score_data=score_data.display()))
top_scorer = list(score_data.display())[0]
assert top_scorer["public_total_score"] in rendered
assert top_scorer["user"].email_hash in rendered
| 1,830
|
Python
|
.py
| 38
| 43.657895
| 77
| 0.692653
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,976
|
models.py
|
translate_pootle/tests/accounts/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pytest_pootle.factories import UserFactory
from pootle.core.views.display import ActionDisplay
from pootle.i18n.dates import timesince
from pootle_statistics.models import Submission
@pytest.mark.django_db
def test_model_user_last_event(member):
last_submission = Submission.objects.filter(submitter=member).last()
last_event = member.last_event()
assert isinstance(last_event, ActionDisplay)
assert last_event.action == last_submission.get_submission_info()
last_event = member.last_event(locale="zu")
assert isinstance(last_event, ActionDisplay)
assert last_event.action == last_submission.get_submission_info()
assert last_event.since == timesince(last_event.action["mtime"], "zu")
user = UserFactory()
assert not user.last_event()
| 1,075
|
Python
|
.py
| 24
| 41.875
| 77
| 0.771292
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,977
|
adapter.py
|
translate_pootle/tests/accounts/adapter.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.core.exceptions import ValidationError
from allauth.account.adapter import get_adapter
@pytest.mark.django_db
def test_account_adapter_unicode():
adapter = get_adapter()
username = 'ascii'
assert username == adapter.clean_username(username)
username = u'lätin1'
assert username == adapter.clean_username(username)
with pytest.raises(ValidationError): # Unicode characters don't yet pass.
adapter.clean_username(u'อัตโนมัติ')
| 783
|
Python
|
.py
| 19
| 37.263158
| 78
| 0.758108
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,978
|
views.py
|
translate_pootle/tests/accounts/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.http import QueryDict
from allauth.account.models import EmailAddress
@pytest.mark.django_db
def test_accounts_login(client, request_users, settings):
user = request_users["user"]
if user.username == "nobody":
return
settings.POOTLE_CAPTCHA_ENABLED = False
password = request_users["password"]
qdict = QueryDict(mutable=True)
qdict.update(
{'login': user.username,
'password': password})
qdict._mutable = False
response = client.post(
'/accounts/login/',
qdict,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
email = EmailAddress.objects.filter(user=user, primary=True).first()
assert response.request['PATH_INFO'] == '/accounts/login/'
assert response.status_code == 200
if email is not None and email.verified:
assert response.json() == {u"location": "/"}
else:
assert response.json() == {u"location": "/accounts/confirm-email/"}
@pytest.mark.django_db
def test_accounts_logout(client, request_users, settings):
user = request_users["user"]
if user.username == "nobody":
return
settings.POOTLE_CAPTCHA_ENABLED = False
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
response = client.post(
'/accounts/logout/',
{},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert response.status_code == 302
assert response.url == '/'
| 1,789
|
Python
|
.py
| 49
| 31.020408
| 77
| 0.679005
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,979
|
project.py
|
translate_pootle/tests/forms/project.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_app.forms import ProjectForm
from pootle_format.models import Format
from pootle_project.models import (PROJECT_CHECKERS, RESERVED_PROJECT_CODES,
Project)
@pytest.mark.parametrize('reserved_code', RESERVED_PROJECT_CODES)
@pytest.mark.django_db
def test_clean_code_invalid(reserved_code, format_registry):
form_data = {
'code': reserved_code,
'checkstyle': PROJECT_CHECKERS.keys()[0],
'fullname': 'Foo',
'fs_plugin': "localfs",
'fs_mapping': "/<language_code>.<ext>",
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}%s" % reserved_code,
'filetypes': [format_registry["po"]["pk"]],
'source_language': 1}
form = ProjectForm(form_data)
assert not form.is_valid()
assert 'code' in form.errors
assert len(form.errors.keys()) == 1
@pytest.mark.django_db
def test_clean_code_blank_invalid(format_registry):
form_data = {
'code': ' ',
'checkstyle': PROJECT_CHECKERS.keys()[0],
'fullname': 'Foo',
'fs_plugin': "localfs",
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}foo",
'fs_mapping': "/<language_code>.<ext>",
'filetypes': [format_registry["po"]["pk"]],
'source_language': 1}
form = ProjectForm(form_data)
assert not form.is_valid()
assert 'code' in form.errors
assert len(form.errors.keys()) == 1
@pytest.mark.django_db
def test_clean_localfiletype_invalid(format_registry):
form_data = {
'code': 'foo',
'checkstyle': PROJECT_CHECKERS.keys()[0],
'fullname': 'Foo',
'fs_plugin': "localfs",
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}foo",
'fs_mapping': "/<language_code>.<ext>",
'filetypes': ["NO_SUCH_FORMAT"],
'source_language': 1}
form = ProjectForm(form_data)
assert not form.is_valid()
assert 'filetypes' in form.errors
assert len(form.errors.keys()) == 1
@pytest.mark.django_db
def test_project_form_bad_filetype_removal(format_registry):
form_data = {
'fullname': "Project 0",
'code': "project0",
'checkstyle': PROJECT_CHECKERS.keys()[0],
'disabled': False,
'fs_plugin': "localfs",
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}project0",
'fs_mapping': "/<language_code>.<ext>",
'filetypes': [Format.objects.get(name="xliff").pk],
'source_language': 1,
'screenshot_search_prefix': "",
'ignoredfiles': "",
'report_email': ""}
form = ProjectForm(form_data, instance=Project.objects.get(code="project0"))
assert not form.is_valid()
assert 'filetypes' in form.errors
assert len(form.errors.keys()) == 1
@pytest.mark.django_db
def test_project_form_change_filetypes(format_registry):
filetype_names = ["xliff", "po", "ts"]
filetypes = []
for filetype in filetype_names:
filetypes.append(Format.objects.get(name=filetype).pk)
form_data = {
'fullname': "Project 0",
'code': "project0",
'checkstyle': PROJECT_CHECKERS.keys()[0],
'disabled': False,
'filetypes': filetypes,
'fs_plugin': "localfs",
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}project0",
'fs_mapping': "/<language_code>.<ext>",
'source_language': 1,
'screenshot_search_prefix': "",
'ignoredfiles': "",
'report_email': ""}
project0 = Project.objects.get(code="project0")
form = ProjectForm(form_data, instance=project0)
assert form.is_valid()
form.save()
assert (
list(project0.filetypes.values_list("pk", flat=True))
== filetypes)
@pytest.mark.django_db
def test_form_project_plugin_missing(format_registry):
form_data = {
'code': 'foo0',
'checkstyle': PROJECT_CHECKERS.keys()[0],
'fullname': 'Foo',
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}foo0",
'fs_mapping': "/<language_code>.<ext>",
'filetypes': [format_registry["po"]["pk"]],
'source_language': 1}
form = ProjectForm(form_data)
assert not form.is_valid()
assert 'fs_plugin' in form.errors
assert len(form.errors.keys()) == 1
@pytest.mark.django_db
def test_form_project_plugin_invalid(format_registry):
form_data = {
'code': 'foo0',
'checkstyle': PROJECT_CHECKERS.keys()[0],
'fullname': 'Foo',
'fs_plugin': "DOES NOT EXIST",
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}foo0",
'fs_mapping': "/<language_code>.<ext>",
'filetypes': [format_registry["po"]["pk"]],
'source_language': 1}
form = ProjectForm(form_data)
assert not form.is_valid()
assert 'fs_plugin' in form.errors
assert len(form.errors.keys()) == 1
@pytest.mark.django_db
def test_form_project_fs_url(format_registry):
form_data = {
'code': 'foo0',
'checkstyle': PROJECT_CHECKERS.keys()[0],
'fullname': 'Foo',
'fs_plugin': "localfs",
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}foo0",
'fs_mapping': "/<language_code>.<ext>",
'filetypes': [format_registry["po"]["pk"]],
'source_language': 1}
form = ProjectForm(form_data)
assert form.is_valid()
form_data["fs_url"] = "/foo/bar/baz"
form = ProjectForm(form_data)
assert form.is_valid()
form_data["fs_url"] = "foo/bar/baz"
form = ProjectForm(form_data)
assert not form.is_valid()
assert form.errors.keys() == ["fs_url"]
form_data["fs_url"] = ""
form = ProjectForm(form_data)
assert not form.is_valid()
assert form.errors.keys() == ["fs_url"]
@pytest.mark.django_db
def test_form_project_fs_mapping(format_registry):
form_data = {
'code': 'foo0',
'checkstyle': PROJECT_CHECKERS.keys()[0],
'fullname': 'Foo',
'fs_plugin': "localfs",
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}foo0",
'fs_mapping': "/<language_code>.<ext>",
'filetypes': [format_registry["po"]["pk"]],
'source_language': 1}
form = ProjectForm(form_data)
assert form.is_valid()
form_data["fs_mapping"] = "<language_code>.<ext>"
form = ProjectForm(form_data)
assert not form.is_valid()
assert 'fs_mapping' in form.errors
form_data["fs_mapping"] = "/<language_code>"
form = ProjectForm(form_data)
assert not form.is_valid()
assert 'fs_mapping' in form.errors
form_data["fs_mapping"] = "/<foo_code>.<ext>"
form = ProjectForm(form_data)
assert not form.is_valid()
assert 'fs_mapping' in form.errors
@pytest.mark.django_db
def test_form_project_template_name(format_registry):
form_data = {
'code': 'foo0',
'checkstyle': PROJECT_CHECKERS.keys()[0],
'fullname': 'Foo',
'fs_plugin': "localfs",
'fs_url': "{POOTLE_TRANSLATION_DIRECTORY}foo0",
'fs_mapping': "/<language_code>.<ext>",
'filetypes': [format_registry["po"]["pk"]],
'source_language': 1}
form = ProjectForm(form_data)
assert form.is_valid()
assert form.cleaned_data["template_name"] == ""
project = form.save()
assert project.lang_mapper.get_upstream_code("templates") == "templates"
form_data["template_name"] = "foo"
form = ProjectForm(instance=project, data=form_data)
assert form.is_valid()
form.save()
del project.__dict__["lang_mapper"]
assert project.lang_mapper.get_upstream_code("templates") == "foo"
form_data["template_name"] = ""
form = ProjectForm(instance=project, data=form_data)
assert form.is_valid()
form.save()
del project.__dict__["lang_mapper"]
assert project.lang_mapper.get_upstream_code("templates") == "templates"
| 7,965
|
Python
|
.py
| 209
| 31.746411
| 80
| 0.624903
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,980
|
language.py
|
translate_pootle/tests/forms/language.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_app.forms import LanguageForm
@pytest.mark.parametrize('specialchars', [
' ',
' abcde ',
' ab cd',
' abcde',
'abcde ',
' a b c d e ',
' a b c d e ',
])
@pytest.mark.django_db
def test_clean_specialchars_whitespace(specialchars):
"""Tests whitespace is accepted in special characters."""
form_data = {
'code': 'foo',
'fullname': 'Foo',
'checkstyle': 'foo',
'nplurals': '2',
'specialchars': specialchars,
}
form = LanguageForm(form_data)
assert form.is_valid()
assert ' ' in form.cleaned_data['specialchars']
@pytest.mark.parametrize('specialchars, count_char', [
(' abcde ', ' '),
(' aaaaaaaaaa', 'a'),
('āéĩøøøøøøü', u'ø'),
])
@pytest.mark.django_db
def test_clean_specialchars_unique(specialchars, count_char):
"""Tests special characters are unique."""
form_data = {
'code': 'foo',
'fullname': 'Foo',
'checkstyle': 'foo',
'nplurals': '2',
'specialchars': specialchars,
}
form = LanguageForm(form_data)
assert form.is_valid()
assert form.cleaned_data['specialchars'].count(count_char) == 1
@pytest.mark.django_db
def test_specialchars_can_be_blank():
"""Test that a blank special character field is valid."""
form_data = {
'code': 'foo',
'fullname': 'Foo',
'checkstyle': 'foo',
'nplurals': '2',
'specialchars': '',
}
form = LanguageForm(form_data)
assert form.is_valid()
assert form.cleaned_data['specialchars'] == ''
| 1,875
|
Python
|
.py
| 62
| 25.193548
| 77
| 0.625418
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,981
|
comment.py
|
translate_pootle/tests/forms/comment.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.plugin import getter
from pootle_comment.delegate import comment_should_not_be_saved
from pootle_comment.models import Comment
from pootle_comment.forms import CommentForm, UnsecuredCommentForm
from pootle_store.models import Unit
@pytest.mark.django_db
def test_comment_form():
# must be bound to an object
with pytest.raises(TypeError):
CommentForm()
with pytest.raises(AttributeError):
CommentForm("some string")
unit = Unit.objects.first()
form = CommentForm(unit)
secdata = form.generate_security_data()
assert secdata["object_pk"] == str(unit.pk)
assert secdata["content_type"] == str(unit._meta)
assert "timestamp" in secdata
assert "security_hash" in secdata
@pytest.mark.django_db
def test_comment_form_post(admin):
unit = Unit.objects.first()
form = CommentForm(unit)
kwargs = dict(
comment="Foo!",
object_pk=str(unit.pk),
content_type=str(unit._meta),
name=admin.display_name,
email=admin.email,
timestamp=form.initial.get("timestamp"),
security_hash=form.initial.get("security_hash"))
post_form = CommentForm(unit, kwargs)
if post_form.is_valid():
post_form.save()
comment = Comment.objects.first()
assert comment.comment == "Foo!"
assert ".".join(comment.content_type.natural_key()) == str(unit._meta)
assert comment.object_pk == str(unit.pk)
assert comment.user is None
assert comment.name == admin.display_name
assert comment.email == admin.email
@pytest.mark.django_db
def test_unsecured_comment_form_post(admin):
unit = Unit.objects.first()
kwargs = dict(
data=dict(comment="Foo!"),
target_object=unit,
request_user=admin)
post_form = UnsecuredCommentForm(**kwargs)
if post_form.is_valid():
post_form.save()
comment = Comment.objects.first()
assert comment.comment == "Foo!"
assert ".".join(comment.content_type.natural_key()) == str(unit._meta)
assert comment.object_pk == str(unit.pk)
assert comment.user == admin
assert comment.name == admin.display_name
assert comment.email == admin.email
@pytest.mark.django_db
def test_unsecured_comment_form_should_save(admin):
unit = Unit.objects.first()
BAD_WORDS = ["google", "oracle", "apple", "microsoft"]
@getter(comment_should_not_be_saved, sender=Unit)
def comment_handler(sender, **kwargs):
for bad_word in BAD_WORDS:
if bad_word in kwargs["comment"].comment:
return "You cant say '%s' round here" % bad_word
kwargs = dict(
data=dict(comment="google is foo!"),
target_object=unit,
request_user=admin)
post_form = UnsecuredCommentForm(**kwargs)
assert not post_form.is_valid()
assert post_form.errors["comment"] == ["You cant say 'google' round here"]
kwargs = dict(
data=dict(
comment="You can say linux though, or gnu/linux if you prefer"),
target_object=unit,
request_user=admin)
post_form = UnsecuredCommentForm(**kwargs)
assert post_form.is_valid()
| 3,423
|
Python
|
.py
| 89
| 33
| 78
| 0.686239
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,982
|
contact.py
|
translate_pootle/tests/forms/contact.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from __future__ import absolute_import
import pytest
from django.conf import settings
from django.template.defaultfilters import escape
from django.template.loader import render_to_string
from contact.forms import ContactForm, ReportForm
from pootle_store.models import Unit
@pytest.mark.django_db
def test_contact_form(admin, rf, mailoutbox):
request = rf.request()
request.user = admin
request.META['REMOTE_ADDR'] = '127.0.0.1'
recipient_email = settings.POOTLE_CONTACT_EMAIL
specified_subject = "My subject"
subject = "[%s] %s" % (settings.POOTLE_TITLE, specified_subject)
data = {
'name': admin.full_name,
'email': admin.email,
'email_subject': specified_subject,
'body': "First paragraph of message\n\nSecond paragraph of message.",
}
form = ContactForm(request=request, data=data)
assert form.is_valid()
form.save()
assert len(mailoutbox) == 1
message = mailoutbox[0]
assert message.from_email == settings.DEFAULT_FROM_EMAIL
reply_to = u'%s <%s>' % (data['name'], data['email'])
assert reply_to == message.extra_headers['Reply-To']
assert [recipient_email] == message.recipients()
assert subject == message.subject
assert data['body'] in message.body
assert "Your question or comment:" not in message.body
@pytest.mark.django_db
def test_contact_form_escaped_tags(admin, rf, mailoutbox):
request = rf.request()
request.user = admin
request.META['REMOTE_ADDR'] = '127.0.0.1'
recipient_email = settings.POOTLE_CONTACT_EMAIL
specified_subject = "My <tag> subject"
subject = "[%s] %s" % (settings.POOTLE_TITLE, specified_subject)
data = {
'name': admin.full_name,
'email': admin.email,
'email_subject': specified_subject,
'body': "First <tag> of message.",
}
form = ContactForm(request=request, data=data)
assert form.is_valid()
form.save()
assert len(mailoutbox) == 1
message = mailoutbox[0]
assert message.from_email == settings.DEFAULT_FROM_EMAIL
reply_to = u'%s <%s>' % (data['name'], data['email'])
assert reply_to == message.extra_headers['Reply-To']
assert [recipient_email] == message.recipients()
assert escape(subject) == message.subject
assert escape(data['body']) in message.body
assert "Your question or comment:" not in message.body
@pytest.mark.django_db
def test_contact_form_subject(admin, rf, mailoutbox):
request = rf.request()
request.user = admin
request.META['REMOTE_ADDR'] = '127.0.0.1'
data = {
'name': admin.full_name,
'email': admin.email,
'email_subject': "a" * 101,
'body': "Whatever",
}
form = ContactForm(request=request, data=data)
assert not form.is_valid()
data['email_subject'] = "a" * 100
form = ContactForm(request=request, data=data)
assert form.is_valid()
@pytest.mark.django_db
def test_contact_form_required_fields(admin, rf, mailoutbox):
request = rf.request()
request.user = admin
request.META['REMOTE_ADDR'] = '127.0.0.1'
form = ContactForm(request=request, data={})
assert not form.is_valid()
assert 'email' in form.errors
assert form.errors['email'] == [u'This field is required.']
assert 'name' in form.errors
assert form.errors['name'] == [u'This field is required.']
assert 'email_subject' in form.errors
assert form.errors['email_subject'] == [u'This field is required.']
assert 'body' in form.errors
assert form.errors['body'] == [u'This field is required.']
def _test_report_form(unit, recipient_email, user, rf, mailoutbox):
request = rf.request()
request.user = user
request.META['REMOTE_ADDR'] = '127.0.0.1'
# Get initial data for the form.
subject_ctx = {
'server_name': settings.POOTLE_TITLE,
'unit': unit.pk,
'language': unit.store.translation_project.language.code,
'project': unit.store.translation_project.project.code,
}
subject = render_to_string('contact_form/report_form_subject.txt',
context=subject_ctx)
subject = subject.strip()
context_ctx = {
'unit': unit,
'unit_absolute_url':
request.build_absolute_uri(unit.get_translate_url()),
}
context = render_to_string('contact_form/report_form_context.txt',
context=context_ctx)
context = context.strip()
translator_comment = "The string is wrong"
data = {
'name': user.full_name,
'email': user.email,
'context': context,
'body': translator_comment,
}
email_body_ctx = {
'request': request,
'context': context,
'ip_address': '127.0.0.1',
'body': translator_comment,
}
email_body = render_to_string('contact_form/report_form.txt',
context=email_body_ctx)
# Instantiate form and test.
form = ReportForm(request=request, initial=data, data=data, unit=unit)
assert form.is_valid()
form.save()
assert len(mailoutbox) == 1
message = mailoutbox[0]
assert message.from_email == settings.DEFAULT_FROM_EMAIL
reply_to = u'%s <%s>' % (data['name'], data['email'])
assert reply_to == message.extra_headers['Reply-To']
assert [recipient_email] == message.recipients()
assert message.subject.startswith(u'[%s] ' % settings.POOTLE_TITLE)
assert subject == message.subject
assert email_body in message.body
@pytest.mark.django_db
def test_report_error_form_settings_email(admin, rf, mailoutbox):
unit = Unit.objects.select_related(
'store__translation_project__project',
'store__translation_project__language',
).last()
recipient_email = getattr(settings, 'POOTLE_CONTACT_REPORT_EMAIL',
settings.POOTLE_CONTACT_EMAIL)
_test_report_form(unit, recipient_email, admin, rf, mailoutbox)
@pytest.mark.django_db
def test_report_error_form_project_email(admin, rf, mailoutbox):
unit = Unit.objects.select_related(
'store__translation_project__project',
'store__translation_project__language',
).last()
project = unit.store.translation_project.project
project.report_email = "errors@example.net"
project.save()
_test_report_form(unit, project.report_email, admin, rf, mailoutbox)
@pytest.mark.django_db
def test_report_error_form_context_cannot_be_altered(admin, rf, mailoutbox):
request = rf.request()
request.user = admin
request.META['REMOTE_ADDR'] = '127.0.0.1'
unit = Unit.objects.select_related(
'store__translation_project__project',
'store__translation_project__language',
).last()
context_ctx = {
'unit': unit,
'unit_absolute_url':
request.build_absolute_uri(unit.get_translate_url()),
}
context = render_to_string('contact_form/report_form_context.txt',
context=context_ctx)
context = context.strip()
initial = {
'name': admin.full_name,
'email': admin.email,
'context': context,
'body': "The string is wrong",
}
data = initial.copy()
sent_context = "Different context"
data['context'] = sent_context
# Instantiate form and test.
form = ReportForm(request=request, initial=initial, data=data, unit=unit)
assert form.is_valid()
form.save()
assert len(mailoutbox) == 1
message = mailoutbox[0]
assert sent_context not in message.body
@pytest.mark.django_db
def test_report_error_form_escaped_tags(admin, rf, mailoutbox):
request = rf.request()
request.user = admin
request.META['REMOTE_ADDR'] = '127.0.0.1'
unit_target = "some <tag>"
unit = Unit.objects.select_related(
'store__translation_project__project',
'store__translation_project__language',
).last()
unit.target = unit_target
unit.save()
context_ctx = {
'unit': unit,
'unit_absolute_url':
request.build_absolute_uri(unit.get_translate_url()),
}
context = render_to_string('contact_form/report_form_context.txt',
context=context_ctx)
context = context.strip()
data = {
'name': admin.full_name,
'email': admin.email,
'context': context,
'body': "The string <tag> is wrong",
}
# Instantiate form and test.
form = ReportForm(request=request, initial=data, data=data, unit=unit)
assert form.is_valid()
form.save()
assert len(mailoutbox) == 1
message = mailoutbox[0]
assert escape(unit_target) in message.body
assert escape(data['body']) in message.body
@pytest.mark.django_db
def test_report_error_form_required_fields(admin, rf, mailoutbox):
request = rf.request()
request.user = admin
request.META['REMOTE_ADDR'] = '127.0.0.1'
unit = Unit.objects.select_related(
'store__translation_project__project',
'store__translation_project__language',
).last()
# Instantiate form and test.
form = ReportForm(request=request, initial={}, data={}, unit=unit)
assert not form.is_valid()
assert 'email' in form.errors
assert form.errors['email'] == [u'This field is required.']
assert 'name' in form.errors
assert form.errors['name'] == [u'This field is required.']
assert 'context' in form.errors
assert form.errors['context'] == [u'This field is required.']
assert 'body' in form.errors
assert form.errors['body'] == [u'This field is required.']
| 9,854
|
Python
|
.py
| 253
| 32.83004
| 77
| 0.65806
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,983
|
unit.py
|
translate_pootle/tests/forms/unit.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.forms import Form
from translate.misc import multistring
from pootle_app.models.permissions import get_matching_permissions
from pootle_store.forms import (
MultiStringFormField, MultiStringWidget, unit_form_factory)
def _create_post_request(rf, directory, user, url='/', data=None):
"""Convenience function to create and setup fake POST requests."""
if data is None:
data = {}
request = rf.post(url, data=data)
request.user = user
request.permissions = get_matching_permissions(request.user, directory)
return request
def _create_unit_form(request, language, unit):
"""Convenience function to create unit forms."""
form_class = unit_form_factory(language, request=request)
return form_class(request.POST, instance=unit, request=request)
@pytest.mark.django_db
def test_submit_no_source(rf, po_directory, default, store0):
"""Tests that the source string cannot be modified."""
language = store0.translation_project.language
unit = store0.units[0]
source_string = unit.source_f
directory = unit.store.parent
post_dict = {
'id': unit.id,
'index': unit.index,
'source_f_0': 'altered source string',
'target_f_0': 'dummy',
}
request = _create_post_request(rf, directory, data=post_dict, user=default)
form = _create_unit_form(request, language, unit)
assert form.is_valid()
form.save()
unit = store0.units[0]
assert unit.source_f == source_string
assert unit.target_f == 'dummy'
@pytest.mark.django_db
def test_submit_fuzzy(rf, po_directory, admin, default, store0):
"""Tests that non-admin users can't set the fuzzy flag."""
language = store0.translation_project.language
unit = store0.units[0]
directory = unit.store.parent
post_dict = {
'id': unit.id,
'index': unit.index,
'target_f_0': unit.target_f,
'is_fuzzy': True,
}
request = _create_post_request(rf, directory, data=post_dict, user=admin)
admin_form = _create_unit_form(request, language, unit)
assert admin_form.is_valid()
request = _create_post_request(rf, directory, data=post_dict, user=default)
user_form = _create_unit_form(request, language, unit)
assert not user_form.is_valid()
assert 'is_fuzzy' in user_form.errors
@pytest.mark.parametrize('nplurals, decompressed_value', [
(1, [None]),
(2, [None, None]),
(3, [None, None, None]),
(4, [None, None, None, None]),
])
def test_multistringwidget_decompress_none(nplurals, decompressed_value):
"""Tests unit's `MultiStringWidget` decompresses None values."""
widget = MultiStringWidget(nplurals=nplurals)
assert widget.decompress(None) == decompressed_value
@pytest.mark.parametrize('value', [
['foo\\bar'],
['foö\r\nbär'],
['foö\\r\\nbär'],
['foö\r\n\\r\\nbär', 'bär\r\n\\r\\nbäz'],
['nfoö\nbär'],
['nfoö\\nbär'],
['foö\n\\nbär', 'bär\n\\nbäz'],
])
def test_multistringwidget_decompress_list_of_values(value):
"""Tests unit's `MultiStringWidget` decompresses a list of values."""
widget = MultiStringWidget()
assert widget.decompress(value) == value
@pytest.mark.parametrize('value', [
'foo\\bar',
'foö\r\nbär',
'foö\\r\\nbär',
'foö\r\n\\r\\nbär',
'nfoö\nbär',
'nfoö\\nbär',
'foö\n\\nbär',
])
def test_multistringwidget_decompress_strings(value):
"""Tests unit's `MultiStringWidget` decompresses string values."""
widget = MultiStringWidget()
assert widget.decompress(value) == [value]
@pytest.mark.parametrize('value', [
'foo\\bar',
'foö\r\nbär',
'foö\\r\\nbär',
'foö\r\n\\r\\nbär',
'nfoö\nbär',
'nfoö\\nbär',
'foö\n\\nbär',
['foo\\bar'],
['foö\r\nbär'],
['foö\\r\\nbär'],
['foö\r\n\\r\\nbär', 'bär\r\n\\r\\nbäz'],
['nfoö\nbär'],
['nfoö\\nbär'],
['foö\n\\nbär', 'bär\n\\nbäz'],
])
def test_multistringwidget_decompress_multistrings(value):
"""Tests unit's `MultiStringWidget` decompresses string values."""
widget = MultiStringWidget()
expected_value = [value] if isinstance(value, basestring) else value
assert widget.decompress(multistring.multistring(value)) == expected_value
@pytest.mark.parametrize('value', [
[u'foo\\bar'],
[u"\t foo\\bar\n"],
[u'foö\r\nbär'],
[u'foö\\r\\nbär'],
[u'foö\r\n\\r\\nbär', u'bär\r\n\\r\\nbäz'],
[u'nfoö\nbär'],
[u'nfoö\\nbär'],
[u'foö\n\\nbär', u'bär\n\\nbäz'],
])
def test_form_multistringformfield(value):
"""Tests `MultiStringFormField`'s value compression in a form."""
def test_form_factory(nplurals):
class TestForm(Form):
value = MultiStringFormField(nplurals=nplurals)
return TestForm
data = {'value_%d' % i: val for i, val in enumerate(value)}
form_class = test_form_factory(nplurals=len(value))
form = form_class(data=data)
assert form.is_valid()
assert form.cleaned_data == {'value': value}
| 5,343
|
Python
|
.py
| 142
| 32.471831
| 79
| 0.668562
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,984
|
state.py
|
translate_pootle/tests/misc/state.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.state import State, ItemState
class DummyContext(object):
def __str__(self):
return "<DummyContext object>"
def test_state_instance():
context = DummyContext()
state = State(context)
assert state.context == context
assert state.__state__ == {}
assert state.prefix == "state"
assert state.has_changed is False
assert state.states == []
assert "x" not in state
assert list(state) == []
assert state.item_state_class == ItemState
assert str(state) == (
"<State(<DummyContext object>): Nothing to report>")
def test_state_states():
"""By default the State class will automagically find any
methods that start with `state_` and create a list of states
from these.
In a descendant class you can manually set the states, in order to
control which state methods are called and in what order. This tests that
"""
class ContextualState(State):
@property
def states(self):
return ["foo", "bar", "empty"]
def state_foo(self, **kwargs):
for x in [1, 2, 3]:
yield {str(x): x}
def state_bar(self, **kwargs):
for x in [4, 5, 6, 7, 8, 9]:
yield {str(x): x}
def state_baz(self, **kwargs):
yield dict(never="called")
def state_empty(self, **kwargs):
return []
context = DummyContext()
state = ContextualState(context)
assert str(state) == (
"<ContextualState(<DummyContext object>): foo: 3, bar: 6>")
assert state.context == context
assert sorted(state.__state__.keys()) == ["bar", "empty", "foo"]
assert "empty" in state.__state__
assert "baz" not in state.__state__
assert state["empty"] == []
with pytest.raises(KeyError):
state["baz"]
assert sorted(state) == ["bar", "foo"]
assert state.has_changed is True
assert state.states == ["foo", "bar", "empty"]
assert len(state["foo"]) == 3
assert isinstance(state["foo"][0], state.item_state_class)
assert state["foo"][0].kwargs == {"1": 1}
assert state["foo"][0].state == state
assert state["foo"][0].state_type == "foo"
def test_state_all_states():
class ContextualState(State):
def state_foo(self, **kwargs):
for x in [1, 2, 3]:
yield {str(x): x}
def state_bar(self, **kwargs):
for x in [4, 5, 6, 7, 8, 9]:
yield {str(x): x}
def state_baz(self, **kwargs):
for x in [10, 11, 12]:
yield {str(x): x}
def state_empty(self, **kwargs):
return []
context = DummyContext()
state = ContextualState(context)
assert str(state) == (
"<ContextualState(<DummyContext object>): bar: 6, baz: 3, foo: 3>")
assert state.context == context
assert sorted(state.__state__.keys()) == ['bar', 'baz', 'empty', 'foo']
assert "baz" in state.__state__
assert sorted(state) == ["bar", "baz", "foo"]
assert state.has_changed is True
assert state.states == ['bar', 'baz', 'empty', 'foo']
assert len(state["baz"]) == 3
def test_state_properties():
class ContextualState(State):
@property
def state_foo(self):
for x in self.kwargs["baz"]:
yield {"foo%s" % x: x}
@property
def state_bar(self):
for x in self.kwargs["baz"]:
yield {"bar%s" % x: x}
context = DummyContext()
state = ContextualState(context, baz=[1, 2])
assert state["foo"][0].kwargs.items() == [("foo1", 1)]
assert state["foo"][1].kwargs.items() == [("foo2", 2)]
assert state["bar"][0].kwargs.items() == [("bar1", 1)]
assert state["bar"][1].kwargs.items() == [("bar2", 2)]
def test_state_item_kwargs():
class ContextualState(State):
@property
def state_foo(self):
for x in self.kwargs["baz"]:
yield {"foo%s" % x: x}
def state_bar(self, **kwargs):
for x in self.kwargs["baz"]:
yield {"bar%s" % x: x}
context = DummyContext()
state = ContextualState(context, baz=[1, 2])
assert state["foo"][0].kwargs.items() == [("foo1", 1)]
assert state["foo"][0].foo1 == 1
assert not hasattr(state["foo"][0], "foo2")
assert state["foo"][1].kwargs.items() == [("foo2", 2)]
assert state["foo"][1].foo2 == 2
assert not hasattr(state["foo"][1], "foo3")
assert state["bar"][0].kwargs.items() == [("bar1", 1)]
assert state["bar"][0].bar1 == 1
assert not hasattr(state["bar"][0], "bar2")
assert state["bar"][1].kwargs.items() == [("bar2", 2)]
assert state["bar"][1].bar2 == 2
assert not hasattr(state["bar"][1], "bar3")
def test_state_bad():
# requires a context
with pytest.raises(TypeError):
State()
class ContextualState(State):
states = 3
# context.states must be iterable if set
with pytest.raises(TypeError):
ContextualState(DummyContext())
class ContextualState(State):
def state_foo(self, **kwargs):
yield []
# context.state_* methods should yield dict-like object
with pytest.raises(TypeError):
ContextualState(DummyContext())
def test_state_item_instance():
class DummyContext(object):
def __str__(self):
return "<DummyContext object>"
context = DummyContext()
state = State(context)
item = ItemState(state, "foo")
assert item.state == state
assert item.state_type == "foo"
assert str(item) == (
"<ItemState(<DummyContext object>): foo {}>")
assert item == ItemState(state, "foo")
def test_state_kwargs():
class ContextualState(State):
def state_foo(self, **kwargs):
yield kwargs
kwargs = dict(kwarg1="kw1", kwarg2="kw2")
state = ContextualState(DummyContext(), **kwargs)
assert state.kwargs == kwargs
assert state["foo"][0].kwargs == kwargs
state["foo"][0].kwarg1 == "kw1"
state["foo"][0].kwarg2 == "kw2"
def test_state_item_bad():
class ContextualState(State):
def state_foo(self, **kwargs):
for x in [1, 2, 3]:
yield {str(x): x}
# needs state and state_type arg
with pytest.raises(TypeError):
ItemState()
# needs state_type arg
with pytest.raises(TypeError):
ItemState(ContextualState(DummyContext()))
assert ItemState(ContextualState(DummyContext()), "foo")
def test_state_reload():
class ContextualState(State):
def state_foo(self, **kwargs):
yield dict(result=(2 * self.context.base))
context = DummyContext()
context.base = 2
state = ContextualState(context)
assert state["foo"][0].kwargs["result"] == 4
context.base = 3
assert state["foo"][0].kwargs["result"] == 4
state.reload()
assert state["foo"][0].kwargs["result"] == 6
state.clear_cache()
assert list(state) == []
| 7,313
|
Python
|
.py
| 192
| 31.057292
| 77
| 0.600255
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,985
|
checks.py
|
translate_pootle/tests/misc/checks.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_checks.constants import Category, CHECK_NAMES
from pootle_checks.utils import (
get_category_code,
get_category_name,
get_qualitychecks,
get_qualitycheck_list,
get_qualitycheck_schema)
def test_get_qualitycheck_schema():
d = {}
checks = get_qualitychecks()
for check, cat in checks.items():
if cat not in d:
d[cat] = {
'code': cat,
'name': get_category_code(cat),
'title': get_category_name(cat),
'checks': []
}
d[cat]['checks'].append({
'code': check,
'title': u"%s" % CHECK_NAMES.get(check, check),
'url': ''
})
result = sorted([item for item in d.values()],
key=lambda x: x['code'],
reverse=True)
assert result == get_qualitycheck_schema()
@pytest.mark.django_db
def test_get_qualitycheck_list(tp0):
result = []
checks = get_qualitychecks()
for check, cat in checks.items():
result.append({
'code': check,
'is_critical': cat == Category.CRITICAL,
'title': u"%s" % CHECK_NAMES.get(check, check),
'url': tp0.get_translate_url(check=check)
})
def alphabetical_critical_first(item):
sort_prefix = 0 if item['is_critical'] else 1
return "%d%s" % (sort_prefix, item['title'].lower())
result = sorted(result, key=alphabetical_critical_first)
assert result == get_qualitycheck_list(tp0)
| 1,826
|
Python
|
.py
| 51
| 28.078431
| 77
| 0.60034
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,986
|
response.py
|
translate_pootle/tests/misc/response.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.response import ItemResponse, Response
class DummyContext(object):
def __str__(self):
return "<DummyContext object>"
def test_response_instance():
context = DummyContext()
resp = Response(context)
assert resp.context == context
assert resp.response_types == []
assert resp.has_failed is False
assert resp.made_changes is False
assert list(resp.failed()) == []
assert list(resp.completed()) == []
assert str(resp) == "<Response(<DummyContext object>): No changes made>"
assert list(resp) == []
with pytest.raises(KeyError):
resp["DOES_NOT_EXIST"]
def test_response_completed():
resp = Response(DummyContext())
resp.add("foo_response", completed=True)
assert resp.has_failed is False
assert resp.made_changes is True
assert resp.response_types == ["foo_response"]
assert len(list(resp.completed())) == 1
assert list(resp.failed()) == []
assert "foo_response" in resp
assert isinstance(resp["foo_response"][0], ItemResponse)
assert str(resp) == "<Response(<DummyContext object>): foo_response: 1>"
resp.add("foo_response")
assert resp.has_failed is False
assert resp.made_changes is True
assert resp.response_types == ["foo_response"]
assert len(list(resp.completed())) == 2
assert list(resp.failed()) == []
assert "foo_response" in resp
assert isinstance(resp["foo_response"][0], ItemResponse)
assert isinstance(resp["foo_response"][1], ItemResponse)
assert str(resp) == "<Response(<DummyContext object>): foo_response: 2>"
resp.add("other_response")
assert resp.has_failed is False
assert resp.made_changes is True
assert sorted(resp.response_types) == ["foo_response", "other_response"]
assert len(list(resp.completed())) == 3
assert list(resp.failed()) == []
assert "foo_response" in resp
assert "other_response" in resp
assert isinstance(resp["other_response"][0], ItemResponse)
assert isinstance(resp["foo_response"][0], ItemResponse)
assert isinstance(resp["foo_response"][1], ItemResponse)
assert str(resp).startswith("<Response(<DummyContext object>): ")
assert "foo_response: 2" in str(resp)
assert "other_response: 1" in str(resp)
assert "FAIL" not in str(resp)
def test_response_failed():
resp = Response(DummyContext())
resp.add("foo_response", complete=False)
assert resp.has_failed is True
assert resp.made_changes is False
assert resp.response_types == ["foo_response"]
assert len(list(resp.failed())) == 1
assert list(resp.completed()) == []
assert "foo_response" in resp
assert isinstance(resp["foo_response"][0], ItemResponse)
assert str(resp) == "<Response(<DummyContext object>): FAIL No changes made>"
# now add some successful responses
resp.add("foo_response")
assert resp.has_failed is True
assert resp.made_changes is True
assert len(list(resp.failed())) == 1
assert len(list(resp.completed())) == 1
assert str(resp) == "<Response(<DummyContext object>): FAIL foo_response: 1>"
resp.add("other_response")
assert resp.has_failed is True
assert resp.made_changes is True
assert len(list(resp.failed())) == 1
assert len(list(resp.completed())) == 2
assert str(resp).startswith("<Response(<DummyContext object>): FAIL ")
assert "foo_response: 1" in str(resp)
assert "other_response: 1" in str(resp)
assert str(resp["foo_response"][0]).startswith(
"<ItemResponse(<Response(<DummyContext object>): FAIL ")
assert str(resp["foo_response"][0]).endswith(
"foo_response FAILED>")
# clear cache, response_types are remembered
resp.clear_cache()
assert str(resp) == "<Response(<DummyContext object>): No changes made>"
assert resp.__responses__["foo_response"] == []
assert resp.__responses__["other_response"] == []
def test_response_kwargs():
resp = Response(DummyContext())
resp.add("foo_response", foo="foo1", bar="bar1")
assert resp.has_failed is False
assert resp.made_changes is True
assert resp.response_types == ["foo_response"]
assert len(list(resp.completed())) == 1
assert list(resp.failed()) == []
assert "foo_response" in resp
assert isinstance(resp["foo_response"][0], ItemResponse)
assert str(resp) == "<Response(<DummyContext object>): foo_response: 1>"
assert resp["foo_response"][0].kwargs["foo"] == "foo1"
assert resp["foo_response"][0].kwargs["bar"] == "bar1"
assert str(resp["foo_response"][0]).startswith(
"<ItemResponse(<Response(<DummyContext object>): foo_response: 1>): "
"foo_response")
assert "'foo': 'foo1'" in str(resp["foo_response"][0])
assert "'bar': 'bar1'" in str(resp["foo_response"][0])
def test_response_msg():
resp = Response(DummyContext())
resp.add("foo_response", msg="Response message")
assert resp.has_failed is False
assert resp.made_changes is True
assert resp.response_types == ["foo_response"]
assert len(list(resp.completed())) == 1
assert list(resp.failed()) == []
assert "foo_response" in resp
assert isinstance(resp["foo_response"][0], ItemResponse)
assert str(resp) == "<Response(<DummyContext object>): foo_response: 1>"
assert str(resp["foo_response"][0]) == (
"<ItemResponse(<Response(<DummyContext object>): foo_response: 1>): "
"foo_response Response message>")
| 5,761
|
Python
|
.py
| 129
| 39.775194
| 81
| 0.681567
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,987
|
lang_mapper.py
|
translate_pootle/tests/misc/lang_mapper.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from collections import OrderedDict
import pytest
from pytest_pootle.factories import ProjectDBFactory
from pootle.core.delegate import lang_mapper
from pootle_config.utils import ObjectConfig, SiteConfig
from pootle_language.models import Language
@pytest.mark.django_db
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]))
@pytest.mark.django_db
def test_lang_mapper_no_config(po_directory, english):
project = ProjectDBFactory(source_language=english)
mapper = lang_mapper.get(project.__class__, instance=project)
# lang exists and its valid
assert mapper["en"] == english
assert mapper.get_pootle_code("en") == "en"
assert mapper.get_upstream_code("en") == "en"
assert "en" in mapper
# The lang doesnt exist but its not excluded
assert mapper["en_FOO"] is None
assert mapper.get_pootle_code("en_FOO") == "en_FOO"
assert mapper.get_upstream_code("en_FOO") == "en_FOO"
assert "en_FOO" not in mapper
@pytest.mark.django_db
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"
@pytest.mark.django_db
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
@pytest.mark.django_db
def test_lang_mapper_mappings(po_directory, 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 _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()))
| 6,626
|
Python
|
.py
| 144
| 40.493056
| 80
| 0.697289
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,988
|
models.py
|
translate_pootle/tests/pootle_language/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.delegate import revision
from pootle_app.models import Directory
from pootle_language.models import Language
@pytest.mark.django_db
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
| 946
|
Python
|
.py
| 23
| 37.695652
| 77
| 0.756257
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,989
|
teams.py
|
translate_pootle/tests/pootle_language/teams.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.contrib.auth import get_user_model
from pootle.core.delegate import language_team
from pootle_language.models import Language
from pootle_language.teams import LanguageTeam
from pootle_store.constants import OBSOLETE
from pootle_store.models import Suggestion
@pytest.mark.django_db
def test_language_team_getter(language0):
team = language_team.get(Language)(language0)
assert isinstance(team, LanguageTeam)
@pytest.mark.django_db
def test_language_team_members(language0, member):
team = language_team.get(Language)(language0)
assert (
list(team.members)
== list(team.submitters)
== list(team.reviewers)
== list(team.admins)
== [])
team.add_member(member, "member")
assert list(team.members) == [member]
assert (
list(team.submitters)
== list(team.reviewers)
== list(team.admins)
== [])
assert (
member.permissionset_set
.filter(directory=language0.directory)
.filter(positive_permissions__codename="suggest")
.count()
== 1)
assert (
member.permissionset_set
.filter(directory=language0.directory)
.exclude(positive_permissions__codename="suggest")
.count()
== 0)
team.add_member(member, "submitter")
assert list(team.submitters) == [member]
assert (
list(team.members)
== list(team.reviewers)
== list(team.admins)
== [])
assert (
member.permissionset_set
.filter(directory=language0.directory)
.filter(positive_permissions__codename__in=["suggest",
"translate"])
.count()
== 2)
assert (
member.permissionset_set
.filter(directory=language0.directory)
.exclude(positive_permissions__codename__in=["suggest",
"translate"])
.count()
== 0)
team.add_member(member, "reviewer")
assert list(team.reviewers) == [member]
assert (
list(team.members)
== list(team.submitters)
== list(team.admins)
== [])
assert (
member.permissionset_set
.filter(directory=language0.directory)
.filter(positive_permissions__codename__in=["suggest",
"review",
"translate"])
.count()
== 3)
assert (
member.permissionset_set
.filter(directory=language0.directory)
.exclude(positive_permissions__codename__in=["suggest",
"review",
"translate"])
.count()
== 0)
team.add_member(member, "admin")
assert list(team.admins) == [member]
assert (
list(team.members)
== list(team.submitters)
== list(team.reviewers)
== [])
assert (
member.permissionset_set
.filter(directory=language0.directory)
.filter(positive_permissions__codename__in=["suggest",
"review",
"administrate",
"translate"])
.count()
== 4)
assert (
member.permissionset_set
.filter(directory=language0.directory)
.exclude(positive_permissions__codename__in=["suggest",
"review",
"administrate",
"translate"])
.count()
== 0)
team.remove_member(member)
assert (
list(team.members)
== list(team.submitters)
== list(team.reviewers)
== list(team.admins)
== [])
assert (
member.permissionset_set
.filter(directory=language0.directory)
.filter(positive_permissions__codename__in=["suggest",
"review",
"administrate",
"translate"])
.count()
== 0)
@pytest.mark.django_db
def test_language_team_non_members(language0, member):
team = language_team.get(Language)(language0)
team.add_member(member, "member")
User = get_user_model()
assert (
sorted(team.non_members.values_list("id", flat=True))
== sorted(
User.objects.exclude(
username=member.username).values_list("id", flat=True)))
@pytest.mark.django_db
def test_language_team_suggestions(language0):
team = language_team.get(Language)(language0)
suggestions = (
Suggestion.objects.filter(
state__name="pending",
unit__state__gt=OBSOLETE,
unit__store__translation_project__language=language0
).exclude(
unit__store__translation_project__project__disabled=True
).exclude(unit__store__obsolete=True))
assert (
list(team.suggestions)
== list(suggestions.order_by("-creation_time", "-pk")))
# there should be some suggestions in the env
assert team.suggestions
assert (
team.users_with_suggestions
== set(
team.suggestions.values_list(
"user__username",
"user__full_name")))
| 6,100
|
Python
|
.py
| 163
| 24.417178
| 77
| 0.523793
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,990
|
panels.py
|
translate_pootle/tests/pootle_language/panels.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.template import loader
from pootle.core.browser import get_table_headings
from pootle.core.delegate import panels
from pootle_app.models.permissions import get_matching_permissions
from pootle_app.panels import ChildrenPanel
from pootle_language.views import LanguageBrowseView
@pytest.mark.django_db
def test_panel_language_table(language0, rf, member):
request = rf.get('/language0/')
request.user = member
request.permissions = get_matching_permissions(
request.user,
language0.directory)
view = LanguageBrowseView(
kwargs=dict(language_code=language0.code))
view.request = request
view.object = view.get_object()
lang_panels = panels.gather(LanguageBrowseView)
assert lang_panels.keys() == ["children"]
assert lang_panels["children"] == ChildrenPanel
panel = ChildrenPanel(view)
assert panel.panel_name == "children"
assert (
panel.cache_key
== ("panel.%s.%s"
% (panel.panel_name, view.cache_key)))
table = {
'id': view.view_name,
'fields': panel.table_fields,
'headings': get_table_headings(panel.table_fields),
'rows': view.object_children}
assert panel.table == table
assert panel.get_context_data() == dict(
table=table, can_translate=view.can_translate)
content = loader.render_to_string(
panel.template_name, context=panel.get_context_data())
assert (
panel.content
== panel.update_times(content))
| 1,800
|
Python
|
.py
| 47
| 33.234043
| 77
| 0.709049
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,991
|
forms.py
|
translate_pootle/tests/pootle_language/forms.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from mock import PropertyMock, patch
import pytest
from django.urls import reverse
from pootle.i18n.gettext import ugettext_lazy as _
from pootle_language.forms import (
LanguageSuggestionAdminForm,
LanguageTeamAdminForm, LanguageTeamNewMemberSearchForm)
from pootle_language.teams import LanguageTeam
from pootle_store.constants import FUZZY, OBSOLETE
@pytest.mark.django_db
def test_form_language_team_new_member(language0, member):
form = LanguageTeamNewMemberSearchForm(language=language0)
assert isinstance(form.language_team, LanguageTeam)
form = LanguageTeamNewMemberSearchForm(
language=language0,
data=dict(q=member.username[:2]))
assert form.is_valid()
assert (
dict(text=member.username, id=member.id)
in form.search()["results"])
form.language_team.add_member(member, "member")
assert (
dict(text=member.username, id=member.id)
not in form.search()["results"])
@pytest.mark.django_db
def test_form_language_admin(language0, member, member2):
form = LanguageTeamAdminForm(language=language0)
assert form.language == language0
assert isinstance(form.language_team, LanguageTeam)
for role in form.language_team.roles:
assert(
list(form.fields["rm_%ss" % role].queryset.values_list("id", flat=True))
== list(getattr(form.language_team, "%ss" % role)))
assert (
form.fields["new_member"].widget.attrs["data-select2-url"]
== reverse(
"pootle-language-admin-team-new-members",
kwargs=dict(language_code=language0.code)))
assert (
list(form.fields["new_member"].queryset.values_list("id", flat=True))
== list(form.language_team.non_members.values_list("id", flat=True)))
# add a team member
assert member not in form.language_team.members
form = LanguageTeamAdminForm(
language=language0,
data=dict(new_member=member.id, role="member"))
assert form.is_valid()
form.save()
assert member in form.language_team.members
# add another team member
assert member2 not in form.language_team.members
form = LanguageTeamAdminForm(
language=language0,
data=dict(new_member=member2.id, role="member"))
assert form.is_valid()
form.save()
assert member in form.language_team.members
assert member2 in form.language_team.members
# remove the first
form = LanguageTeamAdminForm(
language=language0,
data=dict(rm_members=[member.pk]))
assert form.is_valid()
form.save()
assert member not in form.language_team.members
# adding takes priority
form = LanguageTeamAdminForm(
language=language0,
data=dict(
new_member=member.id,
role="reviewer",
rm_members=[member2.id]))
assert form.is_valid()
form.save()
assert member in form.language_team.reviewers
assert member2 in form.language_team.members
@pytest.mark.django_db
def test_form_language_admin_bad(language0, member):
form = LanguageTeamAdminForm(
language=language0,
data=dict(new_member="DOES NOT EXIST", role="member"))
assert not form.is_valid()
assert form.errors["new_member"]
form = LanguageTeamAdminForm(
language=language0,
data=dict(new_member=member.id))
assert form.errors["role"]
@pytest.mark.django_db
def test_form_language_suggestions(language0, admin):
form = LanguageSuggestionAdminForm(
language=language0, user=admin)
suggesters = list(
(username,
("%s (%s)" % (fullname, username)
if fullname.strip()
else username))
for username, fullname
in sorted(form.language_team.users_with_suggestions))
assert (
form.filter_suggester_choices
== [("", "-----")] + suggesters)
suggestions = form.language_team.suggestions.filter(
unit__store__translation_project__project__disabled=False,
unit__store__obsolete=False)
assert (
list(form.suggestions_qs.values_list("id", flat=True))
== list(
suggestions.values_list("id", flat=True)))
tps = form.language.translationproject_set.exclude(
project__disabled=True)
tps = tps.filter(
stores__unit__suggestion__state__name="pending")
assert (
list(form.filter_tp_qs.values_list("id"))
== list(tps.order_by("project__code").distinct().values_list("id")))
assert (
list(form.fields["filter_suggester"].choices)
== list(form.filter_suggester_choices))
assert (
list(form.fields["filter_tp"].queryset)
== list(form.filter_tp_qs))
assert (
list(form.fields["suggestions"].queryset)
== list(form.suggestions_qs))
assert (
form.fields["actions"].choices
== [("", "----"),
("reject", _("Reject")),
("accept", _("Accept"))])
@pytest.mark.django_db
def test_form_language_suggestions_save(language0, admin):
form = LanguageSuggestionAdminForm(
language=language0,
user=admin)
suggestions = form.language_team.suggestions[:3]
form = LanguageSuggestionAdminForm(
language=language0,
user=admin,
data=dict(
actions="accept",
suggestions=list(
suggestions.values_list(
"id", flat=True))))
assert form.is_valid()
assert (
list(form.suggestions_to_save)
== list(suggestions))
form.save()
for suggestion in form.suggestions_to_save:
assert suggestion.state.name == "accepted"
@pytest.mark.django_db
def test_form_language_suggestions_save_all(language0, tp0, admin):
form = LanguageSuggestionAdminForm(
language=language0,
user=admin,
data=dict(
actions="reject",
select_all=True,
filter_tp=tp0.id))
assert (
list(form.suggestions_to_save)
== list(
form.language_team.suggestions.filter(
unit__store__translation_project=tp0)))
form.save()
for suggestion in form.suggestions_to_save:
assert suggestion.state.name == "rejected"
@pytest.mark.django_db
def test_form_language_suggestions_search(language0, tp0, admin):
form = LanguageSuggestionAdminForm(language=language0, user=admin)
team = form.language_team
suggester = team.users_with_suggestions.pop()[0]
suggestions = form.language_team.suggestions.filter(
unit__store__translation_project__project__disabled=False,
unit__store__obsolete=False)
form = LanguageSuggestionAdminForm(
language=language0,
user=admin,
data=dict(filter_suggester=suggester))
assert form.is_valid()
assert (
list(form.search())
== list(suggestions.filter(user__username=suggester)))
form = LanguageSuggestionAdminForm(
language=language0,
user=admin,
data=dict(filter_tp=tp0.id))
assert form.is_valid()
assert (
list(form.search())
== list(suggestions.filter(unit__store__translation_project=tp0)))
form = LanguageSuggestionAdminForm(
language=language0,
user=admin,
data=dict(filter_state=FUZZY))
assert form.is_valid()
assert (
list(form.search())
== list(suggestions.filter(unit__state=FUZZY)))
@pytest.mark.django_db
def test_form_language_suggestions_bad(language0, tp0, admin):
with pytest.raises(KeyError):
LanguageSuggestionAdminForm(language=language0)
with pytest.raises(KeyError):
LanguageSuggestionAdminForm(user=admin)
form = LanguageSuggestionAdminForm(
language=language0,
user=admin,
data=dict(filter_tp=tp0.id, filter_state=OBSOLETE))
assert not form.is_valid()
assert (
list(form.batch().paginator.object_list)
== list(
form.language_team.suggestions.filter(
unit__store__translation_project=tp0)))
assert not form.suggestions_review
assert not form.suggestions_to_save
@pytest.mark.django_db
@patch(
'pootle_language.forms.LanguageSuggestionAdminForm.suggestions_review',
new_callable=PropertyMock)
def test_form_language_suggestions_accept_comment(review_mock, language0,
tp0, admin):
review_mock.configure_mock(**{'return_value.accept.return_value': 23})
form = LanguageSuggestionAdminForm(
language=language0,
user=admin,
data=dict(
actions="accept",
comment="no thanks",
select_all=True,
filter_tp=tp0.id))
assert (
list(form.suggestions_to_save)
== list(
form.language_team.suggestions.filter(
unit__store__translation_project=tp0)))
assert form.save() == 23
assert (
list(review_mock.return_value.accept.call_args)
== [(), {'comment': u'no thanks'}])
@pytest.mark.django_db
def test_form_language_suggestions_reject_comment(language0, tp0, admin,
member2_with_email,
mailoutbox):
form = LanguageSuggestionAdminForm(
language=language0,
user=admin,
data=dict(
actions="reject",
comment="no thanks",
select_all=True,
filter_tp=tp0.id))
assert (
list(form.suggestions_to_save)
== list(
form.language_team.suggestions.filter(
unit__store__translation_project=tp0)))
form.save()
for suggestion in form.suggestions_to_save:
assert suggestion.state.name == "rejected"
assert len(mailoutbox) == 1
for suggestion in form.suggestions_to_save:
assert ("#%s" % suggestion.id) in mailoutbox[0].body
assert "reject" in mailoutbox[0].subject.lower()
| 10,252
|
Python
|
.py
| 272
| 30.029412
| 84
| 0.655211
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,992
|
views.py
|
translate_pootle/tests/pootle_language/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import json
import pytest
from django import forms
from django.urls import reverse
from pootle.core.browser import make_project_item
from pootle.core.delegate import language_team
from pootle.core.exceptions import Http400
from pootle.core.forms import FormtableForm
from pootle.core.views.browse import StatsDisplay
from pootle_language.forms import (
LanguageSuggestionAdminForm, LanguageTeamAdminForm)
from pootle_language.views import (
LanguageBrowseView, SuggestionDisplay, SuggestionFormtable)
from pootle_misc.util import cmp_by_last_activity
from pootle_store.constants import STATES_MAP
from pootle_store.models import Unit
class DummyFormtableForm(FormtableForm):
search_field = "units"
units = forms.ModelMultipleChoiceField(
Unit.objects.order_by("id"),
required=False)
def _test_view_language_children(view, obj):
request = view.request
user_tps = obj.get_children_for_user(request.user)
stats = obj.data_tool.get_stats(user=request.user)
items = [make_project_item(tp) for tp in user_tps]
for item in items:
if item["code"] in stats["children"]:
item["stats"] = stats["children"][item["code"]]
items.sort(cmp_by_last_activity)
stats = StatsDisplay(obj, stats=stats).stats
assert stats == view.stats
assert view.object_children == items
@pytest.mark.django_db
def test_view_language_team_new_member(client, language0, request_users,
member, member2):
user = request_users["user"]
team = language_team.get(language0.__class__)(language0)
admin_url = reverse(
'pootle-language-admin-team-new-members',
kwargs=dict(language_code=language0.code))
client.login(
username=user.username,
password=request_users["password"])
if not user.is_superuser:
response = client.post(admin_url)
assert response.status_code == 403
else:
with pytest.raises(Http400):
client.post(admin_url)
response = client.post(admin_url, data=dict(q="DOES NOT EXIST"))
if not user.is_superuser:
if user.is_anonymous:
assert response.status_code == 402
return
assert response.status_code == 403
team.add_member(user, "admin")
response = client.post(admin_url, data=dict(q="DOES NOT EXIST"))
assert json.loads(response.content)["items"]["results"] == []
search_member = (
member
if user == member2
else member2)
response = client.post(admin_url, data=dict(q=search_member.username[:2]))
result = json.loads(response.content)
assert search_member.username in [r["text"] for r in result["items"]["results"]]
team = language_team.get(language0.__class__)(language0)
team.add_member(search_member, "member")
response = client.post(admin_url, data=dict(q=search_member.username[:2]))
result = json.loads(response.content)
assert (
search_member.username
not in [r["text"] for r in result["items"]["results"]])
if user in team.admins:
team.remove_member(user)
from django.core.cache import cache
from django.utils.encoding import iri_to_uri
key = iri_to_uri('Permissions:%s' % user.username)
key = iri_to_uri('Permissions:%s' % search_member.username)
cache.delete(key)
@pytest.mark.django_db
def test_view_language_team_admin(client, language0, request_users):
user = request_users["user"]
team = language_team.get(language0.__class__)(language0)
admin_url = reverse(
'pootle-language-admin-team',
kwargs=dict(language_code=language0.code))
client.login(
username=user.username,
password=request_users["password"])
response = client.get(admin_url)
if not user.is_superuser:
assert response.status_code == 403
if user.is_anonymous:
return
team.add_member(user, "admin")
response = client.get(admin_url)
assert isinstance(
response.context["form"], LanguageTeamAdminForm)
assert (
list(response.context["tps"])
== list(
language0.translationproject_set.exclude(
project__disabled=True)))
for k in response.context["stats"].keys():
if k.endswith("_display"):
del response.context["stats"][k]
assert (
sorted(response.context["stats"])
== sorted(
language0.data_tool.get_stats(
include_children=False,
user=user)))
assert (
response.context["suggestions"]
== response.context["form"].language_team.suggestions.count())
assert response.context["language"] == language0
if user in team.admins:
team.remove_member(user)
@pytest.mark.django_db
def test_view_language_team_admin_post(client, language0, request_users,
member, member2):
user = request_users["user"]
team = language_team.get(language0.__class__)(language0)
search_member = (
member
if user == member2
else member2)
assert search_member not in team.members
admin_url = reverse(
'pootle-language-admin-team',
kwargs=dict(language_code=language0.code))
client.login(
username=user.username,
password=request_users["password"])
response = client.post(
admin_url,
data=dict(new_member=search_member.id, role="member"))
if not user.is_superuser:
assert search_member not in team.members
if user.is_anonymous:
assert response.status_code == 402
return
team.add_member(user, "admin")
response = client.post(
admin_url,
data=dict(new_member=search_member.id, role="member"))
team.update_permissions()
assert search_member in team.members
assert response.status_code == 302
response = client.post(
admin_url,
data=dict(rm_members=[search_member.id]))
team.update_permissions()
assert search_member not in team.members
assert response.status_code == 302
# TODO: move me to somewhere suggestion related
@pytest.mark.django_db
def test_display_language_suggestion(language0):
team = language_team.get()(language0)
suggestion = team.suggestions.first()
display = SuggestionDisplay(suggestion)
assert display.__suggestion__ is suggestion
assert (
display.project
== ("<a href='%s'>%s</a>"
% (suggestion.unit.store.translation_project.pootle_path,
suggestion.unit.store.translation_project.project.code)))
assert display.unit == display.__suggestion__.unit.source
assert (
display.unit_link
== ("<a href='%s'>#%s</a>"
% (suggestion.unit.get_translate_url(),
suggestion.unit.id)))
assert (
str(display.unit_state)
== STATES_MAP[suggestion.unit.state])
assert (
display.state
== suggestion.state)
with pytest.raises(AttributeError):
display.DOES_NOT_EXIST
@pytest.mark.django_db
def test_formtable_language_team_suggestions(language0):
formtable = SuggestionFormtable(DummyFormtableForm())
assert formtable.row_field == "suggestions"
assert (
formtable.filters_template
== "languages/admin/includes/suggestions_header.html")
assert formtable.messages == []
formtable = SuggestionFormtable(DummyFormtableForm(), messages=["FOO"])
assert formtable.messages == ["FOO"]
@pytest.mark.django_db
def test_view_admin_language_team_suggestion(client, language0, request_users):
user = request_users["user"]
team = language_team.get(language0.__class__)(language0)
admin_url = reverse(
'pootle-language-admin-suggestions',
kwargs=dict(language_code=language0.code))
client.login(
username=user.username,
password=request_users["password"])
response = client.get(admin_url)
if not user.is_superuser:
assert response.status_code == 403
if user.is_anonymous:
return
team.add_member(user, "admin")
response = client.get(admin_url)
assert response.context["language"] == language0
assert response.context["page"] == "admin-suggestions"
formtable = response.context["formtable"]
assert isinstance(formtable, SuggestionFormtable)
assert isinstance(formtable.form, LanguageSuggestionAdminForm)
assert formtable.form.user == response.wsgi_request.user
assert formtable.form.language == language0
assert formtable.form.data == dict(
page_no=1,
results_per_page=10)
assert (
[x[0] for x in formtable.form.fields["suggestions"].choices]
== [item.id
for item in
formtable.form.batch().object_list])
assert isinstance(
formtable.form.fields["suggestions"].choices[0][1],
SuggestionDisplay)
@pytest.mark.django_db
def test_view_admin_language_suggestion_post(client, language0, request_users,
mailoutbox):
user = request_users["user"]
team = language_team.get(language0.__class__)(language0)
admin_url = reverse(
'pootle-language-admin-suggestions',
kwargs=dict(language_code=language0.code))
client.login(
username=user.username,
password=request_users["password"])
suggestion = team.suggestions.first()
data = dict(
actions="accept",
suggestions=[suggestion.id])
response = client.post(admin_url, data=data)
if not user.is_superuser:
if user.is_anonymous:
assert response.status_code == 402
return
assert response.status_code == 403
team.add_member(user, "admin")
response = client.post(admin_url, data=data)
assert response.status_code == 302
suggestion.refresh_from_db()
assert suggestion.state.name == "accepted"
assert len(mailoutbox) == 0
# reject
suggestion = team.suggestions.first()
data = dict(
actions="reject",
suggestions=[suggestion.id])
response = client.post(admin_url, data=data)
assert response.status_code == 302
suggestion.refresh_from_db()
assert suggestion.state.name == "rejected"
assert len(mailoutbox) == 0
# reject with comment
suggestion = team.suggestions.first()
data = dict(
actions="accept",
comment="ta very much!",
suggestions=[suggestion.id])
response = client.post(admin_url, data=data)
assert response.status_code == 302
suggestion.refresh_from_db()
assert suggestion.state.name == "accepted"
assert len(mailoutbox) == 1
# reject with comment
suggestion = team.suggestions.first()
data = dict(
actions="reject",
comment="no way!",
suggestions=[suggestion.id])
response = client.post(admin_url, data=data)
assert response.status_code == 302
suggestion.refresh_from_db()
assert suggestion.state.name == "rejected"
assert len(mailoutbox) == 2
@pytest.mark.django_db
def test_view_language_children(language0, rf, request_users):
request = rf.get('/language0/')
request.user = request_users["user"]
view = LanguageBrowseView(
kwargs=dict(
language_code=language0.code))
view.request = request
view.object = view.get_object()
assert view.object == language0
_test_view_language_children(view, language0)
| 11,798
|
Python
|
.py
| 304
| 31.884868
| 84
| 0.670127
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,993
|
models.py
|
translate_pootle/tests/pootle_score/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from datetime import timedelta
from django.db.utils import IntegrityError
from django.utils import timezone
from pootle_score.models import UserStoreScore, UserTPScore
@pytest.mark.django_db
def test_user_tp_score_repr(tp0, member):
score = UserTPScore.objects.create(
user=member,
tp=tp0,
score=2,
date=timezone.now().date() + timedelta(days=5))
score_info = (
"%s(%s) %s score: %s, suggested: %s, translated: %s, reviewed: %s"
% (score.user.username,
score.tp.pootle_path,
score.date,
score.score,
score.suggested,
score.translated,
score.reviewed))
assert str(score) == score_info
assert repr(score) == u"<UserTPScore: %s>" % score_info
@pytest.mark.django_db
def test_user_tp_score_instance(tp0, member):
theday = timezone.now().date() + timedelta(days=5)
score = UserTPScore.objects.create(
user=member, tp=tp0, score=2, date=theday)
assert score.user == member
assert score.tp == tp0
assert score.date == theday
assert score.score is 2
assert score.suggested is 0
assert score.translated is 0
assert score.reviewed is 0
score.score = -3
score.suggested = 1
score.translated = 4
score.reviewed = 10005
score.save()
@pytest.mark.django_db
def test_user_tp_score_bad_no_user(tp0, member):
with pytest.raises(IntegrityError):
UserTPScore.objects.create(
tp=tp0,
score=2,
date=timezone.now().date() + timedelta(days=5))
@pytest.mark.django_db
def test_user_tp_score_bad_no_tp(tp0, member):
with pytest.raises(IntegrityError):
UserTPScore.objects.create(
user=member,
score=2,
date=timezone.now().date() + timedelta(days=5))
@pytest.mark.django_db
def test_user_tp_score_bad_no_date(tp0, member):
with pytest.raises(IntegrityError):
UserTPScore.objects.create(
user=member, tp=tp0, score=2)
@pytest.mark.django_db
def test_user_tp_score_bad_dupe(tp0, member):
theday = timezone.now().date() + timedelta(days=5)
UserTPScore.objects.create(
user=member, tp=tp0, score=2, date=theday)
with pytest.raises(IntegrityError):
UserTPScore.objects.create(
user=member, tp=tp0, score=3, date=theday)
@pytest.mark.django_db
def test_user_store_score_repr(store0, member):
score = UserStoreScore.objects.create(
user=member,
store=store0,
score=2,
date=timezone.now().date() + timedelta(days=5))
score_info = (
"%s(%s) %s score: %s, suggested: %s, translated: %s, reviewed: %s"
% (score.user.username,
score.store.pootle_path,
score.date,
score.score,
score.suggested,
score.translated,
score.reviewed))
assert str(score) == score_info
assert repr(score) == u"<UserStoreScore: %s>" % score_info
| 3,273
|
Python
|
.py
| 92
| 29.119565
| 77
| 0.656339
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,994
|
receivers.py
|
translate_pootle/tests/pootle_score/receivers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle.core.delegate import review
from pootle.core.utils.timezone import localdate
from pootle_store.constants import UNTRANSLATED
from pootle_store.models import Suggestion
@pytest.mark.django_db
def test_user_tp_score_update_suggestions(store0, member, member2):
unit = store0.units.filter(state=UNTRANSLATED)[0]
suggestions = review.get(Suggestion)
suggestion_text = "made a suggestion!"
# member adds a suggestion
# score and sugg increase
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
old_suggested = current_score.suggested
old_score = round(current_score.score, 2)
old_suggested = current_score.suggested
old_translated = current_score.translated
old_reviewed = current_score.reviewed
sugg, added = suggestions().add(
unit, suggestion_text, user=member)
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(current_score.score, 2) == old_score
assert (
current_score.suggested
== old_suggested + unit.unit_source.source_wordcount)
assert current_score.translated == old_translated
assert current_score.reviewed == old_reviewed
# member2 reviews members suggestion
# score and review increase
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
old_m2_score = round(m2_score.score, 2)
old_m2_suggested = m2_score.suggested
old_m2_translated = m2_score.translated
old_m2_reviewed = m2_score.reviewed
suggestions([sugg], member2).accept()
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(m2_score.score, 2) > old_m2_score
assert (
m2_score.reviewed
== old_m2_reviewed + unit.unit_source.source_wordcount)
assert m2_score.suggested == old_m2_suggested
assert m2_score.translated == old_m2_translated
@pytest.mark.django_db
def test_user_tp_score_update_translated(store0, member, member2):
# member translates another unit, by suggesting and
# accepting own suggestion
# score, suggested and translated increase
suggestion_text = "made a suggestion!"
suggestions = review.get(Suggestion)
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
old_score = round(current_score.score, 2)
old_suggested = current_score.suggested
old_translated = current_score.translated
old_reviewed = current_score.reviewed
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
m2_old_score = round(m2_score.score, 2)
m2_suggested = m2_score.suggested
m2_translated = m2_score.translated
m2_reviewed = m2_score.reviewed
unit = store0.units.filter(state=UNTRANSLATED)[0]
sugg, added = suggestions().add(
unit, suggestion_text, user=member)
suggestions([sugg], member2).accept()
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(current_score.score, 2) > old_score
assert current_score.reviewed == old_reviewed
assert (
current_score.suggested
== old_suggested + unit.unit_source.source_wordcount)
assert (
current_score.translated
== old_translated + unit.unit_source.source_wordcount)
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(m2_score.score, 2) > m2_old_score
assert m2_score.suggested == m2_suggested
assert m2_score.translated == m2_translated
assert (
m2_score.reviewed
== m2_reviewed + unit.unit_source.source_wordcount)
@pytest.mark.django_db
def test_user_tp_score_update_rejects(store0, member, member2):
# member makes another suggestion then member2 rejects
suggestion_text = "made a suggestion!"
suggestions = review.get(Suggestion)
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
old_score = round(current_score.score, 2)
old_suggested = current_score.suggested
old_translated = current_score.translated
old_reviewed = current_score.reviewed
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
m2_old_score = round(m2_score.score, 2)
m2_suggested = m2_score.suggested
m2_translated = m2_score.translated
m2_reviewed = m2_score.reviewed
unit = store0.units.filter(state=UNTRANSLATED)[0]
sugg, added = suggestions().add(
unit, suggestion_text, user=member)
suggestions([sugg], member2).reject()
current_score = member.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(current_score.score, 2) == old_score
assert current_score.reviewed == old_reviewed
assert current_score.translated == old_translated
assert (
current_score.suggested
== old_suggested + unit.unit_source.source_wordcount)
m2_score = member2.scores.get(
tp=store0.translation_project,
date=localdate())
assert round(m2_score.score, 2) > m2_old_score
assert m2_score.suggested == m2_suggested
assert m2_score.translated == m2_translated
assert (
m2_score.reviewed
== m2_reviewed + unit.unit_source.source_wordcount)
| 5,739
|
Python
|
.py
| 143
| 34.412587
| 77
| 0.707252
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,995
|
utils.py
|
translate_pootle/tests/pootle_score/utils.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from datetime import timedelta
import pytest
from django.contrib.auth import get_user_model
from django.db.models import Sum
from accounts.proxy import DisplayUser
from pootle.core.delegate import revision, scores
from pootle.core.utils.timezone import localdate
from pootle.i18n import formatter
from pootle_app.models import Directory
from pootle_language.models import Language
from pootle_score.apps import PootleScoreConfig
from pootle_score.display import TopScoreDisplay
from pootle_score.models import UserTPScore
from pootle_score.utils import (
LanguageScores, ProjectScores, ProjectSetScores, TPScores, UserScores)
User = get_user_model()
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
@pytest.mark.django_db
def test_scores_language(language0):
score_data = scores.get(language0.__class__)(language0)
assert isinstance(score_data, LanguageScores)
_test_scores("language", language0, score_data)
assert (
score_data.cache_key
== ("%s.%s.%s"
% (language0.code,
localdate(),
score_data.revision)))
qs = score_data.scores_within_days(30)
assert (
list(score_data.filter_scores(qs))
== list(qs.filter(tp__language_id=language0.id)))
@pytest.mark.django_db
def test_scores_project(project0):
score_data = scores.get(project0.__class__)(project0)
assert isinstance(score_data, ProjectScores)
_test_scores("project", project0, score_data)
assert (
score_data.cache_key
== ("%s.%s.%s"
% (project0.code,
localdate(),
score_data.revision)))
qs = score_data.scores_within_days(30)
assert (
list(score_data.filter_scores(qs))
== list(qs.filter(tp__project_id=project0.id)))
@pytest.mark.django_db
def test_scores_tp(tp0):
score_data = scores.get(tp0.__class__)(tp0)
assert isinstance(score_data, TPScores)
_test_scores("tp", tp0, score_data)
assert (
score_data.cache_key
== ("%s/%s.%s.%s"
% (tp0.language.code,
tp0.project.code,
localdate(),
score_data.revision)))
qs = score_data.scores_within_days(30)
assert (
list(score_data.filter_scores(qs))
== list(qs.filter(tp_id=tp0.id)))
@pytest.mark.django_db
def test_scores_project_set(project_set):
score_data = scores.get(project_set.__class__)(project_set)
assert isinstance(score_data, ProjectSetScores)
_test_scores("projects", project_set, score_data)
assert (
score_data.cache_key
== ("%s.%s"
% (localdate(),
score_data.revision)))
qs = score_data.scores_within_days(30)
assert score_data.filter_scores(qs) is qs
@pytest.mark.django_db
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,
localdate(),
score_data.revision)))
# system gets no rank
sys_score_data = scores.get(system.__class__)(system)
assert (
sys_score_data.top_language
== (-1, None))
| 6,981
|
Python
|
.py
| 176
| 32.198864
| 83
| 0.638025
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,996
|
updater.py
|
translate_pootle/tests/pootle_score/updater.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from datetime import timedelta
from mock import PropertyMock, patch
import pytest
from django.db.models import Sum
from pootle.core.delegate import event_score, score_updater
from pootle.core.plugin import provider
from pootle.core.plugin.results import GatheredDict
from pootle.core.utils.timezone import localdate
from pootle_log.utils import LogEvent, StoreLog
from pootle_score.models import UserStoreScore
from pootle_score.updater import (
StoreScoreUpdater, TPScoreUpdater, UserScoreUpdater)
from pootle_score.utils import to_datetime
from pootle_store.models import Store
from pootle_translationproject.models import TranslationProject
GET_EVENT_KWARGS = {
'end': None,
'users': None,
'event_sources': ('suggestion', 'submission'),
'include_meta': False,
'start': None,
'only': {
'submission': (
'unit__unit_source__source_wordcount',
'unit__unit_source__created_by_id',
'unit_id',
'submitter__id',
'old_value',
'new_value',
'creation_time',
'revision',
'field'),
'suggestion': (
'unit__unit_source__source_wordcount',
'user_id',
'reviewer_id',
'state_id')},
'ordered': False}
@pytest.mark.django_db
def test_score_store_updater(store0, admin):
updater = score_updater.get(Store)(store0)
assert updater.store == store0
assert updater.user is None
assert isinstance(updater, StoreScoreUpdater)
assert isinstance(updater.logs, StoreLog)
assert updater.event_class == LogEvent
assert isinstance(updater.scoring, GatheredDict)
updater = score_updater.get(Store)(store0, user=admin)
assert updater.user == admin
@pytest.mark.django_db
@patch('pootle_score.updater.StoreScoreUpdater.logs', new_callable=PropertyMock)
def test_score_store_updater_event(logs_mock, store0, admin, member,
today, yesterday):
unit0 = store0.units[0]
unit1 = store0.units[1]
_events = [
LogEvent(unit0, admin, today, "action0", 0),
LogEvent(unit0, admin, yesterday, "action1", 1),
LogEvent(unit1, member, today, "action2", 2)]
def _get_events(start=None, end=None, **kwargs):
for event in _events:
yield event
logs_mock.configure_mock(
**{'return_value.get_events.side_effect': _get_events})
updater = StoreScoreUpdater(store0)
result = updater.calculate()
assert (
list(logs_mock.return_value.get_events.call_args)
== [(), GET_EVENT_KWARGS])
# no score adapters
assert result == {}
result = updater.calculate(start=yesterday, end=today)
kwargs = GET_EVENT_KWARGS.copy()
kwargs['start'] = to_datetime(yesterday)
kwargs['end'] = to_datetime(today)
assert (
list(logs_mock.return_value.get_events.call_args)
== [(), kwargs])
assert result == {}
updater = StoreScoreUpdater(store0)
updater.calculate(users=(admin, ))
kwargs = GET_EVENT_KWARGS.copy()
kwargs['users'] = (admin, )
assert (
list(logs_mock.return_value.get_events.call_args)
== [(), kwargs])
updater.calculate(users=(admin, member))
kwargs['users'] = (admin, member)
assert (
list(logs_mock.return_value.get_events.call_args)
== [(), kwargs])
@pytest.mark.django_db
@patch('pootle_score.updater.StoreScoreUpdater.logs', new_callable=PropertyMock)
def test_score_store_updater_event_score(logs_mock, store0,
admin, member, member2,
today, yesterday,
dt_today, dt_yesterday):
unit0 = store0.units[0]
unit1 = store0.units[1]
_events = [
LogEvent(unit0, admin, dt_yesterday, "action0", 0),
LogEvent(unit0, admin, dt_yesterday, "action1", 1),
LogEvent(unit0, admin, dt_today, "action0", 0),
LogEvent(unit0, member2, dt_today, "action1", 1),
LogEvent(unit0, member, dt_today, "action2", 2),
LogEvent(unit1, member, dt_today, "action2", 3)]
def _get_events(start=None, end=None, **kwargs):
for event in _events:
yield event
logs_mock.configure_mock(
**{'return_value.get_events.side_effect': _get_events})
updater = StoreScoreUpdater(store0)
result = updater.calculate()
assert result == {}
class DummyScore(object):
def __init__(self, event):
self.event = event
def get_score(self):
return dict(
score=(self.event.value * self.base_score),
translated=(7 * self.base_score),
reviewed=(23 * self.base_score),
suggested=(108 * self.base_score))
class Action0Score(DummyScore):
base_score = 0
class Action1Score(DummyScore):
base_score = 1
class Action2Score(DummyScore):
base_score = 2
def get_score(self):
score = super(Action2Score, self).get_score()
score["reviewed"] = 0
return score
@provider(event_score, sender=LogEvent)
def dummy_event_score_provider(**kwargs_):
return dict(
action0=Action0Score,
action1=Action1Score,
action2=Action2Score)
updater = StoreScoreUpdater(store0)
result = updater.calculate()
assert len(result) == 2
assert len(result[today]) == 2
assert result[today][member.id] == {
'suggested': 432,
'score': 10,
'translated': 28}
assert result[today][member2.id] == {
'suggested': 108,
'score': 1,
'translated': 7,
'reviewed': 23}
assert len(result[yesterday]) == 1
assert result[yesterday][admin.id] == {
'suggested': 108,
'score': 1,
'translated': 7,
'reviewed': 23}
store0.user_scores.all().delete()
updater.update()
mem_score = UserStoreScore.objects.filter(
store=store0, user=member)
assert mem_score.get(date=today).suggested == 432
assert mem_score.get(date=today).score == 10
assert mem_score.get(date=today).translated == 28
assert mem_score.get(date=today).reviewed == 0
today_score = mem_score.get(date=today)
today_score.reviewed = 99999
today_score.score = 0
today_score.save()
updater.update()
assert mem_score.get(date=today).suggested == 432
assert mem_score.get(date=today).score == 10
assert mem_score.get(date=today).translated == 28
assert mem_score.get(date=today).reviewed == 0
@pytest.mark.django_db
def test_score_tp_updater(tp0, admin, member, member2):
updater = score_updater.get(TranslationProject)(tp0)
assert updater.tp == tp0
assert isinstance(updater, TPScoreUpdater)
@pytest.fixture
def create_score_data(today, yesterday, admin, member, member2):
def _generate_data(store):
data = {}
data[today] = dict()
data[yesterday] = dict()
for user in [admin, member, member2]:
data[today][user.id] = dict(
score=(store.id * user.id),
suggested=(2 * store.id * user.id),
translated=(3 * store.id * user.id),
reviewed=(4 * store.id * user.id))
data[yesterday][user.id] = dict(
score=(5 * store.id * user.id),
suggested=(6 * store.id * user.id),
translated=(7 * store.id * user.id),
reviewed=(8 * store.id * user.id))
return data
return _generate_data
@pytest.mark.django_db
def test_score_tp_updater_update(store0, tp0, admin, member, member2,
today, yesterday, create_score_data):
updater = score_updater.get(TranslationProject)(tp0)
store1 = tp0.stores.exclude(id=store0.id).first()
tp0.user_scores.all().delete()
UserStoreScore.objects.filter(store__translation_project=tp0).delete()
score_updater.get(Store)(store0).set_scores(create_score_data(store0))
score_updater.get(Store)(store1).set_scores(create_score_data(store1))
updater.update()
for user in [admin, member, member2]:
scores_today = tp0.user_scores.get(date=today, user=user)
assert scores_today.score == (
(store0.id * user.id)
+ (store1.id * user.id))
assert scores_today.suggested == (
(2 * store0.id * user.id)
+ (2 * store1.id * user.id))
assert scores_today.translated == (
(3 * store0.id * user.id)
+ (3 * store1.id * user.id))
assert scores_today.reviewed == (
(4 * store0.id * user.id)
+ (4 * store1.id * user.id))
scores_yesterday = tp0.user_scores.get(date=yesterday, user=user)
assert scores_yesterday.score == (
(5 * store0.id * user.id)
+ (5 * store1.id * user.id))
assert scores_yesterday.suggested == (
(6 * store0.id * user.id)
+ (6 * store1.id * user.id))
assert scores_yesterday.translated == (
(7 * store0.id * user.id)
+ (7 * store1.id * user.id))
assert scores_yesterday.reviewed == (
(8 * store0.id * user.id)
+ (8 * store1.id * user.id))
@pytest.mark.django_db
def test_score_user_updater_calculate(tp0, admin, member):
user_updater = score_updater.get(admin.__class__)
admin.score = -999
admin.save()
member.score = -777
member.save()
assert user_updater == UserScoreUpdater
updater = user_updater(users=[admin, member])
assert updater.users == [admin, member]
result = updater.calculate()
admin_score = admin.scores.filter(
date__gte=(
localdate()
- timedelta(days=30)))
admin_score = round(sum(
admin_score.values_list(
"score", flat=True)), 2)
member_score = member.scores.filter(
date__gte=(
localdate()
- timedelta(days=30)))
member_score = round(sum(
member_score.values_list(
"score", flat=True)), 2)
assert round(dict(result)[admin.pk], 2) == admin_score
assert round(dict(result)[member.pk], 2) == member_score
updater.set_scores(result)
admin.refresh_from_db()
member.refresh_from_db()
assert round(admin.score, 2) == admin_score
assert round(member.score, 2) == member_score
admin.score = -999
admin.save()
updater = user_updater((admin, ))
assert updater.users == (admin, )
result = updater.calculate()
assert round(dict(result)[admin.pk], 2) == admin_score
updater.set_scores(result)
admin.refresh_from_db()
assert round(admin.score, 2) == admin_score
@pytest.mark.django_db
def test_score_user_updater_refresh(tp0, admin, member):
user_updater = score_updater.get(admin.__class__)
updater = user_updater((admin, ))
admin_score = admin.score
admin.score = 0
admin.save()
member_score = member.score
member.score = 0
member.save()
updater.refresh_scores()
member.refresh_from_db()
admin.refresh_from_db()
assert admin.score == admin_score
assert member.score == member_score
admin.score = 0
admin.save()
member.score = 0
member.save()
updater.refresh_scores(users=[admin])
member.refresh_from_db()
admin.refresh_from_db()
assert admin.score == admin_score
assert member.score == 0
@pytest.mark.django_db
def test_score_tp_updater_clear(tp0, admin, member):
tp_scores = tp0.user_scores.filter(
date__gte=localdate() - timedelta(days=30))
updater = TPScoreUpdater(tp0)
admin_score = admin.score
member_score = member.score
admin_tp_score = tp_scores.filter(
user=admin).aggregate(score=Sum('score'))['score']
member_tp_score = tp_scores.filter(
user=member).aggregate(score=Sum('score'))['score']
updater.clear()
member.refresh_from_db()
admin.refresh_from_db()
assert (
round(admin.score, 2)
== round(admin_score - admin_tp_score, 2))
assert (
round(member.score, 2)
== round(member_score - member_tp_score, 2))
@pytest.mark.django_db
def test_score_tp_updater_clear_users(tp0, admin, member):
tp_scores = tp0.user_scores.filter(
date__gte=localdate() - timedelta(days=30))
updater = TPScoreUpdater(tp0)
admin_score = admin.score
member_score = member.score
member_tp_score = tp_scores.filter(
user=member).aggregate(score=Sum('score'))['score']
updater.clear(users=[member.id])
member.refresh_from_db()
admin.refresh_from_db()
assert admin.score == admin_score
assert (
round(member.score, 2)
== round(member_score - member_tp_score, 2))
| 13,119
|
Python
|
.py
| 344
| 30.674419
| 80
| 0.627838
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,997
|
scores.py
|
translate_pootle/tests/pootle_score/scores.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from datetime import datetime
import pytest
from django.utils import timezone
from pootle.core.delegate import event_score
from pootle.core.utils.timezone import make_aware
from pootle_log.utils import LogEvent
from pootle_score import scores
from pootle_statistics.models import Submission
from pootle_store.constants import FUZZY, TRANSLATED, UNTRANSLATED
@pytest.mark.django_db
def test_score_event_suggestion_created(store0, admin, settings):
unit = store0.units.filter(suggestion__state__name="pending").first()
suggestion = unit.suggestion_set.filter(state__name="pending").first()
scoring = event_score.gather(LogEvent)
scorer = scoring["suggestion_created"]
assert scorer == scores.SuggestionCreatedScore
event = LogEvent(
unit, admin, datetime.now(), "example", suggestion)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.suggestion == suggestion
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["suggestion_add"]))
assert score.translated == 0
assert score.reviewed == 0
assert score.suggested == unit.unit_source.source_wordcount
@pytest.mark.django_db
def test_score_event_suggestion_accepted(store0, admin, settings):
unit = store0.units.filter(suggestion__state__name="pending").first()
suggestion = unit.suggestion_set.filter(state__name="pending").first()
scoring = event_score.gather(LogEvent)
scorer = scoring["suggestion_accepted"]
assert scorer == scores.SuggestionAcceptedScore
event = LogEvent(
unit, admin, datetime.now(), "example", suggestion)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.suggestion == suggestion
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["suggestion_accept"]))
assert score.translated == 0
assert score.reviewed == unit.unit_source.source_wordcount
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=0,
reviewed=unit.unit_source.source_wordcount,
suggested=0))
@pytest.mark.django_db
def test_score_event_suggestion_rejected(store0, admin, settings):
unit = store0.units.filter(suggestion__state__name="pending").first()
suggestion = unit.suggestion_set.filter(state__name="pending").first()
scoring = event_score.gather(LogEvent)
scorer = scoring["suggestion_rejected"]
assert scorer == scores.SuggestionRejectedScore
event = LogEvent(
unit, admin, datetime.now(), "example", suggestion)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.suggestion == suggestion
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["suggestion_reject"]))
assert score.translated == 0
assert score.reviewed == unit.unit_source.source_wordcount
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=0,
reviewed=unit.unit_source.source_wordcount,
suggested=0))
@pytest.mark.django_db
def test_score_event_target_updated(store0, admin, settings):
unit = store0.units.first()
scoring = event_score.gather(LogEvent)
scorer = scoring["target_updated"]
assert scorer == scores.TargetUpdatedScore
event = LogEvent(
unit, admin, datetime.now(), "example", None)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["target_updated"]))
assert score.translated == unit.unit_source.source_wordcount
assert score.reviewed == 0
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=unit.unit_source.source_wordcount,
reviewed=0,
suggested=0))
@pytest.mark.django_db
def test_score_event_state_updated(store0, admin, settings):
unit = store0.units.first()
scoring = event_score.gather(LogEvent)
scorer = scoring["state_updated"]
assert scorer == scores.StateUpdatedScore
sub = Submission.objects.create(
unit=unit,
submitter=admin,
translation_project=unit.store.translation_project,
creation_time=make_aware(timezone.now()),
old_value=UNTRANSLATED,
new_value=TRANSLATED)
event = LogEvent(
unit, admin, datetime.now(), "example", sub)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.submission == sub
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["state_translated"]))
assert score.translated == unit.unit_source.source_wordcount
assert score.reviewed == 0
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=unit.unit_source.source_wordcount,
reviewed=0,
suggested=0))
sub = Submission.objects.create(
unit=unit,
submitter=admin,
translation_project=unit.store.translation_project,
creation_time=make_aware(timezone.now()),
old_value=FUZZY,
new_value=TRANSLATED)
event = LogEvent(
unit, admin, datetime.now(), "example", sub)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.submission == sub
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["state_unfuzzy"]))
assert score.translated == 0
assert score.reviewed == unit.unit_source.source_wordcount
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=0,
reviewed=unit.unit_source.source_wordcount,
suggested=0))
sub = Submission.objects.create(
unit=unit,
submitter=admin,
translation_project=unit.store.translation_project,
creation_time=make_aware(timezone.now()),
old_value=TRANSLATED,
new_value=FUZZY)
event = LogEvent(
unit, admin, datetime.now(), "example", sub)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.submission == sub
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["state_fuzzy"]))
assert score.translated == 0
assert score.reviewed == unit.unit_source.source_wordcount
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=0,
reviewed=unit.unit_source.source_wordcount,
suggested=0))
| 7,428
|
Python
|
.py
| 202
| 29.980198
| 77
| 0.668608
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,998
|
path_matcher.py
|
translate_pootle/tests/vfolders/path_matcher.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from pootle_fs.utils import PathFilter
from pootle_store.models import Store
from virtualfolder.models import VirtualFolder
from virtualfolder.utils import VirtualFolderPathMatcher
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_path_matcher():
vfolder = VirtualFolder.objects.create(
name="avfolder",
filter_rules="FOO,BAR")
path_matcher = VirtualFolderPathMatcher(vfolder)
assert path_matcher.vf == vfolder
assert path_matcher.tp_path == "/[^/]*/[^/]*/"
assert isinstance(
vfolder.path_matcher,
VirtualFolderPathMatcher)
# no projects/languages set by default
assert (
list(vfolder.path_matcher.languages)
== list(vfolder.path_matcher.projects)
== list(vfolder.path_matcher.existing_stores)
== [])
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_path_matcher_languages(language0, language1):
vfolder = VirtualFolder.objects.create(
name="avfolder",
filter_rules="FOO,BAR")
vfolder.languages.add(language0)
vfolder.languages.add(language1)
# no projects set so no stores
assert list(vfolder.path_matcher.existing_stores) == []
assert (
sorted(vfolder.path_matcher.languages)
== [language0.pk, language1.pk])
vfolder.all_languages = True
vfolder.save()
assert vfolder.path_matcher.languages is None
assert list(vfolder.path_matcher.projects) == []
# no projects set so no stores
assert list(vfolder.path_matcher.existing_stores) == []
# didnt forget lang preferences
vfolder.all_languages = False
vfolder.save()
assert (
sorted(vfolder.path_matcher.languages.values_list("code", flat=True))
== ["language0", "language1"])
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_path_matcher_projects(project0, project1):
vfolder = VirtualFolder.objects.create(
name="avfolder",
filter_rules="FOO,BAR")
vfolder.projects.add(project0)
vfolder.projects.add(project1)
# no languages set so no stores
assert list(vfolder.path_matcher.existing_stores) == []
assert (
sorted(vfolder.path_matcher.projects.values_list("code", flat=True))
== ["project0", "project1"])
vfolder.all_projects = True
vfolder.save()
assert vfolder.path_matcher.projects is None
assert list(vfolder.path_matcher.languages) == []
# no languages set so no stores
assert list(vfolder.path_matcher.existing_stores) == []
# didnt forget project preferences
vfolder.all_projects = False
vfolder.save()
assert (
sorted(vfolder.path_matcher.projects.values_list("code", flat=True))
== ["project0", "project1"])
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_path_matcher_all_proj_lang():
vfolder = VirtualFolder.objects.create(
name="avfolder",
all_projects=True,
all_languages=True,
filter_rules="*")
assert (
list(vfolder.path_matcher.existing_stores.order_by("pk"))
== list(Store.objects.order_by("pk")))
vfolder.all_languages = False
vfolder.save()
assert (
list(vfolder.path_matcher.existing_stores.order_by("pk"))
== [])
vfolder.all_languages = True
vfolder.all_projects = False
vfolder.save()
assert (
list(vfolder.path_matcher.existing_stores.order_by("pk"))
== [])
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_path_matcher_some_proj_lang(tp0, language1):
vfolder = VirtualFolder.objects.create(
name="avfolder",
filter_rules="*")
vfolder.languages.add(tp0.language)
vfolder.projects.add(tp0.project)
# m2m handler?
vfolder.save()
assert (
list(vfolder.path_matcher.existing_stores.order_by("pk"))
== list(tp0.stores.order_by("pk")))
vfolder.languages.add(language1)
vfolder.save()
assert (
list(vfolder.path_matcher.existing_stores.order_by("pk"))
== list(
Store.objects.filter(
translation_project__project=tp0.project,
translation_project__language__in=[
tp0.language,
language1]).order_by("pk")))
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_path_matcher_get_rule_regex(vfolder0, tp0, vf_rules):
rule = vf_rules
assert (
vfolder0.path_matcher.get_rule_regex(rule)
== ("^%s%s"
% (vfolder0.path_matcher.tp_path,
PathFilter().path_regex(rule))))
vfolder0.filter_rules = rule
vfolder0.languages.add(tp0.language)
vfolder0.projects.add(tp0.project)
vfolder0.save()
regex = vfolder0.path_matcher.get_rule_regex(rule)
assert (
list(vfolder0.stores.order_by("pk"))
== list(tp0.stores.filter(pootle_path__regex=regex).order_by("pk")))
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_path_matcher_rules(vfolder0):
vfolder0.filter_rules = "foo,bar"
assert (
list(vfolder0.path_matcher.rules)
== ["foo", "bar"])
# convert to json field? for now be ws tolerant
vfolder0.filter_rules = "foo, bar"
assert (
list(vfolder0.path_matcher.rules)
== ["foo", "bar"])
| 5,612
|
Python
|
.py
| 154
| 30.506494
| 77
| 0.679287
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
14,999
|
vf_data.py
|
translate_pootle/tests/vfolders/vf_data.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import pytest
from django.db.models import Sum
from pootle.core.browser import get_table_headings
from virtualfolder.display import VFolderStatsDisplay
from virtualfolder.delegate import vfolders_data_view
from virtualfolder.views import VFoldersDataView, make_vfolder_dict
from virtualfolder.utils import DirectoryVFDataTool
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_data_view(tp0, request_users):
user = request_users["user"]
dir0 = tp0.directory
vf_data = vfolders_data_view.get(dir0.__class__)(dir0, user=user)
assert isinstance(vf_data, VFoldersDataView)
assert vf_data.context is dir0
assert isinstance(vf_data.vfolder_data_tool, DirectoryVFDataTool)
assert vf_data.vfolder_data_tool.context is dir0
stats = vf_data.vfolder_data_tool.get_stats(user=user)
assert vf_data.all_stats == VFolderStatsDisplay(dir0, stats=stats).stats
assert vf_data.stats["children"] == vf_data.all_stats
# ordering?
rows = [
make_vfolder_dict(dir0, *vf)
for vf
in vf_data.all_stats.items()]
for i, row in enumerate(vf_data.table_items):
assert rows[i] == row
assert "priority" in vf_data.table_fields
expected_table_data = dict(
children=dict(
id='vfolders',
fields=vf_data.table_fields,
headings=get_table_headings(vf_data.table_fields),
rows=vf_data.table_items))
assert vf_data.table_data == expected_table_data
@pytest.mark.pootle_vfolders
@pytest.mark.django_db
def test_vfolder_data_checks(subdir0, request_users):
user = request_users["user"]
vf_data = vfolders_data_view.get(subdir0.__class__)(subdir0, user=user)
data_tool = vf_data.vfolder_data_tool
checks = {}
cd = data_tool.filter_data(data_tool.checks_data_model)
if not data_tool.show_all_to(user):
cd = data_tool.filter_accessible(cd)
cd = (cd.values_list("store__vfolders", "name")
.annotate(Sum("count")))
for vf, name, count in cd:
checks[vf] = checks.get(vf, {})
checks[vf][name] = count
assert checks == data_tool.get_checks(user=user)
| 2,424
|
Python
|
.py
| 58
| 36.810345
| 77
| 0.710894
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|