# -*- coding: utf-8 -*- # # Unit tests for the `drf_haystack.serializers` classes. # from __future__ import absolute_import, unicode_literals import json from datetime import datetime, timedelta import six from django.conf.urls import url, include from django.core.exceptions import ImproperlyConfigured from django.http import QueryDict from django.utils import six from django.test import TestCase, SimpleTestCase, override_settings from haystack.query import SearchQuerySet from rest_framework import serializers from rest_framework.fields import CharField, IntegerField from rest_framework.routers import DefaultRouter from rest_framework.test import APIRequestFactory, APITestCase from drf_haystack import fields from drf_haystack.serializers import ( HighlighterMixin, HaystackSerializer, HaystackSerializerMixin, HaystackFacetSerializer, HaystackSerializerMeta) from drf_haystack.viewsets import HaystackViewSet from drf_haystack.mixins import MoreLikeThisMixin, FacetMixin from .mixins import WarningTestCaseMixin from .mockapp.models import MockPerson, MockAllField from .mockapp.search_indexes import MockPersonIndex, MockPetIndex, MockAllFieldIndex factory = APIRequestFactory() # More like this stuff class SearchPersonMLTSerializer(HaystackSerializer): more_like_this = serializers.HyperlinkedIdentityField(view_name="search-person-mlt-more-like-this", read_only=True) class Meta: index_classes = [MockPersonIndex] fields = ["firstname", "lastname", "full_name"] class SearchPersonMLTViewSet(MoreLikeThisMixin, HaystackViewSet): serializer_class = SearchPersonMLTSerializer class Meta: index_models = [MockPerson] # Faceting stuff class SearchPersonFSerializer(HaystackSerializer): class Meta: index_classes = [MockPersonIndex] fields = ["firstname", "lastname", "full_name"] class SearchPersonFacetSerializer(HaystackFacetSerializer): serialize_objects = True class Meta: index_classes = [MockPersonIndex] fields = ["firstname", "lastname", "created"] field_options = { "firstname": {}, "lastname": {}, "created": { "start_date": datetime.now() - timedelta(days=10 * 365), "end_date": datetime.now(), "gap_by": "month", "gap_amount": 1 } } class SearchPersonFacetViewSet(FacetMixin, HaystackViewSet): serializer_class = SearchPersonFSerializer facet_serializer_class = SearchPersonFacetSerializer class Meta: index_models = [MockPerson] router = DefaultRouter() router.register("search-person-mlt", viewset=SearchPersonMLTViewSet, base_name="search-person-mlt") router.register("search-person-facet", viewset=SearchPersonFacetViewSet, base_name="search-person-facet") urlpatterns = [ url(r"^", include(router.urls)) ] class HaystackSerializerTestCase(WarningTestCaseMixin, TestCase): fixtures = ["mockperson", "mockpet"] def setUp(self): MockPersonIndex().reindex() MockPetIndex().reindex() class Serializer1(HaystackSerializer): integer_field = serializers.IntegerField() city = serializers.CharField() class Meta: index_classes = [MockPersonIndex] fields = ["text", "firstname", "lastname", "autocomplete"] def get_integer_field(self, obj): return 1 def get_city(self, obj): return "Declared overriding field" class Serializer2(HaystackSerializer): class Meta: index_classes = [MockPersonIndex] exclude = ["firstname"] class Serializer3(HaystackSerializer): class Meta: index_classes = [MockPersonIndex] fields = ["text", "firstname", "lastname", "autocomplete"] ignore_fields = ["autocomplete"] class Serializer7(HaystackSerializer): class Meta: index_classes = [MockPetIndex] class ViewSet1(HaystackViewSet): serializer_class = Serializer1 class Meta: index_models = [MockPerson] self.serializer1 = Serializer1 self.serializer2 = Serializer2 self.serializer3 = Serializer3 self.serializer7 = Serializer7 self.view1 = ViewSet1 def tearDown(self): MockPersonIndex().clear() def test_serializer_raise_without_meta_class(self): try: class Serializer(HaystackSerializer): pass self.fail("Did not fail when defining a Serializer without a Meta class") except ImproperlyConfigured as e: self.assertEqual(str(e), "%s must implement a Meta class or have the property _abstract" % "Serializer") def test_serializer_gets_default_instance(self): serializer = self.serializer1(instance=None) self.assertIsInstance(serializer.instance, SearchQuerySet, "Did not get default instance of type SearchQuerySet") def test_serializer_get_fields(self): obj = SearchQuerySet().filter(lastname="Foreman")[0] serializer = self.serializer1(instance=obj) fields = serializer.get_fields() self.assertIsInstance(fields, dict) self.assertIsInstance(fields["integer_field"], IntegerField) self.assertIsInstance(fields["text"], CharField) self.assertIsInstance(fields["firstname"], CharField) self.assertIsInstance(fields["lastname"], CharField) self.assertIsInstance(fields["autocomplete"], CharField) def test_serializer_get_fields_with_exclude(self): obj = SearchQuerySet().filter(lastname="Foreman")[0] serializer = self.serializer2(instance=obj) fields = serializer.get_fields() self.assertIsInstance(fields, dict) self.assertIsInstance(fields["text"], CharField) self.assertIsInstance(fields["lastname"], CharField) self.assertIsInstance(fields["autocomplete"], CharField) self.assertFalse("firstname" in fields) def test_serializer_get_fields_with_ignore_fields(self): obj = SearchQuerySet().filter(lastname="Foreman")[0] serializer = self.serializer3(instance=obj) fields = serializer.get_fields() self.assertIsInstance(fields, dict) self.assertIsInstance(fields["text"], CharField) self.assertIsInstance(fields["firstname"], CharField) self.assertIsInstance(fields["lastname"], CharField) self.assertFalse("autocomplete" in fields) def test_serializer_boolean_field(self): dog = self.serializer7(instance=SearchQuerySet().filter(species="Dog")[0]) iguana = self.serializer7(instance=SearchQuerySet().filter(species="Iguana")[0]) self.assertTrue(dog.data["has_rabies"]) self.assertFalse(iguana.data["has_rabies"]) class HaystackSerializerAllFieldsTestCase(TestCase): fixtures = ["mockallfield"] def setUp(self): MockAllFieldIndex().reindex() class Serializer1(HaystackSerializer): class Meta: index_classes = [MockAllFieldIndex] fields = ["charfield", "integerfield", "floatfield", "decimalfield", "boolfield", "datefield", "datetimefield", "multivaluefield"] self.serializer1 = Serializer1 def test_serialize_field_is_correct_type(self): obj = SearchQuerySet().models(MockAllField).latest('datetimefield') serializer = self.serializer1(instance=obj, many=False) self.assertIsInstance(serializer.fields['charfield'], fields.HaystackCharField) self.assertIsInstance(serializer.fields['integerfield'], fields.HaystackIntegerField) self.assertIsInstance(serializer.fields['floatfield'], fields.HaystackFloatField) self.assertIsInstance(serializer.fields['decimalfield'], fields.HaystackDecimalField) self.assertIsInstance(serializer.fields['boolfield'], fields.HaystackBooleanField) self.assertIsInstance(serializer.fields['datefield'], fields.HaystackDateField) self.assertIsInstance(serializer.fields['datetimefield'], fields.HaystackDateTimeField) self.assertIsInstance(serializer.fields['multivaluefield'], fields.HaystackMultiValueField) class HaystackSerializerMultipleIndexTestCase(WarningTestCaseMixin, TestCase): fixtures = ["mockperson", "mockpet"] def setUp(self): MockPersonIndex().reindex() MockPetIndex().reindex() class Serializer1(HaystackSerializer): """ Regular multiple index serializer """ class Meta: index_classes = [MockPersonIndex, MockPetIndex] fields = ["text", "firstname", "lastname", "name", "species", "autocomplete"] class Serializer2(HaystackSerializer): """ Multiple index serializer with declared fields """ _MockPersonIndex__hair_color = serializers.CharField() extra = serializers.IntegerField() class Meta: index_classes = [MockPersonIndex, MockPetIndex] exclude = ["firstname"] def get__MockPersonIndex__hair_color(self): return "black" def get_extra(self): return 1 class Serializer3(HaystackSerializer): """ Multiple index serializer with index aliases """ class Meta: index_classes = [MockPersonIndex, MockPetIndex] exclude = ["firstname"] index_aliases = { 'mockapp.MockPersonIndex': 'People' } class ViewSet1(HaystackViewSet): serializer_class = Serializer1 class ViewSet2(HaystackViewSet): serializer_class = Serializer2 class ViewSet3(HaystackViewSet): serializer_class = Serializer3 self.serializer1 = Serializer1 self.serializer2 = Serializer2 self.serializer3 = Serializer3 self.view1 = ViewSet1 self.view2 = ViewSet2 self.view3 = ViewSet3 def tearDown(self): MockPersonIndex().clear() MockPetIndex().clear() def test_serializer_multiple_index_data(self): objs = SearchQuerySet().filter(text="John") serializer = self.serializer1(instance=objs, many=True) data = serializer.data self.assertEqual(len(data), 4) for result in data: if "name" in result: self.assertTrue("species" in result, "Pet results should have 'species' and 'name' fields") self.assertTrue("firstname" not in result, "Pet results should have 'species' and 'name' fields") self.assertTrue("lastname" not in result, "Pet results should have 'species' and 'name' fields") elif "firstname" in result: self.assertTrue("lastname" in result, "Person results should have 'firstname' and 'lastname' fields") self.assertTrue("name" not in result, "Person results should have 'firstname' and 'lastname' fields") self.assertTrue("species" not in result, "Person results should have 'firstname' and 'lastname' fields") else: self.fail("Result should contain either Pet or Person fields") def test_serializer_multiple_index_declared_fields(self): objs = SearchQuerySet().filter(text="John") serializer = self.serializer2(instance=objs, many=True) data = serializer.data self.assertEqual(len(data), 4) for result in data: if "name" in result: self.assertTrue("extra" in result, "'extra' should be present in Pet results") self.assertTrue("hair_color" not in result, "'hair_color' should not be present in Pet results") elif "lastname" in result: self.assertTrue("extra" in result, "'extra' should be present in Person results") self.assertTrue("hair_color" in result, "'hair_color' should be present in Person results") else: self.fail("Result should contain either Pet or Person fields") class HaystackSerializerHighlighterMixinTestCase(WarningTestCaseMixin, TestCase): fixtures = ["mockperson"] def setUp(self): MockPersonIndex().reindex() class Serializer2(HighlighterMixin, HaystackSerializer): highlighter_html_tag = "div" highlighter_css_class = "my-fancy-highlighter" highlighter_field = "description" class Meta: index_classes = [MockPersonIndex] fields = ["firstname", "lastname", "description"] class Serializer3(Serializer2): highlighter_class = None class ViewSet1(HaystackViewSet): serializer_class = Serializer2 class ViewSet2(HaystackViewSet): serializer_class = Serializer3 self.view1 = ViewSet1 self.view2 = ViewSet2 def tearDown(self): MockPersonIndex().clear() def test_serializer_highlighting(self): request = factory.get(path="/", data={"firstname": "jeremy"}, content_type="application/json") response = self.view1.as_view(actions={"get": "list"})(request) response.render() for result in json.loads(response.content.decode()): self.assertTrue("highlighted" in result) self.assertEqual( result["highlighted"], " ".join(('<%(tag)s class="%(css_class)s">Jeremy' % { "tag": self.view1.serializer_class.highlighter_html_tag, "css_class": self.view1.serializer_class.highlighter_css_class }, "%s" % "is a nice chap!")) ) def test_serializer_highlighter_raise_no_highlighter_class(self): request = factory.get(path="/", data={"firstname": "jeremy"}, content_type="application/json") try: self.view2.as_view(actions={"get": "list"})(request) self.fail("Did not raise ImproperlyConfigured error when called without a serializer_class") except ImproperlyConfigured as e: self.assertEqual( str(e), "%(cls)s is missing a highlighter_class. Define %(cls)s.highlighter_class, " "or override %(cls)s.get_highlighter()." % {"cls": self.view2.serializer_class.__name__} ) @override_settings(ROOT_URLCONF="tests.test_serializers") class HaystackSerializerMoreLikeThisTestCase(APITestCase): fixtures = ["mockperson"] def setUp(self): MockPersonIndex().reindex() def tearDown(self): MockPersonIndex().clear() def test_serializer_more_like_this_link(self): response = self.client.get( path="/search-person-mlt/", data={"firstname": "odysseus", "lastname": "cooley"}, format="json" ) self.assertEqual( response.data, [{ "lastname": "Cooley", "full_name": "Odysseus Cooley", "firstname": "Odysseus", "more_like_this": "http://testserver/search-person-mlt/18/more-like-this/" }] ) @override_settings(ROOT_URLCONF="tests.test_serializers") class HaystackFacetSerializerTestCase(TestCase): fixtures = ["mockperson"] def setUp(self): MockPersonIndex().reindex() self.response = self.client.get( path="/search-person-facet/facets/", data={}, format="json" ) def tearDown(self): MockPersonIndex().clear() @staticmethod def build_absolute_uri(location): """ Builds an absolute URI using the test server's domain and the specified location. """ location = location.lstrip("/") return "http://testserver/{location}".format(location=location) @staticmethod def is_paginated_facet_response(response): """ Returns True if the response.data seems like a faceted result. Only works for responses created with the test client. """ return "objects" in response.data and \ all([k in response.data["objects"] for k in ("count", "next", "previous", "results")]) def test_serializer_facet_top_level_structure(self): for key in ("fields", "dates", "queries"): self.assertContains(self.response, key, count=1) def test_serializer_facet_field_result(self): fields = self.response.data["fields"] for field in ("firstname", "lastname"): self.assertTrue(field in fields) self.assertTrue(isinstance(fields[field], list)) firstname = fields["firstname"][0] self.assertTrue({"text", "count", "narrow_url"} <= set(firstname)) self.assertEqual( firstname["narrow_url"], self.build_absolute_uri("/search-person-facet/facets/?selected_facets=firstname_exact%3A{term}".format( term=firstname["text"])) ) lastname = fields["lastname"][0] self.assertTrue({"text", "count", "narrow_url"} <= set(lastname)) self.assertEqual( lastname["narrow_url"], self.build_absolute_uri("/search-person-facet/facets/?selected_facets=lastname_exact%3A{term}".format( term=lastname["text"] )) ) def test_serializer_facet_date_result(self): dates = self.response.data["dates"] self.assertTrue("created" in dates) self.assertEqual(len(dates["created"]), 1) created = dates["created"][0] self.assertTrue(all([k in created for k in ("text", "count", "narrow_url")])) self.assertEqual(created["text"], "2015-05-01T00:00:00Z") self.assertEqual(created["count"], 100) self.assertEqual( created["narrow_url"], self.build_absolute_uri("/search-person-facet/facets/?selected_facets=created_exact%3A2015-05-01+00%3A00%3A00") ) def test_serializer_facet_queries_result(self): # Not Implemented pass def test_serializer_facet_narrow(self): response = self.client.get( path="/search-person-facet/facets/", data=QueryDict("selected_facets=firstname_exact:John&selected_facets=lastname_exact:McClane"), format="json" ) self.assertEqual(response.data["queries"], {}) self.assertTrue([all(("firstname", "lastname" in response.data["fields"]))]) self.assertEqual(len(response.data["fields"]["firstname"]), 1) self.assertEqual(response.data["fields"]["firstname"][0]["text"], "John") self.assertEqual(response.data["fields"]["firstname"][0]["count"], 1) self.assertEqual( response.data["fields"]["firstname"][0]["narrow_url"], self.build_absolute_uri("/search-person-facet/facets/?selected_facets=firstname_exact%3AJohn" "&selected_facets=lastname_exact%3AMcClane") ) self.assertEqual(len(response.data["fields"]["lastname"]), 1) self.assertEqual(response.data["fields"]["lastname"][0]["text"], "McClane") self.assertEqual(response.data["fields"]["lastname"][0]["count"], 1) self.assertEqual( response.data["fields"]["lastname"][0]["narrow_url"], self.build_absolute_uri("/search-person-facet/facets/?selected_facets=firstname_exact%3AJohn" "&selected_facets=lastname_exact%3AMcClane") ) self.assertTrue("created" in response.data["dates"]) self.assertEqual(len(response.data["dates"]), 1) self.assertEqual(response.data["dates"]["created"][0]["text"], "2015-05-01T00:00:00Z") self.assertEqual(response.data["dates"]["created"][0]["count"], 1) self.assertEqual( response.data["dates"]["created"][0]["narrow_url"], self.build_absolute_uri("/search-person-facet/facets/?selected_facets=created_exact%3A2015-05-01+00%3A00%3A00" "&selected_facets=firstname_exact%3AJohn&selected_facets=lastname_exact%3AMcClane" ) ) def test_serializer_raise_without_meta_class(self): try: class FacetSerializer(HaystackFacetSerializer): pass self.fail("Did not fail when defining a Serializer without a Meta class") except ImproperlyConfigured as e: self.assertEqual(str(e), "%s must implement a Meta class or have the property _abstract" % "FacetSerializer") class HaystackSerializerMixinTestCase(WarningTestCaseMixin, TestCase): fixtures = ["mockperson"] def setUp(self): MockPersonIndex().reindex() class MockPersonSerializer(serializers.ModelSerializer): class Meta: model = MockPerson fields = ('id', 'firstname', 'lastname', 'created', 'updated') read_only_fields = ('created', 'updated') class Serializer1(HaystackSerializerMixin, MockPersonSerializer): class Meta(MockPersonSerializer.Meta): search_fields = ['text', ] class Viewset1(HaystackViewSet): serializer_class = Serializer1 self.serializer1 = Serializer1 self.viewset1 = Viewset1 def tearDown(self): MockPersonIndex().clear() def test_serializer_mixin(self): objs = SearchQuerySet().filter(text="Foreman") serializer = self.serializer1(instance=objs, many=True) self.assertEqual( json.loads(json.dumps(serializer.data)), [{ "id": 1, "firstname": "Abel", "lastname": "Foreman", "created": "2015-05-19T10:48:08.686000Z", "updated": "2016-04-24T16:02:59.378000Z" }] ) class HaystackMultiSerializerTestCase(WarningTestCaseMixin, TestCase): fixtures = ["mockperson", "mockpet"] def setUp(self): MockPersonIndex().reindex() MockPetIndex().reindex() class MockPersonSerializer(HaystackSerializer): class Meta: index_classes = [MockPersonIndex] fields = ('text', 'firstname', 'lastname', 'description') class MockPetSerializer(HaystackSerializer): class Meta: index_classes = [MockPetIndex] exclude = ('description', 'autocomplete') class Serializer1(HaystackSerializer): class Meta: serializers = { MockPersonIndex: MockPersonSerializer, MockPetIndex: MockPetSerializer } self.serializer1 = Serializer1 def tearDown(self): MockPersonIndex().clear() MockPetIndex().clear() def test_multi_serializer(self): objs = SearchQuerySet().filter(text="Zane") serializer = self.serializer1(instance=objs, many=True) self.assertEqual( json.loads(json.dumps(serializer.data)), [{ "has_rabies": True, "text": "Zane", "name": "Zane", "species": "Dog" }, { "text": "Zane Griffith\n", "firstname": "Zane", "lastname": "Griffith", "description": "Zane is a nice chap!" }] ) class TestHaystackSerializerMeta(SimpleTestCase): def test_abstract_not_inherited(self): class Base(six.with_metaclass(HaystackSerializerMeta, serializers.Serializer)): _abstract = True def create_subclass(): class Sub(HaystackSerializer): pass self.assertRaises(ImproperlyConfigured, create_subclass) class TestMeta(SimpleTestCase): def test_inheritance(self): """ Tests that Meta fields are correctly overriden by subclasses. """ class Serializer(HaystackSerializer): class Meta: fields = ('overriden_fields',) self.assertEqual(Serializer.Meta.fields, ('overriden_fields',)) def test_default_attrs(self): class Serializer(HaystackSerializer): class Meta: fields = ('overriden_fields',) self.assertEqual(Serializer.Meta.exclude, tuple()) def test_raises_if_fields_and_exclude_defined(self): def create_subclass(): class Serializer(HaystackSerializer): class Meta: fields = ('include_field',) exclude = ('exclude_field',) return Serializer self.assertRaises(ImproperlyConfigured, create_subclass)