Debian Codegraph @

tests/postgres_tests/test_search.py

raw
1 """
2 Test PostgreSQL full text search.
3
4 These tests use dialogue from the 1975 film Monty Python and the Holy Grail.
5 All text copyright Python (Monty) Pictures. Thanks to sacred-texts.com for the
6 transcript.
7 """
8
9 from django.db.models import F, Value
10
11 from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase
12 from .models import Character, Line, LineSavedSearch, Scene
13
14 try:
15 from django.contrib.postgres.search import (
16 SearchConfig,
17 SearchHeadline,
18 SearchQuery,
19 SearchRank,
20 SearchVector,
21 )
22 except ImportError:
23 pass
24
25
26 class GrailTestData:
27 @classmethod
28 def setUpTestData(cls):
29 cls.robin = Scene.objects.create(
30 scene="Scene 10", setting="The dark forest of Ewing"
31 )
32 cls.minstrel = Character.objects.create(name="Minstrel")
33 verses = [
34 (
35 "Bravely bold Sir Robin, rode forth from Camelot. "
36 "He was not afraid to die, o Brave Sir Robin. "
37 "He was not at all afraid to be killed in nasty ways. "
38 "Brave, brave, brave, brave Sir Robin"
39 ),
40 (
41 "He was not in the least bit scared to be mashed into a pulp, "
42 "Or to have his eyes gouged out, and his elbows broken. "
43 "To have his kneecaps split, and his body burned away, "
44 "And his limbs all hacked and mangled, brave Sir Robin!"
45 ),
46 (
47 "His head smashed in and his heart cut out, "
48 "And his liver removed and his bowels unplugged, "
49 "And his nostrils ripped and his bottom burned off,"
50 "And his --"
51 ),
52 ]
53 cls.verses = [
54 Line.objects.create(
55 scene=cls.robin,
56 character=cls.minstrel,
57 dialogue=verse,
58 )
59 for verse in verses
60 ]
61 cls.verse0, cls.verse1, cls.verse2 = cls.verses
62
63 cls.witch_scene = Scene.objects.create(
64 scene="Scene 5", setting="Sir Bedemir's Castle"
65 )
66 bedemir = Character.objects.create(name="Bedemir")
67 crowd = Character.objects.create(name="Crowd")
68 witch = Character.objects.create(name="Witch")
69 duck = Character.objects.create(name="Duck")
70
71 cls.bedemir0 = Line.objects.create(
72 scene=cls.witch_scene,
73 character=bedemir,
74 dialogue="We shall use my larger scales!",
75 dialogue_config="english",
76 )
77 cls.bedemir1 = Line.objects.create(
78 scene=cls.witch_scene,
79 character=bedemir,
80 dialogue="Right, remove the supports!",
81 dialogue_config="english",
82 )
83 cls.duck = Line.objects.create(
84 scene=cls.witch_scene, character=duck, dialogue=None
85 )
86 cls.crowd = Line.objects.create(
87 scene=cls.witch_scene, character=crowd, dialogue="A witch! A witch!"
88 )
89 cls.witch = Line.objects.create(
90 scene=cls.witch_scene, character=witch, dialogue="It's a fair cop."
91 )
92
93 trojan_rabbit = Scene.objects.create(
94 scene="Scene 8", setting="The castle of Our Master Ruiz' de lu la Ramper"
95 )
96 guards = Character.objects.create(name="French Guards")
97 cls.french = Line.objects.create(
98 scene=trojan_rabbit,
99 character=guards,
100 dialogue="Oh. Un beau cadeau. Oui oui.",
101 dialogue_config="french",
102 )
103
104
105 class SimpleSearchTest(GrailTestData, PostgreSQLTestCase):
106 def test_simple(self):
107 searched = Line.objects.filter(dialogue__search="elbows")
108 self.assertSequenceEqual(searched, [self.verse1])
109
110 def test_non_exact_match(self):
111 self.check_default_text_search_config()
112 searched = Line.objects.filter(dialogue__search="hearts")
113 self.assertSequenceEqual(searched, [self.verse2])
114
115 def test_search_two_terms(self):
116 self.check_default_text_search_config()
117 searched = Line.objects.filter(dialogue__search="heart bowel")
118 self.assertSequenceEqual(searched, [self.verse2])
119
120 def test_search_two_terms_with_partial_match(self):
121 searched = Line.objects.filter(dialogue__search="Robin killed")
122 self.assertSequenceEqual(searched, [self.verse0])
123
124 def test_search_query_config(self):
125 searched = Line.objects.filter(
126 dialogue__search=SearchQuery("nostrils", config="simple"),
127 )
128 self.assertSequenceEqual(searched, [self.verse2])
129
130 def test_search_with_F_expression(self):
131 # Non-matching query.
132 LineSavedSearch.objects.create(line=self.verse1, query="hearts")
133 # Matching query.
134 match = LineSavedSearch.objects.create(line=self.verse1, query="elbows")
135 for query_expression in [F("query"), SearchQuery(F("query"))]:
136 with self.subTest(query_expression):
137 searched = LineSavedSearch.objects.filter(
138 line__dialogue__search=query_expression,
139 )
140 self.assertSequenceEqual(searched, [match])
141
142
143 class SearchVectorFieldTest(GrailTestData, PostgreSQLTestCase):
144 def test_existing_vector(self):
145 Line.objects.update(dialogue_search_vector=SearchVector("dialogue"))
146 searched = Line.objects.filter(
147 dialogue_search_vector=SearchQuery("Robin killed")
148 )
149 self.assertSequenceEqual(searched, [self.verse0])
150
151 def test_existing_vector_config_explicit(self):
152 Line.objects.update(dialogue_search_vector=SearchVector("dialogue"))
153 searched = Line.objects.filter(
154 dialogue_search_vector=SearchQuery("cadeaux", config="french")
155 )
156 self.assertSequenceEqual(searched, [self.french])
157
158 def test_single_coalesce_expression(self):
159 searched = Line.objects.annotate(search=SearchVector("dialogue")).filter(
160 search="cadeaux"
161 )
162 self.assertNotIn("COALESCE(COALESCE", str(searched.query))
163
164 def test_values_with_percent(self):
165 searched = Line.objects.annotate(
166 search=SearchVector(Value("This week everything is 10% off"))
167 ).filter(search="10 % off")
168 self.assertEqual(len(searched), 9)
169
170
171 class SearchConfigTests(PostgreSQLSimpleTestCase):
172 def test_from_parameter(self):
173 self.assertIsNone(SearchConfig.from_parameter(None))
174 self.assertEqual(SearchConfig.from_parameter("foo"), SearchConfig("foo"))
175 self.assertEqual(
176 SearchConfig.from_parameter(SearchConfig("bar")), SearchConfig("bar")
177 )
178
179
180 class MultipleFieldsTest(GrailTestData, PostgreSQLTestCase):
181 def test_simple_on_dialogue(self):
182 searched = Line.objects.annotate(
183 search=SearchVector("scene__setting", "dialogue"),
184 ).filter(search="elbows")
185 self.assertSequenceEqual(searched, [self.verse1])
186
187 def test_simple_on_scene(self):
188 searched = Line.objects.annotate(
189 search=SearchVector("scene__setting", "dialogue"),
190 ).filter(search="Forest")
191 self.assertCountEqual(searched, self.verses)
192
193 def test_non_exact_match(self):
194 searched = Line.objects.annotate(
195 search=SearchVector("scene__setting", "dialogue"),
196 ).filter(search="heart")
197 self.assertSequenceEqual(searched, [self.verse2])
198
199 def test_search_two_terms(self):
200 searched = Line.objects.annotate(
201 search=SearchVector("scene__setting", "dialogue"),
202 ).filter(search="heart forest")
203 self.assertSequenceEqual(searched, [self.verse2])
204
205 def test_terms_adjacent(self):
206 searched = Line.objects.annotate(
207 search=SearchVector("character__name", "dialogue"),
208 ).filter(search="minstrel")
209 self.assertCountEqual(searched, self.verses)
210 searched = Line.objects.annotate(
211 search=SearchVector("scene__setting", "dialogue"),
212 ).filter(search="minstrelbravely")
213 self.assertSequenceEqual(searched, [])
214
215 def test_search_with_null(self):
216 searched = Line.objects.annotate(
217 search=SearchVector("scene__setting", "dialogue"),
218 ).filter(search="bedemir")
219 self.assertCountEqual(
220 searched, [self.bedemir0, self.bedemir1, self.crowd, self.witch, self.duck]
221 )
222
223 def test_search_with_non_text(self):
224 searched = Line.objects.annotate(
225 search=SearchVector("id"),
226 ).filter(search=str(self.crowd.id))
227 self.assertSequenceEqual(searched, [self.crowd])
228
229 def test_phrase_search(self):
230 line_qs = Line.objects.annotate(search=SearchVector("dialogue"))
231 searched = line_qs.filter(
232 search=SearchQuery("burned body his away", search_type="phrase")
233 )
234 self.assertSequenceEqual(searched, [])
235 searched = line_qs.filter(
236 search=SearchQuery("his body burned away", search_type="phrase")
237 )
238 self.assertSequenceEqual(searched, [self.verse1])
239
240 def test_phrase_search_with_config(self):
241 line_qs = Line.objects.annotate(
242 search=SearchVector("scene__setting", "dialogue", config="french"),
243 )
244 searched = line_qs.filter(
245 search=SearchQuery("cadeau beau un", search_type="phrase", config="french"),
246 )
247 self.assertSequenceEqual(searched, [])
248 searched = line_qs.filter(
249 search=SearchQuery("un beau cadeau", search_type="phrase", config="french"),
250 )
251 self.assertSequenceEqual(searched, [self.french])
252
253 def test_raw_search(self):
254 line_qs = Line.objects.annotate(search=SearchVector("dialogue"))
255 searched = line_qs.filter(search=SearchQuery("Robin", search_type="raw"))
256 self.assertCountEqual(searched, [self.verse0, self.verse1])
257 searched = line_qs.filter(
258 search=SearchQuery("Robin & !'Camelot'", search_type="raw")
259 )
260 self.assertSequenceEqual(searched, [self.verse1])
261
262 def test_raw_search_with_config(self):
263 line_qs = Line.objects.annotate(
264 search=SearchVector("dialogue", config="french")
265 )
266 searched = line_qs.filter(
267 search=SearchQuery(
268 "'cadeaux' & 'beaux'", search_type="raw", config="french"
269 ),
270 )
271 self.assertSequenceEqual(searched, [self.french])
272
273 def test_web_search(self):
274 line_qs = Line.objects.annotate(search=SearchVector("dialogue"))
275 searched = line_qs.filter(
276 search=SearchQuery(
277 '"burned body" "split kneecaps"',
278 search_type="websearch",
279 ),
280 )
281 self.assertSequenceEqual(searched, [])
282 searched = line_qs.filter(
283 search=SearchQuery(
284 '"body burned" "kneecaps split" -"nostrils"',
285 search_type="websearch",
286 ),
287 )
288 self.assertSequenceEqual(searched, [self.verse1])
289 searched = line_qs.filter(
290 search=SearchQuery(
291 '"Sir Robin" ("kneecaps" OR "Camelot")',
292 search_type="websearch",
293 ),
294 )
295 self.assertSequenceEqual(searched, [self.verse0, self.verse1])
296
297 def test_web_search_with_config(self):
298 line_qs = Line.objects.annotate(
299 search=SearchVector("scene__setting", "dialogue", config="french"),
300 )
301 searched = line_qs.filter(
302 search=SearchQuery(
303 "cadeau -beau", search_type="websearch", config="french"
304 ),
305 )
306 self.assertSequenceEqual(searched, [])
307 searched = line_qs.filter(
308 search=SearchQuery("beau cadeau", search_type="websearch", config="french"),
309 )
310 self.assertSequenceEqual(searched, [self.french])
311
312 def test_bad_search_type(self):
313 with self.assertRaisesMessage(
314 ValueError, "Unknown search_type argument 'foo'."
315 ):
316 SearchQuery("kneecaps", search_type="foo")
317
318 def test_config_query_explicit(self):
319 searched = Line.objects.annotate(
320 search=SearchVector("scene__setting", "dialogue", config="french"),
321 ).filter(search=SearchQuery("cadeaux", config="french"))
322 self.assertSequenceEqual(searched, [self.french])
323
324 def test_config_query_implicit(self):
325 searched = Line.objects.annotate(
326 search=SearchVector("scene__setting", "dialogue", config="french"),
327 ).filter(search="cadeaux")
328 self.assertSequenceEqual(searched, [self.french])
329
330 def test_config_from_field_explicit(self):
331 searched = Line.objects.annotate(
332 search=SearchVector(
333 "scene__setting", "dialogue", config=F("dialogue_config")
334 ),
335 ).filter(search=SearchQuery("cadeaux", config=F("dialogue_config")))
336 self.assertSequenceEqual(searched, [self.french])
337
338 def test_config_from_field_implicit(self):
339 searched = Line.objects.annotate(
340 search=SearchVector(
341 "scene__setting", "dialogue", config=F("dialogue_config")
342 ),
343 ).filter(search="cadeaux")
344 self.assertSequenceEqual(searched, [self.french])
345
346
347 class TestCombinations(GrailTestData, PostgreSQLTestCase):
348 def test_vector_add(self):
349 searched = Line.objects.annotate(
350 search=SearchVector("scene__setting") + SearchVector("character__name"),
351 ).filter(search="bedemir")
352 self.assertCountEqual(
353 searched, [self.bedemir0, self.bedemir1, self.crowd, self.witch, self.duck]
354 )
355
356 def test_vector_add_multi(self):
357 searched = Line.objects.annotate(
358 search=(
359 SearchVector("scene__setting")
360 + SearchVector("character__name")
361 + SearchVector("dialogue")
362 ),
363 ).filter(search="bedemir")
364 self.assertCountEqual(
365 searched, [self.bedemir0, self.bedemir1, self.crowd, self.witch, self.duck]
366 )
367
368 def test_vector_combined_mismatch(self):
369 msg = (
370 "SearchVector can only be combined with other SearchVector "
371 "instances, got NoneType."
372 )
373 with self.assertRaisesMessage(TypeError, msg):
374 Line.objects.filter(dialogue__search=None + SearchVector("character__name"))
375
376 def test_combine_different_vector_configs(self):
377 self.check_default_text_search_config()
378 searched = Line.objects.annotate(
379 search=(
380 SearchVector("dialogue", config="english")
381 + SearchVector("dialogue", config="french")
382 ),
383 ).filter(
384 search=SearchQuery("cadeaux", config="french") | SearchQuery("nostrils")
385 )
386 self.assertCountEqual(searched, [self.french, self.verse2])
387
388 def test_query_and(self):
389 searched = Line.objects.annotate(
390 search=SearchVector("scene__setting", "dialogue"),
391 ).filter(search=SearchQuery("bedemir") & SearchQuery("scales"))
392 self.assertSequenceEqual(searched, [self.bedemir0])
393
394 def test_query_multiple_and(self):
395 searched = Line.objects.annotate(
396 search=SearchVector("scene__setting", "dialogue"),
397 ).filter(
398 search=SearchQuery("bedemir")
399 & SearchQuery("scales")
400 & SearchQuery("nostrils")
401 )
402 self.assertSequenceEqual(searched, [])
403
404 searched = Line.objects.annotate(
405 search=SearchVector("scene__setting", "dialogue"),
406 ).filter(
407 search=SearchQuery("shall") & SearchQuery("use") & SearchQuery("larger")
408 )
409 self.assertSequenceEqual(searched, [self.bedemir0])
410
411 def test_query_or(self):
412 searched = Line.objects.filter(
413 dialogue__search=SearchQuery("kneecaps") | SearchQuery("nostrils")
414 )
415 self.assertCountEqual(searched, [self.verse1, self.verse2])
416
417 def test_query_multiple_or(self):
418 searched = Line.objects.filter(
419 dialogue__search=SearchQuery("kneecaps")
420 | SearchQuery("nostrils")
421 | SearchQuery("Sir Robin")
422 )
423 self.assertCountEqual(searched, [self.verse1, self.verse2, self.verse0])
424
425 def test_query_invert(self):
426 searched = Line.objects.filter(
427 character=self.minstrel, dialogue__search=~SearchQuery("kneecaps")
428 )
429 self.assertCountEqual(searched, [self.verse0, self.verse2])
430
431 def test_combine_different_configs(self):
432 searched = Line.objects.filter(
433 dialogue__search=(
434 SearchQuery("cadeau", config="french")
435 | SearchQuery("nostrils", config="english")
436 )
437 )
438 self.assertCountEqual(searched, [self.french, self.verse2])
439
440 def test_combined_configs(self):
441 searched = Line.objects.filter(
442 dialogue__search=(
443 SearchQuery("nostrils", config="simple")
444 & SearchQuery("bowels", config="simple")
445 ),
446 )
447 self.assertSequenceEqual(searched, [self.verse2])
448
449 def test_combine_raw_phrase(self):
450 self.check_default_text_search_config()
451 searched = Line.objects.filter(
452 dialogue__search=(
453 SearchQuery("burn:*", search_type="raw", config="simple")
454 | SearchQuery("rode forth from Camelot", search_type="phrase")
455 )
456 )
457 self.assertCountEqual(searched, [self.verse0, self.verse1, self.verse2])
458
459 def test_query_combined_mismatch(self):
460 msg = (
461 "SearchQuery can only be combined with other SearchQuery "
462 "instances, got NoneType."
463 )
464 with self.assertRaisesMessage(TypeError, msg):
465 Line.objects.filter(dialogue__search=None | SearchQuery("kneecaps"))
466
467 with self.assertRaisesMessage(TypeError, msg):
468 Line.objects.filter(dialogue__search=None & SearchQuery("kneecaps"))
469
470
471 class TestRankingAndWeights(GrailTestData, PostgreSQLTestCase):
472 def test_ranking(self):
473 searched = (
474 Line.objects.filter(character=self.minstrel)
475 .annotate(
476 rank=SearchRank(
477 SearchVector("dialogue"), SearchQuery("brave sir robin")
478 ),
479 )
480 .order_by("rank")
481 )
482 self.assertSequenceEqual(searched, [self.verse2, self.verse1, self.verse0])
483
484 def test_rank_passing_untyped_args(self):
485 searched = (
486 Line.objects.filter(character=self.minstrel)
487 .annotate(
488 rank=SearchRank("dialogue", "brave sir robin"),
489 )
490 .order_by("rank")
491 )
492 self.assertSequenceEqual(searched, [self.verse2, self.verse1, self.verse0])
493
494 def test_weights_in_vector(self):
495 vector = SearchVector("dialogue", weight="A") + SearchVector(
496 "character__name", weight="D"
497 )
498 searched = (
499 Line.objects.filter(scene=self.witch_scene)
500 .annotate(
501 rank=SearchRank(vector, SearchQuery("witch")),
502 )
503 .order_by("-rank")[:2]
504 )
505 self.assertSequenceEqual(searched, [self.crowd, self.witch])
506
507 vector = SearchVector("dialogue", weight="D") + SearchVector(
508 "character__name", weight="A"
509 )
510 searched = (
511 Line.objects.filter(scene=self.witch_scene)
512 .annotate(
513 rank=SearchRank(vector, SearchQuery("witch")),
514 )
515 .order_by("-rank")[:2]
516 )
517 self.assertSequenceEqual(searched, [self.witch, self.crowd])
518
519 def test_ranked_custom_weights(self):
520 vector = SearchVector("dialogue", weight="D") + SearchVector(
521 "character__name", weight="A"
522 )
523 weights = [1.0, 0.0, 0.0, 0.5]
524 searched = (
525 Line.objects.filter(scene=self.witch_scene)
526 .annotate(
527 rank=SearchRank(vector, SearchQuery("witch"), weights=weights),
528 )
529 .order_by("-rank")[:2]
530 )
531 self.assertSequenceEqual(searched, [self.crowd, self.witch])
532
533 def test_ranking_chaining(self):
534 searched = (
535 Line.objects.filter(character=self.minstrel)
536 .annotate(
537 rank=SearchRank(
538 SearchVector("dialogue"), SearchQuery("brave sir robin")
539 ),
540 )
541 .filter(rank__gt=0.3)
542 )
543 self.assertSequenceEqual(searched, [self.verse0])
544
545 def test_cover_density_ranking(self):
546 not_dense_verse = Line.objects.create(
547 scene=self.robin,
548 character=self.minstrel,
549 dialogue=(
550 "Bravely taking to his feet, he beat a very brave retreat. "
551 "A brave retreat brave Sir Robin."
552 ),
553 )
554 searched = (
555 Line.objects.filter(character=self.minstrel)
556 .annotate(
557 rank=SearchRank(
558 SearchVector("dialogue"),
559 SearchQuery("brave robin"),
560 cover_density=True,
561 ),
562 )
563 .order_by("rank", "-pk")
564 )
565 self.assertSequenceEqual(
566 searched,
567 [self.verse2, not_dense_verse, self.verse1, self.verse0],
568 )
569
570 def test_ranking_with_normalization(self):
571 short_verse = Line.objects.create(
572 scene=self.robin,
573 character=self.minstrel,
574 dialogue="A brave retreat brave Sir Robin.",
575 )
576 searched = (
577 Line.objects.filter(character=self.minstrel)
578 .annotate(
579 rank=SearchRank(
580 SearchVector("dialogue"),
581 SearchQuery("brave sir robin"),
582 # Divide the rank by the document length.
583 normalization=2,
584 ),
585 )
586 .order_by("rank")
587 )
588 self.assertSequenceEqual(
589 searched,
590 [self.verse2, self.verse1, self.verse0, short_verse],
591 )
592
593 def test_ranking_with_masked_normalization(self):
594 short_verse = Line.objects.create(
595 scene=self.robin,
596 character=self.minstrel,
597 dialogue="A brave retreat brave Sir Robin.",
598 )
599 searched = (
600 Line.objects.filter(character=self.minstrel)
601 .annotate(
602 rank=SearchRank(
603 SearchVector("dialogue"),
604 SearchQuery("brave sir robin"),
605 # Divide the rank by the document length and by the number of
606 # unique words in document.
607 normalization=Value(2).bitor(Value(8)),
608 ),
609 )
610 .order_by("rank")
611 )
612 self.assertSequenceEqual(
613 searched,
614 [self.verse2, self.verse1, self.verse0, short_verse],
615 )
616
617
618 class SearchQueryTests(PostgreSQLSimpleTestCase):
619 def test_str(self):
620 tests = (
621 (~SearchQuery("a"), "~SearchQuery(Value('a'))"),
622 (
623 (SearchQuery("a") | SearchQuery("b"))
624 & (SearchQuery("c") | SearchQuery("d")),
625 "((SearchQuery(Value('a')) || SearchQuery(Value('b'))) && "
626 "(SearchQuery(Value('c')) || SearchQuery(Value('d'))))",
627 ),
628 (
629 SearchQuery("a") & (SearchQuery("b") | SearchQuery("c")),
630 "(SearchQuery(Value('a')) && (SearchQuery(Value('b')) || "
631 "SearchQuery(Value('c'))))",
632 ),
633 (
634 (SearchQuery("a") | SearchQuery("b")) & SearchQuery("c"),
635 "((SearchQuery(Value('a')) || SearchQuery(Value('b'))) && "
636 "SearchQuery(Value('c')))",
637 ),
638 (
639 SearchQuery("a")
640 & (SearchQuery("b") & (SearchQuery("c") | SearchQuery("d"))),
641 "(SearchQuery(Value('a')) && (SearchQuery(Value('b')) && "
642 "(SearchQuery(Value('c')) || SearchQuery(Value('d')))))",
643 ),
644 )
645 for query, expected_str in tests:
646 with self.subTest(query=query):
647 self.assertEqual(str(query), expected_str)
648
649
650 class SearchHeadlineTests(GrailTestData, PostgreSQLTestCase):
651 def test_headline(self):
652 self.check_default_text_search_config()
653 searched = Line.objects.annotate(
654 headline=SearchHeadline(
655 F("dialogue"),
656 SearchQuery("brave sir robin"),
657 config=SearchConfig("english"),
658 ),
659 ).get(pk=self.verse0.pk)
660 self.assertEqual(
661 searched.headline,
662 "<b>Robin</b>. He was not at all afraid to be killed in nasty "
663 "ways. <b>Brave</b>, <b>brave</b>, <b>brave</b>, <b>brave</b> "
664 "<b>Sir</b> <b>Robin</b>",
665 )
666
667 def test_headline_untyped_args(self):
668 self.check_default_text_search_config()
669 searched = Line.objects.annotate(
670 headline=SearchHeadline("dialogue", "killed", config="english"),
671 ).get(pk=self.verse0.pk)
672 self.assertEqual(
673 searched.headline,
674 "Robin. He was not at all afraid to be <b>killed</b> in nasty "
675 "ways. Brave, brave, brave, brave Sir Robin",
676 )
677
678 def test_headline_with_config(self):
679 searched = Line.objects.annotate(
680 headline=SearchHeadline(
681 "dialogue",
682 SearchQuery("cadeaux", config="french"),
683 config="french",
684 ),
685 ).get(pk=self.french.pk)
686 self.assertEqual(
687 searched.headline,
688 "Oh. Un beau <b>cadeau</b>. Oui oui.",
689 )
690
691 def test_headline_with_config_from_field(self):
692 searched = Line.objects.annotate(
693 headline=SearchHeadline(
694 "dialogue",
695 SearchQuery("cadeaux", config=F("dialogue_config")),
696 config=F("dialogue_config"),
697 ),
698 ).get(pk=self.french.pk)
699 self.assertEqual(
700 searched.headline,
701 "Oh. Un beau <b>cadeau</b>. Oui oui.",
702 )
703
704 def test_headline_separator_options(self):
705 searched = Line.objects.annotate(
706 headline=SearchHeadline(
707 "dialogue",
708 "brave sir robin",
709 start_sel="<span>",
710 stop_sel="</span>",
711 ),
712 ).get(pk=self.verse0.pk)
713 self.assertEqual(
714 searched.headline,
715 "<span>Robin</span>. He was not at all afraid to be killed in "
716 "nasty ways. <span>Brave</span>, <span>brave</span>, <span>brave"
717 "</span>, <span>brave</span> <span>Sir</span> <span>Robin</span>",
718 )
719
720 def test_headline_highlight_all_option(self):
721 self.check_default_text_search_config()
722 searched = Line.objects.annotate(
723 headline=SearchHeadline(
724 "dialogue",
725 SearchQuery("brave sir robin", config="english"),
726 highlight_all=True,
727 ),
728 ).get(pk=self.verse0.pk)
729 self.assertIn(
730 "<b>Bravely</b> bold <b>Sir</b> <b>Robin</b>, rode forth from "
731 "Camelot. He was not afraid to die, o ",
732 searched.headline,
733 )
734
735 def test_headline_short_word_option(self):
736 self.check_default_text_search_config()
737 searched = Line.objects.annotate(
738 headline=SearchHeadline(
739 "dialogue",
740 SearchQuery("Camelot", config="english"),
741 short_word=5,
742 min_words=8,
743 ),
744 ).get(pk=self.verse0.pk)
745 self.assertEqual(
746 searched.headline,
747 (
748 "<b>Camelot</b>. He was not afraid to die, o Brave Sir Robin. He "
749 "was not at all afraid"
750 ),
751 )
752
753 def test_headline_fragments_words_options(self):
754 self.check_default_text_search_config()
755 searched = Line.objects.annotate(
756 headline=SearchHeadline(
757 "dialogue",
758 SearchQuery("brave sir robin", config="english"),
759 fragment_delimiter="...<br>",
760 max_fragments=4,
761 max_words=3,
762 min_words=1,
763 ),
764 ).get(pk=self.verse0.pk)
765 self.assertEqual(
766 searched.headline,
767 "<b>Sir</b> <b>Robin</b>, rode...<br>"
768 "<b>Brave</b> <b>Sir</b> <b>Robin</b>...<br>"
769 "<b>Brave</b>, <b>brave</b>, <b>brave</b>...<br>"
770 "<b>brave</b> <b>Sir</b> <b>Robin</b>",
771 )