rp/test_project_analyzer.py at 53ed827e4483afb591f06cf2df0cd4abfbe6d28c

 # retoor <retoor@molodetz.nl>
 import pytest
 from rp.core.project_analyzer import ProjectAnalyzer, AnalysisResult
 class TestProjectAnalyzer:
     def setup_method(self):
         self.analyzer = ProjectAnalyzer()
     def test_analyze_requirements_valid_code(self):
         code_content = """
 import json
 import requests
 from pydantic import BaseModel
 class User(BaseModel):
     name: str
     age: int
 """
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             code_content=code_content,
         )
         assert isinstance(result, AnalysisResult)
         assert result.language == 'python'
         assert 'requests' in result.dependencies
         assert 'pydantic' in result.dependencies
     def test_pydantic_breaking_change_detection(self):
         code_content = """
 from pydantic import BaseSettings
 class Config(BaseSettings):
     api_key: str
 """
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             code_content=code_content,
         )
         assert not result.valid
         assert any('BaseSettings' in e for e in result.errors)
     def test_shell_command_validation_valid(self):
         commands = [
             "pip install fastapi",
             "mkdir -p /tmp/test",
             "python script.py",
         ]
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             commands=commands,
         )
         valid_commands = [c for c in result.shell_commands if c['valid']]
         assert len(valid_commands) > 0
     def test_shell_command_validation_invalid_brace_expansion(self):
         commands = [
             "mkdir -p {app/{api,database,model)",
         ]
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             commands=commands,
         )
         assert not result.valid
         assert any('brace' in e.lower() or 'syntax' in e.lower() for e in result.errors)
     def test_python_version_detection(self):
         code_with_walrus = """
 if (x := 10) > 5:
     print(x)
 """
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             code_content=code_with_walrus,
         )
         version_parts = result.language_version.split('.')
         assert int(version_parts[1]) >= 8
     def test_directory_structure_planning(self):
         spec_content = """
 Create the following structure:
 - directory: src/app
 - directory: src/tests
 - file: src/main.py
 - file: src/config.py
 """
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             code_content=spec_content,
         )
         assert len(result.file_structure) > 1
         assert '.' in result.file_structure
     def test_import_compatibility_check(self):
         dependencies = {'pydantic': '2.0', 'fastapi': '0.100'}
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             code_content="",
         )
         assert isinstance(result.import_compatibility, dict)
     def test_token_budget_calculation(self):
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             code_content="import json\nimport requests\n",
             commands=["pip install -r requirements.txt"],
         )
         assert result.estimated_tokens > 0
     def test_stdlib_detection(self):
         code = """
 import os
 import sys
 import json
 import custom_module
 """
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             code_content=code,
         )
         assert 'custom_module' in result.dependencies
         assert 'json' not in result.dependencies or len(result.dependencies) == 1
     def test_optional_dependencies_detection(self):
         code = """
 import structlog
 import uvicorn
 """
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             code_content=code,
         )
         assert 'structlog' in result.dependencies or len(result.warnings) > 0
     def test_fastapi_breaking_change_detection(self):
         code = """
 from fastapi.middleware.gzip import GZIPMiddleware
 """
         result = self.analyzer.analyze_requirements(
             spec_file="test.txt",
             code_content=code,
         )
         assert not result.valid
         assert any('GZIPMiddleware' in str(e) or 'fastapi' in str(e).lower() for e in result.errors)
 class TestCLanguageAnalyzer:
     def setup_method(self):
         self.analyzer = ProjectAnalyzer()
     def test_detect_c_language(self):
         c_code = """
 #include <stdio.h>
 #include <stdlib.h>
 int main(int argc, char *argv[]) {
     printf("Hello, World!\\n");
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert result.language == 'c'
     def test_c_standard_headers_detection(self):
         c_code = """
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 int main() {
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert 'stdio.h' in result.dependencies
         assert result.dependencies['stdio.h'] == 'stdlib'
         assert result.dependencies['math.h'] == 'stdlib'
     def test_c_posix_headers_detection(self):
         c_code = """
 #include <unistd.h>
 #include <pthread.h>
 #include <sys/socket.h>
 int main() {
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert 'unistd.h' in result.dependencies
         assert result.dependencies['unistd.h'] == 'posix'
         assert any('POSIX' in w for w in result.warnings)
     def test_c_local_headers_detection(self):
         c_code = """
 #include <stdio.h>
 #include "myheader.h"
 #include "utils/helper.h"
 int main() {
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert 'myheader.h' in result.dependencies
         assert result.dependencies['myheader.h'] == 'local'
     def test_c_external_library_headers(self):
         c_code = """
 #include <stdio.h>
 #include <curl/curl.h>
 #include <openssl/ssl.h>
 int main() {
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert 'curl/curl.h' in result.dependencies
         assert result.dependencies['curl/curl.h'] == 'curl'
         assert any('curl' in w for w in result.warnings)
     def test_c_standard_detection_c99(self):
         c_code = """
 #include <stdio.h>
 int main() {
     for (int i = 0; i < 10; i++) {
         printf("%d\\n", i);
     }
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert result.language_version == 'c99'
     def test_c_standard_detection_c11(self):
         c_code = """
 #include <stdio.h>
 #include <stdatomic.h>
 int main() {
     _Static_assert(sizeof(int) >= 4, "int must be at least 4 bytes");
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert result.language_version == 'c11'
     def test_c_standard_detection_gnu(self):
         c_code = """
 #include <stdio.h>
 int main() {
     typeof(5) x = 10;
     printf("%d\\n", x);
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert 'gnu' in result.language_version
     def test_c_compiler_flags_suggestion(self):
         c_code = """
 #include <stdio.h>
 #include <math.h>
 #include <pthread.h>
 int main() {
     pthread_t thread;
     double x = sqrt(2.0);
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert '-lm' in result.compiler_flags
         assert '-pthread' in result.compiler_flags
         assert any('-std=' in f for f in result.compiler_flags)
         assert '-Wall' in result.compiler_flags
     def test_c_valid_analysis_no_errors(self):
         c_code = """
 #include <stdio.h>
 int main() {
     printf("Hello\\n");
     return 0;
 }
 """
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
         )
         assert result.valid
         assert len(result.errors) == 0
     def test_c_shell_commands_validation(self):
         c_code = """
 #include <stdio.h>
 int main() { return 0; }
 """
         commands = [
             "gcc -o main main.c",
             "make clean",
             "./main",
         ]
         result = self.analyzer.analyze_requirements(
             spec_file="main.c",
             code_content=c_code,
             commands=commands,
         )
         valid_commands = [c for c in result.shell_commands if c['valid']]
         assert len(valid_commands) == 3
 class TestLanguageDetection:
     def setup_method(self):
         self.analyzer = ProjectAnalyzer()
     def test_detect_python_from_content(self):
         python_code = """
 def hello():
     print("Hello, World!")
 if __name__ == "__main__":
     hello()
 """
         lang = self.analyzer.detect_language(python_code)
         assert lang == 'python'
     def test_detect_c_from_content(self):
         c_code = """
 #include <stdio.h>
 int main(int argc, char *argv[]) {
     printf("Hello\\n");
     return 0;
 }
 """
         lang = self.analyzer.detect_language(c_code)
         assert lang == 'c'
     def test_detect_cpp_from_content(self):
         cpp_code = """
 #include <iostream>
 int main() {
     std::cout << "Hello" << std::endl;
     return 0;
 }
 """
         lang = self.analyzer.detect_language(cpp_code)
         assert lang == 'cpp'
     def test_detect_rust_from_content(self):
         rust_code = """
 fn main() {
     let x = 5;
     println!("x = {}", x);
 }
 """
         lang = self.analyzer.detect_language(rust_code)
         assert lang == 'rust'
     def test_detect_go_from_content(self):
         go_code = """
 package main
 import "fmt"
 func main() {
     fmt.Println("Hello")
 }
 """
         lang = self.analyzer.detect_language(go_code)
         assert lang == 'go'
     def test_detect_javascript_from_content(self):
         js_code = """
 const express = require('express');
 function hello() {
     console.log("Hello");
 }
 export default hello;
 """
         lang = self.analyzer.detect_language(js_code)
         assert lang == 'javascript'
     def test_detect_language_from_file_extension(self):
         lang = self.analyzer.detect_language("", "main.c")
         assert lang == 'c'
         lang = self.analyzer.detect_language("", "app.py")
         assert lang == 'python'
     def test_detect_unknown_language(self):
         weird_content = "some random text without any language patterns"
         lang = self.analyzer.detect_language(weird_content)
         assert lang == 'unknown'