astrololo/services/logic/tests/test_aspects.py

"""Testy aspektów (LOG-06) — czysta matematyka."""
from app.engine.aspects import RIGID_PAIRS, find_aspects, find_cross_aspects, separation


# ── synastria: aspekty MIĘDZY dwoma horoskopami (PRE-04) ──

def test_cross_aspects_between_two_charts():
    a = [{"name": "Sun", "decimal": 10.0}, {"name": "Moon", "decimal": 100.0}]
    b = [{"name": "Sun", "decimal": 12.0}, {"name": "Mars", "decimal": 70.0}]
    pairs = {(c["obj1"], c["obj2"], c["aspect"]) for c in find_cross_aspects(a, b)}
    assert ("Sun", "Sun", "conjunction") in pairs        # A.Słońce ↔ B.Słońce (2°)
    assert ("Sun", "Mars", "sextile") in pairs           # A.Słońce(10) ↔ B.Mars(70) = 60°


def test_cross_aspect_obj1_is_person_a_obj2_person_b():
    a = [{"name": "Venus", "decimal": 10.0}]
    b = [{"name": "Mars", "decimal": 12.0}]
    c = find_cross_aspects(a, b)[0]
    assert c["obj1"] == "Venus" and c["obj2"] == "Mars"


def test_cross_aspects_do_not_apply_rigid_pair_filter():
    """NN osoby A vs SN osoby B to REALNY aspekt między ludźmi — nie wycinamy go
    jak pary sztywnej w jednym horoskopie."""
    a = [{"name": "North Node", "decimal": 10.0}]
    b = [{"name": "South Node", "decimal": 12.0}]
    assert find_cross_aspects(a, b)                       # niepuste


def test_cross_aspects_no_applying_flag():
    """Dwa natale — brak wspólnego czasu, więc bez applying/separating."""
    a = [{"name": "Sun", "decimal": 10.0, "speed": 1.0}]
    b = [{"name": "Moon", "decimal": 12.0, "speed": 13.0}]
    assert "as" not in find_cross_aspects(a, b)[0]


# ── konfigurowalne aspekty i orby (PRE-06) ──

def test_minor_aspects_only_with_flag():
    """Domyślnie tylko główne; `minor=True` dokłada poboczne (30/45/150°)."""
    pos = [{"name": "A", "decimal": 10.0}, {"name": "B", "decimal": 40.0}]   # 30° = półsekstyl
    assert find_aspects(pos) == []                                          # główne: brak
    assert [a["aspect"] for a in find_aspects(pos, minor=True)] == ["semisextile"]


def test_orb_is_configurable():
    """Węższy orb odsiewa aspekt, który szerszy łapie."""
    pos = [{"name": "A", "decimal": 10.0}, {"name": "B", "decimal": 78.0}]   # 68° = sextile dev 8°
    assert find_aspects(pos, orb=5.0) == []
    assert [a["aspect"] for a in find_aspects(pos, orb=10.0)] == ["sextile"]


def test_luminary_bonus_widens_orb_for_lights():
    """Bonus dolicza orb tylko gdy w parze jest Słońce/Księżyc."""
    lights = [{"name": "Sun", "decimal": 10.0}, {"name": "Mars", "decimal": 79.0}]  # dev 9° od sextile
    assert find_aspects(lights, orb=8.0, luminary_bonus=0.0) == []          # 9 > 8
    assert [a["aspect"] for a in find_aspects(lights, orb=8.0, luminary_bonus=2.0)] == ["sextile"]  # 9 < 10
    plain = [{"name": "Venus", "decimal": 10.0}, {"name": "Mars", "decimal": 79.0}]
    assert find_aspects(plain, orb=8.0, luminary_bonus=2.0) == []           # brak światła → bez bonusu


def test_separation_wraparound():
    assert separation(10, 350) == 20
    assert separation(0, 180) == 180
    assert separation(0, 90) == 90


def test_conjunction_and_opposition():
    pos = [
        {"name": "Sun", "decimal": 10.0},
        {"name": "Moon", "decimal": 12.0},   # 2° od Słońca -> koniunkcja
        {"name": "Mars", "decimal": 190.0},  # 180° od Słońca -> opozycja
    ]
    pairs = {(a["obj1"], a["obj2"], a["aspect"]) for a in find_aspects(pos)}
    assert ("Sun", "Moon", "conjunction") in pairs
    assert ("Sun", "Mars", "opposition") in pairs


def test_orb_limit_excludes_wide():
    pos = [{"name": "Mercury", "decimal": 0.0}, {"name": "Venus", "decimal": 100.0}]
    assert find_aspects(pos, orb=8.0, luminary_bonus=0.0) == []


def test_luminary_bonus_widens_orb():
    # 99.5° -> 9.5° od kwadratury; z bonusem luminarza (8+2) mieści się
    pos = [{"name": "Sun", "decimal": 0.0}, {"name": "Saturn", "decimal": 99.5}]
    assert any(a["aspect"] == "square" for a in find_aspects(pos))


def test_one_aspect_per_pair():
    pos = [{"name": "Sun", "decimal": 0.0}, {"name": "Moon", "decimal": 2.0}]
    assert len(find_aspects(pos)) == 1


def test_applying_when_faster_body_catches_up():
    # Księżyc 5° za Słońcem, szybszy -> koniunkcja aplikacyjna
    pos = [
        {"name": "Sun", "decimal": 40.0, "speed": 0.96},
        {"name": "Moon", "decimal": 35.0, "speed": 13.0},
    ]
    a = find_aspects(pos)[0]
    assert a["applying"] is True and a["as"] == "A"


def test_separating_when_moving_apart():
    # Księżyc 5° przed Słońcem i szybszy -> koniunkcja separacyjna
    pos = [
        {"name": "Sun", "decimal": 40.0, "speed": 0.96},
        {"name": "Moon", "decimal": 45.0, "speed": 13.0},
    ]
    a = find_aspects(pos)[0]
    assert a["applying"] is False and a["as"] == "S"


def test_rigid_pair_nodes_not_reported():
    # SN = NN + 180° z definicji — trywialna opozycja, nie aspekt
    pos = [
        {"name": "North Node", "decimal": 42.0, "speed": -0.053},
        {"name": "South Node", "decimal": 222.0, "speed": -0.053},
        {"name": "Sun", "decimal": 42.5, "speed": 0.96},
    ]
    pairs = {frozenset((a["obj1"], a["obj2"])) for a in find_aspects(pos)}
    assert frozenset({"North Node", "South Node"}) not in pairs
    # aspekty węzłów do innych obiektów zostają nietknięte
    assert frozenset({"Sun", "North Node"}) in pairs
    assert frozenset({"Sun", "South Node"}) in pairs


def test_no_rigid_pairs_in_real_chart(own_engine, reference_moment):
    from app.engine.chart import build_chart

    chart = build_chart(own_engine, reference_moment)
    found = [a for a in chart["aspects"] if frozenset((a["obj1"], a["obj2"])) in RIGID_PAIRS]
    assert not found, f"trywialne aspekty par sztywnych w horoskopie: {found}"


def test_no_as_flag_without_speeds():
    pos = [{"name": "Sun", "decimal": 0.0}, {"name": "Moon", "decimal": 2.0}]
    assert "as" not in find_aspects(pos)[0]


# Referencja A/S z notes3 (astro-seek) dla horoskopu 30.04.1984 07:35 UT, Warszawa.
REFERENCE_AS = {
    ("Sun", "Moon", "conjunction"): "A",
    ("Sun", "Jupiter", "trine"): "A",
    ("Sun", "Saturn", "opposition"): "A",
    ("Sun", "Neptune", "trine"): "S",
    ("Sun", "Pluto", "opposition"): "S",
    ("Moon", "Mercury", "conjunction"): "S",
    ("Moon", "Venus", "conjunction"): "S",
    ("Moon", "Neptune", "trine"): "A",
    ("Moon", "Pluto", "opposition"): "S",
    ("Mercury", "Venus", "conjunction"): "S",
    ("Mercury", "Neptune", "trine"): "S",
    ("Mercury", "Pluto", "opposition"): "S",
    ("Venus", "Neptune", "trine"): "A",
    ("Venus", "Pluto", "opposition"): "A",
    ("Jupiter", "Saturn", "sextile"): "A",
    ("Neptune", "Pluto", "sextile"): "S",
}


def test_applying_separating_matches_astroseek_reference(own_engine, reference_moment):
    from app.engine.chart import build_chart

    chart = build_chart(own_engine, reference_moment)
    got = {(a["obj1"], a["obj2"], a["aspect"]): a.get("as") for a in chart["aspects"]}
    mismatches = {k: (got.get(k), v) for k, v in REFERENCE_AS.items() if got.get(k) != v}
    assert not mismatches, f"rozbieżności A/S vs astro-seek: {mismatches}"