✅ increase test coverage

Author: techouse

src/mysql_to_sqlite3/debug_info.py

@@ -83,7 +83,7 @@ def info() -> t.List[t.List[str]]:
         ["MySQL", _mysql_version()],
         ["SQLite", sqlite3.sqlite_version],
         ["", ""],
-        ["click", click.__version__],
+        ["click", str(click.__version__)],
         ["mysql-connector-python", mysql.connector.__version__],
         ["python-slugify", slugify.__version__],
         ["pytimeparse2", pytimeparse2.__version__],

src/mysql_to_sqlite3/sqlite_utils.py

@@ -34,10 +34,18 @@ def convert_timedelta(value: t.Any) -> timedelta:
 
 def encode_data_for_sqlite(value: t.Any) -> t.Any:
     """Fix encoding bytes."""
-    try:
-        return value.decode()
-    except (UnicodeDecodeError, AttributeError):
-        return sqlite3.Binary(value)
+    if isinstance(value, bytes):
+        try:
+            return value.decode()
+        except (UnicodeDecodeError, AttributeError):
+            return sqlite3.Binary(value)
+    elif isinstance(value, str):
+        return value
+    else:
+        try:
+            return sqlite3.Binary(value)
+        except TypeError:
+            return value
 
 
 class CollatingSequences:

tests/func/test_cli.py

@@ -578,3 +578,67 @@ def test_version(self, cli_runner: CliRunner) -> None:
                 "tqdm",
             }
         )
+
+    def test_invalid_mysql_charset_collation(
+        self,
+        cli_runner: CliRunner,
+        sqlite_database: "os.PathLike[t.Any]",
+        mysql_credentials: MySQLCredentials,
+        mysql_database: Database,
+    ) -> None:
+        """Test CLI with invalid collation for the specified charset."""
+        result: Result = cli_runner.invoke(
+            mysql2sqlite,
+            [
+                "-f",
+                str(sqlite_database),
+                "-d",
+                mysql_credentials.database,
+                "-u",
+                mysql_credentials.user,
+                "--mysql-password",
+                mysql_credentials.password,
+                "-h",
+                mysql_credentials.host,
+                "-P",
+                str(mysql_credentials.port),
+                "--mysql-charset",
+                "utf8mb4",
+                "--mysql-collation",
+                "invalid_collation",
+            ],
+        )
+        assert result.exit_code > 0
+        assert "Error: Invalid value for '--mysql-collation': 'invalid_collation'" in result.output
+
+    def test_without_tables_and_without_data_flags(
+        self,
+        cli_runner: CliRunner,
+        sqlite_database: "os.PathLike[t.Any]",
+        mysql_credentials: MySQLCredentials,
+    ) -> None:
+        """Test CLI with both --without-tables and --without-data flags set."""
+        result: Result = cli_runner.invoke(
+            mysql2sqlite,
+            [
+                "-f",
+                str(sqlite_database),
+                "-d",
+                mysql_credentials.database,
+                "-u",
+                mysql_credentials.user,
+                "--mysql-password",
+                mysql_credentials.password,
+                "-h",
+                mysql_credentials.host,
+                "-P",
+                str(mysql_credentials.port),
+                "--without-tables",
+                "--without-data",
+            ],
+        )
+        assert result.exit_code > 0
+        assert (
+            "Error: Both -Z/--without-tables and -W/--without-data are set. There is nothing to do. Exiting..."
+            in result.output
+        )

tests/unit/test_click_utils.py

@@ -0,0 +1,124 @@
+import typing as t
+
+import click
+import pytest
+from click.testing import CliRunner
+from pytest_mock import MockFixture
+
+from mysql_to_sqlite3.click_utils import OptionEatAll, prompt_password, validate_positive_integer
+
+
+class TestOptionEatAll:
+    def test_init_with_invalid_nargs(self) -> None:
+        """Test OptionEatAll initialization with invalid nargs."""
+        with pytest.raises(ValueError) as excinfo:
+            OptionEatAll("--test", nargs=1)
+        assert "nargs, if set, must be -1 not 1" in str(excinfo.value)
+
+    def test_init_with_valid_nargs(self) -> None:
+        """Test OptionEatAll initialization with valid nargs and behavior."""
+
+        @click.command()
+        @click.option("--test", cls=OptionEatAll, nargs=-1, help="Test option")
+        def cli(test: t.Optional[t.Tuple[str, ...]] = None) -> None:
+            # This just verifies that the option works when nargs=-1
+            assert test is not None
+            click.echo(f"Success: {len(test)} values")
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ["--test", "value1", "value2", "value3"])
+        assert result.exit_code == 0
+        assert "Success:" in result.output
+        assert "values" in result.output
+
+    def test_add_to_parser(self) -> None:
+        """Test add_to_parser method."""
+
+        @click.command()
+        @click.option("--test", cls=OptionEatAll, help="Test option")
+        def cli(test: t.Optional[t.Tuple[str, ...]] = None) -> None:
+            click.echo(f"Test: {test}")
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ["--test", "value1", "value2", "value3"])
+        assert result.exit_code == 0
+        assert "Test: ('value1', 'value2', 'value3')" in result.output
+
+    def test_add_to_parser_with_other_options(self) -> None:
+        """Test add_to_parser method with other options."""
+
+        @click.command()
+        @click.option("--test", cls=OptionEatAll, help="Test option")
+        @click.option("--other", help="Other option")
+        def cli(test: t.Optional[t.Tuple[str, ...]] = None, other: t.Optional[str] = None) -> None:
+            click.echo(f"Test: {test}, Other: {other}")
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ["--test", "value1", "value2", "--other", "value3"])
+        assert result.exit_code == 0
+        assert "Test: ('value1', 'value2'), Other: value3" in result.output
+
+    def test_add_to_parser_without_save_other_options(self) -> None:
+        """Test add_to_parser method without saving other options."""
+
+        @click.command()
+        @click.option("--test", cls=OptionEatAll, save_other_options=False, help="Test option")
+        @click.option("--other", help="Other option")
+        def cli(test: t.Optional[t.Tuple[str, ...]] = None, other: t.Optional[str] = None) -> None:
+            click.echo(f"Test: {test}, Other: {other}")
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ["--test", "value1", "value2", "--other", "value3"])
+        assert result.exit_code == 0
+        # All remaining args should be consumed by --test
+        assert "Test: ('value1', 'value2', '--other', 'value3'), Other: None" in result.output
+
+
+class TestPromptPassword:
+    def test_prompt_password_with_password(self) -> None:
+        """Test prompt_password with password already provided."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"mysql_password": "test_password"}
+
+        result = prompt_password(ctx, None, True)
+        assert result == "test_password"
+
+    def test_prompt_password_without_password(self, mocker: MockFixture) -> None:
+        """Test prompt_password without password provided."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"mysql_password": None}
+
+        mocker.patch("click.prompt", return_value="prompted_password")
+
+        result = prompt_password(ctx, None, True)
+        assert result == "prompted_password"
+
+    def test_prompt_password_use_password_false(self) -> None:
+        """Test prompt_password with use_password=False."""
+        ctx = click.Context(click.Command("test"))
+        ctx.params = {"mysql_password": "test_password"}
+
+        result = prompt_password(ctx, None, False)
+        assert result is None
+
+
+class TestValidatePositiveInteger:
+    def test_validate_positive_integer_valid(self) -> None:
+        """Test validate_positive_integer with valid values."""
+        ctx = click.Context(click.Command("test"))
+
+        assert validate_positive_integer(ctx, None, 0) == 0
+        assert validate_positive_integer(ctx, None, 1) == 1
+        assert validate_positive_integer(ctx, None, 100) == 100
+
+    def test_validate_positive_integer_invalid(self) -> None:
+        """Test validate_positive_integer with invalid values."""
+        ctx = click.Context(click.Command("test"))
+
+        with pytest.raises(click.BadParameter) as excinfo:
+            validate_positive_integer(ctx, None, -1)
+        assert "Should be a positive integer or 0." in str(excinfo.value)
+
+        with pytest.raises(click.BadParameter) as excinfo:
+            validate_positive_integer(ctx, None, -100)
+        assert "Should be a positive integer or 0." in str(excinfo.value)

tests/unit/test_debug_info.py

@@ -0,0 +1,138 @@
+import sys
+import typing as t
+from unittest.mock import MagicMock, patch
+
+import pytest
+from pytest_mock import MockFixture
+
+from mysql_to_sqlite3.debug_info import _implementation, _mysql_version, info
+
+
+class TestDebugInfo:
+    def test_implementation_cpython(self, mocker: MockFixture) -> None:
+        """Test _implementation function with CPython."""
+        mocker.patch("platform.python_implementation", return_value="CPython")
+        mocker.patch("platform.python_version", return_value="3.8.10")
+
+        result = _implementation()
+        assert result == "CPython 3.8.10"
+
+    def test_implementation_pypy(self, mocker: MockFixture) -> None:
+        """Test _implementation function with PyPy."""
+        mocker.patch("platform.python_implementation", return_value="PyPy")
+
+        # Create a mock for pypy_version_info
+        mock_version_info = MagicMock()
+        mock_version_info.major = 3
+        mock_version_info.minor = 7
+        mock_version_info.micro = 4
+        mock_version_info.releaselevel = "final"
+
+        # Need to use patch instead of mocker.patch for sys module attributes
+        with patch.object(sys, "pypy_version_info", mock_version_info, create=True):
+            result = _implementation()
+            assert result == "PyPy 3.7.4"
+
+    def test_implementation_pypy_non_final(self, mocker: MockFixture) -> None:
+        """Test _implementation function with PyPy non-final release."""
+        mocker.patch("platform.python_implementation", return_value="PyPy")
+
+        # Create a mock for pypy_version_info
+        mock_version_info = MagicMock()
+        mock_version_info.major = 3
+        mock_version_info.minor = 7
+        mock_version_info.micro = 4
+        mock_version_info.releaselevel = "beta"
+
+        # Need to use patch instead of mocker.patch for sys module attributes
+        with patch.object(sys, "pypy_version_info", mock_version_info, create=True):
+            result = _implementation()
+            assert result == "PyPy 3.7.4beta"
+
+    def test_implementation_jython(self, mocker: MockFixture) -> None:
+        """Test _implementation function with Jython."""
+        mocker.patch("platform.python_implementation", return_value="Jython")
+        mocker.patch("platform.python_version", return_value="2.7.2")
+
+        result = _implementation()
+        assert result == "Jython 2.7.2"
+
+    def test_implementation_ironpython(self, mocker: MockFixture) -> None:
+        """Test _implementation function with IronPython."""
+        mocker.patch("platform.python_implementation", return_value="IronPython")
+        mocker.patch("platform.python_version", return_value="2.7.9")
+
+        result = _implementation()
+        assert result == "IronPython 2.7.9"
+
+    def test_implementation_unknown(self, mocker: MockFixture) -> None:
+        """Test _implementation function with unknown implementation."""
+        mocker.patch("platform.python_implementation", return_value="UnknownPython")
+
+        result = _implementation()
+        assert result == "UnknownPython Unknown"
+
+    def test_mysql_version_success(self, mocker: MockFixture) -> None:
+        """Test _mysql_version function when mysql client is available."""
+        mocker.patch("mysql_to_sqlite3.debug_info.which", return_value="/usr/bin/mysql")
+        mocker.patch(
+            "mysql_to_sqlite3.debug_info.check_output",
+            return_value=b"mysql  Ver 8.0.26 for Linux on x86_64",
+        )
+
+        result = _mysql_version()
+        assert result == "mysql  Ver 8.0.26 for Linux on x86_64"
+
+    def test_mysql_version_bytes_decode_error(self, mocker: MockFixture) -> None:
+        """Test _mysql_version function when bytes decoding fails."""
+        mocker.patch("mysql_to_sqlite3.debug_info.which", return_value="/usr/bin/mysql")
+        mock_output = MagicMock()
+        mock_output.decode.side_effect = UnicodeDecodeError("utf-8", b"", 0, 1, "invalid")
+        mocker.patch(
+            "mysql_to_sqlite3.debug_info.check_output",
+            return_value=mock_output,
+        )
+
+        result = _mysql_version()
+        assert isinstance(result, str)
+
+    def test_mysql_version_exception(self, mocker: MockFixture) -> None:
+        """Test _mysql_version function when an exception occurs."""
+        mocker.patch("mysql_to_sqlite3.debug_info.which", return_value="/usr/bin/mysql")
+        mocker.patch(
+            "mysql_to_sqlite3.debug_info.check_output",
+            side_effect=Exception("Command failed"),
+        )
+
+        result = _mysql_version()
+        assert result == "MySQL client not found on the system"
+
+    def test_mysql_version_not_found(self, mocker: MockFixture) -> None:
+        """Test _mysql_version function when mysql client is not found."""
+        mocker.patch("mysql_to_sqlite3.debug_info.which", return_value=None)
+
+        result = _mysql_version()
+        assert result == "MySQL client not found on the system"
+
+    def test_info_success(self, mocker: MockFixture) -> None:
+        """Test info function."""
+        mocker.patch("platform.system", return_value="Linux")
+        mocker.patch("platform.release", return_value="5.4.0-80-generic")
+        mocker.patch("mysql_to_sqlite3.debug_info._implementation", return_value="CPython 3.8.10")
+        mocker.patch("mysql_to_sqlite3.debug_info._mysql_version", return_value="mysql  Ver 8.0.26 for Linux on x86_64")
+
+        result = info()
+        assert isinstance(result, list)
+        assert len(result) > 0
+        assert result[2] == ["Operating System", "Linux 5.4.0-80-generic"]
+        assert result[3] == ["Python", "CPython 3.8.10"]
+        assert result[4] == ["MySQL", "mysql  Ver 8.0.26 for Linux on x86_64"]
+
+    def test_info_platform_error(self, mocker: MockFixture) -> None:
+        """Test info function when platform.system raises IOError."""
+        mocker.patch("platform.system", side_effect=IOError("Platform error"))
+
+        result = info()
+        assert isinstance(result, list)
+        assert len(result) > 0
+        assert result[2] == ["Operating System", "Unknown"]