def test_unmatched_newbies_forcefully_match_pros(player_factory):
    newbie = Search([player_factory(1500, 500, ladder_games=0)])
    pro = Search([player_factory(1400, 10, ladder_games=100)])

    searches = [newbie, pro]
    matches = algorithm.RandomlyMatchNewbies().find(searches)
    # No match if the pro is on their first attempt
    assert len(matches) == 0

    pro.register_failed_matching_attempt()
    matches = algorithm.RandomlyMatchNewbies().find(searches)
    assert len(matches) == 2
Esempio n. 2
0
def test_unmatched_newbies_do_not_forcefully_match_teams(p):
    newbie = Search([p(1500, 500, ladder_games=0)])
    team = Search([p(1500, 100), p(1500, 100)])

    searches = [newbie, team]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert len(matches) == 0
Esempio n. 3
0
def test_unmatched_newbies_do_notforcefully_match_top_players(p):
    newbie = Search([p(1500, 500, ladder_games=0)])
    top_player = Search([p(2500, 10, ladder_games=100)])

    searches = [newbie, top_player]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert len(matches) == 0
Esempio n. 4
0
def test_unmatched_newbies_forcefully_match_pros(p):
    newbie = Search([p(1500, 500, ladder_games=0)])
    pro = Search([p(1400, 10, ladder_games=100)])

    searches = [newbie, pro]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert len(matches) == 2
def test_unmatched_newbies_do_not_forcefully_match_top_players(player_factory):
    newbie = Search([player_factory(1500, 500, ladder_games=0)])
    top_player = Search([player_factory(2500, 10, ladder_games=100)])
    top_player.register_failed_matching_attempt()

    searches = [newbie, top_player]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert len(matches) == 0
Esempio n. 6
0
def test_odd_number_of_unmatched_newbies(p):
    newbie1 = Search([p(-250, 500, ladder_games=9)])
    newbie2 = Search([p(750, 500, ladder_games=9)])
    newbie3 = Search([p(1500, 500, ladder_games=9)])
    pro = Search([p(1500, 10, ladder_games=100)])

    searches = [newbie1, pro, newbie2, newbie3]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert len(matches) == 4
Esempio n. 7
0
def unmatched_newbie_teams_do_not_forcefully_match_pros(p):
    newbie_team = Search(
        [p(1500, 500, ladder_games=0),
         p(1500, 500, ladder_games=0)])
    pro = Search([p(1800, 10, ladder_games=100)])

    searches = [newbie_team, pro]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert len(matches) == 0
Esempio n. 8
0
def test_newbies_are_forcefully_matched_with_newbies(p):
    newbie1 = Search([p(0, 500, ladder_games=9)])
    newbie2 = Search([p(1500, 500, ladder_games=9)])
    pro = Search([p(1500, 10, ladder_games=100)])

    searches = [newbie1, pro, newbie2]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert matches[newbie1] == newbie2
    assert matches[newbie2] == newbie1
def test_newbies_are_forcefully_matched_with_newbies(player_factory):
    newbie1 = Search([player_factory(0, 500, ladder_games=9)])
    newbie2 = Search([player_factory(1500, 500, ladder_games=9)])
    pro = Search([player_factory(1500, 10, ladder_games=100)])
    pro.register_failed_matching_attempt()

    searches = [newbie1, pro, newbie2]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert matches[newbie1] == newbie2
    assert matches[newbie2] == newbie1
def test_odd_number_of_unmatched_newbies(player_factory):
    newbie1 = Search([player_factory(-250, 500, ladder_games=9)])
    newbie2 = Search([player_factory(750, 500, ladder_games=9)])
    newbie3 = Search([player_factory(1500, 500, ladder_games=9)])
    pro = Search([player_factory(1500, 10, ladder_games=100)])
    pro.register_failed_matching_attempt()

    searches = [newbie1, pro, newbie2, newbie3]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert len(matches) == 4
def unmatched_newbie_teams_do_not_forcefully_match_pros(player_factory):
    newbie_team = Search([
        player_factory(1500, 500, ladder_games=0),
        player_factory(1500, 500, ladder_games=0)
    ])
    pro = Search([player_factory(1800, 10, ladder_games=100)])
    pro.register_failed_matching_attempt()

    searches = [newbie_team, pro]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert len(matches) == 0
def test_random_newbie_matching_is_symmetric(player_factory):
    s1 = Search([player_factory(1000, 500, name="p1", ladder_games=5)])
    s2 = Search([player_factory(1200, 500, name="p2", ladder_games=5)])
    s3 = Search([player_factory(900, 500, name="p3", ladder_games=5)])
    s4 = Search([player_factory(1500, 500, name="p4", ladder_games=5)])
    s5 = Search([player_factory(1700, 500, name="p5", ladder_games=5)])
    s6 = Search([player_factory(600, 500, name="p6", ladder_games=5)])

    searches = [s1, s2, s3, s4, s5, s6]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    for search in matches:
        opponent = matches[search]
        assert matches[opponent] == search
Esempio n. 13
0
def test_random_newbie_matching_is_symmetric(p):
    s1 = Search([p(1000, 500, name='p1', ladder_games=5)])
    s2 = Search([p(1200, 500, name='p2', ladder_games=5)])
    s3 = Search([p(900, 500, name='p3', ladder_games=5)])
    s4 = Search([p(1500, 500, name='p4', ladder_games=5)])
    s5 = Search([p(1700, 500, name='p5', ladder_games=5)])
    s6 = Search([p(600, 500, name='p6', ladder_games=5)])

    searches = [s1, s2, s3, s4, s5, s6]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    for search in matches:
        opponent = matches[search]
        assert matches[opponent] == search
def test_newbie_and_top_rated_team_not_matched_randomly(player_factory):
    newbie_and_top_rated = Search([
        player_factory(0, 500, ladder_games=9),
        player_factory(2500, 10, ladder_games=1000)
    ])
    newbie = Search([
        player_factory(1500, 500, ladder_games=9),
        player_factory(1500, 500, ladder_games=9)
    ])

    searches = [newbie_and_top_rated, newbie]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert not matches
def test_newbie_team_dos_not_match_with_top_players_team(player_factory):
    newbie = Search([
        player_factory(1500, 500, ladder_games=0),
        player_factory(1500, 500, ladder_games=0)
    ])
    top_player = Search([
        player_factory(2500, 10, ladder_games=100),
        player_factory(2500, 10, ladder_games=100)
    ])
    top_player.register_failed_matching_attempt()

    searches = [newbie, top_player]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert len(matches) == 0
def test_newbie_team_matched_with_newbie_team(player_factory):
    newbie1 = Search([
        player_factory(0, 500, ladder_games=9),
        player_factory(0, 500, ladder_games=9)
    ])
    newbie2 = Search([
        player_factory(1500, 500, ladder_games=9),
        player_factory(1500, 500, ladder_games=9)
    ])

    searches = [newbie1, newbie2]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert matches[newbie1] == newbie2
    assert matches[newbie2] == newbie1
def test_partial_newbie_team_matched_with_newbie_team(player_factory):
    partial_newbie = Search([
        player_factory(0, 500, ladder_games=9),
        player_factory(0, 500, ladder_games=100)
    ])
    newbie = Search([
        player_factory(1500, 500, ladder_games=9),
        player_factory(1500, 500, ladder_games=9)
    ])

    searches = [partial_newbie, newbie]
    matches = algorithm.RandomlyMatchNewbies().find(searches)

    assert matches[partial_newbie] == newbie
    assert matches[newbie] == partial_newbie