solve tests

tests/test_bug_fixes.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+s#!/usr/bin/env python3
 """
 Test script to verify bug fixes for document editor tools
 Tests that:
@@ -20,7 +20,7 @@ def test_internal_functions_exist():
     print("TEST 1: Internal Functions Exist and Have __name__")
     print("=" * 80)
     
-    from utils.doc_editor_tools import (
+    from utils.editor_tools import (
         _replace_html, _add_html, _delete_html, _inspect_document, _attempt_completion
     )
     
@@ -52,7 +52,7 @@ def test_tools_real_are_functions():
     
     # Import agent - this will fail if tools_real has StructuredTools
     try:
-        from subagents.doc_editor import DocumentEditorAgent
+        from agents.doc_editor import DocumentEditorAgent
         
         # We need a mock LLM to initialize
         class MockLLM:
@@ -95,7 +95,7 @@ def test_workflow_builds():
     print("=" * 80)
     
     try:
-        from subagents.doc_editor import DocumentEditorAgent
+        from agents.doc_editor import DocumentEditorAgent
         
         class MockLLM:
             def bind_tools(self, tools):
@@ -127,7 +127,7 @@ def test_tools_callable():
     print("TEST 4: Internal Tools Are Callable")
     print("=" * 80)
     
-    from utils.doc_editor_tools import (
+    from utils.editor_tools import (
         _replace_html, _add_html, _delete_html, _inspect_document, _attempt_completion
     )
     

tests/test_create_draft_document.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Test script for create_draft_document tool
+"""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from utils.tools import create_draft_document, _create_draft_document
+
+
+async def test_tool_facade():
+    """Test the facade version of the tool"""
+    print("🧪 Testing create_draft_document (facade)...")
+    
+    # This should return immediately (facade just returns)
+    result = await create_draft_document.ainvoke({
+        "title": "Test Document",
+        "content": "<h1>Test</h1><p>This is a test document</p>",
+        "path": "Test/"
+    })
+    
+    print(f"✅ Facade test passed: {result}")
+    return result
+
+
+async def test_tool_real():
+    """Test the real implementation of the tool"""
+    print("\n🧪 Testing _create_draft_document (real implementation)...")
+    
+    # Mock user_id
+    test_user_id = os.getenv("TEST_USER_ID", "test-user-uuid-123")
+    
+    # Test with various paths
+    test_cases = [
+        {
+            "title": "Contract de bail",
+            "content": "<h1>Contrat de bail</h1><p>Ce contrat est conclu entre...</p>",
+            "path": "Contracts/",
+            "expected_path": "./Contracts/Contract de bail.pdf"
+        },
+        {
+            "title": "Mon document",
+            "content": "<h1>Document</h1><p>Contenu...</p>",
+            "path": "",
+            "expected_path": "./Mon document.pdf"
+        },
+        {
+            "title": "Note juridique",
+            "content": "<h1>Note</h1><p>Contenu juridique...</p>",
+            "path": "Drafts/Legal/",
+            "expected_path": "./Drafts/Legal/Note juridique.pdf"
+        }
+    ]
+    
+    for i, test_case in enumerate(test_cases, 1):
+        print(f"\n  Test case {i}: {test_case['title']}")
+        print(f"  Path: {test_case['path']}")
+        print(f"  Expected: {test_case['expected_path']}")
+        
+        result = await _create_draft_document.ainvoke({
+            "user_id": test_user_id,
+            "title": test_case["title"],
+            "content": test_case["content"],
+            "path": test_case["path"]
+        })
+        
+        print(f"  Result: {result}")
+        
+        # Check if the path is correct in the result
+        if test_case["expected_path"] in result:
+            print(f"  ✅ Path is correct")
+        else:
+            print(f"  ⚠️  Expected path not found in result")
+    
+    print("\n✅ Real implementation test completed")
+    return True
+
+
+async def test_path_normalization():
+    """Test path normalization logic"""
+    print("\n🧪 Testing path normalization...")
+    
+    test_cases = [
+        ("Contracts/", "./Contracts/"),
+        ("Contracts", "./Contracts/"),
+        ("", "./"),
+        ("./Contracts/", "./Contracts/"),
+        ("Drafts/Legal/", "./Drafts/Legal/"),
+        ("./Drafts/Legal", "./Drafts/Legal/")
+    ]
+    
+    for input_path, expected_suffix in test_cases:
+        # Simulate the path normalization logic
+        path = input_path
+        if path:
+            if path.startswith('./'):
+                path = path[2:]
+            if not path.endswith('/'):
+                path += '/'
+        else:
+            path = ''
+        
+        full_path = f"./{path}Test.pdf"
+        
+        print(f"  Input: '{input_path}' → Output: '{full_path}'")
+        if full_path.startswith(expected_suffix):
+            print(f"  ✅ Correct")
+        else:
+            print(f"  ⚠️  Expected to start with: {expected_suffix}")
+    
+    print("\n✅ Path normalization test completed")
+    return True
+
+
+async def main():
+    """Run all tests"""
+    print("=" * 80)
+    print("🚀 Testing create_draft_document tool")
+    print("=" * 80)
+    
+    try:
+        # Test facade
+        await test_tool_facade()
+        
+        # Test real implementation
+        await test_tool_real()
+        
+        # Test path normalization
+        await test_path_normalization()
+        
+        print("\n" + "=" * 80)
+        print("✅ All tests completed successfully!")
+        print("=" * 80)
+        
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tests/test_doc_creator_endpoint.py

@@ -17,7 +17,7 @@ load_dotenv(dotenv_path=".env", override=False)
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from structured_outputs.api_models import DocCreatorRequest, DocCreatorResponse, Message
-from subagents.doc_editor import DocumentEditorAgent
+from agents.doc_editor import DocumentEditorAgent
 from langchain_openai import ChatOpenAI
 
 

tests/test_doc_editor.py

@@ -16,7 +16,7 @@ load_dotenv()
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
 from langchain_openai import ChatOpenAI
-from subagents.doc_editor import DocumentEditorAgent
+from agents.doc_editor import DocumentEditorAgent
 
 
 # Example HTML document - Service Contract
@@ -80,7 +80,7 @@ async def test_document_editor():
     )
     
     # Initialize document editor agent
-    doc_editor = DocumentEditorAgent(llm=llm)
+    doc_editor = DocumentEditorAgent(llm=llm, llm_tool_calling=llm)
     
     print("=" * 80)
     print("📄 ORIGINAL DOCUMENT (HTML)")
@@ -139,7 +139,7 @@ async def test_document_editor():
 
 async def test_tools_directly():
     """Test document editor tools directly without the agent."""
-    from utils.doc_editor_tools import replace_html, add_html, delete_html, inspect_document, attempt_completion
+    from utils.editor_tools import replace_html, add_html, delete_html, view_current_document, attempt_completion
     
     print("=" * 80)
     print("🔧 TESTING TOOLS DIRECTLY")
@@ -192,14 +192,13 @@ async def test_tools_directly():
     else:
         print(f"❌ Delete failed: {result['error']}")
     
-    print("\n4️⃣ Testing 'inspect_document' tool...")
-    # Note: In direct testing, we can pass doc_text for backward compatibility
-    # But in agent mode, it will be called without arguments
-    result = await inspect_document.ainvoke({"doc_text": current_doc})
+    print("\n4️⃣ Testing 'view_current_document' tool...")
+    # Note: The tool now has no parameters - document is injected by the workflow
+    result = await view_current_document.ainvoke()
     if result['ok']:
-        print(f"✅ inspect_document works! Document size: {len(result['content'])} bytes")
+        print(f"✅ view_current_document works!")
     else:
-        print(f"❌ inspect_document failed")
+        print(f"❌ view_current_document failed")
     
     print("\n5️⃣ Final document after tool tests:")
     print(current_doc)

tests/test_fake_inspect_doc.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+Test pour vérifier que le faux view_current_document initial fonctionne
+"""
+
+import asyncio
+import os
+import sys
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Add parent directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from langchain_openai import ChatOpenAI
+from agents.doc_editor import DocumentEditorAgent
+
+
+# Simple HTML document
+TEST_HTML = """<!DOCTYPE html>
+<html>
+<head>
+    <title>Test Document</title>
+</head>
+<body>
+    <h1>Test Contract</h1>
+    <p>This is a test paragraph with some text.</p>
+</body>
+</html>"""
+
+
+async def test_fake_view_current_document():
+    """
+    Test que le document est fourni via un faux view_current_document au démarrage.
+    L'agent devrait pouvoir faire des modifications sans appeler view_current_document.
+    """
+    
+    # Initialize LLMs
+    api_key = os.getenv("OPENAI_API_KEY") or os.getenv("CEREBRAS_API_KEY")
+    if not api_key:
+        print("❌ Error: OPENAI_API_KEY or CEREBRAS_API_KEY environment variable not set")
+        return
+    
+    # Pour les tests, on peut utiliser le même LLM pour les deux
+    llm_summary = ChatOpenAI(
+        model=os.getenv("LLM_MODEL", "gpt-4o-mini"),
+        temperature=0,
+        api_key=api_key,
+        base_url=os.getenv("OPENAI_API_BASE", None)
+    )
+    
+    llm_tool_calling = ChatOpenAI(
+        model=os.getenv("LLM_MODEL", "gpt-4o-mini"),
+        temperature=0,
+        api_key=api_key,
+        base_url=os.getenv("OPENAI_API_BASE", None)
+    )
+    
+    # Initialize document editor agent avec les deux LLMs
+    doc_editor = DocumentEditorAgent(llm=llm_summary, llm_tool_calling=llm_tool_calling)
+    
+    print("=" * 80)
+    print("🔧 TEST: Fake view_current_document initial")
+    print("=" * 80)
+    print("\n📄 DOCUMENT ORIGINAL:")
+    print(TEST_HTML)
+    print()
+    
+    # Test simple: changer "test paragraph" en "modified paragraph"
+    print("=" * 80)
+    print("🔧 INSTRUCTION: Change 'test paragraph' to 'modified paragraph'")
+    print("=" * 80)
+    
+    result = await doc_editor.edit_document(
+        doc_text=TEST_HTML,
+        user_instruction="Change the text 'test paragraph' to 'modified paragraph'",
+        max_iterations=5
+    )
+    
+    print(f"\n✅ Success: {result['success']}")
+    print(f"📝 Message: {result['message']}")
+    print(f"🔄 Iterations: {result['iteration_count']}")
+    
+    if result['success']:
+        print("\n📄 DOCUMENT MODIFIÉ:")
+        print(result['doc_text'])
+        
+        # Vérifier que le texte a été modifié
+        if "modified paragraph" in result['doc_text']:
+            print("\n✅ VERIFICATION PASSED: Texte modifié avec succès!")
+        else:
+            print("\n❌ VERIFICATION FAILED: Le texte n'a pas été modifié")
+    else:
+        print("\n❌ ERREUR: L'édition a échoué")
+        print(result.get('error', 'No error details'))
+    
+    print("\n" + "=" * 80)
+    print("🎯 POINT CLÉ: L'agent ne devrait PAS appeler view_current_document")
+    print("   car le document est déjà disponible via le faux tool call initial")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    print("🚀 Test du faux view_current_document initial\n")
+    asyncio.run(test_fake_view_current_document())

tests/test_gemini_tool_calling.py

@@ -95,7 +95,7 @@ async def test_llm_config():
     # Test DocumentEditorAgent initialization
     print(f"\n🧪 Testing DocumentEditorAgent initialization...")
     try:
-        from subagents.doc_editor import DocumentEditorAgent
+        from agents.doc_editor import DocumentEditorAgent
         
         doc_editor = DocumentEditorAgent(
             llm=llm_config.openai_llm,

tests/test_jpg.py

@@ -8,7 +8,7 @@ import asyncio
 from dotenv import load_dotenv
 from langchain_openai import ChatOpenAI
 from mistralai import Mistral
-from subagents.pdf_analyzer import PDFAnalyzerAgent
+from agents.pdf_analyzer import PDFAnalyzerAgent
 
 load_dotenv()
 

tests/test_logging_doc_editor.py

@@ -14,8 +14,8 @@ from pathlib import Path
 # Add parent directory to path for imports
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-from utils.doc_editor_tools import replace, add, delete, attempt_completion
-from subagents.doc_editor import DocumentEditorAgent
+from utils.editor_tools import replace, add, delete, attempt_completion
+from agents.doc_editor import DocumentEditorAgent
 from langchain_openai import ChatOpenAI
 
 # Configure detailed logging

tests/test_pdf_analyzer.py

@@ -9,7 +9,7 @@ from dotenv import load_dotenv
 from langchain_openai import ChatOpenAI
 from mistralai import Mistral
 
-from subagents.pdf_analyzer import PDFAnalyzerAgent
+from agents.pdf_analyzer import PDFAnalyzerAgent
 
 load_dotenv()
 

tests/test_tools_ainvoke.py

@@ -10,7 +10,7 @@ import os
 # Add parent directory to path
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
-from utils.doc_editor_tools import replace_html, add_html, delete_html, inspect_document, attempt_completion
+from utils.editor_tools import replace_html, add_html, delete_html, inspect_document, attempt_completion
 
 
 async def test_tool_ainvoke():

tests/test_update_notifier.py

@@ -11,7 +11,7 @@ from dotenv import load_dotenv
 # Add parent directory to path
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
-from utils.update_notifier import push_document_update
+from utils.utils_fn import push_document_update
 
 # Load environment variables
 load_dotenv(dotenv_path=".env", override=False)