trivial: Increase code coverage (#451)

Author: martin-majlis

tests/wikipedia_page_section_test.py

@@ -0,0 +1,161 @@
+"""Unit tests for Wikipedia page section functionality."""
+
+import unittest
+from unittest.mock import MagicMock
+
+from tests.mock_data import create_mock_wikipedia
+import wikipediaapi
+
+
+class TestWikipediaPageSection(unittest.TestCase):
+    """Test cases for WikipediaPageSection functionality."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.wiki = create_mock_wikipedia()
+        # Set the extract format to WIKI for consistent testing
+        self.wiki.extract_format = wikipediaapi.ExtractFormat.WIKI
+
+    def test_subsection_by_title_found(self):
+        """Test getting a subsection when it exists."""
+        # Create mock subsections
+        subsection1 = MagicMock()
+        subsection1.title = "Subsection 1"
+        subsection1.level = 2
+        subsection1.full_text.return_value = "Subsection 1 content"
+
+        subsection2 = MagicMock()
+        subsection2.title = "Subsection 2"
+        subsection2.level = 2
+        subsection2.full_text.return_value = "Subsection 2 content"
+
+        # Create main section with subsections
+        section = wikipediaapi.WikipediaPageSection(wiki=self.wiki, title="Main Section", level=1)
+        section._section = [subsection1, subsection2]
+
+        # Test getting existing subsection
+        result = section.section_by_title("Subsection 2")
+        self.assertEqual(result, subsection2)
+
+        # Test getting first subsection when multiple exist
+        result = section.section_by_title("Subsection 1")
+        self.assertEqual(result, subsection1)
+
+    def test_subsection_by_title_not_found(self):
+        """Test getting a subsection when it doesn't exist."""
+        section = wikipediaapi.WikipediaPageSection(wiki=self.wiki, title="Main Section", level=1)
+        section._section = []
+
+        result = section.section_by_title("Nonexistent")
+        self.assertIsNone(result)
+
+    def test_subsection_by_title_multiple_returns_last(self):
+        """Test that section_by_title returns the last matching subsection."""
+        subsection1 = MagicMock()
+        subsection1.title = "Same Name"
+        subsection1.level = 2
+        subsection1.full_text.return_value = "First content"
+
+        subsection2 = MagicMock()
+        subsection2.title = "Same Name"
+        subsection2.level = 3
+        subsection2.full_text.return_value = "Second content"
+
+        section = wikipediaapi.WikipediaPageSection(wiki=self.wiki, title="Main Section", level=1)
+        section._section = [subsection1, subsection2]
+
+        result = section.section_by_title("Same Name")
+        self.assertEqual(result, subsection2)  # Should return the last one
+
+    def test_full_text_wiki_format(self):
+        """Test full_text method with WIKI format."""
+        section = wikipediaapi.WikipediaPageSection(
+            wiki=self.wiki, title="Test Section", level=2, text="Section content"
+        )
+
+        result = section.full_text()
+        expected = "Test Section\nSection content\n\n"
+        self.assertEqual(result, expected)
+
+    def test_full_text_html_format(self):
+        """Test full_text method with HTML format."""
+        # Create a wiki with HTML format
+        wiki_html = create_mock_wikipedia()
+        wiki_html.extract_format = wikipediaapi.ExtractFormat.HTML
+
+        section = wikipediaapi.WikipediaPageSection(
+            wiki=wiki_html,
+            title="Test Section",
+            level=1,  # Use level 1 since full_text starts from level 1
+            text="Section content",
+        )
+
+        result = section.full_text()
+        expected = "<h1>Test Section</h1>\nSection content\n\n"
+        self.assertEqual(result, expected)
+
+    def test_full_text_unknown_format_raises_error(self):
+        """Test that full_text raises NotImplementedError for unknown format."""
+        # Create a wiki with unknown format
+        wiki_unknown = create_mock_wikipedia()
+        wiki_unknown.extract_format = "unknown"
+
+        section = wikipediaapi.WikipediaPageSection(
+            wiki=wiki_unknown, title="Test Section", level=1, text="Section content"
+        )
+
+        with self.assertRaises(NotImplementedError) as cm:
+            section.full_text()
+
+        self.assertIn("Unknown ExtractFormat type", str(cm.exception))
+
+    def test_full_text_no_text(self):
+        """Test full_text method when section has no text."""
+        section = wikipediaapi.WikipediaPageSection(
+            wiki=self.wiki, title="Empty Section", level=1, text=""
+        )
+
+        result = section.full_text()
+        expected = "Empty Section\n"
+        self.assertEqual(result, expected)
+
+    def test_full_text_level_1(self):
+        """Test full_text method with level 1 section."""
+        section = wikipediaapi.WikipediaPageSection(
+            wiki=self.wiki, title="Top Level", level=1, text="Top level content"
+        )
+
+        result = section.full_text()
+        expected = "Top Level\nTop level content\n\n"
+        self.assertEqual(result, expected)
+
+    def test_full_text_level_4(self):
+        """Test full_text method with level 4 section."""
+        section = wikipediaapi.WikipediaPageSection(
+            wiki=self.wiki, title="Deep Section", level=4, text="Deep content"
+        )
+
+        result = section.full_text()
+        expected = "Deep Section\nDeep content\n\n"
+        self.assertEqual(result, expected)
+
+    def test_full_text_with_subsections(self):
+        """Test full_text method includes subsections."""
+        # Create mock subsection
+        subsection = MagicMock()
+        subsection.title = "Subsection"
+        subsection.level = 2
+        subsection.full_text.return_value = "Subsection\nSub content\n\n"
+
+        section = wikipediaapi.WikipediaPageSection(
+            wiki=self.wiki, title="Main Section", level=1, text="Main content"
+        )
+        section._section = [subsection]
+
+        result = section.full_text()
+        expected = "Main Section\nMain content\n\nSubsection\nSub content\n\n"
+        self.assertEqual(result, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/wikipedia_page_test.py

@@ -100,3 +100,20 @@ def test_page_with_extra_parameters(self):
         wiki._query = wikipedia_api_request(wiki)
         page = wiki.page("Extra_API_Params")
         self.assertTrue(page.exists())
+
+    def test_sections_by_title_not_found(self):
+        """Test sections_by_title method when section doesn't exist."""
+        wiki = wikipediaapi.Wikipedia(user_agent, "en")
+        wiki._query = wikipedia_api_request(wiki)
+        page = wiki.page("Test_1")
+
+        # Access sections to build the mapping
+        _ = page.sections
+
+        # Test with a section that doesn't exist
+        result = page.sections_by_title("Nonexistent Section")
+        self.assertEqual(result, [])
+
+        # Also test with a section that definitely doesn't exist
+        result2 = page.sections_by_title("Section That Does Not Exist At All")
+        self.assertEqual(result2, [])

tests/wikipedia_test.py

@@ -1,5 +1,7 @@
 import unittest
+from unittest.mock import MagicMock
 
+from tests.mock_data import user_agent
 import wikipediaapi
 
 
@@ -103,3 +105,131 @@ def test_user_agent_in_headers_win(self):
             user_agent,
             "header-user-agent (" + wikipediaapi.USER_AGENT + ")",
         )
+
+    def test_extracts_nonexistent_page(self):
+        """Test extracts method when page doesn't exist (pageid = -1)."""
+        wiki = wikipediaapi.Wikipedia(user_agent, "en")
+
+        page = MagicMock()
+        page.language = "en"
+        page._attributes = {}
+
+        # Mock the API response to return pageid = -1 (nonexistent page)
+        def mock_query(page_obj, params):
+            return {"query": {"pages": {"-1": {}}}}
+
+        wiki._query = mock_query
+
+        result = wiki.extracts(page)
+        self.assertEqual(result, "")
+        # The pageid should be set to -1 in the attributes
+        self.assertIn("pageid", page._attributes)
+        self.assertEqual(page._attributes["pageid"], -1)
+
+    def test_info_nonexistent_page(self):
+        """Test info method when page doesn't exist (pageid = -1)."""
+        wiki = wikipediaapi.Wikipedia(user_agent, "en")
+
+        page = MagicMock()
+        page.language = "en"
+        page._attributes = {}
+
+        # Mock the API response to return pageid = -1 (nonexistent page)
+        def mock_query(page_obj, params):
+            return {"query": {"pages": {"-1": {}}}}
+
+        wiki._query = mock_query
+
+        result = wiki.info(page)
+        self.assertEqual(result, page)
+
+    def test_langlinks_nonexistent_page(self):
+        """Test langlinks method when page doesn't exist (pageid = -1)."""
+        wiki = wikipediaapi.Wikipedia(user_agent, "en")
+
+        page = MagicMock()
+        page.language = "en"
+        page._attributes = {}
+
+        # Mock the API response to return pageid = -1 (nonexistent page)
+        def mock_query(page_obj, params):
+            return {"query": {"pages": {"-1": {}}}}
+
+        wiki._query = mock_query
+
+        result = wiki.langlinks(page)
+        self.assertEqual(result, {})
+        # The pageid should be set to -1 in the attributes
+        self.assertIn("pageid", page._attributes)
+        self.assertEqual(page._attributes["pageid"], -1)
+
+    def test_links_nonexistent_page(self):
+        """Test links method when page doesn't exist (pageid = -1)."""
+        wiki = wikipediaapi.Wikipedia(user_agent, "en")
+
+        page = MagicMock()
+        page.language = "en"
+        page._attributes = {}
+
+        # Mock the API response to return pageid = -1 (nonexistent page)
+        def mock_query(page_obj, params):
+            return {"query": {"pages": {"-1": {}}}}
+
+        wiki._query = mock_query
+
+        result = wiki.links(page)
+        self.assertEqual(result, {})
+        # The pageid should be set to -1 in the attributes
+        self.assertIn("pageid", page._attributes)
+        self.assertEqual(page._attributes["pageid"], -1)
+
+    def test_backlinks_nonexistent_page(self):
+        """Test backlinks method when page doesn't exist (pageid = -1)."""
+        wiki = wikipediaapi.Wikipedia(user_agent, "en")
+
+        page = MagicMock()
+        page.language = "en"
+        page._attributes = {}
+
+        # Mock the API response to return pageid = -1 (nonexistent page)
+        def mock_query(page_obj, params):
+            return {"query": {"pages": {"-1": {}}}}
+
+        wiki._query = mock_query
+
+        result = wiki.backlinks(page)
+        self.assertEqual(result, {})
+
+    def test_categories_nonexistent_page(self):
+        """Test categories method when page doesn't exist (pageid = -1)."""
+        wiki = wikipediaapi.Wikipedia(user_agent, "en")
+
+        page = MagicMock()
+        page.language = "en"
+        page._attributes = {}
+
+        # Mock the API response to return pageid = -1 (nonexistent page)
+        def mock_query(page_obj, params):
+            return {"query": {"pages": {"-1": {}}}}
+
+        wiki._query = mock_query
+
+        result = wiki.categories(page)
+        self.assertEqual(result, {})
+
+    def test_categorymembers_nonexistent_page(self):
+        """Test categorymembers method when page doesn't exist (pageid = -1)."""
+        wiki = wikipediaapi.Wikipedia(user_agent, "en")
+
+        page = MagicMock()
+        page.language = "en"
+        page._attributes = {}
+
+        # Mock the API response to return pageid = -1 (nonexistent page)
+        def mock_query(page_obj, params):
+            return {"query": {"pages": {"-1": {}}}}
+
+        wiki._query = mock_query
+
+        result = wiki.categorymembers(page)
+        self.assertEqual(result, {})