✅ increase test coverage

Author: techouse

tests/unit/debug_info_test.py

@@ -0,0 +1,119 @@
+import platform
+import sqlite3
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from sqlite3_to_mysql.debug_info import _implementation, _mysql_version, info
+
+
+class TestDebugInfo:
+    def test_implementation_cpython(self) -> None:
+        """Test _implementation function with CPython."""
+        with patch("platform.python_implementation", return_value="CPython"):
+            with patch("platform.python_version", return_value="3.8.0"):
+                assert _implementation() == "CPython 3.8.0"
+
+    def test_implementation_pypy(self) -> None:
+        """Test _implementation function with PyPy."""
+        with patch("platform.python_implementation", return_value="PyPy"):
+            # Mock sys.pypy_version_info
+            mock_version_info = MagicMock()
+            mock_version_info.major = 7
+            mock_version_info.minor = 3
+            mock_version_info.micro = 1
+            mock_version_info.releaselevel = "final"
+
+            with patch.object(sys, "pypy_version_info", mock_version_info, create=True):
+                assert _implementation() == "PyPy 7.3.1"
+
+    def test_implementation_pypy_non_final(self) -> None:
+        """Test _implementation function with PyPy non-final release."""
+        with patch("platform.python_implementation", return_value="PyPy"):
+            # Mock sys.pypy_version_info
+            mock_version_info = MagicMock()
+            mock_version_info.major = 7
+            mock_version_info.minor = 3
+            mock_version_info.micro = 1
+            mock_version_info.releaselevel = "beta"
+
+            with patch.object(sys, "pypy_version_info", mock_version_info, create=True):
+                assert _implementation() == "PyPy 7.3.1beta"
+
+    def test_implementation_jython(self) -> None:
+        """Test _implementation function with Jython."""
+        with patch("platform.python_implementation", return_value="Jython"):
+            with patch("platform.python_version", return_value="2.7.2"):
+                assert _implementation() == "Jython 2.7.2"
+
+    def test_implementation_ironpython(self) -> None:
+        """Test _implementation function with IronPython."""
+        with patch("platform.python_implementation", return_value="IronPython"):
+            with patch("platform.python_version", return_value="2.7.9"):
+                assert _implementation() == "IronPython 2.7.9"
+
+    def test_implementation_unknown(self) -> None:
+        """Test _implementation function with unknown implementation."""
+        with patch("platform.python_implementation", return_value="Unknown"):
+            assert _implementation() == "Unknown Unknown"
+
+    def test_mysql_version_found(self) -> None:
+        """Test _mysql_version function when MySQL is found."""
+        with patch("sqlite3_to_mysql.debug_info.which", return_value="/usr/bin/mysql"):
+            with patch("sqlite3_to_mysql.debug_info.check_output", return_value=b"mysql  Ver 8.0.23"):
+                assert _mysql_version() == "mysql  Ver 8.0.23"
+
+    def test_mysql_version_decode_error(self) -> None:
+        """Test _mysql_version function with decode error."""
+        with patch("sqlite3_to_mysql.debug_info.which", return_value="/usr/bin/mysql"):
+            with patch("sqlite3_to_mysql.debug_info.check_output", return_value=b"\xff\xfe"):
+                # This should trigger a UnicodeDecodeError
+                result = _mysql_version()
+                assert "b'" in result  # Should contain the string representation of bytes
+
+    def test_mysql_version_exception(self) -> None:
+        """Test _mysql_version function with exception."""
+        with patch("sqlite3_to_mysql.debug_info.which", return_value="/usr/bin/mysql"):
+            with patch("sqlite3_to_mysql.debug_info.check_output", side_effect=Exception("Command failed")):
+                assert _mysql_version() == "MySQL client not found on the system"
+
+    def test_mysql_version_not_found(self) -> None:
+        """Test _mysql_version function when MySQL is not found."""
+        with patch("sqlite3_to_mysql.debug_info.which", return_value=None):
+            assert _mysql_version() == "MySQL client not found on the system"
+
+    def test_info(self) -> None:
+        """Test info function."""
+        with patch("platform.system", return_value="Linux"):
+            with patch("platform.release", return_value="5.4.0"):
+                with patch("sqlite3_to_mysql.debug_info._implementation", return_value="CPython 3.8.0"):
+                    with patch("sqlite3_to_mysql.debug_info._mysql_version", return_value="mysql  Ver 8.0.23"):
+                        with patch.object(sqlite3, "sqlite_version", "3.32.3"):
+                            result = info()
+                            assert result[0][0] == "sqlite3-to-mysql"
+                            assert result[2][0] == "Operating System"
+                            assert result[2][1] == "Linux 5.4.0"
+                            assert result[3][0] == "Python"
+                            assert result[3][1] == "CPython 3.8.0"
+                            assert result[4][0] == "MySQL"
+                            assert result[4][1] == "mysql  Ver 8.0.23"
+                            assert result[5][0] == "SQLite"
+                            assert result[5][1] == "3.32.3"
+
+    def test_info_platform_error(self) -> None:
+        """Test info function with platform error."""
+        with patch("platform.system", side_effect=IOError("Platform error")):
+            with patch("sqlite3_to_mysql.debug_info._implementation", return_value="CPython 3.8.0"):
+                with patch("sqlite3_to_mysql.debug_info._mysql_version", return_value="mysql  Ver 8.0.23"):
+                    with patch.object(sqlite3, "sqlite_version", "3.32.3"):
+                        result = info()
+                        assert result[0][0] == "sqlite3-to-mysql"
+                        assert result[2][0] == "Operating System"
+                        assert result[2][1] == "Unknown"
+                        assert result[3][0] == "Python"
+                        assert result[3][1] == "CPython 3.8.0"
+                        assert result[4][0] == "MySQL"
+                        assert result[4][1] == "mysql  Ver 8.0.23"
+                        assert result[5][0] == "SQLite"
+                        assert result[5][1] == "3.32.3"

tests/unit/mysql_utils_test.py

@@ -1,11 +1,15 @@
+from unittest.mock import MagicMock, patch
+
 import pytest
 from packaging.version import Version
 
 from sqlite3_to_mysql.mysql_utils import (
+    CharSet,
     check_mysql_fulltext_support,
     check_mysql_json_support,
     check_mysql_values_alias_support,
     get_mysql_version,
+    mysql_supported_character_sets,
     safe_identifier_length,
 )
 
@@ -85,3 +89,68 @@ def test_check_mysql_fulltext_support(self, version_string: str, expected: bool)
     )
     def test_safe_identifier_length(self, identifier: str, expected: str) -> None:
         assert safe_identifier_length(identifier) == expected
+
+    def test_mysql_supported_character_sets_with_charset(self) -> None:
+        """Test mysql_supported_character_sets function with a specific charset."""
+        # Mock the MYSQL_CHARACTER_SETS list
+        mock_character_sets = [
+            None,  # Index 0
+            ("utf8", "utf8_general_ci", True),  # Index 1
+            ("latin1", "latin1_swedish_ci", True),  # Index 2
+        ]
+
+        with patch("sqlite3_to_mysql.mysql_utils.MYSQL_CHARACTER_SETS", mock_character_sets):
+            # Test with a charset that exists
+            result = list(mysql_supported_character_sets(charset="utf8"))
+            assert len(result) == 1
+            assert result[0] == CharSet(1, "utf8", "utf8_general_ci")
+
+            # Test with a charset that doesn't exist
+            result = list(mysql_supported_character_sets(charset="unknown"))
+            assert len(result) == 0
+
+    def test_mysql_supported_character_sets_without_charset(self) -> None:
+        """Test mysql_supported_character_sets function without a specific charset."""
+        # Mock the MYSQL_CHARACTER_SETS list
+        mock_character_sets = [
+            None,  # Index 0
+            ("utf8", "utf8_general_ci", True),  # Index 1
+            ("latin1", "latin1_swedish_ci", True),  # Index 2
+        ]
+
+        # Mock the CharacterSet().get_supported() method
+        mock_get_supported = MagicMock(return_value=["utf8", "latin1"])
+
+        with patch("sqlite3_to_mysql.mysql_utils.MYSQL_CHARACTER_SETS", mock_character_sets):
+            with patch("mysql.connector.CharacterSet.get_supported", mock_get_supported):
+                result = list(mysql_supported_character_sets())
+                # The function yields a CharSet for each combination of charset and index
+                assert len(result) == 4
+                assert CharSet(1, "utf8", "utf8_general_ci") in result
+                assert CharSet(2, "utf8", "latin1_swedish_ci") in result
+                assert CharSet(1, "latin1", "utf8_general_ci") in result
+                assert CharSet(2, "latin1", "latin1_swedish_ci") in result
+
+    def test_mysql_supported_character_sets_with_keyerror(self) -> None:
+        """Test mysql_supported_character_sets function with KeyError."""
+        # Mock the MYSQL_CHARACTER_SETS list with an entry that will cause a KeyError
+        mock_character_sets = [
+            None,  # Index 0
+            ("utf8", "utf8_general_ci", True),  # Index 1
+            None,  # Index 2 - This will cause a KeyError when accessed
+        ]
+
+        with patch("sqlite3_to_mysql.mysql_utils.MYSQL_CHARACTER_SETS", mock_character_sets):
+            # Test with a charset that exists but will cause a KeyError
+            result = list(mysql_supported_character_sets(charset="utf8"))
+            assert len(result) == 1
+            assert result[0] == CharSet(1, "utf8", "utf8_general_ci")
+
+        # Mock for testing without charset
+        mock_get_supported = MagicMock(return_value=["utf8"])
+
+        with patch("sqlite3_to_mysql.mysql_utils.MYSQL_CHARACTER_SETS", mock_character_sets):
+            with patch("mysql.connector.CharacterSet.get_supported", mock_get_supported):
+                result = list(mysql_supported_character_sets())
+                assert len(result) == 1
+                assert CharSet(1, "utf8", "utf8_general_ci") in result

tests/unit/sqlite_utils_test.py

@@ -0,0 +1,93 @@
+from datetime import date, timedelta
+from decimal import Decimal
+from unittest.mock import patch
+
+import pytest
+from dateutil.parser import ParserError
+from packaging.version import Version
+
+from sqlite3_to_mysql.sqlite_utils import (
+    adapt_decimal,
+    adapt_timedelta,
+    check_sqlite_table_xinfo_support,
+    convert_date,
+    convert_decimal,
+    convert_timedelta,
+    unicase_compare,
+)
+
+
+class TestSQLiteUtils:
+    def test_adapt_decimal(self) -> None:
+        """Test adapt_decimal function."""
+        assert adapt_decimal(Decimal("123.45")) == "123.45"
+        assert adapt_decimal(Decimal("0")) == "0"
+        assert adapt_decimal(Decimal("-123.45")) == "-123.45"
+
+    def test_convert_decimal(self) -> None:
+        """Test convert_decimal function."""
+        assert convert_decimal(b"123.45") == Decimal("123.45")
+        assert convert_decimal(b"0") == Decimal("0")
+        assert convert_decimal(b"-123.45") == Decimal("-123.45")
+
+    def test_adapt_timedelta(self) -> None:
+        """Test adapt_timedelta function."""
+        assert adapt_timedelta(timedelta(hours=1, minutes=30, seconds=45)) == "01:30:45"
+        assert adapt_timedelta(timedelta(hours=0, minutes=0, seconds=0)) == "00:00:00"
+        assert adapt_timedelta(timedelta(hours=100, minutes=30, seconds=45)) == "100:30:45"
+
+    def test_convert_timedelta(self) -> None:
+        """Test convert_timedelta function."""
+        assert convert_timedelta(b"01:30:45") == timedelta(hours=1, minutes=30, seconds=45)
+        assert convert_timedelta(b"00:00:00") == timedelta(hours=0, minutes=0, seconds=0)
+        assert convert_timedelta(b"100:30:45") == timedelta(hours=100, minutes=30, seconds=45)
+
+    def test_unicase_compare(self) -> None:
+        """Test unicase_compare function."""
+        # Test with lowercase strings
+        assert unicase_compare("abc", "def") == -1
+        assert unicase_compare("def", "abc") == 1
+        assert unicase_compare("abc", "abc") == 0
+
+        # Test with mixed case strings
+        assert unicase_compare("Abc", "def") == -1
+        assert unicase_compare("DEF", "abc") == 1
+        assert unicase_compare("ABC", "abc") == 0
+
+        # Test with accented characters
+        assert unicase_compare("café", "cafe") == 0
+        assert unicase_compare("café", "cafz") == -1
+        assert unicase_compare("cafz", "café") == 1
+
+    def test_convert_date(self) -> None:
+        """Test convert_date function."""
+        # Test with string
+        assert convert_date("2020-01-01") == date(2020, 1, 1)
+        assert convert_date("2020/01/01") == date(2020, 1, 1)
+        assert convert_date("Jan 1, 2020") == date(2020, 1, 1)
+
+        # Test with bytes
+        assert convert_date(b"2020-01-01") == date(2020, 1, 1)
+        assert convert_date(b"2020/01/01") == date(2020, 1, 1)
+        assert convert_date(b"Jan 1, 2020") == date(2020, 1, 1)
+
+    def test_convert_date_error(self) -> None:
+        """Test convert_date function with invalid date."""
+        with pytest.raises(ValueError):
+            convert_date("not a date")
+
+        with pytest.raises(ValueError):
+            convert_date(b"not a date")
+
+    @pytest.mark.parametrize(
+        "version_string,expected",
+        [
+            ("3.25.0", False),
+            ("3.26.0", True),
+            ("3.27.0", True),
+            ("4.0.0", True),
+        ],
+    )
+    def test_check_sqlite_table_xinfo_support(self, version_string: str, expected: bool) -> None:
+        """Test check_sqlite_table_xinfo_support function."""
+        assert check_sqlite_table_xinfo_support(version_string) == expected