logo

searx

My custom branche(s) on searx, a meta-search engine git clone https://hacktivis.me/git/searx.git

test_duckduckgo_definitions.py (9068B)

    

  1. from collections import defaultdict

  2. import mock

  3. from searx.engines import duckduckgo_definitions

  4. from searx.testing import SearxTestCase

  5. 

  6. 

  7. class TestDDGDefinitionsEngine(SearxTestCase):

  8. 

  9.     def test_result_to_text(self):

  10.         url = ''

  11.         text = 'Text'

  12.         html_result = 'Html'

  13.         result = duckduckgo_definitions.result_to_text(url, text, html_result)

  14.         self.assertEqual(result, text)

  15. 

  16.         html_result = '<a href="url">Text in link</a>'

  17.         result = duckduckgo_definitions.result_to_text(url, text, html_result)

  18.         self.assertEqual(result, 'Text in link')

  19. 

  20.     def test_request(self):

  21.         duckduckgo_definitions.supported_languages = ['en-US', 'es-ES']

  22.         query = 'test_query'

  23.         dicto = defaultdict(dict)

  24.         dicto['pageno'] = 1

  25.         dicto['language'] = 'es'

  26.         params = duckduckgo_definitions.request(query, dicto)

  27.         self.assertIn('url', params)

  28.         self.assertIn(query, params['url'])

  29.         self.assertIn('duckduckgo.com', params['url'])

  30.         self.assertIn('headers', params)

  31.         self.assertIn('Accept-Language', params['headers'])

  32.         self.assertIn('es', params['headers']['Accept-Language'])

  33. 

  34.     def test_response(self):

  35.         self.assertRaises(AttributeError, duckduckgo_definitions.response, None)

  36.         self.assertRaises(AttributeError, duckduckgo_definitions.response, [])

  37.         self.assertRaises(AttributeError, duckduckgo_definitions.response, '')

  38.         self.assertRaises(AttributeError, duckduckgo_definitions.response, '[]')

  39. 

  40.         response = mock.Mock(text='{}')

  41.         self.assertEqual(duckduckgo_definitions.response(response), [])

  42. 

  43.         response = mock.Mock(text='{"data": []}')

  44.         self.assertEqual(duckduckgo_definitions.response(response), [])

  45. 

  46.         json = """

  47.         {

  48.           "DefinitionSource": "definition source",

  49.           "Heading": "heading",

  50.           "ImageWidth": 0,

  51.           "RelatedTopics": [

  52.             {

  53.               "Result": "Top-level domains",

  54.               "Icon": {

  55.                 "URL": "",

  56.                 "Height": "",

  57.                 "Width": ""

  58.               },

  59.               "FirstURL": "https://first.url",

  60.               "Text": "text"

  61.             },

  62.             {

  63.               "Topics": [

  64.                 {

  65.                   "Result": "result topic",

  66.                   "Icon": {

  67.                     "URL": "",

  68.                     "Height": "",

  69.                     "Width": ""

  70.                   },

  71.                   "FirstURL": "https://duckduckgo.com/?q=2%2F2",

  72.                   "Text": "result topic text"

  73.                 }

  74.               ],

  75.               "Name": "name"

  76.             }

  77.           ],

  78.           "Entity": "Entity",

  79.           "Type": "A",

  80.           "Redirect": "",

  81.           "DefinitionURL": "http://definition.url",

  82.           "AbstractURL": "https://abstract.url",

  83.           "Definition": "this is the definition",

  84.           "AbstractSource": "abstract source",

  85.           "Infobox": {

  86.             "content": [

  87.               {

  88.                 "data_type": "string",

  89.                 "value": "1999",

  90.                 "label": "Introduced",

  91.                 "wiki_order": 0

  92.               }

  93.             ],

  94.             "meta": [

  95.               {

  96.                 "data_type": "string",

  97.                 "value": ".test",

  98.                 "label": "article_title"

  99.               }

  100.             ]

  101.           },

  102.           "Image": "image.png",

  103.           "ImageIsLogo": 0,

  104.           "Abstract": "abstract",

  105.           "AbstractText": "abstract text",

  106.           "AnswerType": "",

  107.           "ImageHeight": 0,

  108.           "Results": [{

  109.                  "Result" : "result title",

  110.                  "Icon" : {

  111.                     "URL" : "result url",

  112.                     "Height" : 16,

  113.                     "Width" : 16

  114.                  },

  115.                  "FirstURL" : "result first url",

  116.                  "Text" : "result text"

  117.               }

  118.           ],

  119.           "Answer": "answer"

  120.         }

  121.         """

  122.         response = mock.Mock(text=json)

  123.         results = duckduckgo_definitions.response(response)

  124.         self.assertEqual(type(results), list)

  125.         self.assertEqual(len(results), 4)

  126.         self.assertEqual(results[0]['answer'], 'answer')

  127.         self.assertEqual(results[1]['title'], 'heading')

  128.         self.assertEqual(results[1]['url'], 'result first url')

  129.         self.assertEqual(results[2]['suggestion'], 'text')

  130.         self.assertEqual(results[3]['infobox'], 'heading')

  131.         self.assertEqual(results[3]['id'], 'https://definition.url')

  132.         self.assertEqual(results[3]['entity'], 'Entity')

  133.         self.assertIn('abstract', results[3]['content'])

  134.         self.assertIn('this is the definition', results[3]['content'])

  135.         self.assertEqual(results[3]['img_src'], 'image.png')

  136.         self.assertIn('Introduced', results[3]['attributes'][0]['label'])

  137.         self.assertIn('1999', results[3]['attributes'][0]['value'])

  138.         self.assertIn({'url': 'https://abstract.url', 'title': 'abstract source'}, results[3]['urls'])

  139.         self.assertIn({'url': 'http://definition.url', 'title': 'definition source'}, results[3]['urls'])

  140.         self.assertIn({'name': 'name', 'suggestions': ['result topic text']}, results[3]['relatedTopics'])

  141. 

  142.         json = """

  143.         {

  144.           "DefinitionSource": "definition source",

  145.           "Heading": "heading",

  146.           "ImageWidth": 0,

  147.           "RelatedTopics": [],

  148.           "Entity": "Entity",

  149.           "Type": "A",

  150.           "Redirect": "",

  151.           "DefinitionURL": "",

  152.           "AbstractURL": "https://abstract.url",

  153.           "Definition": "",

  154.           "AbstractSource": "abstract source",

  155.           "Image": "",

  156.           "ImageIsLogo": 0,

  157.           "Abstract": "",

  158.           "AbstractText": "abstract text",

  159.           "AnswerType": "",

  160.           "ImageHeight": 0,

  161.           "Results": [],

  162.           "Answer": ""

  163.         }

  164.         """

  165.         response = mock.Mock(text=json)

  166.         results = duckduckgo_definitions.response(response)

  167.         self.assertEqual(type(results), list)

  168.         self.assertEqual(len(results), 1)

  169.         self.assertEqual(results[0]['url'], 'https://abstract.url')

  170.         self.assertEqual(results[0]['title'], 'heading')

  171.         self.assertEqual(results[0]['content'], '')

  172. 

  173.         json = """

  174.         {

  175.           "DefinitionSource": "definition source",

  176.           "Heading": "heading",

  177.           "ImageWidth": 0,

  178.           "RelatedTopics": [

  179.             {

  180.               "Result": "Top-level domains",

  181.               "Icon": {

  182.                 "URL": "",

  183.                 "Height": "",

  184.                 "Width": ""

  185.               },

  186.               "FirstURL": "https://first.url",

  187.               "Text": "heading"

  188.             },

  189.             {

  190.               "Name": "name"

  191.             },

  192.             {

  193.               "Topics": [

  194.                 {

  195.                   "Result": "result topic",

  196.                   "Icon": {

  197.                     "URL": "",

  198.                     "Height": "",

  199.                     "Width": ""

  200.                   },

  201.                   "FirstURL": "https://duckduckgo.com/?q=2%2F2",

  202.                   "Text": "heading"

  203.                 }

  204.               ],

  205.               "Name": "name"

  206.             }

  207.           ],

  208.           "Entity": "Entity",

  209.           "Type": "A",

  210.           "Redirect": "",

  211.           "DefinitionURL": "http://definition.url",

  212.           "AbstractURL": "https://abstract.url",

  213.           "Definition": "this is the definition",

  214.           "AbstractSource": "abstract source",

  215.           "Infobox": {

  216.             "meta": [

  217.               {

  218.                 "data_type": "string",

  219.                 "value": ".test",

  220.                 "label": "article_title"

  221.               }

  222.             ]

  223.           },

  224.           "Image": "image.png",

  225.           "ImageIsLogo": 0,

  226.           "Abstract": "abstract",

  227.           "AbstractText": "abstract text",

  228.           "AnswerType": "",

  229.           "ImageHeight": 0,

  230.           "Results": [{

  231.                  "Result" : "result title",

  232.                  "Icon" : {

  233.                     "URL" : "result url",

  234.                     "Height" : 16,

  235.                     "Width" : 16

  236.                  },

  237.                  "Text" : "result text"

  238.               }

  239.           ],

  240.           "Answer": ""

  241.         }

  242.         """

  243.         response = mock.Mock(text=json)

  244.         results = duckduckgo_definitions.response(response)

  245.         self.assertEqual(type(results), list)

  246.         self.assertEqual(len(results), 1)

  247.         self.assertEqual(results[0]['infobox'], 'heading')

  248.         self.assertEqual(results[0]['id'], 'https://definition.url')

  249.         self.assertEqual(results[0]['entity'], 'Entity')

  250.         self.assertIn('abstract', results[0]['content'])

  251.         self.assertIn('this is the definition', results[0]['content'])

  252.         self.assertEqual(results[0]['img_src'], 'image.png')

  253.         self.assertIn({'url': 'https://abstract.url', 'title': 'abstract source'}, results[0]['urls'])

  254.         self.assertIn({'url': 'http://definition.url', 'title': 'definition source'}, results[0]['urls'])

  255.         self.assertIn({'name': 'name', 'suggestions': []}, results[0]['relatedTopics'])