Add more unit tests to increase the coverage of the CLI module

tests/unit/test_cli.py

@@ -1,9 +1,10 @@
 """
 Unit tests for the cli module.
 """
-from unittest.mock import patch, MagicMock
+import argparse
 import sys
 from pathlib import Path
+from unittest.mock import patch, MagicMock
 
 import pytest
 
@@ -11,6 +12,9 @@ from slidedeckai.cli import (
     group_models_by_provider,
     format_models_as_bullets,
     CustomArgumentParser,
+    CustomHelpFormatter,
+    format_models_list,
+    format_model_help,
     main
 )
 from slidedeckai.global_config import GlobalConfig
@@ -31,6 +35,12 @@ def test_group_models_by_provider():
     assert 'az' in result
     assert len(result['gg']) == 2
 
+    # Test with empty list
+    assert group_models_by_provider([]) == {}
+
+    # Test with invalid format
+    assert len(group_models_by_provider(['invalid-model'])) == 0
+
 
 def test_format_models_as_bullets():
     test_models = [
@@ -47,51 +57,238 @@ def test_format_models_as_bullets():
     assert 'deepseek' in result
     assert '• [gg]gemini-2.0-flash-lite' in result
 
+    # Test with empty list
+    assert format_models_as_bullets([]) == ''
 
-def test_argument_parser_model_validation():
-    parser = CustomArgumentParser()
-    parser.add_argument(
-        '--model',
+    # Test with single model
+    single_result = format_models_as_bullets(['[az]model1'])
+    assert '\naz:' in single_result
+    assert '• [az]model1' in single_result
+
+
+def test_custom_help_formatter_comprehensive():
+    formatter = CustomHelpFormatter('prog')
+
+    # Test _format_action_invocation for model argument
+    action = argparse.Action(
+        option_strings=['--model'],
+        dest='model',
+        nargs=None,
         choices=GlobalConfig.VALID_MODELS.keys()
     )
+    result = formatter._format_action_invocation(action)
+    assert result == '--model MODEL'
+
+    # Test non-model argument
+    other_action = argparse.Action(
+        option_strings=['--topic'],
+        dest='topic',
+        nargs=None
+    )
+    other_result = formatter._format_action_invocation(other_action)
+    assert 'MODEL' not in other_result
+
+    # Test _split_lines for model choices
+    text = 'Model choices:\n[az]model1\n[gg]model2'
+    result = formatter._split_lines(text, 80)
+    assert 'Available models:' in result
+    assert '------------------------' in result
+    assert any('az:' in line for line in result)
 
-    # Test valid model
-    valid_model = next(iter(GlobalConfig.VALID_MODELS.keys()))
-    args = parser.parse_args(['--model', valid_model])
-    assert args.model == valid_model
+    # Test _split_lines for 'choose from' format
+    choose_text = "choose from '[az]model1', '[gg]model2'"
+    choose_result = formatter._split_lines(choose_text, 80)
+    assert 'Available models:' in choose_result
+    assert any('az:' in line for line in choose_result)
 
-    # Test invalid model
+    # Test _split_lines for regular text
+    regular_text = 'This is a regular text'
+    regular_result = formatter._split_lines(regular_text, 80)
+    assert regular_text in regular_result
+
+
+def test_custom_argument_parser_error_handling():
+    parser = CustomArgumentParser()
+    parser.add_argument('--model', choices=['[az]model1', '[gg]model2'])
+
+    # Test invalid model error
+    with pytest.raises(SystemExit) as exc_info:
+        with patch('sys.stderr'):  # Suppress stderr output
+            parser.parse_args(['--model', 'invalid-model'])
+    assert exc_info.value.code == 2
+
+    # Test non-model argument error
+    parser.add_argument('--topic', required=True)
     with pytest.raises(SystemExit):
-        parser.parse_args(['--model', 'invalid-model'])
+        with patch('sys.stderr'):  # Suppress stderr output
+            parser.parse_args(['--model', '[az]model1'])  # Missing required --topic
+
+    # Test with no arguments
+    with pytest.raises(SystemExit):
+        with patch('sys.stderr'):
+            parser.parse_args([])
+
+
+def test_format_models_list():
+    result = format_models_list()
+    assert 'Supported SlideDeck AI models:' in result
+    # Verify that at least one model from each provider is present
+    for provider_code in ['az', 'gg']:  # Add more providers as needed
+        assert any(f'[{provider_code}]' in line for line in result.split('\n'))
+
+    # Verify structure
+    lines = result.split('\n')
+    assert len(lines) > 2  # Should have header and at least one model
+    assert lines[0] == 'Supported SlideDeck AI models:'
+
+
+def test_format_model_help():
+    result = format_model_help()
+    # Should have provider sections
+    assert any('az:' in line for line in result.split('\n'))
+    # Should contain actual model names
+    assert any('[az]' in line for line in result.split('\n'))
+
+    # Verify it uses the same format as format_models_as_bullets
+    assert result == format_models_as_bullets(list(GlobalConfig.VALID_MODELS.keys()))
+
+
+def test_main_no_args():
+    # Test behavior when no arguments are provided
+    with patch.object(sys, 'argv', ['slidedeckai']):
+        with patch('argparse.ArgumentParser.print_help') as mock_print_help:
+            main()
+            mock_print_help.assert_called_once()
+
+    # Test with empty args list by providing minimal argv
+    with patch.object(sys, 'argv', ['script.py']):
+        with patch('argparse.ArgumentParser.print_help') as mock_print_help:
+            main()
+            mock_print_help.assert_called_once()
+
+
+def test_main_list_models():
+    # Test --list-models flag
+    with patch.object(sys, 'argv', ['script.py', '--list-models']):
+        with patch('builtins.print') as mock_print:
+            main()
+            mock_print.assert_called_once()
+            output = mock_print.call_args[0][0]
+            assert 'Supported SlideDeck AI models:' in output
 
 
 @patch('slidedeckai.cli.SlideDeckAI')
-def test_main_generate_command(mock_slidedeckai):
+@patch('shutil.move')
+def test_main_generate_command(mock_move, mock_slidedeckai):
     # Mock the SlideDeckAI instance
     mock_instance = MagicMock()
-    mock_instance.generate.return_value = Path("test_presentation.pptx")
+    mock_instance.generate.return_value = Path('test_presentation.pptx')
     mock_slidedeckai.return_value = mock_instance
 
     # Test generate command
     test_args = [
+        'script.py',
         'generate',
         '--model', next(iter(GlobalConfig.VALID_MODELS.keys())),
         '--topic', 'Test Topic'
     ]
 
-    with patch.object(sys, 'argv', ['slidedeckai'] + test_args):
+    with patch.object(sys, 'argv', test_args):
         main()
 
     # Verify SlideDeckAI was called with correct parameters
     mock_slidedeckai.assert_called_once()
     mock_instance.generate.assert_called_once()
+    mock_move.assert_not_called()  # No output path specified, no move needed
 
 
-def test_main_list_models():
-    # Test --list-models flag
-    with patch.object(sys, 'argv', ['slidedeckai', '--list-models']):
-        with patch('builtins.print') as mock_print:
-            main()
-            mock_print.assert_called_once()
-            output = mock_print.call_args[0][0]
-            assert "Supported SlideDeck AI models:" in output
+@patch('slidedeckai.cli.SlideDeckAI')
+@patch('shutil.move')
+def test_main_generate_with_all_options(mock_move, mock_slidedeckai):
+    # Mock the SlideDeckAI instance
+    mock_instance = MagicMock()
+    output_path = Path('test_presentation.pptx')
+    mock_instance.generate.return_value = output_path
+    mock_slidedeckai.return_value = mock_instance
+
+    test_args = [
+        'script.py',
+        'generate',
+        '--model', next(iter(GlobalConfig.VALID_MODELS.keys())),
+        '--topic', 'Test Topic',
+        '--api-key', 'test-key',
+        '--template-id', '1',
+        '--output-path', 'output.pptx'
+    ]
+
+    with patch.object(sys, 'argv', test_args):
+        main()
+
+    # Verify SlideDeckAI was called with correct parameters
+    mock_slidedeckai.assert_called_once_with(
+        model=next(iter(GlobalConfig.VALID_MODELS.keys())),
+        topic='Test Topic',
+        api_key='test-key',
+        template_idx=1
+    )
+    mock_instance.generate.assert_called_once_with()
+
+    # Verify file was moved to specified output path
+    mock_move.assert_called_once_with(str(output_path), 'output.pptx')
+
+
+@patch('slidedeckai.cli.SlideDeckAI')
+def test_main_generate_missing_required_args(mock_slidedeckai):
+    # Test generate command without required arguments
+    test_args = ['script.py', 'generate']
+
+    with pytest.raises(SystemExit):
+        with patch.object(sys, 'argv', test_args):
+            with patch('sys.stderr'):  # Suppress stderr output
+                main()
+
+    # Verify SlideDeckAI was not called
+    mock_slidedeckai.assert_not_called()
+
+    # Test with only --model
+    test_args = ['script.py', 'generate', '--model', next(iter(GlobalConfig.VALID_MODELS.keys()))]
+    with pytest.raises(SystemExit):
+        with patch.object(sys, 'argv', test_args):
+            with patch('sys.stderr'):
+                main()
+
+    # Test with only --topic
+    test_args = ['script.py', 'generate', '--topic', 'Test Topic']
+    with pytest.raises(SystemExit):
+        with patch.object(sys, 'argv', test_args):
+            with patch('sys.stderr'):
+                main()
+
+
+@patch('slidedeckai.cli.SlideDeckAI')
+def test_main_generate_invalid_template_id(mock_slidedeckai):
+    # Mock the SlideDeckAI instance
+    mock_instance = MagicMock()
+    mock_slidedeckai.return_value = mock_instance
+    mock_instance.generate.return_value = Path('test_presentation.pptx')
+
+    # Test generate command with invalid template_id
+    test_args = [
+        'script.py',
+        'generate',
+        '--model', next(iter(GlobalConfig.VALID_MODELS.keys())),
+        '--topic', 'Test Topic',
+        '--template-id', '-1'  # Invalid template ID
+    ]
+
+    with patch.object(sys, 'argv', test_args):
+        main()  # Should still work, as validation is handled by SlideDeckAI
+
+    # Verify SlideDeckAI was called with the invalid template_id
+    mock_slidedeckai.assert_called_once_with(
+        model=next(iter(GlobalConfig.VALID_MODELS.keys())),
+        topic='Test Topic',
+        api_key=None,
+        template_idx=-1
+    )
+    mock_instance.generate.assert_called_once_with()