AnonymousSpottedToad/securityPatternsRecovery / codebase /repos /python /contextfs_contextfs /tests /conftest.py
| """ | |
| Pytest configuration and shared fixtures. | |
| """ | |
| import sys | |
| import tempfile | |
| from collections.abc import Generator | |
| from pathlib import Path | |
| import pytest | |
| # Add src to path for imports | |
| sys.path.insert(0, str(Path(__file__).parent.parent / "src")) | |
| def reset_config_and_env(monkeypatch): | |
| """Reset config cache and use embedded ChromaDB for tests.""" | |
| from contextfs.config import reset_config | |
| # Reset config cache so new env vars are picked up | |
| reset_config() | |
| # DELETE env vars so tests use embedded ChromaDB (chroma_host=None) | |
| # This ensures tests don't connect to local dev server at localhost:8000 | |
| monkeypatch.delenv("CONTEXTFS_CHROMA_HOST", raising=False) | |
| monkeypatch.delenv("CONTEXTFS_CHROMA_AUTO_SERVER", raising=False) | |
| # Enable test mode to disable auto-indexing (much faster tests) | |
| monkeypatch.setenv("CONTEXTFS_TEST_MODE", "true") | |
| yield | |
| reset_config() | |
| def temp_dir() -> Generator[Path, None, None]: | |
| """Create a temporary directory for tests.""" | |
| with tempfile.TemporaryDirectory() as tmpdir: | |
| yield Path(tmpdir) | |
| def sample_python_code() -> str: | |
| """Sample Python code for testing.""" | |
| return ''' | |
| """Sample module for testing.""" | |
| from typing import Optional | |
| import os | |
| class MyClass: | |
| """A sample class.""" | |
| def __init__(self, name: str): | |
| """Initialize with name.""" | |
| self.name = name | |
| def greet(self) -> str: | |
| """Return greeting.""" | |
| return f"Hello, {self.name}!" | |
| def helper_function(x: int, y: int) -> int: | |
| """Add two numbers.""" | |
| return x + y | |
| async def async_function() -> None: | |
| """An async function.""" | |
| pass | |
| ''' | |
| def sample_typescript_code() -> str: | |
| """Sample TypeScript code for testing.""" | |
| return """ | |
| import { useState, useEffect } from 'react'; | |
| import type { User } from './types'; | |
| interface Props { | |
| name: string; | |
| age?: number; | |
| } | |
| type Status = 'active' | 'inactive'; | |
| export class UserService { | |
| private users: User[] = []; | |
| async getUser(id: string): Promise<User | null> { | |
| return this.users.find(u => u.id === id) ?? null; | |
| } | |
| } | |
| export function useUser(id: string) { | |
| const [user, setUser] = useState<User | null>(null); | |
| useEffect(() => { | |
| // fetch user | |
| }, [id]); | |
| return user; | |
| } | |
| """ | |
| def sample_java_code() -> str: | |
| """Sample Java code for testing.""" | |
| return """ | |
| package com.example.app; | |
| import java.util.List; | |
| import java.util.Optional; | |
| /** | |
| * A sample Java class. | |
| */ | |
| public class UserService { | |
| private final UserRepository repository; | |
| public UserService(UserRepository repository) { | |
| this.repository = repository; | |
| } | |
| /** | |
| * Find user by ID. | |
| * @param id User ID | |
| * @return Optional user | |
| */ | |
| public Optional<User> findById(String id) { | |
| return repository.findById(id); | |
| } | |
| } | |
| interface UserRepository { | |
| Optional<User> findById(String id); | |
| List<User> findAll(); | |
| } | |
| """ | |
| def sample_go_code() -> str: | |
| """Sample Go code for testing.""" | |
| return """ | |
| package main | |
| import ( | |
| "fmt" | |
| "net/http" | |
| ) | |
| // User represents a user in the system. | |
| type User struct { | |
| ID string | |
| Name string | |
| } | |
| // UserService handles user operations. | |
| type UserService struct { | |
| users map[string]*User | |
| } | |
| // NewUserService creates a new UserService. | |
| func NewUserService() *UserService { | |
| return &UserService{ | |
| users: make(map[string]*User), | |
| } | |
| } | |
| // GetUser retrieves a user by ID. | |
| func (s *UserService) GetUser(id string) (*User, error) { | |
| user, ok := s.users[id] | |
| if !ok { | |
| return nil, fmt.Errorf("user not found: %s", id) | |
| } | |
| return user, nil | |
| } | |
| """ | |
| def sample_rust_code() -> str: | |
| """Sample Rust code for testing.""" | |
| return """ | |
| use std::collections::HashMap; | |
| /// A user in the system. | |
| #[derive(Debug, Clone)] | |
| pub struct User { | |
| pub id: String, | |
| pub name: String, | |
| } | |
| /// Service for managing users. | |
| pub struct UserService { | |
| users: HashMap<String, User>, | |
| } | |
| impl UserService { | |
| /// Create a new UserService. | |
| pub fn new() -> Self { | |
| Self { | |
| users: HashMap::new(), | |
| } | |
| } | |
| /// Get a user by ID. | |
| pub fn get_user(&self, id: &str) -> Option<&User> { | |
| self.users.get(id) | |
| } | |
| } | |
| impl Default for UserService { | |
| fn default() -> Self { | |
| Self::new() | |
| } | |
| } | |
| """ | |
| def sample_markdown() -> str: | |
| """Sample Markdown for testing.""" | |
| return """ | |
| # Sample Document | |
| This is a sample markdown document. | |
| ## Introduction | |
| Some introductory text. | |
| ### Subsection | |
| More detailed content here. | |
| ```python | |
| def hello(): | |
| print("Hello, World!") | |
| ``` | |
| ## Conclusion | |
| Final thoughts. | |
| [Link to docs](./docs/README.md) | |
| """ | |
| def sample_sql() -> str: | |
| """Sample SQL for testing.""" | |
| return """ | |
| -- Users table | |
| CREATE TABLE users ( | |
| id UUID PRIMARY KEY DEFAULT gen_random_uuid(), | |
| email VARCHAR(255) NOT NULL UNIQUE, | |
| name VARCHAR(100), | |
| created_at TIMESTAMP DEFAULT NOW() | |
| ); | |
| -- Posts table | |
| CREATE TABLE posts ( | |
| id SERIAL PRIMARY KEY, | |
| user_id UUID REFERENCES users(id) ON DELETE CASCADE, | |
| title VARCHAR(255) NOT NULL, | |
| content TEXT, | |
| published BOOLEAN DEFAULT false | |
| ); | |
| -- Create index | |
| CREATE INDEX idx_posts_user_id ON posts(user_id); | |
| -- Sample query | |
| SELECT u.name, COUNT(p.id) as post_count | |
| FROM users u | |
| LEFT JOIN posts p ON u.id = p.user_id | |
| GROUP BY u.id, u.name; | |
| """ | |
| def sample_json() -> str: | |
| """Sample JSON for testing.""" | |
| return """ | |
| { | |
| "name": "my-project", | |
| "version": "1.0.0", | |
| "dependencies": { | |
| "react": "^18.0.0", | |
| "typescript": "^5.0.0" | |
| }, | |
| "scripts": { | |
| "build": "tsc", | |
| "test": "jest" | |
| } | |
| } | |
| """ | |
| def haven_project_path() -> Path: | |
| """Path to haven project for integration tests.""" | |
| path = Path("/Users/mlong/Documents/Development/haven/design-gem-studio") | |
| if path.exists(): | |
| return path | |
| pytest.skip("Haven project not available") | |
| def rag_backend(temp_dir: Path): | |
| """Create a RAG backend for testing.""" | |
| from contextfs.rag import RAGBackend | |
| backend = RAGBackend( | |
| data_dir=temp_dir, | |
| embedding_model="all-MiniLM-L6-v2", | |
| collection_name="test_collection", | |
| ) | |
| yield backend | |
| backend.close() | |
| def fts_backend(temp_dir: Path): | |
| """Create an FTS backend for testing.""" | |
| import sqlite3 | |
| from contextfs.fts import FTSBackend | |
| # FTS triggers require the memories table to exist | |
| # Schema must match the full memories table including source_tool, project | |
| db_path = temp_dir / "test.db" | |
| conn = sqlite3.connect(db_path) | |
| cursor = conn.cursor() | |
| cursor.execute(""" | |
| CREATE TABLE IF NOT EXISTS memories ( | |
| id TEXT PRIMARY KEY NOT NULL, | |
| content TEXT NOT NULL, | |
| type TEXT NOT NULL, | |
| tags TEXT, | |
| summary TEXT, | |
| namespace_id TEXT NOT NULL, | |
| source_file TEXT, | |
| source_repo TEXT, | |
| source_tool TEXT, | |
| project TEXT, | |
| session_id TEXT, | |
| created_at TEXT NOT NULL, | |
| updated_at TEXT NOT NULL, | |
| metadata TEXT, | |
| structured_data TEXT | |
| ) | |
| """) | |
| conn.commit() | |
| conn.close() | |
| backend = FTSBackend(db_path=db_path) | |
| yield backend | |
| backend.close() | |
Xet Storage Details
- Size:
- 7.51 kB
- Xet hash:
- d62c59d14919478ac3f05508fe7574d9c012eec5fd8b299196109c19c9b50717
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.