import datetime import queue import time from threading import Thread from django.test import TestCase from haystack import connections, indexes from haystack.exceptions import SearchFieldError from haystack.utils.loading import UnifiedIndex from test_haystack.core.models import ( AFifthMockModel, AnotherMockModel, AThirdMockModel, ManyToManyLeftSideModel, ManyToManyRightSideModel, MockModel, ) class BadSearchIndex1(indexes.SearchIndex, indexes.Indexable): author = indexes.CharField(model_attr="author") pub_date = indexes.DateTimeField(model_attr="pub_date") def get_model(self): return MockModel class BadSearchIndex2(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) content2 = indexes.CharField(document=True, use_template=True) author = indexes.CharField(model_attr="author") pub_date = indexes.DateTimeField(model_attr="pub_date") def get_model(self): return MockModel class GoodMockSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) author = indexes.CharField(model_attr="author") pub_date = indexes.DateTimeField(model_attr="pub_date") extra = indexes.CharField(indexed=False, use_template=True) def get_model(self): return MockModel # For testing inheritance... class AltGoodMockSearchIndex(GoodMockSearchIndex, indexes.Indexable): additional = indexes.CharField(model_attr="author") def get_model(self): return MockModel class GoodCustomMockSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) author = indexes.CharField(model_attr="author", faceted=True) pub_date = indexes.DateTimeField(model_attr="pub_date", faceted=True) extra = indexes.CharField(indexed=False, use_template=True) hello = indexes.CharField(model_attr="hello") def prepare(self, obj): super().prepare(obj) self.prepared_data["whee"] = "Custom preparation." return self.prepared_data def prepare_author(self, obj): return "Hi, I'm %s" % self.prepared_data["author"] def load_all_queryset(self): return self.get_model()._default_manager.filter(id__gt=1) def get_model(self): return MockModel def index_queryset(self, using=None): return MockModel.objects.all() def read_queryset(self, using=None): return MockModel.objects.filter(author__in=["daniel1", "daniel3"]) def build_queryset(self, start_date=None, end_date=None): return MockModel.objects.filter(author__in=["daniel1", "daniel3"]) class GoodNullableMockSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) author = indexes.CharField(model_attr="author", null=True, faceted=True) def get_model(self): return MockModel class GoodOverriddenFieldNameMockSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField( document=True, use_template=True, index_fieldname="more_content" ) author = indexes.CharField(model_attr="author", index_fieldname="name_s") hello = indexes.CharField(model_attr="hello") def get_model(self): return MockModel class GoodFacetedMockSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, use_template=True) author = indexes.CharField(model_attr="author") author_foo = indexes.FacetCharField(facet_for="author") pub_date = indexes.DateTimeField(model_attr="pub_date") pub_date_exact = indexes.FacetDateTimeField(facet_for="pub_date") def get_model(self): return MockModel def prepare_author(self, obj): return "Hi, I'm %s" % self.prepared_data["author"] def prepare_pub_date_exact(self, obj): return "2010-10-26T01:54:32" class MROFieldsSearchIndexA(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, model_attr="test_a") def get_model(self): return MockModel class MROFieldsSearchIndexB(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True, model_attr="test_b") def get_model(self): return MockModel class MROFieldsSearchChild(MROFieldsSearchIndexA, MROFieldsSearchIndexB): pass class ModelWithManyToManyFieldAndAttributeLookupSearchIndex( indexes.SearchIndex, indexes.Indexable ): text = indexes.CharField(document=True) related_models = indexes.MultiValueField(model_attr="related_models__name") def get_model(self): return ManyToManyLeftSideModel class SearchIndexTestCase(TestCase): fixtures = ["base_data"] def setUp(self): super().setUp() self.sb = connections["default"].get_backend() self.mi = GoodMockSearchIndex() self.cmi = GoodCustomMockSearchIndex() self.cnmi = GoodNullableMockSearchIndex() self.gfmsi = GoodFacetedMockSearchIndex() # Fake the unified index. self.old_unified_index = connections["default"]._index self.ui = UnifiedIndex() self.ui.build(indexes=[self.mi]) connections["default"]._index = self.ui self.sample_docs = { "core.mockmodel.1": { "text": "Indexed!\n1\n", "django_id": "1", "django_ct": "core.mockmodel", "extra": "Stored!\n1", "author": "daniel1", "pub_date": datetime.datetime(2009, 3, 17, 6, 0), "id": "core.mockmodel.1", }, "core.mockmodel.2": { "text": "Indexed!\n2\n", "django_id": "2", "django_ct": "core.mockmodel", "extra": "Stored!\n2", "author": "daniel2", "pub_date": datetime.datetime(2009, 3, 17, 7, 0), "id": "core.mockmodel.2", }, "core.mockmodel.3": { "text": "Indexed!\n3\n", "django_id": "3", "django_ct": "core.mockmodel", "extra": "Stored!\n3", "author": "daniel3", "pub_date": datetime.datetime(2009, 3, 17, 8, 0), "id": "core.mockmodel.3", }, } def tearDown(self): connections["default"]._index = self.old_unified_index super().tearDown() def test_no_contentfield_present(self): self.assertRaises(SearchFieldError, BadSearchIndex1) def test_too_many_contentfields_present(self): self.assertRaises(SearchFieldError, BadSearchIndex2) def test_contentfield_present(self): try: mi = GoodMockSearchIndex() except: self.fail() def test_proper_fields(self): self.assertEqual(len(self.mi.fields), 4) self.assertTrue("text" in self.mi.fields) self.assertTrue(isinstance(self.mi.fields["text"], indexes.CharField)) self.assertTrue("author" in self.mi.fields) self.assertTrue(isinstance(self.mi.fields["author"], indexes.CharField)) self.assertTrue("pub_date" in self.mi.fields) self.assertTrue(isinstance(self.mi.fields["pub_date"], indexes.DateTimeField)) self.assertTrue("extra" in self.mi.fields) self.assertTrue(isinstance(self.mi.fields["extra"], indexes.CharField)) self.assertEqual(len(self.cmi.fields), 7) self.assertTrue("text" in self.cmi.fields) self.assertTrue(isinstance(self.cmi.fields["text"], indexes.CharField)) self.assertTrue("author" in self.cmi.fields) self.assertTrue(isinstance(self.cmi.fields["author"], indexes.CharField)) self.assertTrue("author_exact" in self.cmi.fields) self.assertTrue( isinstance(self.cmi.fields["author_exact"], indexes.FacetCharField) ) self.assertTrue("pub_date" in self.cmi.fields) self.assertTrue(isinstance(self.cmi.fields["pub_date"], indexes.DateTimeField)) self.assertTrue("pub_date_exact" in self.cmi.fields) self.assertTrue( isinstance(self.cmi.fields["pub_date_exact"], indexes.FacetDateTimeField) ) self.assertTrue("extra" in self.cmi.fields) self.assertTrue(isinstance(self.cmi.fields["extra"], indexes.CharField)) self.assertTrue("hello" in self.cmi.fields) self.assertTrue(isinstance(self.cmi.fields["extra"], indexes.CharField)) def test_index_queryset(self): self.assertEqual(self.cmi.index_queryset().count(), 3) def test_read_queryset(self): self.assertEqual(self.cmi.read_queryset().count(), 2) def test_build_queryset(self): # The custom SearchIndex.build_queryset returns the same records as # the read_queryset self.assertEqual(self.cmi.build_queryset().count(), 2) # Store a reference to the original method old_guf = self.mi.__class__.get_updated_field self.mi.__class__.get_updated_field = lambda self: "pub_date" # With an updated field, we should get have filtered results sd = datetime.datetime(2009, 3, 17, 7, 0) self.assertEqual(len(self.mi.build_queryset(start_date=sd)), 2) ed = datetime.datetime(2009, 3, 17, 7, 59) self.assertEqual(len(self.mi.build_queryset(end_date=ed)), 2) sd = datetime.datetime(2009, 3, 17, 6, 0) ed = datetime.datetime(2009, 3, 17, 6, 59) self.assertEqual(len(self.mi.build_queryset(start_date=sd, end_date=ed)), 1) # Remove the updated field for the next test del self.mi.__class__.get_updated_field # The default should return all 3 even if we specify a start date # because there is no updated field specified self.assertEqual(len(self.mi.build_queryset(start_date=sd)), 3) # Restore the original attribute self.mi.__class__.get_updated_field = old_guf def test_prepare(self): mock = MockModel() mock.pk = 20 mock.author = "daniel%s" % mock.id mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) self.assertEqual(len(self.mi.prepare(mock)), 7) self.assertEqual( sorted(self.mi.prepare(mock).keys()), ["author", "django_ct", "django_id", "extra", "id", "pub_date", "text"], ) def test_custom_prepare(self): mock = MockModel() mock.pk = 20 mock.author = "daniel%s" % mock.id mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) self.assertEqual(len(self.cmi.prepare(mock)), 11) self.assertEqual( sorted(self.cmi.prepare(mock).keys()), [ "author", "author_exact", "django_ct", "django_id", "extra", "hello", "id", "pub_date", "pub_date_exact", "text", "whee", ], ) self.assertEqual(len(self.cmi.full_prepare(mock)), 11) self.assertEqual( sorted(self.cmi.full_prepare(mock).keys()), [ "author", "author_exact", "django_ct", "django_id", "extra", "hello", "id", "pub_date", "pub_date_exact", "text", "whee", ], ) def test_thread_safety(self): # This is a regression. ``SearchIndex`` used to write to # ``self.prepared_data``, which would leak between threads if things # went too fast. exceptions = [] def threaded_prepare(index_queue, index, model): try: index.queue = index_queue prepped = index.prepare(model) except Exception as e: exceptions.append(e) raise class ThreadedSearchIndex(GoodMockSearchIndex): def prepare_author(self, obj): if obj.pk == 20: time.sleep(0.1) else: time.sleep(0.5) index_queue.put(self.prepared_data["author"]) return self.prepared_data["author"] tmi = ThreadedSearchIndex() index_queue = queue.Queue() mock_1 = MockModel() mock_1.pk = 20 mock_1.author = "foo" mock_1.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) mock_2 = MockModel() mock_2.pk = 21 mock_2.author = "daniel%s" % mock_2.id mock_2.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) th1 = Thread(target=threaded_prepare, args=(index_queue, tmi, mock_1)) th2 = Thread(target=threaded_prepare, args=(index_queue, tmi, mock_2)) th1.start() th2.start() th1.join() th2.join() mock_1_result = index_queue.get() mock_2_result = index_queue.get() self.assertEqual(mock_1_result, "foo") self.assertEqual(mock_2_result, "daniel21") def test_custom_prepare_author(self): mock = MockModel() mock.pk = 20 mock.author = "daniel%s" % mock.id mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) self.assertEqual(len(self.cmi.prepare(mock)), 11) self.assertEqual( sorted(self.cmi.prepare(mock).keys()), [ "author", "author_exact", "django_ct", "django_id", "extra", "hello", "id", "pub_date", "pub_date_exact", "text", "whee", ], ) self.assertEqual(len(self.cmi.full_prepare(mock)), 11) self.assertEqual( sorted(self.cmi.full_prepare(mock).keys()), [ "author", "author_exact", "django_ct", "django_id", "extra", "hello", "id", "pub_date", "pub_date_exact", "text", "whee", ], ) self.assertEqual(self.cmi.prepared_data["author"], "Hi, I'm daniel20") self.assertEqual(self.cmi.prepared_data["author_exact"], "Hi, I'm daniel20") def test_custom_model_attr(self): mock = MockModel() mock.pk = 20 mock.author = "daniel%s" % mock.id mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) self.assertEqual(len(self.cmi.prepare(mock)), 11) self.assertEqual( sorted(self.cmi.prepare(mock).keys()), [ "author", "author_exact", "django_ct", "django_id", "extra", "hello", "id", "pub_date", "pub_date_exact", "text", "whee", ], ) self.assertEqual(len(self.cmi.full_prepare(mock)), 11) self.assertEqual( sorted(self.cmi.full_prepare(mock).keys()), [ "author", "author_exact", "django_ct", "django_id", "extra", "hello", "id", "pub_date", "pub_date_exact", "text", "whee", ], ) self.assertEqual(self.cmi.prepared_data["hello"], "World!") def test_custom_index_fieldname(self): mock = MockModel() mock.pk = 20 mock.author = "daniel%s" % mock.id mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) cofnmi = GoodOverriddenFieldNameMockSearchIndex() self.assertEqual(len(cofnmi.prepare(mock)), 6) self.assertEqual( sorted(cofnmi.prepare(mock).keys()), ["django_ct", "django_id", "hello", "id", "more_content", "name_s"], ) self.assertEqual(cofnmi.prepared_data["name_s"], "daniel20") self.assertEqual(cofnmi.get_content_field(), "more_content") def test_get_content_field(self): self.assertEqual(self.mi.get_content_field(), "text") def test_update(self): self.sb.clear() self.assertEqual(self.sb.search("*")["hits"], 0) self.mi.update() self.assertEqual(self.sb.search("*")["hits"], 3) self.sb.clear() def test_update_object(self): self.sb.clear() self.assertEqual(self.sb.search("*")["hits"], 0) mock = MockModel() mock.pk = 20 mock.author = "daniel%s" % mock.id mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) self.mi.update_object(mock) self.assertEqual( [(res.content_type(), res.pk) for res in self.sb.search("*")["results"]], [("core.mockmodel", "20")], ) self.sb.clear() def test_remove_object(self): self.mi.update() self.assertEqual(self.sb.search("*")["hits"], 3) mock = MockModel() mock.pk = 20 mock.author = "daniel%s" % mock.id mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) self.mi.update_object(mock) self.assertEqual(self.sb.search("*")["hits"], 4) self.mi.remove_object(mock) self.assertEqual( [(res.content_type(), res.pk) for res in self.sb.search("*")["results"]], [("core.mockmodel", "1"), ("core.mockmodel", "2"), ("core.mockmodel", "3")], ) # Put it back so we can test passing kwargs. mock = MockModel() mock.pk = 20 mock.author = "daniel%s" % mock.id mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) self.mi.update_object(mock) self.assertEqual(self.sb.search("*")["hits"], 4) self.mi.remove_object(mock, commit=False) self.assertEqual( [(res.content_type(), res.pk) for res in self.sb.search("*")["results"]], [ ("core.mockmodel", "1"), ("core.mockmodel", "2"), ("core.mockmodel", "3"), ("core.mockmodel", "20"), ], ) self.sb.clear() def test_clear(self): self.mi.update() self.assertGreater(self.sb.search("*")["hits"], 0) self.mi.clear() self.assertEqual(self.sb.search("*")["hits"], 0) def test_reindex(self): self.mi.reindex() self.assertEqual( [(res.content_type(), res.pk) for res in self.sb.search("*")["results"]], [("core.mockmodel", "1"), ("core.mockmodel", "2"), ("core.mockmodel", "3")], ) self.sb.clear() def test_inheritance(self): try: agmi = AltGoodMockSearchIndex() except: self.fail() self.assertEqual(len(agmi.fields), 5) self.assertTrue("text" in agmi.fields) self.assertTrue(isinstance(agmi.fields["text"], indexes.CharField)) self.assertTrue("author" in agmi.fields) self.assertTrue(isinstance(agmi.fields["author"], indexes.CharField)) self.assertTrue("pub_date" in agmi.fields) self.assertTrue(isinstance(agmi.fields["pub_date"], indexes.DateTimeField)) self.assertTrue("extra" in agmi.fields) self.assertTrue(isinstance(agmi.fields["extra"], indexes.CharField)) self.assertTrue("additional" in agmi.fields) self.assertTrue(isinstance(agmi.fields["additional"], indexes.CharField)) def test_proper_field_resolution(self): mrofsc = MROFieldsSearchChild() mock = MockModel() mock.pk = 20 mock.author = "daniel%s" % mock.id mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) mock.test_a = "This is A" mock.test_b = "This is B" self.assertEqual(len(mrofsc.fields), 1) prepped_data = mrofsc.prepare(mock) self.assertEqual(len(prepped_data), 4) self.assertEqual(prepped_data["text"], "This is A") def test_load_all_queryset(self): self.assertEqual([obj.id for obj in self.cmi.load_all_queryset()], [2, 3]) def test_nullable(self): mock = MockModel() mock.pk = 20 mock.author = None mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) prepared_data = self.cnmi.prepare(mock) self.assertEqual(len(prepared_data), 6) self.assertEqual( sorted(prepared_data.keys()), ["author", "author_exact", "django_ct", "django_id", "id", "text"], ) prepared_data = self.cnmi.full_prepare(mock) self.assertEqual(len(prepared_data), 4) self.assertEqual( sorted(prepared_data.keys()), ["django_ct", "django_id", "id", "text"] ) def test_custom_facet_fields(self): mock = MockModel() mock.pk = 20 mock.author = "daniel" mock.pub_date = datetime.datetime(2009, 1, 31, 4, 19, 0) prepared_data = self.gfmsi.prepare(mock) self.assertEqual(len(prepared_data), 8) self.assertEqual( sorted(prepared_data.keys()), [ "author", "author_foo", "django_ct", "django_id", "id", "pub_date", "pub_date_exact", "text", ], ) prepared_data = self.gfmsi.full_prepare(mock) self.assertEqual(len(prepared_data), 8) self.assertEqual( sorted(prepared_data.keys()), [ "author", "author_foo", "django_ct", "django_id", "id", "pub_date", "pub_date_exact", "text", ], ) self.assertEqual(prepared_data["author_foo"], "Hi, I'm daniel") self.assertEqual(prepared_data["pub_date_exact"], "2010-10-26T01:54:32") class BasicModelSearchIndex(indexes.ModelSearchIndex, indexes.Indexable): class Meta: model = MockModel class FieldsModelSearchIndex(indexes.ModelSearchIndex, indexes.Indexable): class Meta: model = MockModel fields = ["author", "pub_date"] class ExcludesModelSearchIndex(indexes.ModelSearchIndex, indexes.Indexable): class Meta: model = MockModel excludes = ["author", "foo"] class FieldsWithOverrideModelSearchIndex(indexes.ModelSearchIndex, indexes.Indexable): foo = indexes.IntegerField(model_attr="foo") class Meta: model = MockModel fields = ["author", "foo"] def get_index_fieldname(self, f): if f.name == "author": return "author_bar" return f.name class YetAnotherBasicModelSearchIndex(indexes.ModelSearchIndex, indexes.Indexable): text = indexes.CharField(document=True) class Meta: model = AThirdMockModel class PolymorphicModelSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True) author = indexes.CharField(model_attr="author") pub_date = indexes.DateTimeField(model_attr="pub_date") average_delay = indexes.FloatField(null=True) def get_model(self): return AnotherMockModel def prepare(self, obj): self.prepared_data = super().prepare(obj) if isinstance(obj, AThirdMockModel): self.prepared_data["average_delay"] = obj.average_delay return self.prepared_data def index_queryset(self, using=None): return self.get_model().objects.all() class GhettoAFifthMockModelSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(document=True) def get_model(self): return AFifthMockModel def index_queryset(self, using=None): # Index everything, return self.get_model().objects.complete_set() def read_queryset(self, using=None): return self.get_model().objects.all() class ReadQuerySetTestSearchIndex(indexes.SearchIndex, indexes.Indexable): author = indexes.CharField(model_attr="author", document=True) def get_model(self): return AFifthMockModel def read_queryset(self, using=None): return self.get_model().objects.complete_set() class TextReadQuerySetTestSearchIndex(indexes.SearchIndex, indexes.Indexable): text = indexes.CharField(model_attr="author", document=True) def get_model(self): return AFifthMockModel def read_queryset(self, using=None): return self.get_model().objects.complete_set() class ModelWithManyToManyFieldModelSearchIndex(indexes.ModelSearchIndex): def get_model(self): return ManyToManyLeftSideModel class ModelSearchIndexTestCase(TestCase): def setUp(self): super().setUp() self.sb = connections["default"].get_backend() self.bmsi = BasicModelSearchIndex() self.fmsi = FieldsModelSearchIndex() self.emsi = ExcludesModelSearchIndex() self.fwomsi = FieldsWithOverrideModelSearchIndex() self.yabmsi = YetAnotherBasicModelSearchIndex() self.m2mmsi = ModelWithManyToManyFieldModelSearchIndex() def test_basic(self): self.assertEqual(len(self.bmsi.fields), 4) self.assertTrue("foo" in self.bmsi.fields) self.assertTrue(isinstance(self.bmsi.fields["foo"], indexes.CharField)) self.assertEqual(self.bmsi.fields["foo"].null, False) self.assertEqual(self.bmsi.fields["foo"].index_fieldname, "foo") self.assertTrue("author" in self.bmsi.fields) self.assertTrue(isinstance(self.bmsi.fields["author"], indexes.CharField)) self.assertEqual(self.bmsi.fields["author"].null, False) self.assertTrue("pub_date" in self.bmsi.fields) self.assertTrue(isinstance(self.bmsi.fields["pub_date"], indexes.DateTimeField)) self.assertTrue( isinstance(self.bmsi.fields["pub_date"].default, datetime.datetime) ) self.assertTrue("text" in self.bmsi.fields) self.assertTrue(isinstance(self.bmsi.fields["text"], indexes.CharField)) self.assertEqual(self.bmsi.fields["text"].document, True) self.assertEqual(self.bmsi.fields["text"].use_template, True) def test_fields(self): self.assertEqual(len(self.fmsi.fields), 3) self.assertTrue("author" in self.fmsi.fields) self.assertTrue(isinstance(self.fmsi.fields["author"], indexes.CharField)) self.assertTrue("pub_date" in self.fmsi.fields) self.assertTrue(isinstance(self.fmsi.fields["pub_date"], indexes.DateTimeField)) self.assertTrue("text" in self.fmsi.fields) self.assertTrue(isinstance(self.fmsi.fields["text"], indexes.CharField)) def test_excludes(self): self.assertEqual(len(self.emsi.fields), 2) self.assertTrue("pub_date" in self.emsi.fields) self.assertTrue(isinstance(self.emsi.fields["pub_date"], indexes.DateTimeField)) self.assertTrue("text" in self.emsi.fields) self.assertTrue(isinstance(self.emsi.fields["text"], indexes.CharField)) self.assertNotIn("related_models", self.m2mmsi.fields) def test_fields_with_override(self): self.assertEqual(len(self.fwomsi.fields), 3) self.assertTrue("author" in self.fwomsi.fields) self.assertTrue(isinstance(self.fwomsi.fields["author"], indexes.CharField)) self.assertTrue("foo" in self.fwomsi.fields) self.assertTrue(isinstance(self.fwomsi.fields["foo"], indexes.IntegerField)) self.assertTrue("text" in self.fwomsi.fields) self.assertTrue(isinstance(self.fwomsi.fields["text"], indexes.CharField)) def test_overriding_field_name_with_get_index_fieldname(self): self.assertTrue(self.fwomsi.fields["foo"].index_fieldname, "foo") self.assertTrue(self.fwomsi.fields["author"].index_fieldname, "author_bar") def test_float_integer_fields(self): self.assertEqual(len(self.yabmsi.fields), 5) self.assertEqual( sorted(self.yabmsi.fields.keys()), ["author", "average_delay", "pub_date", "text", "view_count"], ) self.assertTrue("author" in self.yabmsi.fields) self.assertTrue(isinstance(self.yabmsi.fields["author"], indexes.CharField)) self.assertEqual(self.yabmsi.fields["author"].null, False) self.assertTrue("pub_date" in self.yabmsi.fields) self.assertTrue( isinstance(self.yabmsi.fields["pub_date"], indexes.DateTimeField) ) self.assertTrue( isinstance(self.yabmsi.fields["pub_date"].default, datetime.datetime) ) self.assertTrue("text" in self.yabmsi.fields) self.assertTrue(isinstance(self.yabmsi.fields["text"], indexes.CharField)) self.assertEqual(self.yabmsi.fields["text"].document, True) self.assertEqual(self.yabmsi.fields["text"].use_template, False) self.assertTrue("view_count" in self.yabmsi.fields) self.assertTrue( isinstance(self.yabmsi.fields["view_count"], indexes.IntegerField) ) self.assertEqual(self.yabmsi.fields["view_count"].null, False) self.assertEqual(self.yabmsi.fields["view_count"].index_fieldname, "view_count") self.assertTrue("average_delay" in self.yabmsi.fields) self.assertTrue( isinstance(self.yabmsi.fields["average_delay"], indexes.FloatField) ) self.assertEqual(self.yabmsi.fields["average_delay"].null, False) self.assertEqual( self.yabmsi.fields["average_delay"].index_fieldname, "average_delay" ) class ModelWithManyToManyFieldAndAttributeLookupSearchIndexTestCase(TestCase): def test_full_prepare(self): index = ModelWithManyToManyFieldAndAttributeLookupSearchIndex() left_model = ManyToManyLeftSideModel.objects.create() right_model_1 = ManyToManyRightSideModel.objects.create(name="Right side 1") right_model_2 = ManyToManyRightSideModel.objects.create() left_model.related_models.add(right_model_1) left_model.related_models.add(right_model_2) result = index.full_prepare(left_model) self.assertDictEqual( result, { "django_ct": "core.manytomanyleftsidemodel", "django_id": "1", "text": None, "id": "core.manytomanyleftsidemodel.1", "related_models": ["Right side 1", "Default name"], }, ) class PolymorphicModelTestCase(TestCase): def test_prepare_with_polymorphic(self): index = PolymorphicModelSearchIndex() parent_model = AnotherMockModel() parent_model.author = "Paul" parent_model.pub_date = datetime.datetime(2018, 5, 23, 13, 57) parent_model.save() child_model = AThirdMockModel() child_model.author = "Paula" child_model.pub_date = datetime.datetime(2018, 5, 23, 13, 58) child_model.average_delay = 0.5 child_model.save() prepared_data = index.prepare(parent_model) self.assertEqual(len(prepared_data), 7) self.assertEqual( sorted(prepared_data.keys()), [ "author", "average_delay", "django_ct", "django_id", "id", "pub_date", "text", ], ) self.assertEqual(prepared_data["django_ct"], "core.anothermockmodel") self.assertEqual(prepared_data["average_delay"], None) prepared_data = index.prepare(child_model) self.assertEqual(len(prepared_data), 7) self.assertEqual( sorted(prepared_data.keys()), [ "author", "average_delay", "django_ct", "django_id", "id", "pub_date", "text", ], ) self.assertEqual(prepared_data["django_ct"], "core.anothermockmodel") self.assertEqual(prepared_data["average_delay"], 0.5)