def test_index_returns_result(self, mock_index):
"""Test returns 'OK' + status 200 when index returns results."""
mock_index.search.return_value = DocumentSet({}, [Document()])
response, status_code, _ = health_check()
self.assertEqual(response, 'OK', "Response content should be OK")
self.assertEqual(status_code, status.HTTP_200_OK,
"Should return 200 status code.")
def test_index_returns_no_result(self, mock_index):
"""Test returns 'DOWN' + status 500 when index returns no results."""
mock_index.search.return_value = DocumentSet({}, [])
response, status_code, _ = health_check()
self.assertEqual(response, 'DOWN', "Response content should be DOWN")
self.assertEqual(status_code, status.HTTP_500_INTERNAL_SERVER_ERROR,
"Should return 500 status code.")
def test_single_field_term(self, mock_index):
"""Form data are present."""
mock_index.search.return_value = DocumentSet(metadata={}, results=[])
request_data = MultiDict({'searchtype': 'title', 'query': 'foo title'})
response_data, code, headers = simple.search(request_data)
self.assertEqual(mock_index.search.call_count, 1,
"A search should be attempted")
call_args, call_kwargs = mock_index.search.call_args
self.assertIsInstance(call_args[0], SimpleQuery,
"An SimpleQuery is passed to the search index")
self.assertEqual(code, status.HTTP_200_OK, "Response should be OK.")
def test_title_search_contains_classic_syntax(self, mock_index):
"""User has entered a `surname_f` query in a title search."""
request_data = MultiDict({
'searchtype': 'title',
'query': 'franklin_r',
'size': 50,
'order': ''
})
mock_index.search.return_value = DocumentSet(metadata={}, results=[])
data, code, headers = simple.search(request_data)
self.assertEqual(data['query'].value, "franklin_r",
"The query should not be rewritten.")
self.assertFalse(data['has_classic_format'],
"Flag should not be set, as no rewrite has occurred.")
def to_documentset(query: Query, response: Response, highlight: bool = True) \
-> DocumentSet:
"""
Transform a response from ES to a :class:`.DocumentSet`.
Parameters
----------
query : :class:`.Query`
The original search query.
response : :class:`.Response`
The response from Elasticsearch.
Returns
-------
:class:`.DocumentSet`
The set of :class:`.Document`s responding to the query on the current
page, along with pagination metadata.
"""
max_pages = int(MAX_RESULTS / query.size)
N_pages_raw = response['hits']['total'] / query.size
N_pages = int(floor(N_pages_raw)) + \
int(N_pages_raw % query.size > 0)
logger.debug('got %i results', response['hits']['total'])
return DocumentSet(
**{ # type: ignore
'metadata': {
'start':
query.page_start,
'end':
min(query.page_start + query.size, response['hits']['total']),
'total':
response['hits']['total'],
'current_page':
query.page,
'total_pages':
N_pages,
'size':
query.size,
'max_pages':
max_pages
},
'results':
[to_document(raw, highlight=highlight) for raw in response]
})
def test_all_fields_search_multiple_classic_syntax(self, mock_index):
"""User has entered a classic query with multiple authors."""
request_data = MultiDict({
'searchtype': 'all',
'query': 'j franklin_r hawking_s',
'size': 50,
'order': ''
})
mock_index.search.return_value = DocumentSet(metadata={}, results=[])
data, code, headers = simple.search(request_data)
self.assertEqual(data['query'].value, "j franklin, r; hawking, s",
"The query should be rewritten.")
self.assertTrue(data['has_classic_format'],
"A flag denoting the syntax interception should be set"
" in the response context, so that a message may be"
" rendered in the template.")
def test_author_search_contains_classic_syntax(self, mock_index):
"""User has entered a `surname_f` query in an author search."""
request_data = MultiDict({
'searchtype': 'author',
'query': 'franklin_r',
'size': 50,
'order': ''
})
mock_index.search.return_value = DocumentSet(metadata={}, results=[])
data, code, headers = simple.search(request_data)
self.assertEqual(data['query'].value, "franklin, r",
"The query should be rewritten.")
self.assertTrue(data['has_classic_format'],
"A flag denoting the syntax interception should be set"
" in the response context, so that a message may be"
" rendered in the template.")
def test_single_field_term(self, mock_index):
"""Form data and ``advanced`` param are present."""
mock_index.search.return_value = DocumentSet(metadata={}, results=[])
request_data = MultiDict({
'advanced': True,
'terms-0-operator': 'AND',
'terms-0-field': 'title',
'terms-0-term': 'foo'
})
response_data, code, headers = advanced.search(request_data)
self.assertEqual(mock_index.search.call_count, 1,
"A search should be attempted")
call_args, call_kwargs = mock_index.search.call_args
self.assertIsInstance(call_args[0], AdvancedQuery,
"An AdvancedQuery is passed to the search index")
self.assertEqual(code, status.HTTP_200_OK, "Response should be OK.")
def test_all_fields_search_contains_classic_syntax(self, mock_index):
"""User has entered a `surname_f` query in an all-fields term."""
request_data = MultiDict({
'advanced': True,
'terms-0-operator': 'AND',
'terms-0-field': 'all',
'terms-0-term': 'franklin_r',
'size': 50,
'order': ''
})
mock_index.search.return_value = DocumentSet(metadata={}, results=[])
data, code, headers = advanced.search(request_data)
self.assertEqual(data['query'].terms[0].term, "franklin, r",
"The query should be rewritten.")
self.assertTrue(data['has_classic_format'],
"A flag denoting the syntax interception should be set"
" in the response context, so that a message may be"
" rendered in the template.")
