179 lines
6.6 KiB
Python
179 lines
6.6 KiB
Python
"""Tests for the parser module."""
|
|
|
|
import pytest
|
|
from cli_explain_fix.parser import ErrorParser, ParsedError
|
|
|
|
|
|
class TestErrorParser:
|
|
"""Test cases for ErrorParser."""
|
|
|
|
def setup_method(self):
|
|
"""Set up parser instance for each test."""
|
|
self.parser = ErrorParser()
|
|
|
|
def test_detect_language_python_traceback(self, sample_python_traceback):
|
|
"""Test language detection for Python traceback."""
|
|
lang = self.parser.detect_language(sample_python_traceback)
|
|
assert lang == "python"
|
|
|
|
def test_detect_language_python_simple(self, sample_python_simple_error):
|
|
"""Test language detection for simple Python error."""
|
|
lang = self.parser.detect_language(sample_python_simple_error)
|
|
assert lang == "python"
|
|
|
|
def test_detect_language_javascript(self, sample_js_error):
|
|
"""Test language detection for JavaScript error."""
|
|
lang = self.parser.detect_language(sample_js_error)
|
|
assert lang == "javascript"
|
|
|
|
def test_detect_language_go(self, sample_go_panic):
|
|
"""Test language detection for Go panic."""
|
|
lang = self.parser.detect_language(sample_go_panic)
|
|
assert lang == "go"
|
|
|
|
def test_detect_language_rust(self, sample_rust_panic):
|
|
"""Test language detection for Rust panic."""
|
|
lang = self.parser.detect_language(sample_rust_panic)
|
|
assert lang == "rust"
|
|
|
|
def test_detect_language_json(self, sample_json_error):
|
|
"""Test language detection for JSON error."""
|
|
lang = self.parser.detect_language(sample_json_error)
|
|
assert lang == "json"
|
|
|
|
def test_detect_language_yaml(self, sample_yaml_error):
|
|
"""Test language detection for YAML error."""
|
|
lang = self.parser.detect_language(sample_yaml_error)
|
|
assert lang == "yaml"
|
|
|
|
def test_detect_language_cli(self, sample_cli_error):
|
|
"""Test language detection for CLI error."""
|
|
lang = self.parser.detect_language(sample_cli_error)
|
|
assert lang == "cli"
|
|
|
|
def test_detect_language_unknown(self, sample_unknown_error):
|
|
"""Test language detection for unknown error."""
|
|
lang = self.parser.detect_language(sample_unknown_error)
|
|
assert lang == "unknown"
|
|
|
|
def test_parse_python_traceback(self, sample_python_traceback):
|
|
"""Test parsing Python traceback."""
|
|
result = self.parser.parse(sample_python_traceback)
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "ModuleNotFoundError"
|
|
assert result.language == "python"
|
|
assert "requests" in result.message
|
|
assert result.file_name == "/app/main.py"
|
|
assert result.line_number == 10
|
|
assert len(result.stack_frames) > 0
|
|
|
|
def test_parse_python_simple(self, sample_python_simple_error):
|
|
"""Test parsing simple Python error."""
|
|
result = self.parser.parse(sample_python_simple_error)
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "ValueError"
|
|
assert result.language == "python"
|
|
assert "invalid value" in result.message
|
|
|
|
def test_parse_javascript_error(self, sample_js_error):
|
|
"""Test parsing JavaScript error."""
|
|
result = self.parser.parse(sample_js_error)
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "TypeError"
|
|
assert result.language == "javascript"
|
|
|
|
def test_parse_go_panic(self, sample_go_panic):
|
|
"""Test parsing Go panic."""
|
|
result = self.parser.parse(sample_go_panic)
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "panic"
|
|
assert result.language == "go"
|
|
|
|
def test_parse_rust_panic(self, sample_rust_panic):
|
|
"""Test parsing Rust panic."""
|
|
result = self.parser.parse(sample_rust_panic)
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "panic"
|
|
assert result.language == "rust"
|
|
|
|
def test_parse_json_error(self, sample_json_error):n """Test parsing JSON error."""
|
|
result = self.parser.parse(sample_json_error)
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "JSONParseError"
|
|
assert result.language == "json"
|
|
|
|
def test_parse_yaml_error(self, sample_yaml_error):
|
|
"""Test parsing YAML error."""
|
|
result = self.parser.parse(sample_yaml_error)
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "YAMLParseError"
|
|
assert result.language == "yaml"
|
|
|
|
def test_parse_cli_error(self, sample_cli_error):
|
|
"""Test parsing CLI error."""
|
|
result = self.parser.parse(sample_cli_error)
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "GenericError"
|
|
assert result.language == "cli"
|
|
|
|
def test_parse_with_explicit_language(self, sample_python_simple_error):
|
|
"""Test parsing with explicit language specification."""
|
|
result = self.parser.parse(sample_python_simple_error, language="python")
|
|
|
|
assert result.language == "python"
|
|
assert result.error_type == "ValueError"
|
|
|
|
def test_parse_unknown_error(self, sample_unknown_error):
|
|
"""Test parsing unknown error returns default."""
|
|
result = self.parser.parse(sample_unknown_error)
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "UnknownError"
|
|
assert result.language == "unknown"
|
|
|
|
def test_parse_empty_input(self):
|
|
"""Test parsing empty input."""
|
|
result = self.parser.parse("")
|
|
|
|
assert isinstance(result, ParsedError)
|
|
assert result.error_type == "UnknownError"
|
|
assert result.message == "Unknown error occurred"
|
|
|
|
def test_parsed_error_to_dict(self, sample_python_simple_error):
|
|
"""Test ParsedError.to_dict() method."""
|
|
result = self.parser.parse(sample_python_simple_error)
|
|
data = result.to_dict()
|
|
|
|
assert isinstance(data, dict)
|
|
assert "error_type" in data
|
|
assert "message" in data
|
|
assert "language" in data
|
|
assert "stack_frames" in data
|
|
|
|
def test_parse_complex_python_traceback(self):
|
|
"""Test parsing complex Python traceback with multiple frames."""
|
|
traceback = '''Traceback (most recent call last):
|
|
File "app.py", line 5, in <module>
|
|
main()
|
|
File "app.py", line 10, in main
|
|
process()
|
|
File "processor.py", line 20, in process
|
|
result = data['key']
|
|
KeyError: 'key'
|
|
'''
|
|
result = self.parser.parse(traceback)
|
|
|
|
assert result.error_type == "KeyError"
|
|
assert result.language == "python"
|
|
assert result.file_name == "processor.py"
|
|
assert result.line_number == 20
|
|
assert len(result.stack_frames) == 3
|