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
  7. class TestDDGDefinitionsEngine(SearxTestCase):
  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)
  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')
  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'])
  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, '[]')
  40.         response = mock.Mock(text='{}')
  41.         self.assertEqual(duckduckgo_definitions.response(response), [])
  43.         response = mock.Mock(text='{"data": []}')
  44.         self.assertEqual(duckduckgo_definitions.response(response), [])
  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'])
  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'], '')
  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'])