test_airis.py

from src.agents.fashion_advisor import AIris
from dotenv import load_dotenv
import pytest

def test_fashion_advisor():
    # Initialize AIris with online mode (requires GROQ_API_KEY)
    advisor = AIris(offline_mode=False)
    
    print("\nTesting outfit advice:")
    advice = advisor.get_outfit_advice("What should I wear to a summer wedding?")
    print(advice)
    
    print("\nTesting style inspiration:")
    inspiration = advisor.get_inspiration("bohemian")
    print(inspiration)

def test_airis_memory_and_preferences():
    """Test AIris's ability to remember and use context."""
    airis = AIris(offline_mode=True)
    
    # First interaction
    response1 = airis.get_outfit_advice("I love bohemian style and earth tones")
    assert "Agent is running in offline mode" in response1
    
    # Check if preferences were stored
    memory = airis.get_memory()
    assert memory["preferences"]  # Should have stored style preferences
    
    # Second interaction should have context from first
    response2 = airis.get_outfit_advice("What should I wear to a summer wedding?")
    assert "Agent is running in offline mode" in response2
    
    # Verify conversation history
    memory = airis.get_memory()
    assert len(memory["history"]) == 2  # Should have both interactions

def test_fashion_knowledge_tool():
    """Test the fashion knowledge tool's ability to provide relevant information."""
    airis = AIris()
    knowledge = airis.fashion_knowledge("What should I wear to a beach wedding?")
    assert "beach" in knowledge.lower()
    assert "wedding" in knowledge.lower()

def test_style_analyzer_tool():
    """Test the style analyzer's ability to extract preferences."""
    airis = AIris()
    analysis = airis.style_analyzer("I want a bohemian summer dress for a beach party")
    assert "bohemian" in analysis.lower()
    assert "summer" in analysis.lower()
    assert "beach" in analysis.lower()

def test_contextual_advice():
    """Test AIris's ability to provide contextual advice."""
    airis = AIris(offline_mode=True)
    
    # First establish some preferences
    airis.get_outfit_advice("I prefer minimalist style with neutral colors")
    
    # Second request should incorporate previous preferences
    response = airis.get_outfit_advice("What should I wear to a business meeting?")
    assert "Agent is running in offline mode" in response
    
    # Check if memory was maintained
    memory = airis.get_memory()
    assert "minimalist" in str(memory["preferences"]).lower()

def test_multi_step_planning():
    """Test AIris's ability to plan and execute multi-step responses."""
    airis = AIris(offline_mode=True)
    
    # Complex request requiring multiple steps
    response = airis.get_outfit_advice(
        "I need help building a capsule wardrobe for fall. "
        "I work in a business casual office and like to go hiking on weekends."
    )
    assert "Agent is running in offline mode" in response
    
    # Verify that multiple aspects were considered
    memory = airis.get_memory()
    prefs = str(memory["preferences"]).lower()
    assert any(term in prefs for term in ["business casual", "hiking", "fall"])

if __name__ == "__main__":
    # Load environment variables
    load_dotenv()
    test_fashion_advisor()