508 lines
10 KiB
Python
508 lines
10 KiB
Python
"""Pytest configuration and fixtures for codechunk tests."""
|
|
|
|
import tempfile
|
|
from collections.abc import Generator
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
|
|
@pytest.fixture
|
|
def temp_project_dir() -> Generator[Path, None, None]:
|
|
"""Create a temporary directory for testing."""
|
|
with tempfile.TemporaryDirectory() as tmp_dir:
|
|
yield Path(tmp_dir)
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_python_code():
|
|
return '''
|
|
"""Sample module for testing."""
|
|
|
|
import os
|
|
import json
|
|
from typing import List, Dict
|
|
|
|
|
|
class DataProcessor:
|
|
"""A class for processing data."""
|
|
|
|
def __init__(self, config: Dict[str, str]):
|
|
self.config = config
|
|
self.cache = {}
|
|
|
|
def process(self, items: List[str]) -> List[Dict]:
|
|
"""Process a list of items.
|
|
|
|
Args:
|
|
items: List of strings to process
|
|
|
|
Returns:
|
|
List of processed dictionaries
|
|
"""
|
|
results = []
|
|
for item in items:
|
|
if item in self.cache:
|
|
results.append(self.cache[item])
|
|
else:
|
|
processed = self._process_single(item)
|
|
self.cache[item] = processed
|
|
results.append(processed)
|
|
return results
|
|
|
|
def _process_single(self, item: str) -> Dict:
|
|
"""Process a single item."""
|
|
return {"item": item, "length": len(item)}
|
|
|
|
|
|
def main():
|
|
"""Main entry point."""
|
|
processor = DataProcessor({"debug": "true"})
|
|
result = processor.process(["hello", "world"])
|
|
print(json.dumps(result))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
'''
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_javascript_code():
|
|
return '''
|
|
import { useState, useEffect } from 'react';
|
|
import api from './api';
|
|
|
|
class DataManager {
|
|
constructor(config) {
|
|
this.config = config;
|
|
this.cache = new Map();
|
|
}
|
|
|
|
async fetchData(url) {
|
|
if (this.cache.has(url)) {
|
|
return this.cache.get(url);
|
|
}
|
|
|
|
const response = await fetch(url);
|
|
const data = await response.json();
|
|
this.cache.set(url, data);
|
|
return data;
|
|
}
|
|
|
|
clearCache() {
|
|
this.cache.clear();
|
|
}
|
|
}
|
|
|
|
export function useCustomHook(initialValue) {
|
|
const [value, setValue] = useState(initialValue);
|
|
|
|
useEffect(() => {
|
|
console.log('Value changed:', value);
|
|
}, [value]);
|
|
|
|
return [value, setValue];
|
|
}
|
|
|
|
export default DataManager;
|
|
'''
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_go_code():
|
|
return '''package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
)
|
|
|
|
type Config struct {
|
|
Host string
|
|
Port int
|
|
}
|
|
|
|
func (c *Config) Load() error {
|
|
return nil
|
|
}
|
|
|
|
func NewProcessor(config Config) *Processor {
|
|
return &Processor{config: config}
|
|
}
|
|
|
|
type Processor struct {
|
|
config Config
|
|
}
|
|
|
|
func (p *Processor) Process(data string) error {
|
|
fmt.Println("Processing:", data)
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
config := Config{Host: "localhost", Port: 8080}
|
|
processor := NewProcessor(config)
|
|
err := processor.Process("test")
|
|
if err != nil {
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
'''
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_rust_code():
|
|
return '''use std::collections::HashMap;
|
|
|
|
pub struct Config {
|
|
host: String,
|
|
port: u16,
|
|
}
|
|
|
|
impl Config {
|
|
pub fn new(host: String, port: u16) -> Self {
|
|
Config { host, port }
|
|
}
|
|
|
|
pub fn load(&self) -> Result<(), std::io::Error> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub struct Processor {
|
|
config: Config,
|
|
cache: HashMap<String, String>,
|
|
}
|
|
|
|
impl Processor {
|
|
pub fn new(config: Config) -> Self {
|
|
Processor {
|
|
config,
|
|
cache: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
pub fn process(&mut self, input: &str) -> Result<String, std::io::Error> {
|
|
if let Some(cached) = self.cache.get(input) {
|
|
return Ok(cached.clone());
|
|
}
|
|
|
|
let result = format!("Processed: {}", input);
|
|
self.cache.insert(input.to_string(), result.clone());
|
|
Ok(result)
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let config = Config::new("localhost".to_string(), 8080);
|
|
let mut processor = Processor::new(config);
|
|
|
|
match processor.process("test") {
|
|
Ok(result) => println!("{}", result),
|
|
Err(e) => eprintln!("Error: {}", e),
|
|
}
|
|
}
|
|
'''
|
|
|
|
|
|
@pytest.fixture
|
|
def python_project(temp_project_dir: Path) -> Path:
|
|
"""Create a mock Python project structure."""
|
|
src_dir = temp_project_dir / "src"
|
|
src_dir.mkdir(exist_ok=True)
|
|
|
|
(src_dir / "__init__.py").write_text('"""Package init."""')
|
|
(src_dir / "main.py").write_text('''
|
|
"""Main module."""
|
|
|
|
def main():
|
|
print("Hello, World!")
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
''')
|
|
|
|
(src_dir / "utils.py").write_text('''
|
|
"""Utility functions."""
|
|
|
|
def helper_function():
|
|
"""A helper function."""
|
|
return "helper"
|
|
|
|
class HelperClass:
|
|
"""Helper class."""
|
|
pass
|
|
''')
|
|
|
|
(temp_project_dir / "requirements.txt").write_text('''
|
|
requests>=2.28.0
|
|
pyyaml>=6.0
|
|
pytest>=7.0.0
|
|
''')
|
|
|
|
(temp_project_dir / "setup.py").write_text('''
|
|
"""Setup script."""
|
|
|
|
from setuptools import setup, find_packages
|
|
|
|
setup(
|
|
name="test_package",
|
|
version="0.1.0",
|
|
packages=find_packages(),
|
|
install_requires=[
|
|
"requests>=2.28.0",
|
|
],
|
|
)
|
|
''')
|
|
|
|
return temp_project_dir
|
|
|
|
|
|
@pytest.fixture
|
|
def nodejs_project(temp_project_dir: Path) -> Path:
|
|
"""Create a mock Node.js project structure."""
|
|
(temp_project_dir / "package.json").write_text('''
|
|
{
|
|
"name": "test-nodejs-project",
|
|
"version": "1.0.0",
|
|
"description": "Test Node.js project",
|
|
"main": "index.js",
|
|
"scripts": {
|
|
"start": "node index.js",
|
|
"test": "jest"
|
|
},
|
|
"dependencies": {
|
|
"express": "^4.18.0",
|
|
"lodash": "^4.17.21"
|
|
},
|
|
"devDependencies": {
|
|
"jest": "^29.0.0"
|
|
}
|
|
}
|
|
''')
|
|
|
|
(temp_project_dir / "index.js").write_text('''
|
|
const express = require('express');
|
|
const app = express();
|
|
|
|
app.get('/', (req, res) => {
|
|
res.send('Hello World!');
|
|
});
|
|
|
|
app.listen(3000, () => {
|
|
console.log('Server running on port 3000');
|
|
});
|
|
|
|
module.exports = app;
|
|
''')
|
|
|
|
return temp_project_dir
|
|
|
|
|
|
@pytest.fixture
|
|
def django_project(temp_project_dir: Path) -> Path:
|
|
"""Create a mock Django project structure."""
|
|
project_dir = temp_project_dir / "project"
|
|
project_dir.mkdir(exist_ok=True)
|
|
|
|
(temp_project_dir / "manage.py").write_text('''
|
|
#!/usr/bin/env python
|
|
"""Django's command-line utility for administrative tasks."""
|
|
import os
|
|
import sys
|
|
|
|
def main():
|
|
"""Run administrative tasks."""
|
|
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'project.settings')
|
|
try:
|
|
from django.core.management import execute_from_command_line
|
|
except ImportError as exc:
|
|
raise ImportError(
|
|
"Couldn't import Django. Are you sure it's installed?"
|
|
) from exc
|
|
execute_from_command_line(sys.argv)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
''')
|
|
|
|
(project_dir / "__init__.py").write_text('')
|
|
(project_dir / "settings.py").write_text('''
|
|
"""Django settings for test_project."""
|
|
|
|
SECRET_KEY = 'test-secret-key'
|
|
DEBUG = True
|
|
ALLOWED_HOSTS = []
|
|
|
|
INSTALLED_APPS = [
|
|
'django.contrib.admin',
|
|
'django.contrib.auth',
|
|
'django.contrib.contenttypes',
|
|
'django.contrib.sessions',
|
|
'django.contrib.messages',
|
|
'django.contrib.staticfiles',
|
|
]
|
|
|
|
MIDDLEWARE = [
|
|
'django.middleware.security.SecurityMiddleware',
|
|
'django.contrib.sessions.middleware.SessionMiddleware',
|
|
'django.middleware.common.CommonMiddleware',
|
|
'django.middleware.csrf.CsrfViewMiddleware',
|
|
'django.contrib.auth.middleware.AuthenticationMiddleware',
|
|
]
|
|
|
|
ROOT_URLCONF = 'project.urls'
|
|
|
|
DATABASES = {
|
|
'default': {
|
|
'ENGINE': 'django.db.backends.sqlite3',
|
|
'NAME': 'db.sqlite3',
|
|
}
|
|
}
|
|
''')
|
|
|
|
(project_dir / "urls.py").write_text('''
|
|
from django.contrib import admin
|
|
from django.urls import path
|
|
|
|
urlpatterns = [
|
|
path('admin/', admin.site.urls),
|
|
]
|
|
''')
|
|
|
|
return temp_project_dir
|
|
|
|
|
|
@pytest.fixture
|
|
def react_project(temp_project_dir: Path) -> Path:
|
|
"""Create a mock React project structure."""
|
|
(temp_project_dir / "package.json").write_text('''
|
|
{
|
|
"name": "test-react-project",
|
|
"version": "1.0.0",
|
|
"private": true,
|
|
"dependencies": {
|
|
"react": "^18.2.0",
|
|
"react-dom": "^18.2.0",
|
|
"react-scripts": "5.0.1"
|
|
},
|
|
"scripts": {
|
|
"start": "react-scripts start",
|
|
"build": "react-scripts build",
|
|
"test": "react-scripts test"
|
|
},
|
|
"browserslist": {
|
|
"production": [
|
|
">0.2%",
|
|
"not dead",
|
|
"not op_mini all"
|
|
],
|
|
"development": [
|
|
"last 1 chrome version",
|
|
"last 1 firefox version",
|
|
"last 1 safari version"
|
|
]
|
|
}
|
|
}
|
|
''')
|
|
|
|
public_dir = temp_project_dir / "public"
|
|
public_dir.mkdir(exist_ok=True)
|
|
|
|
(public_dir / "index.html").write_text('''
|
|
<!DOCTYPE html>
|
|
<html lang="en">
|
|
<head>
|
|
<meta charset="utf-8" />
|
|
<title>React App</title>
|
|
</head>
|
|
<body>
|
|
<noscript>You need to enable JavaScript to run this app.</noscript>
|
|
<div id="root"></div>
|
|
</body>
|
|
</html>
|
|
''')
|
|
|
|
src_dir = temp_project_dir / "src"
|
|
src_dir.mkdir(exist_ok=True)
|
|
|
|
(src_dir / "index.js").write_text('''
|
|
import React from 'react';
|
|
import ReactDOM from 'react-dom/client';
|
|
import './index.css';
|
|
import App from './App';
|
|
|
|
const root = ReactDOM.createRoot(document.getElementById('root'));
|
|
root.render(
|
|
<React.StrictMode>
|
|
<App />
|
|
</React.StrictMode>
|
|
);
|
|
''')
|
|
|
|
(src_dir / "App.js").write_text('''
|
|
import React from 'react';
|
|
|
|
function App() {
|
|
return (
|
|
<div className="App">
|
|
<h1>Welcome to React</h1>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
export default App;
|
|
''')
|
|
|
|
return temp_project_dir
|
|
|
|
|
|
@pytest.fixture
|
|
def mixed_project(temp_project_dir: Path) -> Path:
|
|
"""Create a mixed project with Python and Node.js."""
|
|
src_dir = temp_project_dir / "src"
|
|
src_dir.mkdir(exist_ok=True)
|
|
|
|
(temp_project_dir / "requirements.txt").write_text('''
|
|
requests>=2.28.0
|
|
flask>=2.0.0
|
|
''')
|
|
|
|
(temp_project_dir / "package.json").write_text('''
|
|
{
|
|
"name": "mixed-project",
|
|
"version": "1.0.0",
|
|
"dependencies": {
|
|
"express": "^4.18.0"
|
|
}
|
|
}
|
|
''')
|
|
|
|
(src_dir / "main.py").write_text('''
|
|
"""Main Python module."""
|
|
from flask import Flask
|
|
|
|
app = Flask(__name__)
|
|
|
|
@app.route('/')
|
|
def index():
|
|
return "Hello"
|
|
''')
|
|
|
|
return temp_project_dir
|
|
|
|
|
|
@pytest.fixture
|
|
def default_config():
|
|
"""Return default configuration."""
|
|
from codechunk.config import Config
|
|
return Config()
|
|
|
|
|
|
@pytest.fixture
|
|
def chunking_config():
|
|
"""Return chunking configuration."""
|
|
from codechunk.config import ChunkingConfig
|
|
return ChunkingConfig()
|