🔨 refactor(cli)!: replace typer with click for cli commands and tests

Author: Jannchie

pyproject.toml

@@ -11,7 +11,7 @@ dependencies = [
     "jinja2>=3.1.4",
     "questionary>=2.0.1",
     "beautifulsoup4>=4.13.3",
-    "typer>=0.15.1",
+    "click>=8.0.0",
 ]
 readme = { content-type = "text/markdown", file = "README.md" }
 requires-python = ">= 3.11"
@@ -80,19 +80,15 @@ ignore = [
     "ARG002",
     "PLR0913",
     "PT011",
-    "B017"
+    "B017",
 ]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py", "*_test.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
-addopts = [
-    "--strict-markers",
-    "--disable-warnings",
-    "-v",
-]
+addopts = ["--strict-markers", "--disable-warnings", "-v"]
 markers = [
     "slow: marks tests as slow (deselect with '-m \"not slow\"')",
     "integration: marks tests as integration tests",

tests/unit/test_add.py

@@ -1,5 +1,6 @@
 import pytest
 from unittest.mock import patch, MagicMock
+from click.testing import CliRunner
 
 from tgit.add import add
 
@@ -10,47 +11,56 @@ class TestAdd:
     @patch("tgit.add.simple_run_command")
     def test_add_single_file(self, mock_simple_run_command):
         """Test adding a single file"""
-        files = ["test.txt"]
-        add(files)
+        runner = CliRunner()
+        result = runner.invoke(add, ["test.txt"])
 
+        assert result.exit_code == 0
         mock_simple_run_command.assert_called_once_with("git add test.txt")
 
     @patch("tgit.add.simple_run_command")
     def test_add_multiple_files(self, mock_simple_run_command):
         """Test adding multiple files"""
-        files = ["file1.txt", "file2.py", "file3.md"]
-        add(files)
+        runner = CliRunner()
+        result = runner.invoke(add, ["file1.txt", "file2.py", "file3.md"])
 
+        assert result.exit_code == 0
         mock_simple_run_command.assert_called_once_with("git add file1.txt file2.py file3.md")
 
     @patch("tgit.add.simple_run_command")
     def test_add_files_with_spaces(self, mock_simple_run_command):
         """Test adding files with spaces in names"""
-        files = ["file with spaces.txt", "another file.py"]
-        add(files)
+        runner = CliRunner()
+        result = runner.invoke(add, ["file with spaces.txt", "another file.py"])
 
+        assert result.exit_code == 0
         mock_simple_run_command.assert_called_once_with("git add file with spaces.txt another file.py")
 
     @patch("tgit.add.simple_run_command")
     def test_add_empty_list(self, mock_simple_run_command):
         """Test adding empty file list"""
-        files = []
-        add(files)
+        runner = CliRunner()
+        result = runner.invoke(add, [])
 
-        mock_simple_run_command.assert_called_once_with("git add ")
+        # Since files argument is required=True, this should fail
+        assert result.exit_code == 2
+        mock_simple_run_command.assert_not_called()
 
     @patch("tgit.add.simple_run_command")
     def test_add_files_with_special_characters(self, mock_simple_run_command):
         """Test adding files with special characters"""
-        files = ["file-with-dashes.txt", "file_with_underscores.py", "file.with.dots.md"]
-        add(files)
+        runner = CliRunner()
+        result = runner.invoke(add, ["file-with-dashes.txt", "file_with_underscores.py", "file.with.dots.md"])
 
+        assert result.exit_code == 0
         mock_simple_run_command.assert_called_once_with("git add file-with-dashes.txt file_with_underscores.py file.with.dots.md")
 
     @patch("tgit.add.simple_run_command")
     def test_add_propagates_exception(self, mock_simple_run_command):
         """Test that exceptions from simple_run_command are propagated"""
         mock_simple_run_command.side_effect = Exception("Git command failed")
+        runner = CliRunner()
 
-        with pytest.raises(Exception, match="Git command failed"):
-            add(["test.txt"])
+        result = runner.invoke(add, ["test.txt"])
+        
+        # Exception should cause non-zero exit code
+        assert result.exit_code != 0

tests/unit/test_changelog.py

@@ -6,6 +6,7 @@
 from datetime import datetime, UTC
 import git
 import re
+from click.testing import CliRunner
 
 
 from tgit.changelog import (
@@ -765,8 +766,10 @@ class TestChangelogFunction:
     @patch("tgit.changelog.handle_changelog")
     def test_changelog_function_defaults(self, mock_handle):
         """Test changelog function with default arguments."""
-        changelog()
-
+        runner = CliRunner()
+        result = runner.invoke(changelog, ["."])
+        
+        assert result.exit_code == 0
         mock_handle.assert_called_once()
         # Get the actual args passed to handle_changelog - it should be a ChangelogArgs object
         called_args = mock_handle.call_args[0][0]
@@ -779,17 +782,21 @@ def test_changelog_function_defaults(self, mock_handle):
     @patch("tgit.changelog.handle_changelog")
     def test_changelog_function_with_output_flag(self, mock_handle):
         """Test changelog function with output flag."""
-        changelog(output="")
-
+        runner = CliRunner()
+        result = runner.invoke(changelog, [".", "--output", ""])
+        
+        assert result.exit_code == 0
         mock_handle.assert_called_once()
         args = mock_handle.call_args[0][0]
         assert args.output == "CHANGELOG.md"
 
     @patch("tgit.changelog.handle_changelog")
     def test_changelog_function_with_custom_args(self, mock_handle):
         """Test changelog function with custom arguments."""
-        changelog(path="/tmp", from_raw="v1.0.0", to_raw="v1.1.0", verbose=2, output="custom.md")  # noqa: S108
-
+        runner = CliRunner()
+        result = runner.invoke(changelog, ["/tmp", "--from", "v1.0.0", "--to", "v1.1.0", "-vv", "--output", "custom.md"])  # noqa: S108
+        
+        assert result.exit_code == 0
         mock_handle.assert_called_once()
         args = mock_handle.call_args[0][0]
         assert args.path == "/tmp"  # noqa: S108

tests/unit/test_cli.py

@@ -1,69 +1,68 @@
 import pytest
 from unittest.mock import patch, MagicMock
-import typer
+import click
 import threading
 import time
+from click.testing import CliRunner
 
-from tgit.cli import app, version_callback, main
+from tgit.cli import app, version_callback
 
 
 class TestCLI:
     """Test cases for the CLI module"""
 
     def test_app_instance(self):
-        """Test that app is a Typer instance with correct configuration"""
-        assert isinstance(app, typer.Typer)
-        assert app.info.name == "tgit"
-        assert app.info.help == "TGIT cli"
-        assert app.info.no_args_is_help is True
+        """Test that app is a Click group with correct configuration"""
+        assert isinstance(app, click.Group)
+        assert app.name == "tgit"
+        assert app.help == "TGIT cli"
+        assert app.no_args_is_help is True
 
     def test_commands_registered(self):
         """Test that all expected commands are registered"""
         # Just verify the app object exists and has the right type
-        # since the command registration details may vary by Typer version
-        assert isinstance(app, typer.Typer)
+        # since the command registration details may vary by Click version
+        assert isinstance(app, click.Group)
 
     @patch("tgit.cli.importlib.metadata.version")
     @patch("tgit.cli.console.print")
     def test_version_callback_true(self, mock_print, mock_version):
         """Test version callback when value is True"""
         mock_version.return_value = "1.0.0"
+        mock_ctx = MagicMock()
+        mock_ctx.resilient_parsing = False
+        mock_param = MagicMock()
 
-        with pytest.raises(typer.Exit):
-            version_callback(value=True)
+        version_callback(ctx=mock_ctx, _param=mock_param, value=True)
 
         mock_version.assert_called_once_with("tgit")
         mock_print.assert_called_once_with("TGIT - ver.1.0.0", highlight=False)
+        mock_ctx.exit.assert_called_once()
 
     @patch("tgit.cli.importlib.metadata.version")
     @patch("tgit.cli.console.print")
     def test_version_callback_false(self, mock_print, mock_version):
         """Test version callback when value is False"""
-        version_callback(value=False)
+        mock_ctx = MagicMock()
+        mock_ctx.resilient_parsing = False
+        mock_param = MagicMock()
+        
+        version_callback(ctx=mock_ctx, _param=mock_param, value=False)
 
         mock_version.assert_not_called()
         mock_print.assert_not_called()
+        mock_ctx.exit.assert_not_called()
 
     @patch("tgit.cli.threading.Thread")
-    def test_main_starts_openai_import_thread(self, mock_thread):
-        """Test that main starts a thread for OpenAI import"""
-        mock_thread_instance = MagicMock()
-        mock_thread.return_value = mock_thread_instance
-        
-        main(_version=False)
-        
-        mock_thread.assert_called_once()
-        mock_thread_instance.start.assert_called_once()
-
-    @patch("tgit.cli.threading.Thread")
-    def test_main_with_version_false(self, mock_thread):
-        """Test main function with version=False"""
+    def test_app_starts_openai_import_thread(self, mock_thread):
+        """Test that app starts a thread for OpenAI import"""
         mock_thread_instance = MagicMock()
         mock_thread.return_value = mock_thread_instance
 
-        main(_version=False)
+        # Directly call the app function to test the callback
+        app.callback()
 
-        # Should still start the import thread
+        # The app should run the callback and start the thread
         mock_thread.assert_called_once()
         mock_thread_instance.start.assert_called_once()
 
@@ -82,23 +81,8 @@ def mock_import():
 
         assert import_called.is_set()
 
-    @patch("tgit.cli.threading.Thread")
-    def test_openai_import_with_exception_suppression(self, mock_thread):
-        """Test that OpenAI import exceptions are suppressed"""
-        # Create a mock thread that we can control
-        mock_thread_instance = MagicMock()
-        mock_thread.return_value = mock_thread_instance
-        
-        main(_version=False)
-        
-        # Just verify that the thread was created and started
-        mock_thread.assert_called_once()
-        mock_thread_instance.start.assert_called_once()
-
     def test_app_callback_registration(self):
-        """Test that main is registered as app callback"""
-        # The callback should be registered - check if app has the callback mechanism
-        # This may vary by Typer version, so we'll check if the app object is properly configured
-        assert isinstance(app, typer.Typer)
-        # In newer Typer versions, the callback structure might be different
-        # We'll just verify the app exists and is configured correctly
+        """Test that app is properly configured"""
+        # Check if app has the callback mechanism
+        assert isinstance(app, click.Group)
+        # Verify the app exists and is configured correctly

tests/unit/test_commit.py

@@ -5,6 +5,7 @@
 import git
 from pathlib import Path
 import tempfile
+from click.testing import CliRunner
 
 from tgit.commit import (
     CommitArgs,
@@ -543,8 +544,10 @@ class TestCommitFunction:
     @patch("tgit.commit.handle_commit")
     def test_commit_function_default_args(self, mock_handle_commit):
         """Test commit function with default arguments."""
-        commit()
+        runner = CliRunner()
+        result = runner.invoke(commit, [])
 
+        assert result.exit_code == 0
         # Check that handle_commit was called once
         mock_handle_commit.assert_called_once()
 
@@ -558,8 +561,10 @@ def test_commit_function_default_args(self, mock_handle_commit):
     @patch("tgit.commit.handle_commit")
     def test_commit_function_with_args(self, mock_handle_commit):
         """Test commit function with custom arguments."""
-        commit(message=["feat", "add feature"], emoji=True, breaking=True, ai=True)
+        runner = CliRunner()
+        result = runner.invoke(commit, ["feat", "add feature", "--emoji", "--breaking", "--ai"])
 
+        assert result.exit_code == 0
         expected_args = CommitArgs(message=["feat", "add feature"], emoji=True, breaking=True, ai=True)
         mock_handle_commit.assert_called_once()