Add unit tests for partisan primaries and coverage gaps (codecov)

- Exercise nominee_restricted_plurality, pairwise_majority, open/closed
  primaries, top_two_runoff_reduced_turnout (including sntv edge cases)
- Cover three_two_one pairwise branches and 2D validation
- Cover honest_321_ratings and honest_normed_scores invalid min/max range

Co-authored-by: endolith <endolith@gmail.com>

Author: cursoragent

tests/test_partisan_primaries.py

@@ -0,0 +1,119 @@
+import numpy as np
+import pytest
+
+from elsim.methods.partisan_primaries import (
+    closed_partisan_primary_runoff,
+    nominee_restricted_plurality,
+    open_partisan_primary,
+    pairwise_majority_from_rankings,
+    top_two_runoff_reduced_turnout,
+)
+
+
+def test_nominee_restricted_plurality_basic():
+    rankings = np.array([
+        [0, 1, 2, 3],
+        [0, 2, 1, 3],
+        [2, 3, 0, 1],
+        [2, 0, 1, 3],
+    ], dtype=np.uint8)
+    assert nominee_restricted_plurality(
+        rankings, [0, 1], np.array([0, 1]), 'order') == 0
+    assert nominee_restricted_plurality(
+        rankings, [2, 3], np.array([2, 3]), 'order') == 2
+
+
+def test_nominee_restricted_plurality_tie_order():
+    rankings = np.array([[0, 1], [1, 0]], dtype=np.uint8)
+    assert nominee_restricted_plurality(
+        rankings, [0, 1], np.array([0, 1]), 'order') == 0
+
+
+def test_pairwise_majority_prefers_a():
+    rankings = np.array([
+        [0, 1],
+        [0, 1],
+        [1, 0],
+    ], dtype=np.uint8)
+    assert pairwise_majority_from_rankings(
+        rankings, [0, 1, 2], 0, 1, 'order') == 0
+
+
+def test_pairwise_majority_prefers_b():
+    rankings = np.array([
+        [1, 0],
+        [1, 0],
+        [0, 1],
+    ], dtype=np.uint8)
+    assert pairwise_majority_from_rankings(
+        rankings, [0, 1, 2], 0, 1, 'order') == 1
+
+
+def test_pairwise_majority_tie_order():
+    rankings = np.array([[0, 1], [1, 0]], dtype=np.uint8)
+    assert pairwise_majority_from_rankings(
+        rankings, [0, 1], 0, 1, 'order') == 0
+
+
+def test_open_partisan_primary():
+    rankings = np.array([
+        [0, 1, 2, 3],
+        [0, 1, 2, 3],
+        [2, 3, 0, 1],
+        [2, 3, 0, 1],
+    ], dtype=np.uint8)
+    w = open_partisan_primary(
+        rankings, 2, [0, 1], [2, 3], [0, 1, 2, 3], 'order')
+    assert w == 0
+
+
+def test_closed_partisan_primary_runoff_subset():
+    rankings = np.array([
+        [0, 1, 2, 3],
+        [0, 1, 2, 3],
+        [2, 3, 0, 1],
+        [2, 3, 0, 1],
+    ], dtype=np.uint8)
+    w = closed_partisan_primary_runoff(
+        rankings, 2, [0, 1], [2, 3], [0, 2], 'order')
+    assert w == 0
+
+
+def test_top_two_runoff_unanimous_first_place():
+    rankings = np.array([[0, 1, 2], [0, 2, 1], [0, 1, 2]], dtype=np.uint8)
+    w = top_two_runoff_reduced_turnout(
+        rankings, [0, 1, 2], [0, 1, 2], 'order')
+    assert w == 0
+
+
+def test_top_two_runoff_two_finalists_pairwise():
+    rankings = np.array([
+        [0, 1, 2],
+        [0, 2, 1],
+        [1, 0, 2],
+        [1, 2, 0],
+    ], dtype=np.uint8)
+    w = top_two_runoff_reduced_turnout(
+        rankings, np.arange(4), np.arange(4), 'order')
+    assert w == 0
+
+
+def test_top_two_runoff_sntv_returns_none():
+    rankings = np.array([
+        [0, 1, 2, 3],
+        [1, 0, 2, 3],
+        [2, 1, 0, 3],
+        [3, 1, 2, 0],
+    ], dtype=np.uint8)
+    assert top_two_runoff_reduced_turnout(
+        rankings, [0, 1, 2, 3], [0, 1, 2, 3], tiebreaker=None) is None
+
+
+def test_top_two_runoff_too_many_sntv_winners_returns_none():
+    from unittest.mock import patch
+
+    rankings = np.array([[0, 1], [1, 0]], dtype=np.uint8)
+    with patch('elsim.methods.partisan_primaries.sntv',
+               return_value={0, 1, 2}):
+        assert top_two_runoff_reduced_turnout(
+            rankings, [0, 1], [0, 1], 'order') is None

tests/test_strategies.py

@@ -5,7 +5,8 @@
 from hypothesis.strategies import floats, integers, tuples
 from numpy.testing import assert_array_equal
 
-from elsim.strategies import approval_optimal, honest_normed_scores, vote_for_k
+from elsim.strategies import (approval_optimal, honest_321_ratings,
+                              honest_normed_scores, vote_for_k)
 
 
 def test_approval_optimal():
@@ -38,6 +39,28 @@ def test_honest_normed_scores():
                                                             ])
 
 
+def test_honest_normed_scores_invalid_range():
+    with pytest.raises(ValueError):
+        honest_normed_scores([[0.0, 1.0]], max_score=1, min_score=5)
+
+
+def test_honest_321_ratings_shapes():
+    assert_array_equal(honest_321_ratings([[1.0]]), [[2]])
+    assert_array_equal(
+        honest_321_ratings([[0.0, 1.0], [1.0, 0.0]]),
+        [[0, 2], [2, 0]])
+    u = np.ones((1, 9))
+    r = honest_321_ratings(u)
+    assert r.shape == (1, 9)
+    assert set(np.unique(r)) <= {0, 1, 2}
+
+
+def test_honest_321_ratings_too_many_candidates():
+    utilities = np.ones((1, 256))
+    with pytest.raises(ValueError):
+        honest_321_ratings(utilities)
+
+
 def test_vote_for_k():
     utilities = np.array([[0.0, 0.4, 1.0],
                           [1.0, 0.5, 0.9],

tests/test_three_two_one.py

@@ -2,6 +2,7 @@
 import pytest
 
 from elsim.methods import three_two_one
+from elsim.methods.three_two_one import _pairwise_rating_preference
 
 
 def test_three_two_one_invalid_ballots():
@@ -24,6 +25,31 @@ def test_three_two_one_two_candidates():
     assert three_two_one(election, 'order') == 0
 
 
+def test_three_two_one_two_candidates_second_wins():
+    election = np.array([[0, 2], [0, 2], [2, 0]], dtype=np.uint8)
+    assert three_two_one(election, 'order') == 1
+
+
+def test_three_two_one_requires_2d():
+    with pytest.raises(ValueError, match='2D'):
+        three_two_one(np.array([0, 1, 2]))
+
+
+def test_pairwise_rating_preference_total_score_favors_a():
+    election = np.array([[0, 1], [2, 0]], dtype=np.uint8)
+    assert _pairwise_rating_preference(election, 0, 1, 'order') == 0
+
+
+def test_pairwise_rating_preference_total_score_favors_b():
+    election = np.array([[0, 2], [1, 0]], dtype=np.uint8)
+    assert _pairwise_rating_preference(election, 0, 1, 'order') == 1
+
+
+def test_pairwise_rating_preference_full_tie_none_tiebreaker():
+    election = np.array([[1, 1], [1, 1]], dtype=np.uint8)
+    assert _pairwise_rating_preference(election, 0, 1, None) is None
+
+
 def test_three_two_one_eliminates_most_bad():
     # Semifinalists 0,1,2 by Good count; among them candidate 1 has most Bad.
     election = np.array([