tests/api/test_singularity_api.py

from unittest.mock import MagicMock, patch

import pytest
from animetix.containers import get_container
from django.contrib.auth.models import User
from rest_framework.test import APIClient


@pytest.fixture
def api_client():
    return APIClient()


@pytest.fixture
def authenticated_user(api_client, db):
    user = User.objects.create_user(username="testuser", password="password")
    api_client.force_authenticate(user=user)
    return user


@pytest.mark.django_db
def test_singularity_synthesize_success(api_client, authenticated_user):
    url = "/api/v1/singularity-lab/"
    payload = {
        "action": "synthesize",
        "universe_name": "NeonGenesisX",
        "genre": "Sci-Fi",
    }

    mock_synthesizer = MagicMock()

    # Mock universe data
    universe_data = {
        "name": "NeonGenesisX",
        "genre": "Sci-Fi",
        "characters": [{"name": "Shinji"}],
        "episodes": [{"summary": "Test episode"}],
    }
    mock_synthesizer.synthesize_multiverse.return_value = universe_data
    mock_synthesizer.persist_universe_to_graph.return_value = True

    # Mock evaluation
    evaluation = {
        "is_worthy": True,
        "ai_score": 0.85,
        "community_score": 0.8,
        "reasoning": "Highly coherent.",
    }
    mock_synthesizer.evaluate_coherence_and_interest.return_value = evaluation

    container = get_container()
    container.core.autonomous_domain_synthesizer.override(mock_synthesizer)
    try:
        with patch("animetix.api.labs.singularity.deduct_berrix") as mock_deduct:
            response = api_client.post(url, payload, format="json")

            assert response.status_code == 200
            assert response.data["status"] == "success"
            assert response.data["universe"]["name"] == "NeonGenesisX"
            assert response.data["evaluation"]["is_worthy"] is True
            assert response.data["persisted"] is True
            assert "synthétisé et stagé pour validation" in response.data["message"]

            # Verify calls
            mock_deduct.assert_called_once_with(
                authenticated_user, 100, "Singularity: Synthèse Multivers"
            )
            mock_synthesizer.synthesize_multiverse.assert_called_once_with(
                universe_name="NeonGenesisX", primary_genre="Sci-Fi"
            )
            mock_synthesizer.persist_universe_to_graph.assert_called_once_with(
                universe_data
            )
            mock_synthesizer.evaluate_coherence_and_interest.assert_called_once_with(
                universe_data
            )
    finally:
        container.core.autonomous_domain_synthesizer.reset_last_overriding()


@pytest.mark.django_db
def test_singularity_synthesize_error(api_client, authenticated_user):
    url = "/api/v1/singularity-lab/"
    payload = {"action": "synthesize", "universe_name": "NeonGenesisX"}

    mock_synthesizer = MagicMock()
    mock_synthesizer.synthesize_multiverse.side_effect = Exception("Synthesis failed")

    container = get_container()
    container.core.autonomous_domain_synthesizer.override(mock_synthesizer)
    try:
        with patch("animetix.api.labs.singularity.deduct_berrix"):
            response = api_client.post(url, payload, format="json")

            assert response.status_code == 500
            assert response.data["error"] == "Internal server error"
    finally:
        container.core.autonomous_domain_synthesizer.reset_last_overriding()


@pytest.mark.django_db
def test_singularity_unknown_action(api_client, authenticated_user):
    url = "/api/v1/singularity-lab/"
    payload = {"action": "invalid"}
    response = api_client.post(url, payload, format="json")
    assert response.status_code == 400
    assert response.data["error"] == "Action inconnue"


@pytest.mark.django_db
def test_singularity_lab_get_unified_state(api_client, authenticated_user):
    import numpy as np

    url = "/api/v1/singularity-lab/"

    mock_plasticity = MagicMock()
    mock_drift = MagicMock()

    mock_plasticity.W = np.zeros((10, 10))
    mock_plasticity.tau_plus = 20.0
    mock_plasticity.tau_minus = 20.0
    mock_plasticity.num_concepts = 10

    mock_drift_config = MagicMock()
    mock_drift_config.archetype_id = "shonen_hero"
    mock_drift_config.primary_accent = "#FD7706"
    mock_drift_config.aura_type = "none"
    mock_drift_config.aura_intensity = 0.0
    mock_drift_config.font_vibe = "default"

    mock_drift.calculate_drift.return_value = mock_drift_config

    container = get_container()
    container.core.synaptic_plasticity_simulator.override(mock_plasticity)
    container.core.archetype_drift_service.override(mock_drift)
    try:
        response = api_client.get(url)
        assert response.status_code == 200
        assert "weights" in response.data
        assert "plasticity_config" in response.data
        assert "personalization_settings" in response.data
        assert response.data["current_archetype"]["id"] == "shonen_hero"
    finally:
        container.core.synaptic_plasticity_simulator.reset_last_overriding()
        container.core.archetype_drift_service.reset_last_overriding()


@pytest.mark.django_db
def test_singularity_lab_update_config(api_client, authenticated_user):
    import numpy as np

    url = "/api/v1/singularity-lab/"
    payload = {
        "action": "update_config",
        "tau_plus": 35.0,
        "tau_minus": 15.0,
        "mode": "manual",
        "manual_archetype": "cyberpunk_rebel",
        "intensity_multiplier": 1.5,
        "features": {"aura": True, "font": False, "accent": True},
    }

    # Verify profile exists
    profile = authenticated_user.profile

    mock_plasticity = MagicMock()
    mock_drift = MagicMock()

    mock_plasticity.W = np.zeros((10, 10))
    mock_plasticity.tau_plus = 20.0
    mock_plasticity.tau_minus = 20.0
    mock_plasticity.num_concepts = 10

    mock_drift_config = MagicMock()
    mock_drift_config.archetype_id = "cyberpunk_rebel"
    mock_drift_config.primary_accent = "#FF00FF"
    mock_drift_config.aura_type = "electric"
    mock_drift_config.aura_intensity = 1.5
    mock_drift_config.font_vibe = "cyber"

    mock_drift.calculate_drift.return_value = mock_drift_config

    container = get_container()
    container.core.synaptic_plasticity_simulator.override(mock_plasticity)
    container.core.archetype_drift_service.override(mock_drift)
    try:
        response = api_client.post(url, payload, format="json")
        assert response.status_code == 200

        # Verify plasticity mock parameters were set
        assert mock_plasticity.tau_plus == 35.0
        assert mock_plasticity.tau_minus == 15.0

        # Verify profile settings updated in DB
        profile.refresh_from_db()
        assert profile.personalization_settings["mode"] == "manual"
        assert profile.personalization_settings["manual_archetype"] == "cyberpunk_rebel"
        assert profile.personalization_settings["intensity_multiplier"] == 1.5
        assert profile.personalization_settings["features"]["font"] is False
    finally:
        container.core.synaptic_plasticity_simulator.reset_last_overriding()
        container.core.archetype_drift_service.reset_last_overriding()