264 lines
10 KiB
Python
264 lines
10 KiB
Python
#!/usr/bin/env python3
|
|
"""Tests for analyze subcommand integration in main CLI."""
|
|
|
|
import sys
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
|
|
|
|
from skill_seekers.cli.main import create_parser
|
|
|
|
|
|
class TestAnalyzeSubcommand(unittest.TestCase):
|
|
"""Test analyze subcommand registration and argument parsing."""
|
|
|
|
def setUp(self):
|
|
"""Create parser for testing."""
|
|
self.parser = create_parser()
|
|
|
|
def test_analyze_subcommand_exists(self):
|
|
"""Test that analyze subcommand is registered."""
|
|
args = self.parser.parse_args(["analyze", "--directory", "."])
|
|
self.assertEqual(args.command, "analyze")
|
|
self.assertEqual(args.directory, ".")
|
|
|
|
def test_analyze_with_output_directory(self):
|
|
"""Test analyze with custom output directory."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--output", "custom/"])
|
|
self.assertEqual(args.output, "custom/")
|
|
|
|
def test_quick_preset_flag(self):
|
|
"""Test --quick preset flag parsing."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--quick"])
|
|
self.assertTrue(args.quick)
|
|
self.assertFalse(args.comprehensive)
|
|
|
|
def test_comprehensive_preset_flag(self):
|
|
"""Test --comprehensive preset flag parsing."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--comprehensive"])
|
|
self.assertTrue(args.comprehensive)
|
|
self.assertFalse(args.quick)
|
|
|
|
def test_quick_and_comprehensive_mutually_exclusive(self):
|
|
"""Test that both flags can be parsed (mutual exclusion enforced at runtime)."""
|
|
# The parser allows both flags; runtime logic prevents simultaneous use
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--quick", "--comprehensive"])
|
|
self.assertTrue(args.quick)
|
|
self.assertTrue(args.comprehensive)
|
|
# Note: Runtime will catch this and return error code 1
|
|
|
|
def test_enhance_level_flag(self):
|
|
"""Test --enhance-level flag parsing."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--enhance-level", "2"])
|
|
self.assertEqual(args.enhance_level, 2)
|
|
|
|
def test_skip_flags_passed_through(self):
|
|
"""Test that skip flags are recognized."""
|
|
args = self.parser.parse_args(
|
|
["analyze", "--directory", ".", "--skip-patterns", "--skip-test-examples"]
|
|
)
|
|
self.assertTrue(args.skip_patterns)
|
|
self.assertTrue(args.skip_test_examples)
|
|
|
|
def test_all_skip_flags(self):
|
|
"""Test all skip flags are properly parsed."""
|
|
args = self.parser.parse_args(
|
|
[
|
|
"analyze",
|
|
"--directory",
|
|
".",
|
|
"--skip-api-reference",
|
|
"--skip-dependency-graph",
|
|
"--skip-patterns",
|
|
"--skip-test-examples",
|
|
"--skip-how-to-guides",
|
|
"--skip-config-patterns",
|
|
"--skip-docs",
|
|
]
|
|
)
|
|
self.assertTrue(args.skip_api_reference)
|
|
self.assertTrue(args.skip_dependency_graph)
|
|
self.assertTrue(args.skip_patterns)
|
|
self.assertTrue(args.skip_test_examples)
|
|
self.assertTrue(args.skip_how_to_guides)
|
|
self.assertTrue(args.skip_config_patterns)
|
|
self.assertTrue(args.skip_docs)
|
|
|
|
def test_backward_compatible_depth_flag(self):
|
|
"""Test that deprecated --depth flag still works."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--depth", "full"])
|
|
self.assertEqual(args.depth, "full")
|
|
|
|
def test_depth_flag_choices(self):
|
|
"""Test that depth flag accepts correct values."""
|
|
for depth in ["surface", "deep", "full"]:
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--depth", depth])
|
|
self.assertEqual(args.depth, depth)
|
|
|
|
def test_languages_flag(self):
|
|
"""Test languages flag parsing."""
|
|
args = self.parser.parse_args(
|
|
["analyze", "--directory", ".", "--languages", "Python,JavaScript"]
|
|
)
|
|
self.assertEqual(args.languages, "Python,JavaScript")
|
|
|
|
def test_file_patterns_flag(self):
|
|
"""Test file patterns flag parsing."""
|
|
args = self.parser.parse_args(
|
|
["analyze", "--directory", ".", "--file-patterns", "*.py,src/**/*.js"]
|
|
)
|
|
self.assertEqual(args.file_patterns, "*.py,src/**/*.js")
|
|
|
|
def test_no_comments_flag(self):
|
|
"""Test no-comments flag parsing."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--no-comments"])
|
|
self.assertTrue(args.no_comments)
|
|
|
|
def test_verbose_flag(self):
|
|
"""Test verbose flag parsing."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--verbose"])
|
|
self.assertTrue(args.verbose)
|
|
|
|
def test_complex_command_combination(self):
|
|
"""Test complex command with multiple flags."""
|
|
args = self.parser.parse_args(
|
|
[
|
|
"analyze",
|
|
"--directory",
|
|
"./src",
|
|
"--output",
|
|
"analysis/",
|
|
"--quick",
|
|
"--languages",
|
|
"Python",
|
|
"--skip-patterns",
|
|
"--verbose",
|
|
]
|
|
)
|
|
self.assertEqual(args.directory, "./src")
|
|
self.assertEqual(args.output, "analysis/")
|
|
self.assertTrue(args.quick)
|
|
self.assertEqual(args.languages, "Python")
|
|
self.assertTrue(args.skip_patterns)
|
|
self.assertTrue(args.verbose)
|
|
|
|
def test_directory_is_required(self):
|
|
"""Test that directory argument is required."""
|
|
with self.assertRaises(SystemExit):
|
|
self.parser.parse_args(["analyze"])
|
|
|
|
def test_default_output_directory(self):
|
|
"""Test default output directory value."""
|
|
args = self.parser.parse_args(["analyze", "--directory", "."])
|
|
self.assertEqual(args.output, "output/codebase/")
|
|
|
|
|
|
class TestAnalyzePresetBehavior(unittest.TestCase):
|
|
"""Test preset flag behavior and argument transformation."""
|
|
|
|
def setUp(self):
|
|
"""Create parser for testing."""
|
|
self.parser = create_parser()
|
|
|
|
def test_quick_preset_implies_surface_depth(self):
|
|
"""Test that --quick preset should trigger surface depth."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--quick"])
|
|
self.assertTrue(args.quick)
|
|
# Note: Depth transformation happens in dispatch handler
|
|
|
|
def test_comprehensive_preset_implies_full_depth(self):
|
|
"""Test that --comprehensive preset should trigger full depth."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--comprehensive"])
|
|
self.assertTrue(args.comprehensive)
|
|
# Note: Depth transformation happens in dispatch handler
|
|
|
|
def test_enhance_level_standalone(self):
|
|
"""Test --enhance-level can be used without presets."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--enhance-level", "3"])
|
|
self.assertEqual(args.enhance_level, 3)
|
|
self.assertFalse(args.quick)
|
|
self.assertFalse(args.comprehensive)
|
|
|
|
|
|
class TestAnalyzeWorkflowFlags(unittest.TestCase):
|
|
"""Test workflow and parity flags added to the analyze subcommand."""
|
|
|
|
def setUp(self):
|
|
"""Create parser for testing."""
|
|
self.parser = create_parser()
|
|
|
|
def test_enhance_workflow_accepted_as_list(self):
|
|
"""Test --enhance-workflow is accepted and stored as a list."""
|
|
args = self.parser.parse_args(
|
|
["analyze", "--directory", ".", "--enhance-workflow", "security-focus"]
|
|
)
|
|
self.assertEqual(args.enhance_workflow, ["security-focus"])
|
|
|
|
def test_enhance_workflow_chained_twice(self):
|
|
"""Test --enhance-workflow can be chained to produce a two-item list."""
|
|
args = self.parser.parse_args(
|
|
[
|
|
"analyze",
|
|
"--directory",
|
|
".",
|
|
"--enhance-workflow",
|
|
"security-focus",
|
|
"--enhance-workflow",
|
|
"minimal",
|
|
]
|
|
)
|
|
self.assertEqual(args.enhance_workflow, ["security-focus", "minimal"])
|
|
|
|
def test_enhance_stage_accepted_as_list(self):
|
|
"""Test --enhance-stage is accepted with action=append."""
|
|
args = self.parser.parse_args(
|
|
["analyze", "--directory", ".", "--enhance-stage", "sec:Analyze security"]
|
|
)
|
|
self.assertEqual(args.enhance_stage, ["sec:Analyze security"])
|
|
|
|
def test_var_accepted_as_list(self):
|
|
"""Test --var is accepted with action=append (dest is 'var')."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--var", "focus=performance"])
|
|
self.assertEqual(args.var, ["focus=performance"])
|
|
|
|
def test_workflow_dry_run_flag(self):
|
|
"""Test --workflow-dry-run sets the flag."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--workflow-dry-run"])
|
|
self.assertTrue(args.workflow_dry_run)
|
|
|
|
def test_api_key_stored_correctly(self):
|
|
"""Test --api-key is stored in args."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--api-key", "sk-ant-test"])
|
|
self.assertEqual(args.api_key, "sk-ant-test")
|
|
|
|
def test_dry_run_stored_correctly(self):
|
|
"""Test --dry-run is stored in args."""
|
|
args = self.parser.parse_args(["analyze", "--directory", ".", "--dry-run"])
|
|
self.assertTrue(args.dry_run)
|
|
|
|
def test_workflow_flags_combined(self):
|
|
"""Test workflow flags can be combined with other analyze flags."""
|
|
args = self.parser.parse_args(
|
|
[
|
|
"analyze",
|
|
"--directory",
|
|
".",
|
|
"--enhance-workflow",
|
|
"security-focus",
|
|
"--api-key",
|
|
"sk-ant-test",
|
|
"--dry-run",
|
|
"--enhance-level",
|
|
"1",
|
|
]
|
|
)
|
|
self.assertEqual(args.enhance_workflow, ["security-focus"])
|
|
self.assertEqual(args.api_key, "sk-ant-test")
|
|
self.assertTrue(args.dry_run)
|
|
self.assertEqual(args.enhance_level, 1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|