Merge branch 'main' of https://github.com/GammardX/MinimumViableProduct

Author: intmainale

backend/requirements-dev.txt

@@ -0,0 +1,2 @@
+pytest==9.0.2
+pytest-asyncio==1.3.0

backend/test/adapters/output/test_json_parser_adapter.py

@@ -0,0 +1,58 @@
+import pytest
+from adapters.output.json_parser_adapter import JSONParserAdapter
+from domain.models import ResultStatus, ResultCode
+
+@pytest.fixture
+def parser():
+    return JSONParserAdapter()
+
+def test_parse_perfect_json(parser):
+    """Testa il caso ideale: JSON pulito"""
+    raw = '{"outcome": {"status": "success", "code": "OK"}, "data": {"rewritten_text": "Ciao"}}'
+    result = parser.parse_response(raw)
+    
+    assert result.status == ResultStatus.SUCCESS
+    assert result.rewritten_text == "Ciao"
+
+def test_parse_markdown_json(parser):
+    """Testa il caso comune: LLM risponde dentro blocchi Markdown"""
+    raw = """
+    Ecco il risultato:
+    ```json
+    {
+      "outcome": {"status": "success", "code": "OK"},
+      "data": {"rewritten_text": "Testo pulito"}
+    }
+    ```
+    Spero sia utile.
+    """
+    result = parser.parse_response(raw)
+    
+    assert result.status == ResultStatus.SUCCESS
+    assert result.rewritten_text == "Testo pulito"
+
+def test_parse_invalid_json_fallback(parser):
+    """Verifica che il parser gestisca errori di sintassi JSON restituendo un LLMResult di errore"""
+    raw = "Questa non è una stringa JSON"
+    result = parser.parse_response(raw)
+    
+    assert result.status == ResultStatus.ERROR
+    assert result.code == ResultCode.TECHNICAL_ERROR
+    assert "Parse error" in result.violation_category
+
+def test_parse_malformed_enum_values(parser):
+    """Verifica il fallback se l'LLM inventa stati o codici non esistenti"""
+    raw = '{"outcome": {"status": "inventato", "code": "BOOOH"}}'
+    result = parser.parse_response(raw)
+    
+    # Grazie ai tuoi try-except interni, deve fare il fallback sui default
+    assert result.status == ResultStatus.ERROR
+    assert result.code == ResultCode.TECHNICAL_ERROR
+
+def test_parse_with_special_characters(parser):
+    """Testa la sanitizzazione di newline e tabulazioni (logica interna dell'adapter)"""
+    raw = '{"outcome": {"status": "success"}, "data": {"rewritten_text": "Riga 1\nRiga 2"}}'
+    result = parser.parse_response(raw)
+    
+    assert result.status == ResultStatus.SUCCESS
+    assert "Riga 1" in result.rewritten_text

backend/test/adapters/output/test_llm_client_adapter.py

@@ -0,0 +1,60 @@
+import pytest
+import json
+from unittest.mock import AsyncMock, patch, MagicMock
+from adapters.output.llm_client_adapter import LLMClientAdapter
+
+@pytest.fixture
+def providers():
+    return [
+        {"name": "Primary", "url": "http://primary.ai", "model": "gpt-1"},
+        {"name": "Fallback", "url": "http://fallback.ai", "model": "gpt-2"}
+    ]
+
+@pytest.fixture
+def adapter(providers):
+    return LLMClientAdapter(providers)
+
+@pytest.mark.asyncio
+async def test_generate_completion_success_first_try(adapter):
+    """Verifica che se il primo provider funziona, restituisca la risposta corretta"""
+    # Mock _call_api_stream 
+    async def mock_stream(*args, **kwargs):
+        yield "Ciao "
+        yield "mondo"
+
+    with patch.object(LLMClientAdapter, '_call_api_stream', side_effect=mock_stream):
+        result = await adapter.generate_completion([{"role": "user", "content": "hi"}])
+        
+        assert result == "Ciao mondo"
+
+@pytest.mark.asyncio
+async def test_generate_completion_fallback_logic(adapter):
+    """Verifica che se il primo fallisce, provi il secondo"""
+    call_count = 0
+
+    async def mock_stream_with_fallback(*args, **kwargs):
+        nonlocal call_count
+        call_count += 1
+        if call_count == 1:
+            raise Exception("Primary Down")
+        yield "Risposta da fallback"
+
+    with patch.object(LLMClientAdapter, '_call_api_stream', side_effect=mock_stream_with_fallback):
+        result = await adapter.generate_completion([{"role": "user", "content": "hi"}])
+        
+        assert result == "Risposta da fallback"
+        assert call_count == 2 # Conferma che ha provato entrambi
+
+@pytest.mark.asyncio
+async def test_all_providers_fail_raises_exception(adapter):
+    """Verifica che se tutti i provider falliscono, venga lanciata un'eccezione"""
+    with patch.object(LLMClientAdapter, '_call_api_stream', side_effect=Exception("Network Error")):
+        with pytest.raises(Exception) as excinfo:
+            await adapter.generate_completion([{"role": "user", "content": "hi"}])
+        
+        assert "Nessun servizio AI disponibile" in str(excinfo.value)
+
+@pytest.mark.asyncio
+async def test_validate_connection_always_true(adapter):
+    """Verifica il metodo obbligatorio dal contratto"""
+    assert await adapter.validate_connection() is True

backend/test/adapters/output/test_prompt_builder_adapter.py

@@ -0,0 +1,58 @@
+import pytest
+from adapters.output.prompt_builder_adapter import PromptBuilderAdapter
+from domain.models import TextDocument
+
+@pytest.fixture
+def builder():
+    return PromptBuilderAdapter()
+
+def test_build_summarize_prompt_contains_variables(builder):
+    """Verifica che il prompt di riassunto includa la percentuale e il testo"""
+    doc = TextDocument(content="Questo è un testo di prova.")
+    percentage = 50
+    
+    messages = builder.build_summarize_prompt(doc, percentage)
+    
+    # Verifichiamo la struttura (System + User)
+    assert len(messages) == 2
+    assert messages[0]["role"] == "system"
+    assert messages[1]["role"] == "user"
+    
+    # Verifichiamo che i parametri siano stati iniettati
+    user_content = messages[1]["content"]
+    assert str(percentage) in user_content
+    assert "Questo è un testo di prova." in user_content
+    # Verifica protezione XML
+    assert "<text_to_process>" in user_content
+
+def test_build_six_hats_specific_instruction(builder):
+    """Verifica che il cappello 'nero' carichi le istruzioni di cautela"""
+    doc = TextDocument(content="Idea di business")
+    
+    messages = builder.build_six_hats_prompt(doc, "nero")
+    system_content = messages[0]["content"]
+    
+    assert "CAPPELLO NERO" in system_content.upper()
+    assert "avvocato del diavolo" in system_content.lower()
+
+def test_build_generate_prompt_with_context(builder):
+    """Verifica che la generazione includa il contesto se fornito"""
+    prompt = "Scrivi un articolo"
+    context = "Usa uno stile amichevole"
+    
+    messages = builder.build_generate_prompt(prompt, context_text=context, word_count=100)
+    user_content = messages[1]["content"]
+    
+    assert "<context>" in user_content
+    assert context in user_content
+    assert "100" in messages[0]["content"] # Word count nel system prompt
+
+def test_build_translate_target_language(builder):
+    """Verifica che la lingua di destinazione sia corretta nel prompt"""
+    doc = TextDocument(content="Hello")
+    target = "Italiano"
+    
+    messages = builder.build_translate_prompt(doc, target)
+    
+    assert target in messages[1]["content"]
+    assert "motore di traduzione AI" in messages[0]["content"]

backend/test/application/use_cases/test_analyze_six_hats.py

@@ -0,0 +1,81 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+from application.use_cases.analyze_six_hats import AnalyzeSixHatsUseCase
+from domain.models import TextDocument, LLMResult, ResultStatus, ResultCode
+
+@pytest.fixture
+def mocks():
+    return {
+        "llm": AsyncMock(),
+        "builder": MagicMock(),
+        "parser": MagicMock()
+    }
+
+@pytest.fixture
+def use_case(mocks):
+    return AnalyzeSixHatsUseCase(
+        llm_provider=mocks["llm"],
+        prompt_builder=mocks["builder"],
+        response_parser=mocks["parser"]
+    )
+
+@pytest.mark.asyncio
+async def test_six_hats_invalid_hat_name(use_case):
+    """Verifica che un cappello con nome errato (es. 'viola') venga rifiutato"""
+    doc = TextDocument(content="Testo valido")
+    result = await use_case.execute(doc, hat="viola")
+    
+    assert result.status == ResultStatus.INVALID_INPUT
+    assert "non supportato" in result.violation_category
+
+@pytest.mark.asyncio
+async def test_six_hats_case_insensitivity(use_case, mocks):
+    """Verifica che 'ROSSO', 'Rosso' e 'rosso' siano tutti accettati"""
+    doc = TextDocument(content="Testo")
+    mocks["builder"].build_six_hats_prompt.return_value = ["prompt"]
+    mocks["llm"].generate_completion.return_value = "raw"
+    mocks["parser"].parse_response.return_value = LLMResult(status=ResultStatus.SUCCESS, code=ResultCode.OK)
+    
+    # Test con maiuscole
+    result = await use_case.execute(doc, hat="ROSSO")
+    
+    assert result.is_successful()
+    # Verifichiamo che il builder sia stato chiamato (la logica passa la validazione)
+    mocks["builder"].build_six_hats_prompt.assert_called_once()
+
+@pytest.mark.asyncio
+async def test_six_hats_empty_hat_returns_invalid(use_case):
+    """Verifica che un cappello None o vuoto venga rifiutato"""
+    doc = TextDocument(content="Testo")
+    result = await use_case.execute(doc, hat="")
+    
+    assert result.status == ResultStatus.INVALID_INPUT
+    assert "non supportato" in result.violation_category
+
+@pytest.mark.asyncio
+async def test_six_hats_success_flow(use_case, mocks):
+    """Verifica il successo con un cappello valido (es. 'verde')"""
+    doc = TextDocument(content="Analisi creativa")
+    hat = "verde"
+    
+    mocks["builder"].build_six_hats_prompt.return_value = [{"role": "system", "content": "verde"}]
+    mocks["llm"].generate_completion.return_value = "Risposta creativa"
+    expected = LLMResult(status=ResultStatus.SUCCESS, code=ResultCode.OK, rewritten_text="Analisi verde")
+    mocks["parser"].parse_response.return_value = expected
+    
+    result = await use_case.execute(doc, hat=hat)
+    
+    mocks["builder"].build_six_hats_prompt.assert_called_with(doc, hat)
+    assert result == expected
+
+@pytest.mark.asyncio
+async def test_six_hats_llm_exception(use_case, mocks):
+    """Verifica la gestione dell'errore se il provider LLM fallisce"""
+    doc = TextDocument(content="Testo")
+    mocks["builder"].build_six_hats_prompt.return_value = ["prompt"]
+    mocks["llm"].generate_completion.side_effect = Exception("LLM Down")
+    
+    result = await use_case.execute(doc, hat="nero")
+    
+    assert result.status == ResultStatus.ERROR
+    assert "LLM Down" in result.violation_category

backend/test/application/use_cases/test_generate_text.py

@@ -0,0 +1,72 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+from application.use_cases.generate_text import GenerateTextUseCase
+from domain.models import LLMResult, ResultStatus, ResultCode
+
+@pytest.fixture
+def mocks():
+    return {
+        "llm": AsyncMock(),
+        "builder": MagicMock(),
+        "parser": MagicMock()
+    }
+
+@pytest.fixture
+def use_case(mocks):
+    return GenerateTextUseCase(
+        llm_provider=mocks["llm"],
+        prompt_builder=mocks["builder"],
+        response_parser=mocks["parser"]
+    )
+
+@pytest.mark.asyncio
+async def test_generate_empty_prompt_returns_invalid(use_case):
+    """Verifica che un prompt vuoto o composto da soli spazi venga rifiutato"""
+    result = await use_case.execute(prompt="   ")
+    
+    assert result.status == ResultStatus.INVALID_INPUT
+    assert result.code == ResultCode.EMPTY_PROMPT
+    assert "Il prompt non può essere vuoto" in result.violation_category
+
+@pytest.mark.asyncio
+async def test_generate_success_with_context(use_case, mocks):
+    """Verifica il flusso con prompt, contesto e word count personalizzato"""
+    # ARRANGE
+    prompt = "Scrivi una mail"
+    context = "L'utente è un manager"
+    words = 150
+    
+    mocks["builder"].build_generate_prompt.return_value = [{"role": "user", "content": "..."}]
+    mocks["llm"].generate_completion.return_value = "Risposta AI"
+    expected = LLMResult(status=ResultStatus.SUCCESS, code=ResultCode.OK, rewritten_text="Mail generata")
+    mocks["parser"].parse_response.return_value = expected
+    
+    # ACT
+    result = await use_case.execute(prompt=prompt, context_text=context, word_count=words)
+    
+    # ASSERT
+    # Verifichiamo che il builder riceva tutti i parametri corretti
+    mocks["builder"].build_generate_prompt.assert_called_once_with(prompt, context, words)
+    assert result == expected
+
+@pytest.mark.asyncio
+async def test_generate_uses_default_values(use_case, mocks):
+    """Verifica che vengano usati i valori di default per contesto e word_count"""
+    prompt = "Genera un'idea"
+    
+    await use_case.execute(prompt=prompt)
+    
+    # Il word_count di default nel tuo codice è 300
+    mocks["builder"].build_generate_prompt.assert_called_once_with(prompt, "", 300)
+
+@pytest.mark.asyncio
+async def test_generate_handles_llm_exception(use_case, mocks):
+    """Verifica la resilienza in caso di crash del provider LLM"""
+    mocks["builder"].build_generate_prompt.return_value = ["prompt"]
+    mocks["llm"].generate_completion.side_effect = Exception("Quota API esaurita")
+    
+    result = await use_case.execute(prompt="Test")
+    
+    assert result.status == ResultStatus.ERROR
+    assert result.code == ResultCode.TECHNICAL_ERROR
+    assert "Quota API esaurita" in result.violation_category