roma-debug 0.1.0__py3-none-any.whl

tests/test_project_scanner.py

@@ -0,0 +1,275 @@
+"""Tests for the project scanner and error analyzer."""
+
+import os
+import tempfile
+import pytest
+
+from roma_debug.core.models import Language
+from roma_debug.tracing.project_scanner import ProjectScanner, ProjectInfo, ProjectFile
+from roma_debug.tracing.error_analyzer import ErrorAnalyzer, ErrorAnalysis
+
+
+class TestProjectScanner:
+    """Tests for ProjectScanner."""
+
+    def test_scan_python_project(self):
+        """Test scanning a Python project."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a simple Python project
+            os.makedirs(f"{tmpdir}/src")
+
+            with open(f"{tmpdir}/app.py", "w") as f:
+                f.write("""
+from flask import Flask
+app = Flask(__name__)
+
+@app.route('/')
+def index():
+    return 'Hello'
+""")
+
+            with open(f"{tmpdir}/src/utils.py", "w") as f:
+                f.write("""
+def helper():
+    return 42
+""")
+
+            with open(f"{tmpdir}/requirements.txt", "w") as f:
+                f.write("flask\n")
+
+            scanner = ProjectScanner(tmpdir)
+            info = scanner.scan()
+
+            assert info.project_type == "flask"
+            assert info.primary_language == Language.PYTHON
+            assert "flask" in info.frameworks_detected
+            assert len(info.entry_points) >= 1
+            assert any("app.py" in ep.path for ep in info.entry_points)
+            assert len(info.config_files) >= 1
+
+    def test_scan_javascript_project(self):
+        """Test scanning a JavaScript project."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with open(f"{tmpdir}/index.js", "w") as f:
+                f.write("""
+const express = require('express');
+const app = express();
+
+app.get('/', (req, res) => {
+    res.send('Hello');
+});
+""")
+
+            with open(f"{tmpdir}/package.json", "w") as f:
+                f.write('{"name": "test", "dependencies": {"express": "^4.0.0"}}')
+
+            scanner = ProjectScanner(tmpdir)
+            info = scanner.scan()
+
+            assert info.project_type == "express"
+            assert info.primary_language == Language.JAVASCRIPT
+            assert "express" in info.frameworks_detected
+            assert len(info.entry_points) >= 1
+
+    def test_find_relevant_files_http_error(self):
+        """Test finding relevant files from HTTP error."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with open(f"{tmpdir}/app.py", "w") as f:
+                f.write("""
+from flask import Flask
+app = Flask(__name__)
+""")
+
+            with open(f"{tmpdir}/routes.py", "w") as f:
+                f.write("""
+from app import app
+
+@app.route('/api/users')
+def users():
+    return []
+""")
+
+            scanner = ProjectScanner(tmpdir)
+            scanner.scan()
+
+            relevant = scanner.find_relevant_files("Cannot GET /index.html")
+
+            # Should find app.py and routes.py as relevant
+            paths = [f.path for f in relevant]
+            assert any("app" in p for p in paths) or any("route" in p for p in paths)
+
+    def test_project_summary(self):
+        """Test project summary generation."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with open(f"{tmpdir}/main.py", "w") as f:
+                f.write("print('hello')")
+
+            scanner = ProjectScanner(tmpdir)
+            info = scanner.scan()
+
+            summary = info.to_summary()
+            assert "Project Type:" in summary
+            assert "Primary Language:" in summary
+
+    def test_skip_directories(self):
+        """Test that node_modules and similar are skipped."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            os.makedirs(f"{tmpdir}/node_modules/lodash")
+            os.makedirs(f"{tmpdir}/src")
+
+            with open(f"{tmpdir}/src/app.js", "w") as f:
+                f.write("console.log('app');")
+
+            with open(f"{tmpdir}/node_modules/lodash/index.js", "w") as f:
+                f.write("module.exports = {};")
+
+            scanner = ProjectScanner(tmpdir)
+            info = scanner.scan()
+
+            # Should not include node_modules files
+            paths = [f.path for f in info.source_files]
+            assert not any("node_modules" in p for p in paths)
+            assert any("app.js" in p for p in paths)
+
+
+class TestErrorAnalyzer:
+    """Tests for ErrorAnalyzer."""
+
+    def test_analyze_http_404_error(self):
+        """Test analyzing HTTP 404 error."""
+        analyzer = ErrorAnalyzer()
+        analysis = analyzer.analyze("Cannot GET /index.html")
+
+        assert analysis.error_type == "http"
+        assert analysis.error_category == "http_404"
+        assert "/index.html" in analysis.affected_routes
+
+    def test_analyze_python_import_error(self):
+        """Test analyzing Python import error."""
+        analyzer = ErrorAnalyzer()
+        analysis = analyzer.analyze("ModuleNotFoundError: No module named 'flask'")
+
+        assert analysis.error_type == "import"
+        assert analysis.error_category == "python_import"
+        assert analysis.suggested_language == Language.PYTHON
+
+    def test_analyze_javascript_error(self):
+        """Test analyzing JavaScript error."""
+        analyzer = ErrorAnalyzer()
+        # Use a more distinctly JavaScript error message
+        analysis = analyzer.analyze("ReferenceError: myVariable is not defined\n    at Object.<anonymous> (/app/index.js:10:5)")
+
+        assert analysis.error_type == "runtime"
+        assert analysis.error_category == "js_reference"
+        assert analysis.suggested_language == Language.JAVASCRIPT
+
+    def test_analyze_config_error(self):
+        """Test analyzing configuration error."""
+        analyzer = ErrorAnalyzer()
+        analysis = analyzer.analyze("API key not valid. Please check your API key.")
+
+        assert analysis.error_type == "config"
+        assert analysis.error_category == "config"
+
+    def test_extract_routes(self):
+        """Test route extraction from error."""
+        analyzer = ErrorAnalyzer()
+        analysis = analyzer.analyze("Cannot GET /api/users/123")
+
+        assert "/api/users/123" in analysis.affected_routes
+
+    def test_with_project_scanner(self):
+        """Test error analyzer with project scanner."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with open(f"{tmpdir}/server.py", "w") as f:
+                f.write("""
+from flask import Flask, send_from_directory
+app = Flask(__name__, static_folder='static')
+""")
+
+            scanner = ProjectScanner(tmpdir)
+            analyzer = ErrorAnalyzer(scanner)
+
+            analysis = analyzer.analyze("Cannot GET /index.html")
+
+            # Should find server.py as relevant
+            assert len(analysis.relevant_files) > 0
+
+    def test_get_fix_context(self):
+        """Test getting comprehensive fix context."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with open(f"{tmpdir}/app.py", "w") as f:
+                f.write("""
+from flask import Flask
+app = Flask(__name__)
+""")
+
+            scanner = ProjectScanner(tmpdir)
+            analyzer = ErrorAnalyzer(scanner)
+
+            context = analyzer.get_fix_context(
+                "Cannot GET /index.html",
+                include_project_structure=True,
+                include_file_contents=True,
+            )
+
+            assert "ERROR ANALYSIS" in context
+            assert "PROJECT STRUCTURE" in context
+
+    def test_error_confidence(self):
+        """Test error detection confidence."""
+        analyzer = ErrorAnalyzer()
+
+        # High confidence for specific error
+        analysis = analyzer.analyze("ModuleNotFoundError: No module named 'flask'")
+        assert analysis.confidence >= 0.9
+
+        # Lower confidence for vague error
+        analysis = analyzer.analyze("Something went wrong")
+        assert analysis.confidence < 0.5
+
+
+class TestIntegration:
+    """Integration tests for project scanner + error analyzer."""
+
+    def test_flask_static_file_error(self):
+        """Test analyzing Flask static file error with project context."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a Flask project structure
+            os.makedirs(f"{tmpdir}/static")
+            os.makedirs(f"{tmpdir}/templates")
+
+            with open(f"{tmpdir}/app.py", "w") as f:
+                f.write("""
+from flask import Flask, render_template, send_from_directory
+import os
+
+app = Flask(__name__)
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+if __name__ == '__main__':
+    app.run(debug=True)
+""")
+
+            with open(f"{tmpdir}/templates/index.html", "w") as f:
+                f.write("<html><body>Hello</body></html>")
+
+            scanner = ProjectScanner(tmpdir)
+            analyzer = ErrorAnalyzer(scanner)
+
+            # Analyze a static file error
+            analysis = analyzer.analyze("Cannot GET /index.html")
+
+            # Should identify as HTTP error
+            assert analysis.error_type == "http"
+
+            # Should find app.py as relevant
+            relevant_paths = [f.path for f in analysis.relevant_files]
+            assert any("app" in p for p in relevant_paths)
+
+            # Context should include file contents
+            context = analyzer.get_fix_context("Cannot GET /index.html")
+            assert "flask" in context.lower() or "Flask" in context

tests/test_traceback_patterns.py

@@ -0,0 +1,222 @@
+"""Tests for multi-language traceback pattern matching."""
+
+import pytest
+from roma_debug.core.models import Language
+from roma_debug.parsers.traceback_patterns import (
+    detect_traceback_language,
+    parse_traceback,
+    extract_frames,
+    extract_file_line_pairs,
+)
+
+
+class TestLanguageDetection:
+    """Tests for traceback language detection."""
+
+    def test_detect_python_traceback(self):
+        traceback = '''
+Traceback (most recent call last):
+  File "/app/main.py", line 10, in main
+    result = process()
+  File "/app/utils.py", line 25, in process
+    return compute(data)
+ValueError: invalid literal for int()
+'''
+        assert detect_traceback_language(traceback) == Language.PYTHON
+
+    def test_detect_javascript_stacktrace(self):
+        traceback = '''
+Error: Cannot read property 'x' of undefined
+    at processData (/app/src/utils.js:15:23)
+    at main (/app/src/index.js:42:10)
+    at Object.<anonymous> (/app/src/index.js:50:1)
+'''
+        assert detect_traceback_language(traceback) == Language.JAVASCRIPT
+
+    def test_detect_go_panic(self):
+        traceback = '''
+panic: runtime error: invalid memory address or nil pointer dereference
+[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x49c2ef]
+
+goroutine 1 [running]:
+main.processData(0x0, 0x0)
+	/app/main.go:25 +0x1f
+main.main()
+	/app/main.go:15 +0x3a
+'''
+        assert detect_traceback_language(traceback) == Language.GO
+
+    def test_detect_rust_panic(self):
+        traceback = '''
+thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/main.rs:15:10
+stack backtrace:
+   0: std::panicking::begin_panic
+   1: core::option::Option<T>::unwrap
+             at /rustc/xxx/library/core/src/option.rs:777:21
+   2: myapp::process_data
+             at ./src/main.rs:15:10
+'''
+        assert detect_traceback_language(traceback) == Language.RUST
+
+    def test_detect_java_exception(self):
+        traceback = '''
+Exception in thread "main" java.lang.NullPointerException
+	at com.example.MyClass.processData(MyClass.java:25)
+	at com.example.Main.main(Main.java:15)
+Caused by: java.lang.IllegalArgumentException: Invalid input
+	at com.example.Utils.validate(Utils.java:42)
+'''
+        assert detect_traceback_language(traceback) == Language.JAVA
+
+
+class TestPythonTraceback:
+    """Tests for Python traceback parsing."""
+
+    def test_simple_traceback(self):
+        traceback = '''
+Traceback (most recent call last):
+  File "/app/main.py", line 10, in main
+    result = process()
+ValueError: invalid value
+'''
+        result = parse_traceback(traceback)
+
+        assert result.language == Language.PYTHON
+        assert len(result.frames) >= 1
+        assert result.frames[0].filepath == "/app/main.py"
+        assert result.frames[0].line_number == 10
+        assert result.frames[0].function_name == "main"
+
+    def test_multi_file_traceback(self):
+        traceback = '''
+Traceback (most recent call last):
+  File "/app/main.py", line 10, in main
+    result = process()
+  File "/app/utils.py", line 25, in process
+    return compute(data)
+  File "/app/compute.py", line 5, in compute
+    return int(value)
+ValueError: invalid literal
+'''
+        result = parse_traceback(traceback)
+
+        assert len(result.frames) == 3
+        assert result.frames[0].filepath == "/app/main.py"
+        assert result.frames[1].filepath == "/app/utils.py"
+        assert result.frames[2].filepath == "/app/compute.py"
+
+    def test_error_extraction(self):
+        traceback = '''
+Traceback (most recent call last):
+  File "/app/main.py", line 10, in main
+    result = int("abc")
+ValueError: invalid literal for int() with base 10: 'abc'
+'''
+        result = parse_traceback(traceback)
+
+        assert result.error_type == "ValueError"
+        assert "invalid literal" in result.error_message
+
+
+class TestJavaScriptStackTrace:
+    """Tests for JavaScript/Node.js stack trace parsing."""
+
+    def test_node_stacktrace(self):
+        traceback = '''
+TypeError: Cannot read property 'name' of undefined
+    at processUser (/app/src/users.js:25:15)
+    at main (/app/src/index.js:10:5)
+'''
+        result = parse_traceback(traceback, Language.JAVASCRIPT)
+
+        assert result.language == Language.JAVASCRIPT
+        assert len(result.frames) >= 1
+        assert "/app/src/users.js" in result.frames[0].filepath
+        assert result.frames[0].line_number == 25
+
+    def test_anonymous_function(self):
+        traceback = '''
+Error: Something went wrong
+    at /app/src/index.js:42:10
+    at Object.<anonymous> (/app/src/index.js:50:1)
+'''
+        result = parse_traceback(traceback, Language.JAVASCRIPT)
+
+        assert len(result.frames) >= 1
+
+
+class TestGoTraceback:
+    """Tests for Go panic/stacktrace parsing."""
+
+    def test_go_panic(self):
+        traceback = '''
+panic: runtime error: index out of range
+
+goroutine 1 [running]:
+main.processData()
+	/app/main.go:25 +0x1f
+main.main()
+	/app/main.go:15 +0x3a
+'''
+        result = parse_traceback(traceback, Language.GO)
+
+        assert result.language == Language.GO
+        assert len(result.frames) >= 1
+        # Should find main.go references
+        assert any("main.go" in f.filepath for f in result.frames)
+
+
+class TestRustTraceback:
+    """Tests for Rust panic parsing."""
+
+    def test_rust_panic(self):
+        traceback = '''
+thread 'main' panicked at 'index out of bounds', src/main.rs:15:10
+'''
+        result = parse_traceback(traceback, Language.RUST)
+
+        assert result.language == Language.RUST
+        assert len(result.frames) >= 1
+        assert "main.rs" in result.frames[0].filepath
+        assert result.frames[0].line_number == 15
+
+
+class TestJavaTraceback:
+    """Tests for Java exception parsing."""
+
+    def test_java_exception(self):
+        traceback = '''
+java.lang.NullPointerException
+	at com.example.MyClass.process(MyClass.java:25)
+	at com.example.Main.main(Main.java:10)
+'''
+        result = parse_traceback(traceback, Language.JAVA)
+
+        assert result.language == Language.JAVA
+        assert len(result.frames) >= 1
+        assert "MyClass.java" in result.frames[0].filepath
+        assert result.frames[0].line_number == 25
+
+
+class TestExtractFilePairs:
+    """Tests for simple file/line extraction."""
+
+    def test_extract_python_pairs(self):
+        traceback = '''
+File "/app/main.py", line 10
+File "/app/utils.py", line 25
+'''
+        pairs = extract_file_line_pairs(traceback)
+
+        assert len(pairs) == 2
+        assert ("/app/main.py", 10) in pairs
+        assert ("/app/utils.py", 25) in pairs
+
+    def test_extract_with_language_hint(self):
+        traceback = '''
+	at com.example.Main.main(Main.java:10)
+'''
+        pairs = extract_file_line_pairs(traceback, Language.JAVA)
+
+        assert len(pairs) >= 1
+        assert any(p[0].endswith("Main.java") for p in pairs)