def test_util_tags_tool_get_tags(glob_mock, tag_mock):
glob_mock.return_value = 17
filter_mock = MagicMock(**{'filter.return_value': 23})
tag_mock.configure_mock(
**
{'return_value.filter.return_value.values.return_value': filter_mock})
tags_tool = TagsTool()
# no slug provided, returns `values`
assert tags_tool.get_tags() is filter_mock
assert not filter_mock.called
assert not glob_mock.called
assert (list(
tag_mock.return_value.filter.return_value.values.call_args) == [
('pk', 'name', 'slug', 'priority', 'project'), {}
])
tag_mock.reset_mock()
# slug provided, `values` is filtered
assert tags_tool.get_tags('FOO') == 23
assert (list(filter_mock.filter.call_args) == [(), {'slug__regex': 17}])
assert list(glob_mock.call_args) == [('FOO', ), {}]
assert (list(
tag_mock.return_value.filter.return_value.values.call_args) == [
('pk', 'name', 'slug', 'priority', 'project'), {}
])
def test_util_tags_tool_get(iter_mock, len_mock, tags_mock, class_mock):
# tests getting a TagTool from TagsTool
tags_tool = TagsTool()
class_mock.return_value = 23
len_mock.return_value = 7
iter_mock.return_value = iter([3, 17, 73])
# with no slug returns first result from iter(self)
assert tags_tool.get() == 3
assert not class_mock.called
assert not tags_mock.called
assert len_mock.called
assert iter_mock.called
len_mock.reset_mock()
iter_mock.reset_mock()
# calling with slug creates a TagTool instance
# and doesnt call iter(self) at all
assert tags_tool.get(113) == 23
assert not len_mock.called
assert not iter_mock.called
assert (
list(class_mock.call_args)
== [(tags_tool, ), {}])
assert (
list(tags_mock.call_args)
== [(), {'slug': 113}])
def test_util_tags_tool_get(iter_mock, len_mock, tags_mock, class_mock):
# tests getting a TagTool from TagsTool
tags_tool = TagsTool()
class_mock.return_value = 23
len_mock.return_value = 7
iter_mock.return_value = iter([3, 17, 73])
# with no slug returns first result from iter(self)
assert tags_tool.get() == 3
assert not class_mock.called
assert not tags_mock.called
assert len_mock.called
assert iter_mock.called
len_mock.reset_mock()
iter_mock.reset_mock()
# calling with slug creates a TagTool instance
# and doesnt call iter(self) at all
assert tags_tool.get(113) == 23
assert not len_mock.called
assert not iter_mock.called
assert (
list(class_mock.call_args)
== [(tags_tool, ), {}])
assert (
list(tags_mock.call_args)
== [(), {'slug': 113}])
def test_util_tags_tool_get_tags(glob_mock, tag_mock):
glob_mock.return_value = 17
filter_mock = MagicMock(
**{'filter.return_value': 23})
tag_mock.configure_mock(
**{'return_value.filter.return_value.values.return_value': filter_mock})
tags_tool = TagsTool()
# no slug provided, returns `values`
assert tags_tool.get_tags() is filter_mock
assert not filter_mock.called
assert not glob_mock.called
assert (
list(tag_mock.return_value.filter.return_value.values.call_args)
== [('pk', 'name', 'slug', 'priority', 'project'), {}])
tag_mock.reset_mock()
# slug provided, `values` is filtered
assert tags_tool.get_tags('FOO') == 23
assert (
list(filter_mock.filter.call_args)
== [(), {'slug__regex': 17}])
assert list(glob_mock.call_args) == [('FOO',), {}]
assert (
list(tag_mock.return_value.filter.return_value.values.call_args)
== [('pk', 'name', 'slug', 'priority', 'project'), {}])
def test_util_tags_tool_iter_tags(tag_mock, trans_mock):
# tests that iter_tags calls instantiates a TagTool with
# stat data and latest_translation data
trans_mock.configure_mock(
**{'return_value.data.get.return_value': 23})
tags_tool = TagsTool()
list(
tags_tool.iter_tags(
[dict(resource__tag=1, foo="bar"),
dict(resource__tag=2, foo="bar"),
dict(resource__tag=3, foo="bar")]))
# translation_tool.data.get() was called 3 times with tag pks
assert (
[x[0][0] for x in trans_mock.return_value.data.get.call_args_list]
== [1, 2, 3])
# TagTool was called 3 times with the tags tool as arg
assert (
[x[0][0] for x in tag_mock.call_args_list]
== [tags_tool] * 3)
# and stat + translation data as kwargs
assert (
[x[1] for x in tag_mock.call_args_list]
== [{'resource__tag': 1, 'latest_translation': 23, 'foo': 'bar'},
{'resource__tag': 2, 'latest_translation': 23, 'foo': 'bar'},
{'resource__tag': 3, 'latest_translation': 23, 'foo': 'bar'}])
def test_util_tags_tool_iter_tags(tag_mock, trans_mock):
# tests that iter_tags calls instantiates a TagTool with
# stat data and latest_translation data
trans_mock.configure_mock(
**{'return_value.data.get.return_value': 23})
tags_tool = TagsTool()
list(
tags_tool.iter_tags(
[dict(resource__tag=1, foo="bar"),
dict(resource__tag=2, foo="bar"),
dict(resource__tag=3, foo="bar")]))
# translation_tool.data.get() was called 3 times with tag pks
assert (
[x[0][0] for x in trans_mock.return_value.data.get.call_args_list]
== [1, 2, 3])
# TagTool was called 3 times with the tags tool as arg
assert (
[x[0][0] for x in tag_mock.call_args_list]
== [tags_tool] * 3)
# and stat + translation data as kwargs
assert (
[x[1] for x in tag_mock.call_args_list]
== [{'resource__tag': 1, 'latest_translation': 23, 'foo': 'bar'},
{'resource__tag': 2, 'latest_translation': 23, 'foo': 'bar'},
{'resource__tag': 3, 'latest_translation': 23, 'foo': 'bar'}])
def test_util_tags_tool_get_tags(tag_mock):
filter_mock = MagicMock(**{"filter.return_value": 23})
tag_mock.configure_mock(
**
{"return_value.filter.return_value.values.return_value": filter_mock})
tags_tool = TagsTool()
# no slug provided, returns `values`
assert tags_tool.get_tags() is filter_mock
assert not filter_mock.called
assert list(
tag_mock.return_value.filter.return_value.values.call_args) == [
("pk", "name", "slug", "priority", "project"),
{},
]
tag_mock.reset_mock()
# slug provided, `values` is filtered
assert tags_tool.get_tags("FOO") == 23
assert list(filter_mock.filter.call_args) == [(), {
"slug__contains": "FOO"
}]
assert list(
tag_mock.return_value.filter.return_value.values.call_args) == [
("pk", "name", "slug", "priority", "project"),
{},
]
def localization(request, code, slug):
"""Locale-project overview."""
locale = get_object_or_404(Locale, code=code)
project = get_object_or_404(Project.objects.visible_for(
request.user).available(),
slug=slug)
project_locale = get_object_or_404(
ProjectLocale,
locale=locale,
project=project,
)
resource_count = len(locale.parts_stats(project)) - 1
return render(
request,
"localizations/localization.html",
{
"locale":
locale,
"project":
project,
"project_locale":
project_locale,
"resource_count":
resource_count,
"tags":
(len(TagsTool(projects=[project], locales=[locale], priority=True))
if project.tags_enabled else None),
},
)
def localization(request, code, slug):
"""Locale-project overview."""
locale = get_object_or_404(Locale, code=code)
project = get_object_or_404(Project.objects.available(), slug=slug)
project_locale = get_object_or_404(
ProjectLocale,
locale=locale,
project=project,
)
resource_count = len(locale.parts_stats(project)) - 1
return render(
request, 'localizations/localization.html', {
'locale':
locale,
'project':
project,
'project_locale':
project_locale,
'resource_count':
resource_count,
'tags':
(len(TagsTool(projects=[project], locales=[locale], priority=True))
if project.tags_enabled else None)
})
def project(request, slug):
"""Project dashboard."""
project = get_object_or_404(Project.objects.visible_for(
request.user).available(),
slug=slug)
project_locales = project.project_locale
chart = project
# Only include filtered teams if provided
teams = request.GET.get("teams", "").split(",")
filtered_locales = Locale.objects.filter(code__in=teams)
if filtered_locales.exists():
project_locales = project_locales.filter(locale__in=filtered_locales)
chart = project_locales.aggregated_stats()
return render(
request,
"projects/project.html",
{
"chart":
chart,
"count":
project_locales.count(),
"project":
project,
"tags": (len(TagsTool(projects=[project], priority=True))
if project.tags_enabled else None),
},
)
def test_util_tag_tool_locale_latest(trans_mock):
trans_mock.configure_mock(**{"return_value.data": 23})
tag_tool = TagTool(
TagsTool(), name=None, pk=None, priority=None, project=None, slug=17
)
assert tag_tool.locale_latest == 23
assert list(trans_mock.call_args) == [(), {"groupby": "locale", "slug": 17}]
def test_util_tags_tool_call_and_clone():
# tests cloning a TagsTool
tags_tool = TagsTool()
cloned = tags_tool()
assert cloned is not tags_tool
assert isinstance(tags_tool, Clonable)
assert isinstance(cloned, Clonable)
def test_util_tag_tool_iter_locales(locale_mock, latest_mock, stats_mock):
tag_tool = TagTool(TagsTool(),
name=None,
pk=None,
priority=None,
project=None,
slug=None)
# Set mocks
locale_mock.return_value = "X"
latest_mock.configure_mock(**{'return_value.get.return_value': 23})
stats_mock.return_value = [
dict(foo=1, locale=1),
dict(foo=2, locale=2),
dict(foo=3, locale=3)
]
# iter_locales - should generate 3 of 'X'
locales = tag_tool.iter_locales()
assert isinstance(locales, types.GeneratorType)
assert list(locales) == ['X'] * 3
assert len(locale_mock.call_args_list) == 3
assert stats_mock.called
# locale_latest is called with each of the locales
assert (list(list(a)
for a in latest_mock.return_value.get.call_args_list) == [[
(1, ), {}
], [(2, ), {}], [(3, ), {}]])
# TaggedLocale is called with locale data
for i, args in enumerate(locale_mock.call_args_list):
assert args[1]['foo'] == i + 1
assert args[1]['latest_translation'] == 23
def test_util_tag_tool_linked_resources(resources_mock):
tag_tool = TagTool(TagsTool(),
name=None,
pk=None,
priority=None,
project=None,
slug=7)
resources_mock.configure_mock(
**{
'return_value.get_linked_resources'
'.return_value.order_by.return_value':
23
})
# linked_resources returns
# resources.get_linked_resources().order_by()
assert tag_tool.linked_resources == 23
# get_linked_resources was called with slug
linked_resources_mock = resources_mock.return_value.get_linked_resources
assert (list(linked_resources_mock.call_args) == [(7, ), {}])
# order_by is called with 'path'
order_by_mock = linked_resources_mock.return_value.order_by
assert (list(order_by_mock.call_args) == [('path', ), {}])
def test_util_tags_tool_getitem(call_mock):
# test that calling __getitem__ calls __call__ with slug
tags_tool = TagsTool()
slugs = ["foo", "bar"]
for slug in slugs:
tags_tool[slug]
assert call_mock.call_args_list[0][1] == dict(slug=slugs[0])
assert call_mock.call_args_list[1][1] == dict(slug=slugs[1])
def test_util_tags_tool_len(stats_mock):
# tests that when you len() you get the len
# of the stats data
m_len = MagicMock()
m_len.__len__.return_value = 23
stats_mock.configure_mock(**{"return_value.data": m_len})
tags_tool = TagsTool()
assert len(tags_tool) == 23
assert m_len.__len__.called
def test_util_tags_tool_iter(stats_mock, iter_mock):
# tests that when you iter it calls iter_tags with
# stats data
tags_tool = TagsTool()
stats_mock.configure_mock(**{"return_value.data": [7, 23]})
iter_mock.return_value = iter([])
assert list(tags_tool) == []
assert stats_mock.called
assert list(iter_mock.call_args) == [([7, 23], ), {}]
def test_util_tag_tool_resource_tool(resources_mock):
tool_mock = MagicMock(return_value=23)
resources_mock.return_value = tool_mock
tag_tool = TagTool(
TagsTool(), name=None, pk=None, priority=None, project=None, slug=None
)
# no project set - returns the tags.resources_tool, but doesnt call it
assert tag_tool.resource_tool is tool_mock
assert not tool_mock.called
# project set
tag_tool = TagTool(
TagsTool(), name=None, pk=None, priority=None, project=43, slug=None
)
# tool was called with project as args
assert tag_tool.resource_tool == 23
assert list(tool_mock.call_args) == [(), {"projects": [43]}]
def project(request, slug):
"""Project dashboard."""
project = get_object_or_404(Project.objects.available(), slug=slug)
return render(
request, 'projects/project.html', {
'project':
project,
'tags': (len(TagsTool(projects=[project], priority=True))
if project.tags_enabled else None)
})
def test_util_tags_tool_iter_tags(tag_mock, trans_mock):
# tests that iter_tags calls instantiates a TagTool with
# stat data and latest_translation data
trans_mock.configure_mock(**{"return_value.data.get.return_value": 23})
tags_tool = TagsTool()
list(
tags_tool.iter_tags([
dict(resource__tag=1, foo="bar"),
dict(resource__tag=2, foo="bar"),
dict(resource__tag=3, foo="bar"),
]))
# translation_tool.data.get() was called 3 times with tag pks
assert [x[0][0]
for x in trans_mock.return_value.data.get.call_args_list] == [
1,
2,
3,
]
# TagTool was called 3 times with the tags tool as arg
assert [x[0][0] for x in tag_mock.call_args_list] == [tags_tool] * 3
# and stat + translation data as kwargs
assert [x[1] for x in tag_mock.call_args_list] == [
{
"resource__tag": 1,
"latest_translation": 23,
"foo": "bar"
},
{
"resource__tag": 2,
"latest_translation": 23,
"foo": "bar"
},
{
"resource__tag": 3,
"latest_translation": 23,
"foo": "bar"
},
]
def test_util_tag_tool_link_resources(resources_mock):
tag_tool = TagTool(
TagsTool(), name=None, pk=None, priority=None, project=None, slug=7
)
resources_mock.configure_mock(**{"return_value.link.return_value": 23})
# link_resources returns resources.link()
assert tag_tool.link_resources(13) == 23
# resources.link() is called with correct args
assert list(resources_mock.return_value.link.call_args) == [(7,), {"resources": 13}]
def test_util_tag_tool_locale_stats(stats_mock):
stats_mock.configure_mock(**{"return_value.data": 23})
tag_tool = TagTool(
TagsTool(), name=None, pk=None, priority=None, project=None, slug=7
)
# locale_stats returns self.tags_tool.stats_tool().data
assert tag_tool.locale_stats == 23
# stats_tool was called with slug and groupby
assert list(stats_mock.call_args) == [(), {"groupby": "locale", "slug": 7}]
def test_util_tags_tool():
# test tags tool instantiation
tags_tool = TagsTool()
assert tags_tool.tag_class is TagTool
assert tags_tool.resources_class is TagsResourcesTool
assert tags_tool.translations_class is TagsLatestTranslationsTool
assert tags_tool.stats_class is TagsStatsTool
assert tags_tool.locales is None
assert tags_tool.projects is None
assert tags_tool.priority is None
assert tags_tool.slug is None
assert tags_tool.path is None
assert tags_tool.tag_manager == Tag.objects
def test_util_tag_tool_locale_latest(trans_mock):
trans_mock.configure_mock(**{'return_value.data': 23})
tag_tool = TagTool(TagsTool(),
name=None,
pk=None,
priority=None,
project=None,
slug=17)
assert tag_tool.locale_latest == 23
assert (list(trans_mock.call_args) == [(), {
'groupby': 'locale',
'slug': 17
}])
def project(request, slug):
"""Project dashboard."""
project = get_object_or_404(Project.objects.visible_for(
request.user).available(),
slug=slug)
return render(
request,
"projects/project.html",
{
"project":
project,
"tags": (len(TagsTool(projects=[project], priority=True))
if project.tags_enabled else None),
},
)
def ajax_tags(request, code, slug):
"""Tags tab."""
locale = get_object_or_404(Locale, code=code)
project = get_object_or_404(Project.objects.visible_for(request.user), slug=slug)
if not project.tags_enabled:
raise Http404
tags_tool = TagsTool(locales=[locale], projects=[project], priority=True,)
return render(
request,
"localizations/includes/tags.html",
{"locale": locale, "project": project, "tags": list(tags_tool)},
)
def test_util_tag_tool_object(tag_mock):
tag_mock.configure_mock(
**{"return_value.select_related" ".return_value.get.return_value": 23}
)
tag_tool = TagTool(
TagsTool(), name=None, pk=13, priority=None, project=None, slug=7
)
# object returns tag_manager.select_related().get()
assert tag_tool.object == 23
# tag_manager.select_related().get() is called with the tag pk
assert list(tag_mock.return_value.select_related.return_value.get.call_args) == [
(),
{"pk": 13},
]
def ajax_tags(request, slug):
"""Tags tab."""
project = get_object_or_404(Project, slug=slug)
if not project.tags_enabled:
raise Http404
tags_tool = TagsTool(
projects=[project],
priority=True,
)
return render(request, 'projects/includes/tags.html', {
'project': project,
'tags': list(tags_tool),
})
def ajax_tags(request, slug):
"""Tags tab."""
project = get_object_or_404(Project.objects.visible_for(request.user), slug=slug)
if not project.tags_enabled:
raise Http404
tags_tool = TagsTool(
projects=[project],
priority=True,
)
return render(
request,
"projects/includes/tags.html",
{"project": project, "tags": list(tags_tool)},
)
def ajax_tags(request, code, slug):
"""Tags tab."""
locale = get_object_or_404(Locale, code=code)
project = get_object_or_404(Project, slug=slug)
if not project.tags_enabled:
raise Http404
tags_tool = TagsTool(
locales=[locale],
projects=[project],
priority=True,
)
return render(request, 'localizations/includes/tags.html', {
'locale': locale,
'project': project,
'tags': list(tags_tool),
})
def test_util_tags_tool_translations(trans_mock, kwargs):
# tests instantiation of tag.translations_tool with different args
tags_tool = TagsTool(**kwargs)
trans_mock.return_value = 23
assert tags_tool.translation_tool == 23
assert trans_mock.call_args[1] == kwargs
def test_util_tags_tool_resources(resources_mock, kwargs):
# tests instantiation of tag.resources_tool with different args
tags_tool = TagsTool(**kwargs)
resources_mock.return_value = 23
assert tags_tool.resource_tool == 23
assert resources_mock.call_args[1] == kwargs
def test_util_tags_tool_stats(stats_mock, tag_init_kwargs):
# tests instantiation of tag.stats_tool with different args
tags_tool = TagsTool(**tag_init_kwargs)
stats_mock.return_value = 23
assert tags_tool.stat_tool == 23
assert stats_mock.call_args[1] == tag_init_kwargs
