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