GerbilManager/tools/import/test_merge_resolve.py

"""Zero-dep tests for merge_and_resolve.py litter-dedup & parent-role logic.

Run: python test_merge_resolve.py   (exit 0 = all pass)

Covers the sibling-pairing data fix:
- litter_compatible(): same-date / compatible-parent dedup, incl. the dateless
  guard that stops unrelated nameless stubs from blind-merging.
- assign_parent_roles(): gender-correct role assignment, self-pairing removal,
  no two same-role parents — the fix for the 16 self-pairings / 30 gender-role
  errors that the old simple swap missed.
"""
import sys
import merge_and_resolve as m


def check(name, cond):
    if not cond:
        print(f"FAIL: {name}")
        check.failed += 1
    else:
        print(f"ok:   {name}")
check.failed = 0


def litter(date, fid=None, mid=None, fname=None, mname=None):
    return {
        "Date": date,
        "FatherId": fid,
        "MotherId": mid,
        "_father_name": fname,
        "_mother_name": mname,
    }


# ── litter_compatible: both sides fully parented ──
check(
    "same date + same parents → compatible",
    m.litter_compatible(litter("2018-09-22", "F", "M"), litter("2018-09-22", "F", "M")),
)
check(
    "same date + different parents → NOT compatible",
    not m.litter_compatible(litter("2018-09-22", "F", "M"), litter("2018-09-22", "X", "Y")),
)
check(
    "different date → NOT compatible",
    not m.litter_compatible(litter("2018-09-22", "F", "M"), litter("2019-01-01", "F", "M")),
)

# ── asymmetric (one resolved, one not), real date ──
check(
    "asymmetric same real date, names agree → merge",
    m.litter_compatible(
        litter("2018-09-22", "F", "M", "Wonderman", "Unique"),
        litter("2018-09-22", None, None, "Wonderman", "Unique"),
    ),
)
check(
    "asymmetric same real date, conflicting names → NO merge",
    not m.litter_compatible(
        litter("2018-09-22", "F", "M", "Wonderman", "Unique"),
        litter("2018-09-22", None, None, "Someone", "Else"),
    ),
)
check(
    "asymmetric real date, parented side nameless stub → merge (no conflict)",
    m.litter_compatible(
        litter("2018-09-22", "F", "M", "Wonderman", "Unique"),
        litter("2018-09-22", None, None, None, None),
    ),
)

# ── dateless guard: the bug that wrongly merged unrelated stubs ──
check(
    "dateless asymmetric, NO name evidence → do NOT merge (was the bug)",
    not m.litter_compatible(
        litter(None, "F", "M", "Akina", "Arrow"),
        litter(None, None, None, None, None),
    ),
)
check(
    "dateless asymmetric WITH positive name match → merge",
    m.litter_compatible(
        litter(None, "F", "M", "Akina", "Arrow"),
        litter(None, None, None, "Akina", None),
    ),
)
check(
    "dateless asymmetric, contradicting names → do NOT merge",
    not m.litter_compatible(
        litter(None, "F", "M", "Akina", "Arrow"),
        litter(None, None, None, "Mismatch", None),
    ),
)

# ── neither side parented → never blind-merge ──
check(
    "neither parented, same date → NOT compatible",
    not m.litter_compatible(litter("2018-09-22"), litter("2018-09-22")),
)


# ── assign_parent_roles ──
GENDER = {"bock": "male", "bock2": "male", "maus": "female", "maus2": "female", "u": "unknown", "u2": "unknown"}
gof = lambda gid: GENDER.get(gid)

check("correct roles stay put", m.assign_parent_roles("bock", "maus", gof) == ("bock", "maus"))
check("reversed roles get swapped", m.assign_parent_roles("maus", "bock", gof) == ("bock", "maus"))
check(
    "self-pairing collapses to gender-correct single role (male→father)",
    m.assign_parent_roles("bock", "bock", gof) == ("bock", None),
)
check(
    "self-pairing collapses to gender-correct single role (female→mother)",
    m.assign_parent_roles("maus", "maus", gof) == (None, "maus"),
)
check(
    "female in father slot, empty mother → moved to mother",
    m.assign_parent_roles("maus", None, gof) == (None, "maus"),
)
check(
    "male in mother slot, empty father → moved to father",
    m.assign_parent_roles(None, "bock", gof) == ("bock", None),
)
check(
    "two males → keep one father, drop impossible second",
    m.assign_parent_roles("bock", "bock2", gof) == ("bock", None),
)
check(
    "two females → keep one mother, drop impossible second",
    m.assign_parent_roles("maus", "maus2", gof) == (None, "maus"),
)
check(
    "male + unknown → unknown fills mother",
    m.assign_parent_roles("bock", "u", gof) == ("bock", "u"),
)
check(
    "female + unknown → unknown fills father",
    m.assign_parent_roles("u", "maus", gof) == ("u", "maus"),
)
check("both empty → both None", m.assign_parent_roles(None, None, gof) == (None, None))
check(
    "single unknown parent kept as father",
    m.assign_parent_roles("u", None, gof) == ("u", None),
)


# ── name helpers ──
check("names_no_conflict: one side empty", m.names_no_conflict(litter(None, fname="A"), litter(None)))
check(
    "names_no_conflict: contradiction detected",
    not m.names_no_conflict(litter(None, fname="A"), litter(None, fname="B")),
)
check("names_overlap: matching father name", m.names_overlap(litter(None, fname="A"), litter(None, fname="A")))
check("names_overlap: nothing in common", not m.names_overlap(litter(None, fname="A"), litter(None, mname="B")))


# ── parent_age_plausible: born before child, within ~6y lifespan ──
check("age: parent 1y before child → plausible", m.parent_age_plausible("16.04.2021", "27.03.2022"))
check("age: parent born AFTER child → implausible", not m.parent_age_plausible("2023-01-01", "2022-03-27"))
check("age: parent born SAME day → implausible", not m.parent_age_plausible("2022-03-27", "2022-03-27"))
check("age: 9 years older (Jayjay→Solice) → implausible", not m.parent_age_plausible("19.06.2013", "27.03.2022"))
check("age: exactly ~5y older → plausible", m.parent_age_plausible("01.06.2017", "01.05.2022"))
check("age: 7 years older → implausible", not m.parent_age_plausible("25.10.2018", "13.08.2025"))
check("age: unknown parent dob → plausible (can't disprove)", m.parent_age_plausible(None, "2022-03-27"))
check("age: unknown litter date → plausible", m.parent_age_plausible("2021-04-16", None))


# ── pick_parent_ref: prefer age-plausible ref, avoid duplicating the other role ──
def pref(name, role, dob=None):
    return {"name": name, "roleGuess": role, "dob": dob}

# Solice case: first father ref (Jayjay, no DOB) loses to the dated, plausible Lui.
solice_refs = [
    pref("Jayjay", "father"),
    pref("Lui von den Kleinen Chaoten", "mother", "16.04.2021"),
    pref("Lui von den Kleinen Chaoten", "father", "16.04.2021"),
    pref("Molly of Black Forest", "mother", "13.09.2021"),
]
f = m.pick_parent_ref(solice_refs, "father", "27.03.2022")
check("pick: father = plausible-dated Lui, not first-listed Jayjay",
      f and f["name"] == "Lui von den Kleinen Chaoten")
mo = m.pick_parent_ref(solice_refs, "mother", "27.03.2022", avoid_name=f["name"])
check("pick: mother = Molly (Lui avoided as it is the father)",
      mo and mo["name"] == "Molly of Black Forest")

check("pick: a dated-but-impossible ref loses to a plausible one",
      m.pick_parent_ref([pref("Old", "father", "2010-01-01"), pref("Dad", "father", "2021-01-01")],
                        "father", "2022-03-27")["name"] == "Dad")
check("pick: no ref for role → None",
      m.pick_parent_ref([pref("X", "mother", "2021-01-01")], "father", "2022-03-27") is None)
check("pick: single ref is returned",
      m.pick_parent_ref([pref("Solo", "father")], "father", "2022-03-27")["name"] == "Solo")

# Gender-aware: a dated FEMALE ref must not win the father slot over an undated
# male/unknown one (Molly regression: Hagrid (unknown, no DOB) vs Danielle
# (female, dated) → father must be Hagrid, not Danielle).
molly_refs = [
    pref("Hagrid Rubeus of Black Forest", "father"),
    pref("Arya Stark von den Kleinen Chaoten", "mother", "30.06.2020"),
    pref("Danielle von den Kleinen Chaoten", "father", "04.03.2020"),
    pref("Hagrid Rubeus of Black Forest", "mother", "18.07.2019"),
]
gender = {
    m.normalize_name("Hagrid Rubeus of Black Forest"): None,         # unknown
    m.normalize_name("Danielle von den Kleinen Chaoten"): "female",
    m.normalize_name("Arya Stark von den Kleinen Chaoten"): "female",
}
gof = lambda name: gender.get(m.normalize_name(name))
fr = m.pick_parent_ref(molly_refs, "father", "13.09.2021", gender_of=gof)
check("pick(gender): father = unknown-sex Hagrid, not dated female Danielle",
      fr and fr["name"] == "Hagrid Rubeus of Black Forest")
mr = m.pick_parent_ref(molly_refs, "mother", "13.09.2021", avoid_name=fr["name"], gender_of=gof)
check("pick(gender): mother = Arya (female)", mr and mr["name"].startswith("Arya"))


if check.failed:
    print(f"\n{check.failed} test(s) FAILED")
    sys.exit(1)
print("\nAll merge_and_resolve tests passed.")