git-commit-msg-ai 1.4.2__tar.gz → 1.5.0__tar.gz

{git_commit_msg_ai-1.4.2 → git_commit_msg_ai-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-commit-msg-ai
-Version: 1.4.2
+Version: 1.5.0
 Summary: AI-powered git commit message generator following Conventional Commits
 License-Expression: MIT
 Requires-Python: >=3.10
@@ -113,3 +113,25 @@ BREAKING CHANGE: /v1/legacy is no longer available
 ```
 
 Supported types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
+
+## Debugging
+
+By default the tool produces no diagnostic output. To enable logging, set the `GIT_COMMIT_AI_LOG_LEVEL` environment variable before running the command. Logs are written to **stderr** and do not interfere with the generated commit message on **stdout**.
+
+Valid values: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`
+
+```sh
+# macOS/Linux - show all internal diagnostic messages
+GIT_COMMIT_AI_LOG_LEVEL=DEBUG git-commit-msg-ai
+
+# Windows PowerShell
+$env:GIT_COMMIT_AI_LOG_LEVEL = 'DEBUG'
+git-commit-msg-ai
+```
+
+| Level | What you see |
+|---|---|
+| `DEBUG` | git commands run, API model/token params, temp file paths, char counts |
+| `INFO` | commit message generated, commit created |
+| `WARNING` | no staged changes found |
+| `ERROR` | git not found, API failures, editor errors |

{git_commit_msg_ai-1.4.2 → git_commit_msg_ai-1.5.0}/README.md

@@ -97,3 +97,25 @@ BREAKING CHANGE: /v1/legacy is no longer available
 ```
 
 Supported types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
+
+## Debugging
+
+By default the tool produces no diagnostic output. To enable logging, set the `GIT_COMMIT_AI_LOG_LEVEL` environment variable before running the command. Logs are written to **stderr** and do not interfere with the generated commit message on **stdout**.
+
+Valid values: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`
+
+```sh
+# macOS/Linux - show all internal diagnostic messages
+GIT_COMMIT_AI_LOG_LEVEL=DEBUG git-commit-msg-ai
+
+# Windows PowerShell
+$env:GIT_COMMIT_AI_LOG_LEVEL = 'DEBUG'
+git-commit-msg-ai
+```
+
+| Level | What you see |
+|---|---|
+| `DEBUG` | git commands run, API model/token params, temp file paths, char counts |
+| `INFO` | commit message generated, commit created |
+| `WARNING` | no staged changes found |
+| `ERROR` | git not found, API failures, editor errors |

{git_commit_msg_ai-1.4.2 → git_commit_msg_ai-1.5.0}/git_commit_msg_ai/ai_client.py

@@ -1,3 +1,4 @@
+import logging
 import textwrap
 from typing import Final, cast
 
@@ -5,6 +6,8 @@ import anthropic
 
 from git_commit_msg_ai.exceptions import AIError
 
+logger = logging.getLogger(__name__)
+
 SYSTEM_PROMPT: Final[str] = textwrap.dedent("""\
     You are a Git commit message generator. Output only the commit message, nothing else. Follow the Conventional Commits specification:
     - First line: <type>(<optional scope>)<!>: <short subject> (50 chars max); append ! before the colon if the commit introduces a breaking change
@@ -21,6 +24,7 @@ def generate_commit_message(diff: str) -> str:
     try:
         anthropic_client = anthropic.Anthropic()
 
+        logger.debug('Calling Anthropic API: model=%s max_tokens=%d', MODEL, MAX_TOKENS)
         anthropic_api_response = anthropic_client.messages.create(
             model=MODEL,
             max_tokens=MAX_TOKENS,
@@ -28,15 +32,21 @@ def generate_commit_message(diff: str) -> str:
             messages=[{'role': 'user', 'content': diff}],
         )
     except anthropic.AuthenticationError:
+        logger.error('Anthropic authentication error')
         raise AIError('Anthropic API key is missing or invalid. Set the ANTHROPIC_API_KEY environment variable.')
     except anthropic.RateLimitError:
+        logger.error('Anthropic rate limit error')
         raise AIError('Anthropic API rate limit reached. Wait a moment and try again.')
     except anthropic.APIConnectionError:
+        logger.error('Anthropic API connection error')
         raise AIError('Could not reach the Anthropic API. Check your network connection.')
     except anthropic.APIStatusError as error:
+        logger.error('Anthropic API status error: %s', error.status_code)
         raise AIError(f'Anthropic API returned an error: {error.status_code}.')
 
     anthropic_api_response_message = anthropic_api_response.content[0]
     commit_message = cast(anthropic.types.TextBlock, anthropic_api_response_message).text.strip()
 
+    logger.info('Commit message generated: %d chars', len(commit_message))
+
     return commit_message

{git_commit_msg_ai-1.4.2 → git_commit_msg_ai-1.5.0}/git_commit_msg_ai/cli.py

@@ -1,10 +1,26 @@
+import logging
+import os
 import sys
+from typing import Final
 
 from git_commit_msg_ai import ai_client, editor, git_ops
 from git_commit_msg_ai.exceptions import GitCommitAIError
 
+LOG_LEVEL_ENV_VAR: Final[str] = 'GIT_COMMIT_AI_LOG_LEVEL'
+
 
 def main() -> None:
+    log_level_name = os.environ.get(LOG_LEVEL_ENV_VAR, 'WARNING').upper()
+    numeric_log_level = getattr(logging, log_level_name, None)
+
+    if not isinstance(numeric_log_level, int):
+        numeric_log_level = logging.WARNING
+
+    logging.basicConfig(level=numeric_log_level, format='%(levelname)s:%(name)s:%(message)s', stream=sys.stderr)
+
+    if not isinstance(getattr(logging, log_level_name, None), int):
+        logging.warning('Invalid %s value %r, defaulting to WARNING', LOG_LEVEL_ENV_VAR, log_level_name)
+
     try:
         diff = git_ops.get_staged_diff()
         commit_message = ai_client.generate_commit_message(diff)

{git_commit_msg_ai-1.4.2 → git_commit_msg_ai-1.5.0}/git_commit_msg_ai/editor.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import platform
 import subprocess
@@ -5,6 +6,8 @@ import tempfile
 
 from git_commit_msg_ai.exceptions import EditorError
 
+logger = logging.getLogger(__name__)
+
 
 def get_default_editor() -> str:
     current_platform = platform.system()
@@ -19,25 +22,38 @@ def open_in_editor(initial_text: str) -> str:
             temp_file.write(initial_text)
             temp_file_path = temp_file.name
     except OSError:
+        logger.error('Could not create temporary file')
         raise EditorError('Could not create a temporary file.')
 
+    logger.debug('Temporary file created: %s', temp_file_path)
+
     platform_default_editor = get_default_editor()
     editor_command = os.environ.get('EDITOR', platform_default_editor)
 
+    logger.debug('Selected editor: %s', editor_command)
+
     try:
         try:
+            logger.debug('Opening editor: %s %s', editor_command, temp_file_path)
             subprocess.run([editor_command, temp_file_path], check=True)
         except FileNotFoundError:
+            logger.error('Editor not found: %s', editor_command)
             raise EditorError(f'Editor "{editor_command}" was not found. Set the EDITOR environment variable to a valid editor.')
         except subprocess.CalledProcessError:
+            logger.error('Editor exited with error: %s', editor_command)
             raise EditorError(f'Editor "{editor_command}" exited with an error.')
 
+        logger.debug('Editor closed, reading edited content')
+
         try:
             with open(temp_file_path) as temp_file:
                 edited_text = temp_file.read().strip()
         except OSError:
+            logger.error('Could not read temporary file: %s', temp_file_path)
             raise EditorError('Could not read the edited commit message from the temporary file.')
     finally:
         os.unlink(temp_file_path)
 
+    logger.debug('Edited text read: %d chars', len(edited_text))
+
     return edited_text

{git_commit_msg_ai-1.4.2 → git_commit_msg_ai-1.5.0}/git_commit_msg_ai/git_ops.py

@@ -1,3 +1,4 @@
+import logging
 import subprocess
 from typing import Final
 
@@ -10,18 +11,28 @@ COMMIT_SUBCOMMAND: Final[str] = 'commit'
 MESSAGE_FLAG: Final[str] = '-m'
 UTF8_ENCODING: Final[str] = 'utf-8'
 
+logger = logging.getLogger(__name__)
+
 
 def get_staged_diff() -> str:
     try:
-        staged_diff = subprocess.check_output([GIT_COMMAND, DIFF_SUBCOMMAND, CACHED_FLAG]).decode(UTF8_ENCODING)
+        logger.debug('Running: %s %s %s', GIT_COMMAND, DIFF_SUBCOMMAND, CACHED_FLAG)
+        raw_diff_bytes = subprocess.check_output([GIT_COMMAND, DIFF_SUBCOMMAND, CACHED_FLAG])
+        staged_diff = raw_diff_bytes.decode(UTF8_ENCODING)
     except FileNotFoundError:
+        logger.error('git not found on PATH')
         raise GitError('git is not installed or not on PATH.')
     except subprocess.CalledProcessError:
+        logger.error('git diff --cached exited non-zero')
         raise GitError('Failed to get staged diff. Are you inside a git repository?')
     except UnicodeDecodeError:
+        logger.error('Staged diff could not be decoded as UTF-8')
         raise GitError('Staged diff contains bytes that could not be decoded as UTF-8.')
 
+    logger.debug('Staged diff received: %d chars', len(staged_diff))
+
     if not staged_diff:
+        logger.warning('No staged changes found')
         raise GitError('No staged changes found. Stage files with git add before running.')
 
     return staged_diff
@@ -29,8 +40,13 @@ def get_staged_diff() -> str:
 
 def commit(message: str) -> None:
     try:
+        logger.debug('Running: %s %s %s <message>', GIT_COMMAND, COMMIT_SUBCOMMAND, MESSAGE_FLAG)
         subprocess.run([GIT_COMMAND, COMMIT_SUBCOMMAND, MESSAGE_FLAG, message], check=True)
     except FileNotFoundError:
+        logger.error('git not found on PATH')
         raise GitError('git is not installed or not on PATH.')
     except subprocess.CalledProcessError:
+        logger.error('git commit exited non-zero')
         raise GitError('git commit failed.')
+
+    logger.info('Commit created successfully')

{git_commit_msg_ai-1.4.2 → git_commit_msg_ai-1.5.0}/git_commit_msg_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-commit-msg-ai
-Version: 1.4.2
+Version: 1.5.0
 Summary: AI-powered git commit message generator following Conventional Commits
 License-Expression: MIT
 Requires-Python: >=3.10
@@ -113,3 +113,25 @@ BREAKING CHANGE: /v1/legacy is no longer available
 ```
 
 Supported types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
+
+## Debugging
+
+By default the tool produces no diagnostic output. To enable logging, set the `GIT_COMMIT_AI_LOG_LEVEL` environment variable before running the command. Logs are written to **stderr** and do not interfere with the generated commit message on **stdout**.
+
+Valid values: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`
+
+```sh
+# macOS/Linux - show all internal diagnostic messages
+GIT_COMMIT_AI_LOG_LEVEL=DEBUG git-commit-msg-ai
+
+# Windows PowerShell
+$env:GIT_COMMIT_AI_LOG_LEVEL = 'DEBUG'
+git-commit-msg-ai
+```
+
+| Level | What you see |
+|---|---|
+| `DEBUG` | git commands run, API model/token params, temp file paths, char counts |
+| `INFO` | commit message generated, commit created |
+| `WARNING` | no staged changes found |
+| `ERROR` | git not found, API failures, editor errors |

{git_commit_msg_ai-1.4.2 → git_commit_msg_ai-1.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "git-commit-msg-ai"
-version = "1.4.2"
+version = "1.5.0"
 description = "AI-powered git commit message generator following Conventional Commits"
 readme = "README.md"
 license = "MIT"

git_commit_msg_ai-1.5.0/tests/test_ai_client.py

@@ -0,0 +1,158 @@
+import logging
+from contextlib import ExitStack
+from unittest.mock import MagicMock, patch
+
+import anthropic
+import pytest
+
+from git_commit_msg_ai.ai_client import MAX_TOKENS, MODEL, generate_commit_message
+from git_commit_msg_ai.exceptions import AIError
+
+
+def _make_api_response(text: str) -> MagicMock:
+    mock_text_block = MagicMock(spec=anthropic.types.TextBlock)
+    mock_text_block.text = text
+
+    mock_response = MagicMock(spec=anthropic.types.Message)
+    mock_response.content = [mock_text_block]
+
+    return mock_response
+
+
+def _make_status_error(exception_class: type[anthropic.APIStatusError], status_code: int) -> anthropic.APIStatusError:
+    mock_response = MagicMock()
+    mock_response.status_code = status_code
+
+    return exception_class('error', response=mock_response, body={})
+
+
+class TestGenerateCommitMessage:
+    def test_returns_stripped_commit_message(self) -> None:
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+            mock_client = MagicMock()
+            mock_client.messages.create.return_value = _make_api_response('  feat: add feature  ')
+            mock_anthropic_class.return_value = mock_client
+
+            result = generate_commit_message('diff content')
+
+        assert result == 'feat: add feature'
+
+    def test_raises_ai_error_on_authentication_error(self) -> None:
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+            mock_client = MagicMock()
+            mock_client.messages.create.side_effect = _make_status_error(anthropic.AuthenticationError, 401)
+            mock_anthropic_class.return_value = mock_client
+
+            with pytest.raises(AIError, match='ANTHROPIC_API_KEY'):
+                generate_commit_message('diff content')
+
+    def test_raises_ai_error_on_rate_limit_error(self) -> None:
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+            mock_client = MagicMock()
+            mock_client.messages.create.side_effect = _make_status_error(anthropic.RateLimitError, 429)
+            mock_anthropic_class.return_value = mock_client
+
+            with pytest.raises(AIError, match='rate limit'):
+                generate_commit_message('diff content')
+
+    def test_raises_ai_error_on_api_connection_error(self) -> None:
+        mock_request = MagicMock()
+
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+            mock_client = MagicMock()
+            mock_client.messages.create.side_effect = anthropic.APIConnectionError(request=mock_request)
+            mock_anthropic_class.return_value = mock_client
+
+            with pytest.raises(AIError, match='network'):
+                generate_commit_message('diff content')
+
+    def test_raises_ai_error_on_api_status_error_with_status_code(self) -> None:
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+            mock_client = MagicMock()
+            mock_client.messages.create.side_effect = _make_status_error(anthropic.APIStatusError, 500)
+            mock_anthropic_class.return_value = mock_client
+
+            with pytest.raises(AIError, match='500'):
+                generate_commit_message('diff content')
+
+    def test_logs_debug_before_api_call(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.DEBUG, logger='git_commit_msg_ai.ai_client'):
+            with ExitStack() as stack:
+                mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_api_response('feat: add feature')
+                mock_anthropic_class.return_value = mock_client
+                generate_commit_message('diff content')
+
+        messages = [r.message for r in caplog.records]
+        assert any(MODEL in m and str(MAX_TOKENS) in m for m in messages)
+
+    def test_logs_info_after_message_generated(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.INFO, logger='git_commit_msg_ai.ai_client'):
+            with ExitStack() as stack:
+                mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+                mock_client = MagicMock()
+                mock_client.messages.create.return_value = _make_api_response('feat: add feature')
+                mock_anthropic_class.return_value = mock_client
+                generate_commit_message('diff content')
+
+        assert any(r.levelno == logging.INFO and 'Commit message generated' in r.message for r in caplog.records)
+
+    def test_logs_error_on_authentication_error(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.ai_client'):
+            with ExitStack() as stack:
+                mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+                mock_client = MagicMock()
+                mock_client.messages.create.side_effect = _make_status_error(anthropic.AuthenticationError, 401)
+                mock_anthropic_class.return_value = mock_client
+
+                with pytest.raises(AIError):
+                    generate_commit_message('diff content')
+
+        assert any(r.levelno == logging.ERROR for r in caplog.records)
+
+    def test_logs_error_on_rate_limit_error(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.ai_client'):
+            with ExitStack() as stack:
+                mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+                mock_client = MagicMock()
+                mock_client.messages.create.side_effect = _make_status_error(anthropic.RateLimitError, 429)
+                mock_anthropic_class.return_value = mock_client
+
+                with pytest.raises(AIError):
+                    generate_commit_message('diff content')
+
+        assert any(r.levelno == logging.ERROR for r in caplog.records)
+
+    def test_logs_error_on_api_connection_error(self, caplog: pytest.LogCaptureFixture) -> None:
+        mock_request = MagicMock()
+
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.ai_client'):
+            with ExitStack() as stack:
+                mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+                mock_client = MagicMock()
+                mock_client.messages.create.side_effect = anthropic.APIConnectionError(request=mock_request)
+                mock_anthropic_class.return_value = mock_client
+
+                with pytest.raises(AIError):
+                    generate_commit_message('diff content')
+
+        assert any(r.levelno == logging.ERROR for r in caplog.records)
+
+    def test_logs_error_on_api_status_error(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.ai_client'):
+            with ExitStack() as stack:
+                mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
+                mock_client = MagicMock()
+                mock_client.messages.create.side_effect = _make_status_error(anthropic.APIStatusError, 500)
+                mock_anthropic_class.return_value = mock_client
+
+                with pytest.raises(AIError):
+                    generate_commit_message('diff content')
+
+        assert any(r.levelno == logging.ERROR and '500' in r.message for r in caplog.records)

{git_commit_msg_ai-1.4.2 → git_commit_msg_ai-1.5.0}/tests/test_cli.py

@@ -1,9 +1,11 @@
+import logging
+import sys
 from contextlib import ExitStack
 from unittest.mock import MagicMock, patch
 
 import pytest
 
-from git_commit_msg_ai.cli import main
+from git_commit_msg_ai.cli import LOG_LEVEL_ENV_VAR, main
 from git_commit_msg_ai.exceptions import AIError, GitError
 
 COMMIT_MESSAGE = 'feat: add feature'
@@ -147,3 +149,71 @@ class TestMain:
 
         assert exc_info.value.code == 1
         assert 'Aborted.' in capsys.readouterr().out
+
+
+class TestLoggingConfiguration:
+    def _run_main_rejecting(self) -> None:
+        mock_git_ops = MagicMock()
+        mock_git_ops.get_staged_diff.return_value = 'diff'
+
+        mock_ai_client = MagicMock()
+        mock_ai_client.generate_commit_message.return_value = 'feat: x'
+
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.cli.git_ops', mock_git_ops))
+            stack.enter_context(patch('git_commit_msg_ai.cli.ai_client', mock_ai_client))
+            stack.enter_context(patch('git_commit_msg_ai.cli.editor'))
+            stack.enter_context(patch('builtins.input', return_value='r'))
+            main()
+
+    def test_uses_warning_level_when_env_var_absent(self) -> None:
+        with ExitStack() as stack:
+            mock_basic_config = stack.enter_context(patch('git_commit_msg_ai.cli.logging.basicConfig'))
+            stack.enter_context(patch.dict('os.environ', {}, clear=True))
+            self._run_main_rejecting()
+
+        mock_basic_config.assert_called_once_with(level=logging.WARNING, format='%(levelname)s:%(name)s:%(message)s', stream=sys.stderr)
+
+    def test_uses_debug_level_from_env_var(self) -> None:
+        with ExitStack() as stack:
+            mock_basic_config = stack.enter_context(patch('git_commit_msg_ai.cli.logging.basicConfig'))
+            stack.enter_context(patch.dict('os.environ', {LOG_LEVEL_ENV_VAR: 'DEBUG'}))
+            self._run_main_rejecting()
+
+        mock_basic_config.assert_called_once_with(level=logging.DEBUG, format='%(levelname)s:%(name)s:%(message)s', stream=sys.stderr)
+
+    def test_uses_info_level_from_env_var(self) -> None:
+        with ExitStack() as stack:
+            mock_basic_config = stack.enter_context(patch('git_commit_msg_ai.cli.logging.basicConfig'))
+            stack.enter_context(patch.dict('os.environ', {LOG_LEVEL_ENV_VAR: 'INFO'}))
+            self._run_main_rejecting()
+
+        mock_basic_config.assert_called_once_with(level=logging.INFO, format='%(levelname)s:%(name)s:%(message)s', stream=sys.stderr)
+
+    def test_invalid_env_var_falls_back_to_warning(self) -> None:
+        with ExitStack() as stack:
+            mock_basic_config = stack.enter_context(patch('git_commit_msg_ai.cli.logging.basicConfig'))
+            mock_log_warning = stack.enter_context(patch('git_commit_msg_ai.cli.logging.warning'))
+            stack.enter_context(patch.dict('os.environ', {LOG_LEVEL_ENV_VAR: 'BANANA'}))
+            self._run_main_rejecting()
+
+        mock_basic_config.assert_called_once_with(level=logging.WARNING, format='%(levelname)s:%(name)s:%(message)s', stream=sys.stderr)
+        assert 'BANANA' in str(mock_log_warning.call_args)
+
+    def test_logs_to_stderr(self) -> None:
+        with ExitStack() as stack:
+            mock_basic_config = stack.enter_context(patch('git_commit_msg_ai.cli.logging.basicConfig'))
+            stack.enter_context(patch.dict('os.environ', {}, clear=True))
+            self._run_main_rejecting()
+
+        _, kwargs = mock_basic_config.call_args
+        assert kwargs['stream'] is sys.stderr
+
+    def test_uses_expected_log_format(self) -> None:
+        with ExitStack() as stack:
+            mock_basic_config = stack.enter_context(patch('git_commit_msg_ai.cli.logging.basicConfig'))
+            stack.enter_context(patch.dict('os.environ', {}, clear=True))
+            self._run_main_rejecting()
+
+        _, kwargs = mock_basic_config.call_args
+        assert kwargs['format'] == '%(levelname)s:%(name)s:%(message)s'

git_commit_msg_ai-1.5.0/tests/test_editor.py

@@ -0,0 +1,245 @@
+import logging
+import os
+import subprocess
+import tempfile
+from contextlib import ExitStack
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from git_commit_msg_ai.editor import get_default_editor, open_in_editor
+from git_commit_msg_ai.exceptions import EditorError
+
+TEMP_FILE_PATH = os.path.join(tempfile.gettempdir(), 'tmpfile.txt')
+INITIAL_TEXT = 'initial text'
+EDITED_TEXT_WITH_WHITESPACE = '  edited text  '
+EDITED_TEXT = 'edited text'
+GENERIC_TEXT = 'text'
+VIM_EDITOR = 'vim'
+
+
+def _make_named_temporary_file_mock() -> MagicMock:
+    mock_temp_file = MagicMock()
+    mock_temp_file.name = TEMP_FILE_PATH
+    mock_temp_file.__enter__ = MagicMock(return_value=mock_temp_file)
+    mock_temp_file.__exit__ = MagicMock(return_value=False)
+
+    return mock_temp_file
+
+
+def _make_open_mock(text: str) -> MagicMock:
+    mock_file = MagicMock()
+    mock_file.read.return_value = text
+    mock_file.__enter__ = MagicMock(return_value=mock_file)
+    mock_file.__exit__ = MagicMock(return_value=False)
+
+    return mock_file
+
+
+class TestOpenInEditor:
+    def test_returns_stripped_edited_text(self) -> None:
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+            stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+            stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(EDITED_TEXT_WITH_WHITESPACE)))
+            stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+
+            result = open_in_editor(INITIAL_TEXT)
+
+        assert result == EDITED_TEXT
+
+    def test_uses_editor_env_var(self) -> None:
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+            mock_run = stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+            stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(GENERIC_TEXT)))
+            stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+            stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
+
+            open_in_editor(INITIAL_TEXT)
+
+        mock_run.assert_called_once_with([VIM_EDITOR, TEMP_FILE_PATH], check=True)
+
+    def test_falls_back_to_platform_default_when_editor_not_set(self) -> None:
+        sentinel_editor = 'test-sentinel-editor'
+
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+            mock_run = stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+            stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(GENERIC_TEXT)))
+            stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+            stack.enter_context(patch('git_commit_msg_ai.editor.get_default_editor', return_value=sentinel_editor))
+            stack.enter_context(patch.dict('os.environ', {}, clear=True))
+
+            open_in_editor(INITIAL_TEXT)
+
+        mock_run.assert_called_once_with([sentinel_editor, TEMP_FILE_PATH], check=True)
+
+    def test_raises_editor_error_on_temp_file_creation_failure(self) -> None:
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', side_effect=OSError))
+            mock_unlink = stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+
+            with pytest.raises(EditorError, match='temporary file'):
+                open_in_editor(INITIAL_TEXT)
+
+        mock_unlink.assert_not_called()
+
+    def test_raises_editor_error_when_editor_not_found(self) -> None:
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+            stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run', side_effect=FileNotFoundError))
+            mock_unlink = stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+            stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
+
+            with pytest.raises(EditorError, match='was not found'):
+                open_in_editor(INITIAL_TEXT)
+
+        mock_unlink.assert_called_once_with(TEMP_FILE_PATH)
+
+    def test_raises_editor_error_when_editor_exits_with_error(self) -> None:
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+            stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run', side_effect=subprocess.CalledProcessError(1, VIM_EDITOR)))
+            mock_unlink = stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+            stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
+
+            with pytest.raises(EditorError, match='exited with an error'):
+                open_in_editor(INITIAL_TEXT)
+
+        mock_unlink.assert_called_once_with(TEMP_FILE_PATH)
+
+    def test_raises_editor_error_when_file_read_fails(self) -> None:
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+            stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+            stack.enter_context(patch('git_commit_msg_ai.editor.open', side_effect=OSError))
+            mock_unlink = stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+
+            with pytest.raises(EditorError, match='Could not read'):
+                open_in_editor(INITIAL_TEXT)
+
+        mock_unlink.assert_called_once_with(TEMP_FILE_PATH)
+
+    def test_logs_debug_temp_file_path(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.DEBUG, logger='git_commit_msg_ai.editor'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+                stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(EDITED_TEXT)))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+                open_in_editor(INITIAL_TEXT)
+
+        assert any(TEMP_FILE_PATH in r.message for r in caplog.records)
+
+    def test_logs_debug_selected_editor(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.DEBUG, logger='git_commit_msg_ai.editor'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+                stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(EDITED_TEXT)))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
+                open_in_editor(INITIAL_TEXT)
+
+        assert any(VIM_EDITOR in r.message for r in caplog.records)
+
+    def test_logs_debug_opening_editor(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.DEBUG, logger='git_commit_msg_ai.editor'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+                stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(EDITED_TEXT)))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
+                open_in_editor(INITIAL_TEXT)
+
+        assert any(VIM_EDITOR in r.message and TEMP_FILE_PATH in r.message for r in caplog.records)
+
+    def test_logs_debug_editor_closed(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.DEBUG, logger='git_commit_msg_ai.editor'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+                stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(EDITED_TEXT)))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+                open_in_editor(INITIAL_TEXT)
+
+        assert any('Editor closed' in r.message for r in caplog.records)
+
+    def test_logs_debug_edited_text_length(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.DEBUG, logger='git_commit_msg_ai.editor'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+                stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(EDITED_TEXT)))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+                open_in_editor(INITIAL_TEXT)
+
+        assert any(str(len(EDITED_TEXT)) in r.message for r in caplog.records)
+
+    def test_logs_error_on_temp_file_create_failure(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.editor'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', side_effect=OSError))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+
+                with pytest.raises(EditorError):
+                    open_in_editor(INITIAL_TEXT)
+
+        assert any(r.levelno == logging.ERROR for r in caplog.records)
+
+    def test_logs_error_when_editor_not_found(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.editor'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+                stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run', side_effect=FileNotFoundError))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
+
+                with pytest.raises(EditorError):
+                    open_in_editor(INITIAL_TEXT)
+
+        assert any(r.levelno == logging.ERROR and VIM_EDITOR in r.message for r in caplog.records)
+
+    def test_logs_error_when_editor_exits_with_error(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.editor'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+                stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run', side_effect=subprocess.CalledProcessError(1, VIM_EDITOR)))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
+
+                with pytest.raises(EditorError):
+                    open_in_editor(INITIAL_TEXT)
+
+        assert any(r.levelno == logging.ERROR and VIM_EDITOR in r.message for r in caplog.records)
+
+    def test_logs_error_when_temp_file_read_fails(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.editor'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
+                stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
+                stack.enter_context(patch('git_commit_msg_ai.editor.open', side_effect=OSError))
+                stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
+
+                with pytest.raises(EditorError):
+                    open_in_editor(INITIAL_TEXT)
+
+        assert any(r.levelno == logging.ERROR and TEMP_FILE_PATH in r.message for r in caplog.records)
+
+
+class TestGetDefaultEditor:
+    def test_returns_notepad_on_windows(self) -> None:
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.editor.platform.system', return_value='Windows'))
+            result = get_default_editor()
+
+        assert result == 'notepad'
+
+    def test_returns_vi_on_non_windows(self) -> None:
+        with ExitStack() as stack:
+            stack.enter_context(patch('git_commit_msg_ai.editor.platform.system', return_value='Linux'))
+            result = get_default_editor()
+
+        assert result == 'vi'

git_commit_msg_ai-1.5.0/tests/test_git_ops.py

@@ -0,0 +1,189 @@
+import logging
+import subprocess
+from contextlib import ExitStack
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from git_commit_msg_ai.exceptions import GitError
+from git_commit_msg_ai.git_ops import CACHED_FLAG, COMMIT_SUBCOMMAND, DIFF_SUBCOMMAND, GIT_COMMAND, MESSAGE_FLAG, commit, get_staged_diff
+
+COMMIT_MESSAGE = 'my message'
+
+
+class TestGetStagedDiff:
+    def test_returns_decoded_diff(self) -> None:
+        with ExitStack() as stack:
+            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+            mock_check_output.return_value = b'diff content'
+
+            result = get_staged_diff()
+
+        assert result == 'diff content'
+
+    def test_raises_git_error_when_git_not_found(self) -> None:
+        with ExitStack() as stack:
+            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+            mock_check_output.side_effect = FileNotFoundError
+
+            with pytest.raises(GitError, match='not installed'):
+                get_staged_diff()
+
+    def test_raises_git_error_on_called_process_error(self) -> None:
+        with ExitStack() as stack:
+            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+            mock_check_output.side_effect = subprocess.CalledProcessError(1, 'git')
+
+            with pytest.raises(GitError, match='git repository'):
+                get_staged_diff()
+
+    def test_raises_git_error_on_unicode_decode_error(self) -> None:
+        mock_bytes = MagicMock()
+        mock_bytes.decode.side_effect = UnicodeDecodeError('utf-8', b'', 0, 1, 'reason')
+
+        with ExitStack() as stack:
+            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+            mock_check_output.return_value = mock_bytes
+
+            with pytest.raises(GitError, match='UTF-8'):
+                get_staged_diff()
+
+    def test_raises_git_error_when_diff_is_empty(self) -> None:
+        with ExitStack() as stack:
+            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+            mock_check_output.return_value = b''
+
+            with pytest.raises(GitError, match='No staged changes'):
+                get_staged_diff()
+
+    def test_logs_debug_before_running_diff(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.DEBUG, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+                mock_check_output.return_value = b'diff content'
+                get_staged_diff()
+
+        messages = [r.message for r in caplog.records]
+        assert any(GIT_COMMAND in m and DIFF_SUBCOMMAND in m and CACHED_FLAG in m for m in messages)
+
+    def test_logs_debug_diff_size(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.DEBUG, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+                mock_check_output.return_value = b'diff content'
+                get_staged_diff()
+
+        messages = [r.message for r in caplog.records]
+        assert any('12' in m for m in messages)
+
+    def test_logs_warning_when_no_staged_changes(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.WARNING, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+                mock_check_output.return_value = b''
+
+                with pytest.raises(GitError):
+                    get_staged_diff()
+
+        assert any(r.levelno == logging.WARNING and 'No staged changes' in r.message for r in caplog.records)
+
+    def test_logs_error_when_git_not_found_in_diff(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+                mock_check_output.side_effect = FileNotFoundError
+
+                with pytest.raises(GitError):
+                    get_staged_diff()
+
+        assert any(r.levelno == logging.ERROR for r in caplog.records)
+
+    def test_logs_error_on_diff_called_process_error(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+                mock_check_output.side_effect = subprocess.CalledProcessError(1, 'git')
+
+                with pytest.raises(GitError):
+                    get_staged_diff()
+
+        assert any(r.levelno == logging.ERROR for r in caplog.records)
+
+    def test_logs_error_on_diff_unicode_decode_error(self, caplog: pytest.LogCaptureFixture) -> None:
+        mock_bytes = MagicMock()
+        mock_bytes.decode.side_effect = UnicodeDecodeError('utf-8', b'', 0, 1, 'reason')
+
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
+                mock_check_output.return_value = mock_bytes
+
+                with pytest.raises(GitError):
+                    get_staged_diff()
+
+        assert any(r.levelno == logging.ERROR for r in caplog.records)
+
+
+class TestCommit:
+    def test_calls_subprocess_run_with_correct_args(self) -> None:
+        with ExitStack() as stack:
+            mock_run = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
+            commit(COMMIT_MESSAGE)
+
+        mock_run.assert_called_once_with([GIT_COMMAND, COMMIT_SUBCOMMAND, MESSAGE_FLAG, COMMIT_MESSAGE], check=True)
+
+    def test_raises_git_error_when_git_not_found(self) -> None:
+        with ExitStack() as stack:
+            mock_run = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
+            mock_run.side_effect = FileNotFoundError
+
+            with pytest.raises(GitError, match='not installed'):
+                commit(COMMIT_MESSAGE)
+
+    def test_raises_git_error_on_called_process_error(self) -> None:
+        with ExitStack() as stack:
+            mock_run = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
+            mock_run.side_effect = subprocess.CalledProcessError(1, GIT_COMMAND)
+
+            with pytest.raises(GitError, match='git commit failed'):
+                commit(COMMIT_MESSAGE)
+
+    def test_logs_debug_before_running_commit(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.DEBUG, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
+                commit(COMMIT_MESSAGE)
+
+        messages = [r.message for r in caplog.records]
+        assert any(GIT_COMMAND in m and COMMIT_SUBCOMMAND in m and MESSAGE_FLAG in m for m in messages)
+        assert not any(COMMIT_MESSAGE in m for m in messages)
+
+    def test_logs_info_after_successful_commit(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.INFO, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
+                commit(COMMIT_MESSAGE)
+
+        assert any(r.levelno == logging.INFO and 'Commit created successfully' in r.message for r in caplog.records)
+
+    def test_logs_error_when_git_not_found_in_commit(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                mock_run = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
+                mock_run.side_effect = FileNotFoundError
+
+                with pytest.raises(GitError):
+                    commit(COMMIT_MESSAGE)
+
+        assert any(r.levelno == logging.ERROR for r in caplog.records)
+
+    def test_logs_error_on_commit_called_process_error(self, caplog: pytest.LogCaptureFixture) -> None:
+        with caplog.at_level(logging.ERROR, logger='git_commit_msg_ai.git_ops'):
+            with ExitStack() as stack:
+                mock_run = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
+                mock_run.side_effect = subprocess.CalledProcessError(1, GIT_COMMAND)
+
+                with pytest.raises(GitError):
+                    commit(COMMIT_MESSAGE)
+
+        assert any(r.levelno == logging.ERROR for r in caplog.records)

git_commit_msg_ai-1.4.2/tests/test_ai_client.py

@@ -1,80 +0,0 @@
-from contextlib import ExitStack
-from unittest.mock import MagicMock, patch
-
-import anthropic
-import pytest
-
-from git_commit_msg_ai.ai_client import generate_commit_message
-from git_commit_msg_ai.exceptions import AIError
-
-
-def _make_api_response(text: str) -> MagicMock:
-    mock_text_block = MagicMock(spec=anthropic.types.TextBlock)
-    mock_text_block.text = text
-
-    mock_response = MagicMock(spec=anthropic.types.Message)
-    mock_response.content = [mock_text_block]
-
-    return mock_response
-
-
-def _make_status_error(exception_class: type[anthropic.APIStatusError], status_code: int) -> anthropic.APIStatusError:
-    mock_response = MagicMock()
-    mock_response.status_code = status_code
-
-    return exception_class('error', response=mock_response, body={})
-
-
-class TestGenerateCommitMessage:
-    def test_returns_stripped_commit_message(self) -> None:
-        with ExitStack() as stack:
-            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
-            mock_client = MagicMock()
-            mock_client.messages.create.return_value = _make_api_response('  feat: add feature  ')
-            mock_anthropic_class.return_value = mock_client
-
-            result = generate_commit_message('diff content')
-
-        assert result == 'feat: add feature'
-
-    def test_raises_ai_error_on_authentication_error(self) -> None:
-        with ExitStack() as stack:
-            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
-            mock_client = MagicMock()
-            mock_client.messages.create.side_effect = _make_status_error(anthropic.AuthenticationError, 401)
-            mock_anthropic_class.return_value = mock_client
-
-            with pytest.raises(AIError, match='ANTHROPIC_API_KEY'):
-                generate_commit_message('diff content')
-
-    def test_raises_ai_error_on_rate_limit_error(self) -> None:
-        with ExitStack() as stack:
-            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
-            mock_client = MagicMock()
-            mock_client.messages.create.side_effect = _make_status_error(anthropic.RateLimitError, 429)
-            mock_anthropic_class.return_value = mock_client
-
-            with pytest.raises(AIError, match='rate limit'):
-                generate_commit_message('diff content')
-
-    def test_raises_ai_error_on_api_connection_error(self) -> None:
-        mock_request = MagicMock()
-
-        with ExitStack() as stack:
-            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
-            mock_client = MagicMock()
-            mock_client.messages.create.side_effect = anthropic.APIConnectionError(request=mock_request)
-            mock_anthropic_class.return_value = mock_client
-
-            with pytest.raises(AIError, match='network'):
-                generate_commit_message('diff content')
-
-    def test_raises_ai_error_on_api_status_error_with_status_code(self) -> None:
-        with ExitStack() as stack:
-            mock_anthropic_class = stack.enter_context(patch('git_commit_msg_ai.ai_client.anthropic.Anthropic'))
-            mock_client = MagicMock()
-            mock_client.messages.create.side_effect = _make_status_error(anthropic.APIStatusError, 500)
-            mock_anthropic_class.return_value = mock_client
-
-            with pytest.raises(AIError, match='500'):
-                generate_commit_message('diff content')

git_commit_msg_ai-1.4.2/tests/test_editor.py

@@ -1,137 +0,0 @@
-import os
-import subprocess
-import tempfile
-from contextlib import ExitStack
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from git_commit_msg_ai.editor import get_default_editor, open_in_editor
-from git_commit_msg_ai.exceptions import EditorError
-
-TEMP_FILE_PATH = os.path.join(tempfile.gettempdir(), 'tmpfile.txt')
-INITIAL_TEXT = 'initial text'
-EDITED_TEXT_WITH_WHITESPACE = '  edited text  '
-EDITED_TEXT = 'edited text'
-GENERIC_TEXT = 'text'
-VIM_EDITOR = 'vim'
-
-
-def _make_named_temporary_file_mock() -> MagicMock:
-    mock_temp_file = MagicMock()
-    mock_temp_file.name = TEMP_FILE_PATH
-    mock_temp_file.__enter__ = MagicMock(return_value=mock_temp_file)
-    mock_temp_file.__exit__ = MagicMock(return_value=False)
-
-    return mock_temp_file
-
-
-def _make_open_mock(text: str) -> MagicMock:
-    mock_file = MagicMock()
-    mock_file.read.return_value = text
-    mock_file.__enter__ = MagicMock(return_value=mock_file)
-    mock_file.__exit__ = MagicMock(return_value=False)
-
-    return mock_file
-
-
-class TestOpenInEditor:
-    def test_returns_stripped_edited_text(self) -> None:
-        with ExitStack() as stack:
-            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
-            stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
-            stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(EDITED_TEXT_WITH_WHITESPACE)))
-            stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
-
-            result = open_in_editor(INITIAL_TEXT)
-
-        assert result == EDITED_TEXT
-
-    def test_uses_editor_env_var(self) -> None:
-        with ExitStack() as stack:
-            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
-            mock_run = stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
-            stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(GENERIC_TEXT)))
-            stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
-            stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
-
-            open_in_editor(INITIAL_TEXT)
-
-        mock_run.assert_called_once_with([VIM_EDITOR, TEMP_FILE_PATH], check=True)
-
-    def test_falls_back_to_platform_default_when_editor_not_set(self) -> None:
-        sentinel_editor = 'test-sentinel-editor'
-
-        with ExitStack() as stack:
-            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
-            mock_run = stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
-            stack.enter_context(patch('git_commit_msg_ai.editor.open', return_value=_make_open_mock(GENERIC_TEXT)))
-            stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
-            stack.enter_context(patch('git_commit_msg_ai.editor.get_default_editor', return_value=sentinel_editor))
-            stack.enter_context(patch.dict('os.environ', {}, clear=True))
-
-            open_in_editor(INITIAL_TEXT)
-
-        mock_run.assert_called_once_with([sentinel_editor, TEMP_FILE_PATH], check=True)
-
-    def test_raises_editor_error_on_temp_file_creation_failure(self) -> None:
-        with ExitStack() as stack:
-            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', side_effect=OSError))
-            mock_unlink = stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
-
-            with pytest.raises(EditorError, match='temporary file'):
-                open_in_editor(INITIAL_TEXT)
-
-        mock_unlink.assert_not_called()
-
-    def test_raises_editor_error_when_editor_not_found(self) -> None:
-        with ExitStack() as stack:
-            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
-            stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run', side_effect=FileNotFoundError))
-            mock_unlink = stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
-            stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
-
-            with pytest.raises(EditorError, match='was not found'):
-                open_in_editor(INITIAL_TEXT)
-
-        mock_unlink.assert_called_once_with(TEMP_FILE_PATH)
-
-    def test_raises_editor_error_when_editor_exits_with_error(self) -> None:
-        with ExitStack() as stack:
-            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
-            stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run', side_effect=subprocess.CalledProcessError(1, VIM_EDITOR)))
-            mock_unlink = stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
-            stack.enter_context(patch('git_commit_msg_ai.editor.os.environ.get', return_value=VIM_EDITOR))
-
-            with pytest.raises(EditorError, match='exited with an error'):
-                open_in_editor(INITIAL_TEXT)
-
-        mock_unlink.assert_called_once_with(TEMP_FILE_PATH)
-
-    def test_raises_editor_error_when_file_read_fails(self) -> None:
-        with ExitStack() as stack:
-            stack.enter_context(patch('git_commit_msg_ai.editor.tempfile.NamedTemporaryFile', return_value=_make_named_temporary_file_mock()))
-            stack.enter_context(patch('git_commit_msg_ai.editor.subprocess.run'))
-            stack.enter_context(patch('git_commit_msg_ai.editor.open', side_effect=OSError))
-            mock_unlink = stack.enter_context(patch('git_commit_msg_ai.editor.os.unlink'))
-
-            with pytest.raises(EditorError, match='Could not read'):
-                open_in_editor(INITIAL_TEXT)
-
-        mock_unlink.assert_called_once_with(TEMP_FILE_PATH)
-
-
-class TestGetDefaultEditor:
-    def test_returns_notepad_on_windows(self) -> None:
-        with ExitStack() as stack:
-            stack.enter_context(patch('git_commit_msg_ai.editor.platform.system', return_value='Windows'))
-            result = get_default_editor()
-
-        assert result == 'notepad'
-
-    def test_returns_vi_on_non_windows(self) -> None:
-        with ExitStack() as stack:
-            stack.enter_context(patch('git_commit_msg_ai.editor.platform.system', return_value='Linux'))
-            result = get_default_editor()
-
-        assert result == 'vi'

git_commit_msg_ai-1.4.2/tests/test_git_ops.py

@@ -1,81 +0,0 @@
-import subprocess
-from contextlib import ExitStack
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from git_commit_msg_ai.exceptions import GitError
-from git_commit_msg_ai.git_ops import COMMIT_SUBCOMMAND, GIT_COMMAND, MESSAGE_FLAG, commit, get_staged_diff
-
-COMMIT_MESSAGE = 'my message'
-
-
-class TestGetStagedDiff:
-    def test_returns_decoded_diff(self) -> None:
-        with ExitStack() as stack:
-            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
-            mock_check_output.return_value = b'diff content'
-
-            result = get_staged_diff()
-
-        assert result == 'diff content'
-
-    def test_raises_git_error_when_git_not_found(self) -> None:
-        with ExitStack() as stack:
-            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
-            mock_check_output.side_effect = FileNotFoundError
-
-            with pytest.raises(GitError, match='not installed'):
-                get_staged_diff()
-
-    def test_raises_git_error_on_called_process_error(self) -> None:
-        with ExitStack() as stack:
-            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
-            mock_check_output.side_effect = subprocess.CalledProcessError(1, 'git')
-
-            with pytest.raises(GitError, match='git repository'):
-                get_staged_diff()
-
-    def test_raises_git_error_on_unicode_decode_error(self) -> None:
-        mock_bytes = MagicMock()
-        mock_bytes.decode.side_effect = UnicodeDecodeError('utf-8', b'', 0, 1, 'reason')
-
-        with ExitStack() as stack:
-            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
-            mock_check_output.return_value = mock_bytes
-
-            with pytest.raises(GitError, match='UTF-8'):
-                get_staged_diff()
-
-    def test_raises_git_error_when_diff_is_empty(self) -> None:
-        with ExitStack() as stack:
-            mock_check_output = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.check_output'))
-            mock_check_output.return_value = b''
-
-            with pytest.raises(GitError, match='No staged changes'):
-                get_staged_diff()
-
-
-class TestCommit:
-    def test_calls_subprocess_run_with_correct_args(self) -> None:
-        with ExitStack() as stack:
-            mock_run = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
-            commit(COMMIT_MESSAGE)
-
-        mock_run.assert_called_once_with([GIT_COMMAND, COMMIT_SUBCOMMAND, MESSAGE_FLAG, COMMIT_MESSAGE], check=True)
-
-    def test_raises_git_error_when_git_not_found(self) -> None:
-        with ExitStack() as stack:
-            mock_run = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
-            mock_run.side_effect = FileNotFoundError
-
-            with pytest.raises(GitError, match='not installed'):
-                commit(COMMIT_MESSAGE)
-
-    def test_raises_git_error_on_called_process_error(self) -> None:
-        with ExitStack() as stack:
-            mock_run = stack.enter_context(patch('git_commit_msg_ai.git_ops.subprocess.run'))
-            mock_run.side_effect = subprocess.CalledProcessError(1, GIT_COMMAND)
-
-            with pytest.raises(GitError, match='git commit failed'):
-                commit(COMMIT_MESSAGE)