Merge branch 'counts_per_term' into develop

django/website/rest_api/serializers.py

@@ -32,6 +32,16 @@ class TermSerializer(serializers.ModelSerializer):
     )
 
 
+class TermItemCountSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Term
+        fields = ('name', 'long_name', 'count', )
+
+    count = serializers.IntegerField(
+        read_only=True
+    )
+
+
 class ItemSerializer(serializers.ModelSerializer):
 
     class Meta:

django/website/rest_api/tests/taxonomy_and_term_create_tests.py

@@ -52,7 +52,10 @@ def add_term(**kwargs):
     url = reverse('term-list')
     request = APIRequestFactory().post(url, kwargs)
     view = TermViewSet.as_view(actions={'post': 'create'})
-    return view(request)
+    response = view(request)
+    assert status.is_success(response.status_code), response.data
+
+    return response
 
 
 @pytest.mark.django_db

django/website/rest_api/tests/term_itemcount_tests.py

+from __future__ import unicode_literals, absolute_import
+import pytest
+
+from django.core.urlresolvers import reverse
+from rest_framework.test import APIRequestFactory
+from rest_framework import status
+
+from ..views import TaxonomyViewSet
+
+from .categorize_items_tests import categorize_item
+from .item_create_view_tests import create_item
+from .taxonomy_and_term_create_tests import (
+    create_category,
+    add_term,
+)
+
+
+def get_term_itemcount(taxonomy_slug):
+    response = get_term_itemcount_response(taxonomy_slug)
+    assert status.is_success(response.status_code), response.data
+
+    return response
+
+
+def get_term_itemcount_response(taxonomy_slug):
+    url = reverse('taxonomy-itemcount', kwargs={'slug': taxonomy_slug})
+    request = APIRequestFactory().get(url)
+    view = TaxonomyViewSet.as_view(actions={'get': 'itemcount'})
+
+    return view(request, slug=taxonomy_slug)
+
+
+@pytest.fixture
+def questions_category_slug():
+    return create_category("Test Ebola Questions").data['slug']
+
+
+@pytest.fixture
+def regions_category():
+    return create_category("Regions").data
+
+
+@pytest.mark.django_db
+def test_term_itemcount_returns_counts_for_terms_in_taxonomy(
+        questions_category_slug, regions_category):
+    origin1 = create_item(body="What was the caused of ebola outbreak in liberia?").data
+    origin2 = create_item(body="Is Ebola a man made sickness").data
+    origin3 = create_item(body="What brought about ebola in liberia").data
+
+    victims1 = create_item(body="How many person died of Ebola in Liberia?").data
+
+    updates1 = create_item(body="When will Liberia be free from Ebola?").data
+    updates2 = create_item(body="Is ebola still here or not?").data
+
+    origins = add_term(taxonomy=questions_category_slug, name="Test Origins").data
+    victims = add_term(taxonomy=questions_category_slug, name="Test Victims").data
+    updates = add_term(taxonomy=questions_category_slug, name="Test Updates").data
+
+    monrovia = add_term(taxonomy=regions_category['slug'], name="Monrovia").data
+
+    categorize_item(origin1, origins)
+    categorize_item(origin2, origins)
+    categorize_item(origin3, origins)
+
+    categorize_item(victims1, victims)
+
+    categorize_item(updates1, updates)
+    categorize_item(updates2, updates)
+
+    categorize_item(origin1, monrovia)
+    categorize_item(updates1, monrovia)
+
+    terms = get_term_itemcount(questions_category_slug).data
+
+    counts = {term['name']: term['count'] for term in terms}
+
+    assert counts[origins['name']] == 3
+    assert counts[victims['name']] == 1
+    assert counts[updates['name']] == 2
+
+
+@pytest.mark.django_db
+def test_term_itemcount_contains_taxonomy_term_name(questions_category_slug):
+    origin1 = create_item(body="What was the caused of ebola outbreak in liberia?").data
+    origins = add_term(taxonomy=questions_category_slug, name="Test Origins").data
+    categorize_item(origin1, origins)
+
+    terms = get_term_itemcount(questions_category_slug).data
+    [name] = [term['name'] for term in terms]
+
+    assert origins['name'] == name
+
+
+@pytest.mark.django_db
+def test_term_itemcount_does_not_contain_term_for_other_taxonomy(
+        questions_category_slug, regions_category):
+    origin1 = create_item(body="What was the caused of ebola outbreak in liberia?").data
+    origins = add_term(taxonomy=questions_category_slug, name="Test Origins").data
+    monrovia = add_term(taxonomy=regions_category['slug'], name="Monrovia").data
+
+    categorize_item(origin1, origins)
+    categorize_item(origin1, monrovia)
+
+    terms = get_term_itemcount(questions_category_slug).data
+    names = [term['name'] for term in terms]
+
+    assert monrovia['name'] not in names
+
+
+@pytest.mark.django_db
+def test_term_itemcount_contains_taxonomy_term_long_name(
+        questions_category_slug):
+    origin1 = create_item(body="What was the caused of ebola outbreak in liberia?").data
+    origins = add_term(taxonomy=questions_category_slug,
+                       name="Test Origins").data
+    categorize_item(origin1, origins)
+
+    terms = get_term_itemcount(questions_category_slug).data
+    [long_name] = [term['long_name'] for term in terms]
+
+    assert origins['long_name'] == long_name
+
+
+@pytest.mark.django_db
+def test_error_for_non_existent_taxonomy():
+    response = get_term_itemcount_response('a-taxonomy-that-does-not-exist')
+
+    assert response.status_code == status.HTTP_400_BAD_REQUEST
+    assert response.data['detail'] == "Taxonomy with slug 'a-taxonomy-that-does-not-exist' does not exist."

django/website/rest_api/urls.py

-from django.conf.urls import patterns, include, url
+from django.conf.urls import patterns, include
 
 from rest_framework import routers
 

django/website/rest_api/views.py

+from django.db.models import Count
+from django.utils.translation import ugettext as _
+
 from rest_framework import viewsets, status
 from rest_framework_bulk.mixins import BulkDestroyModelMixin
 from rest_framework.decorators import detail_route
@@ -16,6 +19,7 @@ from .serializers import (
     ItemSerializer,
     TaxonomySerializer,
     TermSerializer,
+    TermItemCountSerializer,
 )
 
 
@@ -54,6 +58,23 @@ class TaxonomyViewSet(viewsets.ModelViewSet):
 
     queryset = Taxonomy.objects.all()
 
+    lookup_field = 'slug'
+
+    @detail_route(methods=['get'])
+    def itemcount(self, request, slug):
+        try:
+            taxonomy = Taxonomy.objects.get(slug=slug)
+        except Taxonomy.DoesNotExist:
+            message = _("Taxonomy with slug '%s' does not exist.") % (slug)
+
+            data = {'detail': message}
+            return Response(data, status=status.HTTP_400_BAD_REQUEST)
+
+        terms = Term.objects.filter(taxonomy=taxonomy).annotate(count=Count('message'))
+        data = TermItemCountSerializer(terms, many=True).data
+
+        return Response(data, status=status.HTTP_200_OK)
+
 
 class TermViewSet(viewsets.ModelViewSet):
     serializer_class = TermSerializer

django/website/transport/taxonomies.py

@@ -2,8 +2,11 @@ from django.core.urlresolvers import reverse
 
 from rest_api.views import TaxonomyViewSet
 from rest_framework.test import APIRequestFactory
+from rest_framework import status
+
+from .exceptions import TransportException
+
 
-actions = {'get': 'list'}
 request_factory = APIRequestFactory()
 
 
@@ -11,7 +14,11 @@ def list_url():
     return reverse('taxonomy-list')
 
 
-def get_view():
+def itemcount_url(slug):
+    return reverse('taxonomy-itemcount', kwargs={'slug': slug})
+
+
+def get_view(actions):
     return TaxonomyViewSet.as_view(actions)
 
 
@@ -22,6 +29,18 @@ def list(**kwargs):
     to filter the Taxonomies.
     """
 
-    view = get_view()
+    view = get_view(actions={'get': 'list'})
     request = request_factory.get(list_url(), kwargs)
     return view(request).data
+
+
+def term_itemcount(slug):
+    view = get_view(actions={'get': 'itemcount'})
+    request = request_factory.get(itemcount_url(slug))
+    response = view(request, slug=slug)
+
+    if status.is_success(response.status_code):
+        return response.data
+
+    response.data['status_code'] = response.status_code
+    raise TransportException(response.data)

django/website/transport/tests/taxonomy_term_itemcount_tests.py

+from __future__ import unicode_literals, absolute_import
+import pytest
+
+from taxonomies.tests.factories import (
+    TaxonomyFactory,
+    TermFactory,
+)
+
+import transport
+from ..exceptions import TransportException
+
+
+@pytest.fixture
+def item_data():
+    item = {'body': "What is the cuse of ebola?"}
+    return transport.items.create(item)
+
+
+@pytest.fixture
+def questions_category():
+    # TODO: Replace with transport call when we have one
+    return TaxonomyFactory(name="Ebola Questions")
+
+
+@pytest.fixture
+def questions_term(questions_category):
+    # TODO: Replace with transport call when we have one
+    return TermFactory(taxonomy=questions_category)
+
+
+@pytest.mark.django_db
+def test_term_itemcount_returns_terms_and_counts(item_data,
+                                                 questions_category,
+                                                 questions_term):
+
+    # This is tested more comprehensively in the API tests
+    transport.items.add_term(item_data['id'],
+                             questions_category.slug,
+                             questions_term.name)
+
+    terms = transport.taxonomies.term_itemcount(slug=questions_category.slug)
+    counts = {term['name']: term['count'] for term in terms}
+
+    assert counts[questions_term.name] == 1
+
+
+@pytest.mark.django_db
+def test_itemcount_fails_if_taxonomy_does_not_exist(item_data):
+    with pytest.raises(TransportException) as excinfo:
+        transport.taxonomies.term_itemcount(
+            slug='a-taxonomy-that-does-not-exist')
+
+    error = excinfo.value.message
+
+    assert error['status_code'] == 400
+    assert error['detail'] == "Taxonomy with slug 'a-taxonomy-that-does-not-exist' does not exist."