test_basic.py

"""
Basic tests for VARIABOT to prevent workflow failures.
This file ensures pytest has tests to run and prevents CI failures.
"""

import pytest
import os
from pathlib import Path


def test_repository_structure():
    """Test that required files exist in the repository."""
    required_files = [
        'README.md',
        'requirements.txt',
        'st-Qwen1.5-110B-Chat.py',
        'st-Phi3Mini-128k-Chat.py',
        'st-Openelm-3B.py',
        'st-Qwen1.5-MoE-A2.7B-Chat.py'
    ]
    
    for file_path in required_files:
        assert Path(file_path).exists(), f"Required file {file_path} not found"


def test_requirements_file():
    """Test that requirements.txt is readable and contains dependencies."""
    requirements_path = Path('requirements.txt')
    assert requirements_path.exists(), "requirements.txt not found"
    
    with open(requirements_path, 'r') as f:
        content = f.read().strip()
    
    assert content, "requirements.txt is empty"
    assert 'streamlit' in content.lower(), "Streamlit dependency not found"


def test_reference_vault_exists():
    """Test that reference vault directory exists."""
    vault_path = Path('reference_vault')
    assert vault_path.exists(), "reference_vault directory not found"
    assert vault_path.is_dir(), "reference_vault is not a directory"


def test_python_files_syntax():
    """Test that Python files have valid syntax."""
    python_files = [
        'st-Qwen1.5-110B-Chat.py',
        'st-Phi3Mini-128k-Chat.py', 
        'st-Openelm-3B.py',
        'st-Qwen1.5-MoE-A2.7B-Chat.py',
        'Qwen110BChat.py'
    ]
    
    for file_path in python_files:
        if Path(file_path).exists():
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read()
            
            # Basic syntax check - try to compile
            try:
                compile(content, file_path, 'exec')
            except SyntaxError as e:
                pytest.fail(f"Syntax error in {file_path}: {e}")


def test_import_statements():
    """Test that required imports are available."""
    try:
        import streamlit
        assert streamlit.__version__, "Streamlit version not accessible"
    except ImportError:
        pytest.skip("Streamlit not installed - skipping import test")
    
    # Test other critical imports
    import sys
    import os
    import time
    assert sys.version_info >= (3, 7), "Python version too old"


def test_environment_variables():
    """Test environment variable handling."""
    # Test that we can handle missing HF_TOKEN gracefully
    original_token = os.environ.get('HF_TOKEN')
    
    # Remove token temporarily
    if 'HF_TOKEN' in os.environ:
        del os.environ['HF_TOKEN']
    
    # Test graceful handling
    token = os.getenv('HF_TOKEN', 'default_token')
    assert token == 'default_token', "Default token handling failed"
    
    # Restore original token if it existed
    if original_token:
        os.environ['HF_TOKEN'] = original_token


def test_file_permissions():
    """Test that Python files are readable."""
    python_files = list(Path('.').glob('*.py'))
    
    for file_path in python_files:
        assert os.access(file_path, os.R_OK), f"Cannot read {file_path}"


@pytest.mark.parametrize("model_file", [
    'st-Qwen1.5-110B-Chat.py',
    'st-Phi3Mini-128k-Chat.py',
    'st-Openelm-3B.py', 
    'st-Qwen1.5-MoE-A2.7B-Chat.py'
])
def test_model_files_contain_client(model_file):
    """Test that model files contain Client import and usage."""
    if not Path(model_file).exists():
        pytest.skip(f"{model_file} not found")
    
    with open(model_file, 'r', encoding='utf-8') as f:
        content = f.read()
    
    assert 'from gradio_client import Client' in content, f"{model_file} missing gradio_client import"
    assert 'Client(' in content, f"{model_file} missing Client instantiation"


def test_reference_vault_files():
    """Test that reference vault contains expected documentation."""
    vault_path = Path('reference_vault')
    if not vault_path.exists():
        pytest.skip("reference_vault directory not found")
    
    expected_files = [
        'README.md',
        'standards.md',
        'external_sources.md',
        'industry_lists.md',
        'networking_cheatsheet.md',
        'copilot_instructions.md',
        'audit_trail.md',
        'linux_kali_android.md',
        'PRODUCTION_GRADE_STANDARDS.md'
    ]
    
    for file_name in expected_files:
        file_path = vault_path / file_name
        if file_path.exists():
            assert file_path.stat().st_size > 0, f"{file_name} is empty"


if __name__ == "__main__":
    pytest.main([__file__])