| 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 |
) |