tests.py

import json
from django.urls import reverse
from django.test import RequestFactory, TestCase
from django.utils.encoding import force_text
from guardian.shortcuts import assign_perm

from feder.main.tests import PermissionStatusMixin
from feder.teryt.factories import JSTFactory
from feder.users.factories import UserFactory
from .factories import InstitutionFactory, TagFactory
from .models import Institution
from .serializers import InstitutionSerializer
from .views import InstitutionAutocomplete, TagAutocomplete


class InstitutionTestCase(TestCase):
    def setUp(self):
        self.obj = InstitutionFactory(name="Example institution")

    def test_get_absolute_url(self):
        self.assertEqual(self.obj.get_absolute_url(), "/instytucje/example-institution")

    def test_get_str(self):
        self.assertEqual(force_text(self.obj), "Example institution")


class InstitutionSerializerTestCase(TestCase):
    def setUp(self):
        self.data = {
            "name": "xxx",
            "slug": "xxx",
            "tags": ["blabla", "X", "Z"],
            "regon": "0" * 14,
            "jst": JSTFactory().pk,
            "email": "example-2@example.com",
        }

    def test_create_institution(self):
        serializer = InstitutionSerializer(
            data={
                "name": "X",
                "email": "example-2@example.com",
                "regon": "0" * 14,
                "jst": JSTFactory().pk,
            }
        )
        self.assertTrue(serializer.is_valid(), serializer.errors)
        self.assertTrue(serializer.save())

    def test_create_institution_with_tags(self):
        TagFactory(name="X")  # for colission tag name
        serializer = InstitutionSerializer(data=self.data)
        self.assertTrue(serializer.is_valid(), serializer.errors)
        obj = serializer.save()
        self.assertQuerysetEqual(
            qs=obj.tags.all(), values=["blabla", "X", "Z"], transform=force_text
        )

    def test_update_institution_with_tags(self):
        institution = InstitutionFactory()

        self.data["pk"] = institution.pk

        serializer = InstitutionSerializer(institution, data=self.data)
        self.assertTrue(serializer.is_valid(), serializer.errors)
        obj = serializer.save()
        self.assertQuerysetEqual(
            qs=obj.tags.all(), values=["blabla", "X", "Z"], transform=force_text
        )
        self.assertEqual(Institution.objects.count(), 1)  # updated


class ObjectMixin:
    def setUp(self):
        self.user = UserFactory(username="john")
        self.institution = InstitutionFactory()


class InstitutionListViewTestCase(ObjectMixin, PermissionStatusMixin, TestCase):
    url = reverse("institutions:list")
    status_anonymous = 200
    status_no_permission = 200
    permission = []

    def test_content(self):
        response = self.client.get(self.get_url())
        self.assertTemplateUsed(response, "institutions/institution_filter.html")
        self.assertContains(response, self.institution.name)


class InstitutionDetailViewTestCase(ObjectMixin, PermissionStatusMixin, TestCase):
    status_anonymous = 200
    status_no_permission = 200
    permission = []

    def get_url(self):
        return self.institution.get_absolute_url()

    def test_content(self):
        response = self.client.get(self.get_url())
        self.assertTemplateUsed(response, "institutions/institution_detail.html")
        self.assertContains(response, self.institution.name)

    def test_can_view_edit_button_if_permitted(self):
        assign_perm("institutions.change_institution", self.user)
        self.login_permitted_user()
        response = self.client.get(self.get_url())
        self.assertContains(
            response,
            reverse("institutions:update", kwargs={"slug": self.institution.slug}),
        )


class InstitutionCreateViewTestCase(ObjectMixin, PermissionStatusMixin, TestCase):
    url = reverse("institutions:create")
    permission = ["institutions.add_institution"]


class InstitutionUpdateViewTestCase(ObjectMixin, PermissionStatusMixin, TestCase):
    permission = ["institutions.change_institution"]

    def get_url(self):
        return reverse("institutions:update", kwargs={"slug": self.institution.slug})


class InstitutionDeleteViewTestCase(ObjectMixin, PermissionStatusMixin, TestCase):
    permission = ["institutions.delete_institution"]

    def get_url(self):
        return reverse("institutions:delete", kwargs={"slug": self.institution.slug})


class InstitutionViewSetTestCase(ObjectMixin, TestCase):
    def test_csv_renderer(self):
        response = self.client.get("{}?format=csv".format(reverse("institution-list")))
        self.assertEqual(response.status_code, 200)
        self.assertIn("text/csv", response["content-type"])
        self.assertContains(response, self.institution.name)


class InstitutionAutocompleteTestCase(TestCase):
    def setUp(self):
        self.factory = RequestFactory()

    def test_filter_by_name(self):
        InstitutionFactory(name="123")
        InstitutionFactory(name="456")
        request = self.factory.get("/customer/details", data={"q": "123"})
        response = InstitutionAutocomplete.as_view()(request)
        self.assertContains(response, "123")
        self.assertNotContains(response, "456")


class TagAutocompleteTestCase(TestCase):
    def setUp(self):
        self.factory = RequestFactory()

    def test_filter_by_name(self):
        TagFactory(name="123")
        TagFactory(name="456")
        request = self.factory.get("/customer/details", data={"q": "123"})
        response = TagAutocomplete.as_view()(request)
        self.assertContains(response, "123")
        self.assertNotContains(response, "456")

    def test_get_result_label_without_institution(self):
        TagFactory(name="123")
        request = self.factory.get("/customer/details", data={"q": "123"})
        response = TagAutocomplete.as_view()(request)
        self.assertContains(response, "123 (0)")

    def test_get_result_label_with_institution(self):
        institution = InstitutionFactory()
        institution.tags.add(TagFactory(name="123"))
        institution.save()

        request = self.factory.get("/customer/details", data={"q": "123"})
        response = TagAutocomplete.as_view()(request)
        self.assertContains(response, "123 (1)")

    def test_get_sorted_by_name(self):
        source_names = ["a2", "a3", "a1"]
        tags = [TagFactory(name=name) for name in source_names]
        [
            InstitutionFactory.create_batch(tags=[tag], size=count)
            for count, tag in enumerate(tags)
        ]
        request = self.factory.get("/customer/details")
        response = TagAutocomplete.as_view()(request)
        body = json.loads(response.content)

        expected_names = sorted(source_names)
        result_names = [x["text"].split(" ")[0] for x in body["results"]]

        self.assertListEqual(expected_names, result_names)


class SitemapTestCase(ObjectMixin, TestCase):
    def test_institutions(self):
        url = reverse("sitemaps", kwargs={"section": "institutions"})
        needle = reverse("institutions:details", kwargs={"slug": self.institution})
        response = self.client.get(url)
        self.assertContains(response, needle)

    def test_tags(self):
        tag_used = TagFactory()
        institution = InstitutionFactory()
        institution.tags.add(tag_used)
        institution.save()
        tag_free = TagFactory()
        url = reverse("sitemaps", kwargs={"section": "institutions_tags"})
        response = self.client.get(url)
        self.assertContains(response, tag_used.get_absolute_url())
        self.assertNotContains(response, tag_free.get_absolute_url())