def test_eq(self):
s = SearchQuery('test', [EngineRef('bing', 'general', False)],
['general'], 'all', 0, 1, None, None, None)
t = SearchQuery('test', [EngineRef('google', 'general', False)],
['general'], 'all', 0, 1, None, None, None)
self.assertEqual(s, s)
self.assertNotEqual(s, t)
def get_engineref_from_category_list(category_list: List[str], disabled_engines: List[str]) -> List[EngineRef]:
result = []
for categ in category_list:
result.extend(EngineRef(engine.name, categ)
for engine in categories[categ]
if (engine.name, categ) not in disabled_engines)
return result
def parse_generic(preferences: Preferences, form: Dict[str, str], disabled_engines: List[str]) -> List[EngineRef]:
query_engineref_list = []
query_categories = []
# set categories/engines
explicit_engine_list = False
if not is_locked('categories'):
# parse the form only if the categories are not locked
for pd_name, pd in form.items():
if pd_name == 'engines':
pd_engines = [EngineRef(engine_name, engines[engine_name].categories[0])
for engine_name in map(str.strip, pd.split(',')) if engine_name in engines]
if pd_engines:
query_engineref_list.extend(pd_engines)
explicit_engine_list = True
else:
parse_category_form(query_categories, pd_name, pd)
if explicit_engine_list:
# explicit list of engines with the "engines" parameter in the form
if query_categories:
# add engines from referenced by the "categories" parameter and the "category_*"" parameters
query_engineref_list.extend(get_engineref_from_category_list(query_categories, disabled_engines))
else:
# no "engines" parameters in the form
if not query_categories:
# and neither "categories" parameter nor "category_*"" parameters in the form
# -> get the categories from the preferences (the cookies or the settings)
query_categories = get_selected_categories(preferences, None)
# using all engines for that search, which are
# declared under the specific categories
query_engineref_list.extend(get_engineref_from_category_list(query_categories, disabled_engines))
return query_engineref_list
def test_timeout_query_above_max(self):
settings['outgoing']['max_request_timeout'] = 10.0
search_query = SearchQuery('test', [EngineRef(PUBLIC_ENGINE_NAME, 'general')],
'en-US', SAFESEARCH, PAGENO, None, 15.0)
search = searx.search.Search(search_query)
search.search()
self.assertEqual(search.actual_timeout, 10.0)
def test_repr(self):
s = SearchQuery('test', [EngineRef('bing', 'general', False)],
['general'], 'all', 0, 1, '1', 5.0, 'g')
self.assertEqual(repr(
s
), "SearchQuery('test', [EngineRef('bing', 'general', False)], ['general'], 'all', 0, 1, '1', 5.0, 'g')"
) # noqa
def test_get_search_query(self):
"""test get_search_query."""
args = sas.parse_argument(['rain', ])
search_q = sas.get_search_query(args)
self.assertTrue(search_q)
self.assertEqual(search_q, SearchQuery('rain', [EngineRef('engine1', 'general')],
'all', 0, 1, None, None, None))
def test_timeout_query_below_max(self):
searx.search.max_request_timeout = 10.0
search_query = SearchQuery('test',
[EngineRef(PUBLIC_ENGINE_NAME, 'general')],
'en-US', SAFESEARCH, PAGENO, None, 5.0)
search = searx.search.Search(search_query)
search.search()
self.assertEqual(search.actual_timeout, 5.0)
def test_timeout_simple(self):
searx.search.max_request_timeout = None
search_query = SearchQuery('test',
[EngineRef(PUBLIC_ENGINE_NAME, 'general')],
['general'], 'en-US', SAFESEARCH, PAGENO,
None, None)
search = searx.search.Search(search_query)
search.search()
self.assertEqual(search.actual_timeout, 3.0)
def test_external_bang(self):
search_query = SearchQuery('yes yes',
[EngineRef(PUBLIC_ENGINE_NAME, 'general')],
'en-US', SAFESEARCH, PAGENO, None, None,
external_bang="yt")
search = searx.search.Search(search_query)
results = search.search()
# For checking if the user redirected with the youtube external bang
self.assertTrue(results.redirect_url is not None)
search_query = SearchQuery('youtube never gonna give you up',
[EngineRef(PUBLIC_ENGINE_NAME, 'general')],
'en-US', SAFESEARCH, PAGENO, None, None)
search = searx.search.Search(search_query)
results = search.search()
# This should not redirect
self.assertTrue(results.redirect_url is None)
def _parse(self, value):
# check if prefix is equal with engine shortcut
if value in engine_shortcuts:
value = engine_shortcuts[value]
# check if prefix is equal with engine name
if value in engines:
self.raw_text_query.enginerefs.append(EngineRef(value, 'none'))
return True
# check if prefix is equal with categorie name
if value in categories:
# using all engines for that search, which
# are declared under that categorie name
self.raw_text_query.enginerefs.extend(EngineRef(engine.name, value)
for engine in categories[value]
if (engine.name, value) not in self.raw_text_query.disabled_engines)
return True
return False
def test_get_search_query(self):
"""test get_search_query."""
sas = get_standalone_searx_module()
args = sas.parse_argument([
'rain',
])
search_q = sas.get_search_query(args)
self.assertTrue(search_q)
self.assertEqual(
search_q,
SearchQuery('rain', [EngineRef('engine1', 'general', False)],
['general'], 'all', 0, 1, None, None, None))
def parse_generic(preferences: Preferences, form: Dict[str, str], disabled_engines: List[str])\
-> Tuple[List[EngineRef], List[str]]:
query_engineref_list = []
query_categories = []
# set categories/engines
load_default_categories = True
for pd_name, pd in form.items():
if pd_name == 'engines':
pd_engines = [
EngineRef(engine_name, engines[engine_name].categories[0])
for engine_name in map(str.strip, pd.split(','))
if engine_name in engines
]
if pd_engines:
query_engineref_list.extend(pd_engines)
load_default_categories = False
else:
parse_category_form(query_categories, pd_name, pd)
if not load_default_categories:
if not query_categories:
query_categories = list(
set(engine['category'] for engine in query_engineref_list))
else:
if not query_categories:
query_categories = get_selected_categories(preferences, None)
# using all engines for that search, which are
# declared under the specific categories
for categ in query_categories:
query_engineref_list.extend(
EngineRef(engine.name, categ) for engine in categories[categ]
if (engine.name, categ) not in disabled_engines)
return query_engineref_list, query_categories
def _parse_query(self):
self.query_parts = []
# split query, including whitespaces
raw_query_parts = re.split(r'(\s+)', self.query)
parse_next = True
for query_part in raw_query_parts:
if not parse_next:
self.query_parts[-1] += query_part
continue
parse_next = False
# part does only contain spaces, skip
if query_part.isspace()\
or query_part == '':
parse_next = True
self.query_parts.append(query_part)
continue
# this force the timeout
if query_part[0] == '<':
try:
raw_timeout_limit = int(query_part[1:])
if raw_timeout_limit < 100:
# below 100, the unit is the second ( <3 = 3 seconds timeout )
self.timeout_limit = float(raw_timeout_limit)
else:
# 100 or above, the unit is the millisecond ( <850 = 850 milliseconds timeout )
self.timeout_limit = raw_timeout_limit / 1000.0
parse_next = True
except ValueError:
# error not reported to the user
pass
# this force a language
if query_part[0] == ':':
lang = query_part[1:].lower().replace('_', '-')
# check if any language-code is equal with
# declared language-codes
for lc in language_codes:
lang_id, lang_name, country, english_name = map(
str.lower, lc)
# if correct language-code is found
# set it as new search-language
if (lang == lang_id
or lang == lang_name
or lang == english_name
or lang.replace('-', ' ') == country)\
and lang not in self.languages:
parse_next = True
lang_parts = lang_id.split('-')
if len(lang_parts) == 2:
self.languages.append(lang_parts[0] + '-' +
lang_parts[1].upper())
else:
self.languages.append(lang_id)
# to ensure best match (first match is not necessarily the best one)
if lang == lang_id:
break
# user may set a valid, yet not selectable language
if VALID_LANGUAGE_CODE.match(lang):
lang_parts = lang.split('-')
if len(lang_parts) > 1:
lang = lang_parts[0].lower(
) + '-' + lang_parts[1].upper()
if lang not in self.languages:
self.languages.append(lang)
parse_next = True
# external bang
if query_part[0:2] == "!!":
self.external_bang = query_part[2:]
parse_next = True
continue
# this force a engine or category
if query_part[0] == '!' or query_part[0] == '?':
prefix = query_part[1:].replace('-', ' ').replace('_', ' ')
# check if prefix is equal with engine shortcut
if prefix in engine_shortcuts:
parse_next = True
engine_name = engine_shortcuts[prefix]
if engine_name in engines:
self.enginerefs.append(
EngineRef(engine_name, 'none', True))
# check if prefix is equal with engine name
elif prefix in engines:
parse_next = True
self.enginerefs.append(EngineRef(prefix, 'none', True))
# check if prefix is equal with categorie name
elif prefix in categories:
# using all engines for that search, which
# are declared under that categorie name
parse_next = True
self.enginerefs.extend(
EngineRef(engine.name, prefix)
for engine in categories[prefix]
if (engine.name, prefix) not in self.disabled_engines)
if query_part[0] == '!':
self.specific = True
# append query part to query_part list
self.query_parts.append(query_part)
from searx.search import EngineRef
from searx.webadapter import validate_engineref_list
PRIVATE_ENGINE_NAME = 'general private offline'
TEST_ENGINES = [
{
'name': PRIVATE_ENGINE_NAME,
'engine': 'dummy-offline',
'categories': 'general',
'shortcut': 'do',
'timeout': 3.0,
'engine_type': 'offline',
'tokens': ['my-token'],
},
]
SEARCHQUERY = [EngineRef(PRIVATE_ENGINE_NAME, 'general')]
class ValidateQueryCase(SearxTestCase):
@classmethod
def setUpClass(cls):
searx.search.initialize(TEST_ENGINES)
def test_query_private_engine_without_token(self):
preferences = Preferences(['oscar'], ['general'], engines, [])
valid, unknown, invalid_token = validate_engineref_list(
SEARCHQUERY, preferences)
self.assertEqual(len(valid), 0)
self.assertEqual(len(unknown), 0)
self.assertEqual(len(invalid_token), 1)
def test_no_external_bang_query(self):
result = get_bang_url(
SearchQuery('test',
engineref_list=[EngineRef('wikipedia', 'general')]))
self.assertEqual(result, None)