def test_cmd_soulz_for_another_disconnected_player(self):
player = fake_player(123, "Issuing Player", team="red")
fragging_player = fake_player(456, "Fragging Player", team="red")
killed1 = fake_player(4, "Killed1", team="blue")
killed2 = fake_player(5, "Killed2", team="blue")
killed3 = fake_player(6, "Killed3", team="blue")
killed4 = fake_player(7, "Killed4", team="blue")
connected_players(player, killed1, killed2, killed3, killed4)
when(self.db).zrevrangebyscore(f"minqlx:players:{fragging_player.steam_id}:soulz",
"+INF", "-INF", start=0, num=10, withscores=True)\
.thenReturn([
(killed2.steam_id, 2),
(killed3.steam_id, 1)
])
when(self.db).exists(
f"minqlx:players:{fragging_player.steam_id}:last_used_name"
).thenReturn(True)
when(self.db).get(f"minqlx:players:{fragging_player.steam_id}:last_used_name") \
.thenReturn(fragging_player.name)
self.plugin.cmd_soulz(player,
["!soulz", f"{fragging_player.steam_id}"],
self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches(r"Top 10 reaped soulz for Fragging Player.*: "
r"Killed2.* \(2\), Killed3.* \(1\)"))
def test_cmd_mapsoulz_for_another_disconnected_player(self):
player = fake_player(123, "Issuing Player", team="red")
fragging_player = fake_player(456, "Fragging Player", team="red")
killed1 = fake_player(4, "Killed1", team="blue")
killed2 = fake_player(5, "Killed2", team="blue")
killed3 = fake_player(6, "Killed3", team="blue")
killed4 = fake_player(7, "Killed4", team="blue")
connected_players(player, killed1, killed2, killed3, killed4)
self.plugin.frag_log = [(player.steam_id, killed1.steam_id),
(fragging_player.steam_id, killed2.steam_id),
(fragging_player.steam_id, killed2.steam_id),
(fragging_player.steam_id, killed3.steam_id)]
when(self.db).exists(
f"minqlx:players:{fragging_player.steam_id}:last_used_name"
).thenReturn(True)
when(self.db).get(f"minqlx:players:{fragging_player.steam_id}:last_used_name") \
.thenReturn(fragging_player.name)
self.plugin.cmd_mapsoulz(player,
["!mapsoulz", f"{fragging_player.steam_id}"],
self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches(r"Top 10 reaped soulz for Fragging Player.*: "
r"Killed2.* \(2\), Killed3.* \(1\)"))
def test_cmd_soulz_returns_top10(self):
player = fake_player(123, "Issuing Player", team="red")
killed1 = fake_player(4, "Killed1", team="blue")
killed2 = fake_player(5, "Killed2", team="blue")
killed3 = fake_player(6, "Killed3", team="blue")
killed4 = fake_player(7, "Killed4", team="blue")
connected_players(player, killed1, killed2, killed3, killed4)
when(self.db).zrevrangebyscore(f"minqlx:players:{player.steam_id}:soulz",
"+INF", "-INF", start=0, num=10, withscores=True)\
.thenReturn([
(killed1.steam_id, 2),
(killed2.steam_id, 3),
(killed3.steam_id, 5),
(killed4.steam_id, 8)
])
self.plugin.cmd_soulz(player, ["!soulz"], self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches(
r"Top 10 reaped soulz for Issuing Player.*: "
r"Killed4.* \(8\), Killed3.* \(5\), Killed2.* \(3\), Killed1.* \(2\)"
))
def test_cmd_reaperz_returns_top10(self):
player = fake_player(123, "Issuing Player", team="red")
killer1 = fake_player(4, "Killer1", team="blue")
killer2 = fake_player(5, "Killer2", team="blue")
killer3 = fake_player(6, "Killer3", team="blue")
killer4 = fake_player(7, "Killer4", team="blue")
connected_players(player, killer1, killer2, killer3, killer4)
when(self.db).zrevrangebyscore(f"minqlx:players:{player.steam_id}:reaperz",
"+INF", "-INF", start=0, num=10, withscores=True)\
.thenReturn([
(killer1.steam_id, 2),
(killer2.steam_id, 3),
(killer3.steam_id, 5),
(killer4.steam_id, 7),
])
self.plugin.cmd_reaperz(player, ["!reaperz"], self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches(
r"Top 10 reaperz of Issuing Player.*'s soul: "
r"Killer4.* \(7\), Killer3.* \(5\), Killer2.* \(3\), Killer1.* \(2\)"
))
def test_handle_player_connect_logs_error_if_privacy_information_not_included(
self):
setup_cvars({
"qlx_qlstatsPrivacyKick": "0",
"qlx_qlstatsPrivacyBlock": "1",
"qlx_qlstatsPrivacyWhitelist": "public, anonymous",
"qlx_qlstatsPrivacyJoinAttempts": "5",
"qlx_balanceApi": "belo"
})
connecting_player = fake_player(123, "Connecting Player")
result = self.qlstats_response()
when(result).json().thenReturn(
{"playerinfo": {
str(connecting_player.steam_id): {}
}})
self.setup_qlstats_response(result)
self.plugin.handle_player_connect(connecting_player)
verify(minqlx).console_command(
matches(".*QLStatsPrivacyError.*Response.*"
"did not include.*privacy information.*"))
def test_cmd_soulz_with_a_disconnected_player(self):
player = fake_player(123, "Issuing Player", team="red")
killed1 = fake_player(4, "Killed1", team="blue")
disconnected_killed2 = fake_player(5,
"Disconnected Killed2",
team="blue")
connected_players(player, killed1)
when(self.db).zrevrangebyscore(f"minqlx:players:{player.steam_id}:soulz",
"+INF", "-INF", start=0, num=10, withscores=True)\
.thenReturn([
(killed1.steam_id, 1),
(disconnected_killed2.steam_id, 2)
])
when(self.db).exists(
f"minqlx:players:{disconnected_killed2.steam_id}:last_used_name"
).thenReturn(True)
when(self.db).get(f"minqlx:players:{disconnected_killed2.steam_id}:last_used_name") \
.thenReturn(disconnected_killed2.name)
self.plugin.cmd_soulz(player, ["!soulz"], self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches(r"Top 10 reaped soulz for Issuing Player.*: "
r"Disconnected Killed2.* \(2\), Killed1.* \(1\)"))
def test_cmd_mapreaperz_with_a_disconnected_player(self):
player = fake_player(123, "Issuing Player", team="red")
killed1 = fake_player(4, "Killed1", team="blue")
disconnected_killed2 = fake_player(5,
"Disconnected Killed2",
team="blue")
connected_players(player, killed1)
self.plugin.frag_log = [
(killed1.steam_id, player.steam_id),
(disconnected_killed2.steam_id, player.steam_id),
(disconnected_killed2.steam_id, player.steam_id)
]
when(self.db).exists(
f"minqlx:players:{disconnected_killed2.steam_id}:last_used_name"
).thenReturn(True)
when(self.db).get(f"minqlx:players:{disconnected_killed2.steam_id}:last_used_name") \
.thenReturn(disconnected_killed2.name)
self.plugin.cmd_mapreaperz(player, ["!mapreaperz"], self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches(r"Top 10 reaperz of Issuing Player.*'s soul: "
r"Disconnected Killed2.* \(2\), Killed1.* \(1\)"))
def test_cmd_mapreaperz_returns_top10(self):
player = fake_player(123, "Issuing Player", team="red")
killer1 = fake_player(4, "Killer1", team="blue")
killer2 = fake_player(5, "Killer2", team="blue")
killer3 = fake_player(6, "Killer3", team="blue")
killer4 = fake_player(7, "Killer4", team="blue")
connected_players(player, killer1, killer2, killer3, killer4)
self.plugin.frag_log = [(killer1.steam_id, player.steam_id),
(killer2.steam_id, player.steam_id),
(killer3.steam_id, player.steam_id),
(killer4.steam_id, player.steam_id),
(killer4.steam_id, player.steam_id),
(killer3.steam_id, player.steam_id),
(killer4.steam_id, player.steam_id),
(killer2.steam_id, player.steam_id),
(killer4.steam_id, player.steam_id),
(killer3.steam_id, player.steam_id),
(killer4.steam_id, player.steam_id),
(killer4.steam_id, player.steam_id),
(killer2.steam_id, player.steam_id),
(killer1.steam_id, player.steam_id),
(killer3.steam_id, player.steam_id),
(killer4.steam_id, player.steam_id),
(killer3.steam_id, player.steam_id)]
self.plugin.cmd_mapreaperz(player, ["!mapreaperz"], self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches(
r"Top 10 reaperz of Issuing Player.*'s soul: "
r"Killer4.* \(7\), Killer3.* \(5\), Killer2.* \(3\), Killer1.* \(2\)"
))
def test_cmd_switch_plugin_disable_policy_check(self):
reply_channel = mocked_channel()
self.plugin.cmd_switch_plugin(None, ["!policy"], reply_channel)
assert_channel_was_replied(
reply_channel, matches(".*QLStats policy check disabled.*"))
assert_that(self.plugin.plugin_enabled, is_(False))
def test_cmd_switch_plugin_disabled(self):
self.plugin.plugin_enabled = False
reply_channel = mocked_channel()
self.plugin.cmd_switch_plugin(None, ["!policy", "status"],
reply_channel)
assert_channel_was_replied(reply_channel, matches(".*disabled.*"))
def test_cmd_soulz_for_another_non_existent_player(self):
player = fake_player(123, "Issuing Player", team="red")
connected_players(player)
self.plugin.cmd_soulz(player, ["!soulz", "Non-existent"],
self.reply_channel)
assert_player_was_told(player, matches(".*no players matched.*"))
def test_cmd_policy_exception_for_no_matching_player(self):
admin_player = fake_player(123, "Admin Player")
connected_players(admin_player)
self.plugin.cmd_policy_exception(admin_player, ["!except", "except"],
minqlx.CHAT_CHANNEL)
assert_player_was_told(admin_player,
matches(".*Could not find player.*"))
def test_cmd_switch_plugin_moves_anonymous_players_to_spec(self):
self.plugin.plugin_enabled = False
reply_channel = mocked_channel()
red_player = fake_player(123, "Red Player", "red")
blue_player = fake_player(456, "Blue Player", "blue")
connected_players(red_player, blue_player)
self.setup_balance_playerprivacy([(red_player, "public"),
(blue_player, "private")])
self.plugin.cmd_switch_plugin(None, ["!policy"], reply_channel)
assert_player_was_put_on(red_player, "spectator", times=0)
assert_player_was_told(red_player, any, times=0)
assert_player_was_put_on(blue_player, "spectator")
assert_player_was_told(blue_player, matches(".*Open qlstats.net.*"))
assert_player_received_center_print(blue_player,
matches(".*Join not allowed.*"))
assert_plugin_sent_to_console(matches(".*not allowed to join.*"))
def test_handle_team_switch_attempt_player_has_forbidden_privacy_setting_moved_to_spec(
self):
specced_player = fake_player(123, "Test Player")
connected_players(specced_player)
# noinspection PyUnresolvedReferences
self.plugin.plugins["balance"].player_info = {
specced_player.steam_id: {
"privacy": "private"
}
}
self.plugin.handle_team_switch_attempt(specced_player, "red", "blue")
assert_plugin_sent_to_console(matches(".*not allowed to join.*"))
assert_player_received_center_print(specced_player,
matches(r"\^3Join not allowed.*"))
assert_player_was_told(specced_player, matches(".*Open qlstats.net.*"))
assert_player_was_put_on(specced_player, "spectator")
def test_handle_vote_called_for_pql(self):
voting_player = fake_player(123, "Voting Player", _id=3)
return_code = self.plugin.handle_vote_called(voting_player, "mode", "pql")
assert_that(return_code, is_(minqlx.RET_STOP_ALL))
verify(Plugin).callvote("mode pql", "mode pql")
verify(minqlx).client_command(voting_player.id, "vote yes")
assert_plugin_sent_to_console(matches(r".*called a vote\."))
def test_cmd_soulz_for_another_non_existent_lava_player(self):
player = fake_player(123, "Issuing Player", team="red")
connected_players(player)
self.plugin.cmd_soulz(player, ["!soulz", "lava"], self.reply_channel)
assert_player_was_told(player, matches(".*no players matched.*"))
assert_channel_was_replied(self.reply_channel, any_,
times=0) # type: ignore
def test_cmd_mapreaperz_with_no_fragger(self):
player = fake_player(123, "Issuing Player", team="red")
connected_players(player)
self.plugin.cmd_mapreaperz(player, ["!mapreaperz"], self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches("Issuing Player.*'s soul was not reaped by anyone, yet."))
def test_handle_team_switch_attempt_player_has_no_ratings(self):
switching_player = fake_player(123, "Joining Player")
connected_players(switching_player)
return_code = self.plugin.handle_team_switch_attempt(
switching_player, "spectator", "any")
assert_player_was_told(switching_player,
matches("We couldn't fetch your ratings.*"))
assert_that(return_code, is_(minqlx.RET_STOP_ALL))
def test_handle_team_switch_attempt_no_balance_plugin_loaded(self):
self.setup_no_balance_plugin()
player = fake_player(42, "Fake Player")
connected_players(player)
return_code = self.plugin.handle_team_switch_attempt(
player, "spectator", "red")
assert_that(return_code, is_(minqlx.RET_NONE))
assert_plugin_sent_to_console(matches(".*not possible.*"))
def test_cmd_mapsoulz_with_no_frags(self):
player = fake_player(123, "Issuing Player", team="red")
connected_players(player)
self.plugin.cmd_mapsoulz(player, ["!mapsoulz"], self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches("Issuing Player.* didn't reap any soulz, yet."))
def test_cmd_switch_plugin_enables_policy_check(self):
self.plugin.plugin_enabled = False
reply_channel = mocked_channel()
connected_players()
self.plugin.cmd_switch_plugin(None, ["!policy"], reply_channel)
assert_that(self.plugin.plugin_enabled, is_(True))
assert_channel_was_replied(reply_channel,
matches(".*QLStats policy check enabled.*"))
def test_cmd_policy_exception_for_more_than_one_matching_player(self):
admin_player = fake_player(123, "Admin Player")
exception_player = fake_player(456, "Excepted Player")
connected_players(admin_player, exception_player)
self.plugin.cmd_policy_exception(admin_player, ["!except", "player"],
minqlx.CHAT_CHANNEL)
assert_player_was_told(
admin_player,
matches(".*More than one matching spectator found.*"))
def test_cmd_soulz_for_more_than_one_matching_other_player(self):
player = fake_player(123, "Issuing Player", team="red")
killed1 = fake_player(4, "Killed1", team="blue")
killed2 = fake_player(5, "Killed2", team="blue")
killed3 = fake_player(6, "Killed3", team="blue")
killed4 = fake_player(7, "Killed4", team="blue")
connected_players(player, killed1, killed2, killed3, killed4)
self.plugin.cmd_soulz(player, ["!soulz", "Killed"], self.reply_channel)
assert_player_was_told(player, matches(".*4.* players matched.*"))
def test_cmd_switch_plugin_moves_unfetched_rated_players_to_spec(self):
self.plugin.plugin_enabled = False
reply_channel = mocked_channel()
red_player = fake_player(123, "Red Player", "red")
connected_players(red_player, )
self.setup_balance_playerprivacy([])
self.plugin.cmd_switch_plugin(None, ["!policy"], reply_channel)
assert_player_was_put_on(red_player, "spectator")
assert_player_was_told(red_player,
matches(".*couldn't fetch your ratings.*"))
def test_handle_team_switch_attempt_player_has_forbidden_privacy_setting(
self):
specced_player = fake_player(123, "Test Player")
connected_players(specced_player)
# noinspection PyUnresolvedReferences
self.plugin.plugins["balance"].player_info = {
specced_player.steam_id: {
"privacy": "private"
}
}
return_code = self.plugin.handle_team_switch_attempt(
specced_player, "spectator", "any")
assert_plugin_sent_to_console(matches(".*not allowed to join.*"))
assert_player_received_center_print(specced_player,
matches(r"\^3Join not allowed.*"))
assert_player_was_told(specced_player, matches(".*Open qlstats.net.*"))
assert_that(return_code, is_(minqlx.RET_STOP_ALL))
assert_that(specced_player.steam_id in self.plugin.join_attempts,
is_(True))
def test_cmd_reaperz_with_no_fragger(self):
player = fake_player(123, "Issuing Player", team="red")
connected_players(player)
when(self.db).zrevrangebyscore(
f"minqlx:players:{player.steam_id}:reaperz",
"+INF",
"-INF",
start=0,
num=10,
withscores=True).thenReturn([])
self.plugin.cmd_reaperz(player, ["!reaperz"], self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches("Issuing Player.*'s soul was not reaped by anyone, yet."))
def test_handle_player_connect_logs_error_if_result_status_not_ok(self):
result = self.qlstats_response(status_code=500)
self.setup_qlstats_response(result)
setup_cvars({
"qlx_qlstatsPrivacyKick": "0",
"qlx_qlstatsPrivacyBlock": "1",
"qlx_qlstatsPrivacyWhitelist": "public, anonymous",
"qlx_qlstatsPrivacyJoinAttempts": "5",
"qlx_balanceApi": "belo"
})
connecting_player = fake_player(123, "Connecting Player")
self.plugin.handle_player_connect(connecting_player)
verify(minqlx).console_command(
matches(".*QLStatsPrivacyError.*Invalid response code.*"))
def test_handle_player_connect_logs_error_if_playerinfo_not_included(self):
result = self.qlstats_response()
when(result).json().thenReturn({})
self.setup_qlstats_response(result)
setup_cvars({
"qlx_qlstatsPrivacyKick": "0",
"qlx_qlstatsPrivacyBlock": "1",
"qlx_qlstatsPrivacyWhitelist": "public, anonymous",
"qlx_qlstatsPrivacyJoinAttempts": "5",
"qlx_balanceApi": "belo"
})
connecting_player = fake_player(123, "Connecting Player")
self.plugin.handle_player_connect(connecting_player)
verify(minqlx).console_command(
matches(".*QLStatsPrivacyError.*Invalid response content.*"))
def test_cmd_mapreaperz_with_lava_backflips(self):
player = fake_player(123, "Issuing Player", team="red")
fragged_player = fake_player(456, "Fragged Player", team="red")
killer1 = fake_player(4, "Killer1", team="blue")
connected_players(player, fragged_player, killer1)
self.plugin.frag_log = [(killer1.steam_id, player.steam_id),
("lava", fragged_player.steam_id),
("lava", fragged_player.steam_id),
("void", fragged_player.steam_id)]
self.plugin.cmd_mapreaperz(player, ["!mapreaperz", "Fragged"],
self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches(r"Top 10 reaperz of Fragged Player.*'s soul: "
r"lava.* \(2\), void.* \(1\)"))
def test_cmd_soulz_for_acid_deaths(self):
player = fake_player(123, "Issuing Player", team="red")
fragged_player = fake_player(456, "Fragged Player", team="red")
killer1 = fake_player(4, "Killer1", team="blue")
connected_players(player, fragged_player, killer1)
when(self.db).zrevrangebyscore("minqlx:players:acid:soulz",
"+INF", "-INF", start=0, num=10, withscores=True)\
.thenReturn([
(fragged_player.steam_id, 1)
])
self.plugin.cmd_soulz(player, ["!soulz", "!acid"], self.reply_channel)
assert_channel_was_replied(
self.reply_channel,
matches(r"Top 10 reaped soulz for acid.*: "
r"Fragged Player.* \(1\)"))
def testShouldNotSatisfyIfRegexIsNotMatchedByGivenString(self):
self.assertFalse(matches('f..').matches('bar'))
def testShouldAllowSpecifyingRegexFlags(self):
self.assertFalse(matches('f..').matches('Foo'))
self.assertTrue(matches('f..', re.IGNORECASE).matches('Foo'))
def testShouldSatisfyIfRegexMatchesGivenString(self):
self.assertTrue(matches('f..').matches('foo'))
